Kernel: Fix ByteRingBuffer->back()

No need to swap bytes of every 16 bit word in the packet, we can just do
one swap at the return

.clangd

@@ -0,0 +1,13 @@
+Diagnostics:
+  Suppress: target_unsupported_type
+
+CompileFlags:
+  Remove: [
+    -fstrict-volatile-bitfields,
+    -fno-tree-loop-distribute-patterns
+  ]
+  Add: [
+    -D__banan_os__,
+    -D__arch__=x86_64,
+    -D__x86_64__
+  ]

.gitignore

@@ -3,3 +3,4 @@
 build/
 base/
 script/fakeroot-context
+tools/update-image-perms

.gitmodules

@@ -1,4 +0,0 @@
-[submodule "kernel/lai"]
-	path = kernel/lai
-	url = https://github.com/managarm/lai.git
-	ignore = untracked

.pre-commit-config.yaml

@@ -0,0 +1,8 @@
+# .pre-commit-config.yaml
+exclude: '.patch$'
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.1.0  # this is optional, use `pre-commit autoupdate` to get the latest rev!
+    hooks:
+    -   id: end-of-file-fixer
+    -   id: trailing-whitespace

.vscode/c_cpp_properties.json

@@ -0,0 +1,38 @@
+{
+    "configurations": [
+        {
+            "name": "banan-os",
+            "includePath": [
+                "${workspaceFolder}/BAN/include",
+                "${workspaceFolder}/kernel/include",
+                "${workspaceFolder}/userspace/libraries/*/include"
+            ],
+            "defines": [
+                "__arch=x86_64",
+                "__enable_sse=1"
+            ],
+            "compilerPath": "${workspaceFolder}/toolchain/local/bin/x86_64-banan_os-gcc",
+            "cStandard": "c17",
+            "cppStandard": "gnu++20",
+            "intelliSenseMode": "linux-gcc-x64"
+        },
+        {
+            "name": "banan-os-kernel",
+            "includePath": [
+                "${workspaceFolder}/BAN/include",
+                "${workspaceFolder}/kernel/include",
+                "${workspaceFolder}/userspace/libraries/*/include"
+            ],
+            "defines": [
+                "__arch=x86_64",
+                "__is_kernel",
+                "__enable_sse=1"
+            ],
+            "compilerPath": "${workspaceFolder}/toolchain/local/bin/x86_64-banan_os-gcc",
+            "cStandard": "c17",
+            "cppStandard": "gnu++20",
+            "intelliSenseMode": "linux-gcc-x64"
+        }
+    ],
+    "version": 4
+}

.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+    "cmake.configureOnOpen": false,
+    "editor.tabSize": 4,
+    "editor.insertSpaces": false,
+    "editor.detectIndentation": false,
+    "clangd.arguments": [
+        "--compile-commands-dir=${workspaceFolder}/build",
+        "-header-insertion=never"
+    ]
+}

BAN/.gitignore

@@ -1,3 +0,0 @@
-*.a
-*.d
-*.o

BAN/BAN/Assert.cpp

@@ -0,0 +1,22 @@
+#include <BAN/Assert.h>
+
+#if __is_kernel
+
+#include <kernel/Panic.h>
+
+[[noreturn]] void __ban_assertion_failed(const char* location, const char* msg)
+{
+	Kernel::panic_impl(location, msg);
+}
+
+#else
+
+#include <BAN/Debug.h>
+
+[[noreturn]] void __ban_assertion_failed(const char* location, const char* msg)
+{
+	derrorln("{}: {}", location, msg);
+	__builtin_trap();
+}
+
+#endif

BAN/BAN/String.cpp

@@ -1,269 +0,0 @@
-#include <BAN/String.h>
-#include <BAN/New.h>
-
-namespace BAN
-{
-
-	String::String()
-	{
-	}
-
-	String::String(const String& other)
-	{
-		*this = other;
-	}
-
-	String::String(String&& other)
-	{
-		*this = move(other);
-	}
-
-	String::String(StringView other)
-	{
-		*this = other;
-	}
-
-	String::~String()
-	{
-		clear();
-	}
-
-	String& String::operator=(const String& other)
-	{
-		clear();
-		MUST(ensure_capacity(other.size()));
-		memcpy(data(), other.data(), other.size() + 1);
-		m_size = other.size();
-		return *this;
-	}
-
-	String& String::operator=(String&& other)
-	{
-		clear();
-
-		if (other.has_sso())
-			memcpy(data(), other.data(), other.size() + 1);
-		else
-		{
-			m_storage.general_storage = other.m_storage.general_storage;
-			m_has_sso = false;
-		}
-		m_size = other.m_size;
-
-		other.m_size = 0;
-		other.m_storage.sso_storage = SSOStorage();
-		other.m_has_sso = true;
-
-		return *this;
-	}
-
-	String& String::operator=(StringView other)
-	{
-		clear();
-		MUST(ensure_capacity(other.size()));
-		memcpy(data(), other.data(), other.size());
-		m_size = other.size();
-		data()[m_size] = '\0';
-		return *this;
-	}
-
-	ErrorOr<void> String::push_back(char c)
-	{
-		TRY(ensure_capacity(m_size + 1));
-		data()[m_size] = c;
-		m_size++;
-		data()[m_size] = '\0';
-		return {};
-	}
-
-	ErrorOr<void> String::insert(char c, size_type index)
-	{
-		ASSERT(index <= m_size);
-		TRY(ensure_capacity(m_size + 1));
-		memmove(data() + index + 1, data() + index, m_size - index);
-		data()[index] = c;
-		m_size++;
-		data()[m_size] = '\0';
-		return {};
-	}
-
-	ErrorOr<void> String::insert(StringView str, size_type index)
-	{
-		ASSERT(index <= m_size);
-		TRY(ensure_capacity(m_size + str.size()));
-		memmove(data() + index + str.size(), data() + index, m_size - index);
-		memcpy(data() + index, str.data(), str.size());
-		m_size += str.size();
-		data()[m_size] = '\0';
-		return {};
-	}
-
-	ErrorOr<void> String::append(StringView str)
-	{
-		TRY(ensure_capacity(m_size + str.size()));
-		memcpy(data() + m_size, str.data(), str.size());
-		m_size += str.size();
-		data()[m_size] = '\0';
-		return {};
-	}
-
-	void String::pop_back()
-	{
-		ASSERT(m_size > 0);
-		m_size--;
-		data()[m_size] = '\0';
-	}
-
-	void String::remove(size_type index)
-	{
-		ASSERT(index < m_size);
-		memcpy(data() + index, data() + index + 1, m_size - index);
-		m_size--;
-		data()[m_size] = '\0';
-	}
-
-	void String::clear()
-	{
-		if (!has_sso())
-		{
-			deallocator(m_storage.general_storage.data);
-			m_storage.sso_storage = SSOStorage();
-			m_has_sso = true;
-		}
-		m_size = 0;
-		data()[m_size] = '\0';
-	}
-
-	bool String::operator==(StringView str) const
-	{
-		if (size() != str.size())
-			return false;
-		for (size_type i = 0; i < m_size; i++)
-			if (data()[i] != str.data()[i])
-				return false;
-		return true;
-	}
-
-	bool String::operator==(const char* cstr) const
-	{
-		for (size_type i = 0; i < m_size; i++)
-			if (data()[i] != cstr[i])
-				return false;
-		if (cstr[size()] != '\0')
-			return false;
-		return true;
-	}
-
-	ErrorOr<void> String::resize(size_type new_size, char init_c)
-	{
-		if (m_size == new_size)
-			return {};
-
-		// expanding
-		if (m_size < new_size)
-		{
-			TRY(ensure_capacity(new_size));
-			memset(data() + m_size, init_c, new_size - m_size);
-			m_size = new_size;
-			data()[m_size] = '\0';
-			return {};
-		}
-
-		m_size = new_size;
-		data()[m_size] = '\0';
-		return {};
-	}
-
-	ErrorOr<void> String::reserve(size_type new_size)
-	{
-		TRY(ensure_capacity(new_size));
-		return {};
-	}
-
-	ErrorOr<void> String::shrink_to_fit()
-	{
-		if (has_sso())
-			return {};
-
-		if (fits_in_sso())
-		{
-			char* data = m_storage.general_storage.data;
-			m_storage.sso_storage = SSOStorage();
-			m_has_sso = true;
-			memcpy(this->data(), data, m_size + 1);
-			deallocator(data);
-			return {};
-		}
-
-		GeneralStorage& storage = m_storage.general_storage;
-		if (storage.capacity == m_size)
-			return {};
-
-		char* new_data = (char*)allocator(m_size + 1);
-		if (new_data == nullptr)
-			return Error::from_errno(ENOMEM);
-
-		memcpy(new_data, storage.data, m_size);
-		deallocator(storage.data);
-
-		storage.capacity = m_size;
-		storage.data = new_data;
-
-		return {};
-	}
-
-	String::size_type String::capacity() const
-	{
-		if (has_sso())
-			return sso_capacity;
-		return m_storage.general_storage.capacity;
-	}
-
-	char* String::data()
-	{
-		if (has_sso())
-			return m_storage.sso_storage.data;
-		return m_storage.general_storage.data;
-	}
-
-	const char* String::data() const
-	{
-		if (has_sso())
-			return m_storage.sso_storage.data;
-		return m_storage.general_storage.data;
-	}
-
-	ErrorOr<void> String::ensure_capacity(size_type new_size)
-	{
-		if (m_size >= new_size)
-			return {};
-		if (has_sso() && fits_in_sso(new_size))
-			return {};
-		
-		char* new_data = (char*)allocator(new_size + 1);
-		if (new_data == nullptr)
-			return Error::from_errno(ENOMEM);
-		
-		memcpy(new_data, data(), m_size + 1);
-
-		if (has_sso())
-		{
-			m_storage.general_storage = GeneralStorage();
-			m_has_sso = false;
-		}
-		else
-			deallocator(m_storage.general_storage.data);
-
-		auto& storage = m_storage.general_storage;
-		storage.capacity = new_size;
-		storage.data = new_data;
-
-		return {};
-	}
-
-	bool String::has_sso() const
-	{
-		return m_has_sso;
-	}
-
-}

BAN/BAN/StringView.cpp

@@ -1,180 +1,11 @@
 #include <BAN/String.h>
 #include <BAN/StringView.h>
-#include <BAN/Vector.h>
-
-#include <string.h>
 
 namespace BAN
 {
 
-	StringView::StringView()
-	{ }
-
 	StringView::StringView(const String& other)
 		: StringView(other.data(), other.size())
 	{ }
 
-	StringView::StringView(const char* string, size_type len)
-	{
-		if (len == size_type(-1))
-			len = strlen(string);
-		m_data = string;
-		m_size = len;
-	}
-
-	char StringView::operator[](size_type index) const
-	{
-		ASSERT(index < m_size);
-		return m_data[index];
-	}
-
-	bool StringView::operator==(const String& other) const
-	{
-		if (m_size != other.size())
-			return false;
-		return memcmp(m_data, other.data(), m_size) == 0;
-	}
-
-	bool StringView::operator==(StringView other) const
-	{
-		if (m_size != other.m_size)
-			return false;
-		return memcmp(m_data, other.m_data, m_size) == 0;
-	}
-
-	bool StringView::operator==(const char* other) const
-	{
-		if (memcmp(m_data, other, m_size))
-			return false;
-		return other[m_size] == '\0';
-	}
-
-	StringView StringView::substring(size_type index, size_type len) const
-	{
-		ASSERT(index <= m_size);
-		if (len == size_type(-1))
-			len = m_size - index;
-		ASSERT(len <= m_size - index); // weird order to avoid overflow
-		StringView result;
-		result.m_data = m_data + index;
-		result.m_size = len;
-		return result;
-	}
-
-	ErrorOr<Vector<StringView>> StringView::split(char delim, bool allow_empties)
-	{
-		size_type count = 0;
-		{
-			size_type start = 0;
-			for (size_type i = 0; i < m_size; i++)
-			{
-				if (m_data[i] == delim)
-				{
-					if (allow_empties || start != i)
-						count++;
-					start = i + 1;
-				}
-			}
-			if (start != m_size)
-				count++;
-		}
-
-		Vector<StringView> result;
-		TRY(result.reserve(count));
-
-		size_type start = 0;
-		for (size_type i = 0; i < m_size; i++)
-		{
-			if (m_data[i] == delim)
-			{
-				if (allow_empties || start != i)
-					TRY(result.push_back(this->substring(start, i - start)));
-				start = i + 1;
-			}
-		}
-		if (start != m_size)
-			TRY(result.push_back(this->substring(start)));
-		return result;
-	}
-
-	ErrorOr<Vector<StringView>> StringView::split(bool(*comp)(char), bool allow_empties)
-	{
-		size_type count = 0;
-		{
-			size_type start = 0;
-			for (size_type i = 0; i < m_size; i++)
-			{
-				if (comp(m_data[i]))
-				{
-					if (allow_empties || start != i)
-						count++;
-					start = i + 1;
-				}
-			}
-			if (start != m_size)
-				count++;
-		}
-
-		Vector<StringView> result;
-		TRY(result.reserve(count));
-
-		size_type start = 0;
-		for (size_type i = 0; i < m_size; i++)
-		{
-			if (comp(m_data[i]))
-			{
-				if (allow_empties || start != i)
-					TRY(result.push_back(this->substring(start, i - start)));
-				start = i + 1;
-			}
-		}
-		if (start != m_size)
-			TRY(result.push_back(this->substring(start)));
-		return result;
-	}
-
-	char StringView::back() const
-	{
-		ASSERT(m_size > 0);
-		return m_data[m_size - 1];
-	}
-
-	char StringView::front() const
-	{
-		ASSERT(m_size > 0);
-		return m_data[0];
-	}
-
-	bool StringView::contains(char ch) const
-	{
-		for (size_type i = 0; i < m_size; i++)
-			if (m_data[i] == ch)
-				return true;
-		return false;
-	}
-
-	StringView::size_type StringView::count(char ch) const
-	{
-		size_type result = 0;
-		for (size_type i = 0; i < m_size; i++)
-			if (m_data[i] == ch)
-				result++;
-		return result;
-	}
-
-	bool StringView::empty() const
-	{
-		return m_size == 0;
-	}
-
-	StringView::size_type StringView::size() const
-	{
-		return m_size;
-	}
-
-	const char* StringView::data() const
-	{
-		return m_data;
-	}
-
 }

BAN/CMakeLists.txt

@@ -1,24 +1,18 @@
-cmake_minimum_required(VERSION 3.26)
-
-project(BAN CXX)
-
 set(BAN_SOURCES
+	BAN/Assert.cpp
 	BAN/New.cpp
-	BAN/String.cpp
 	BAN/StringView.cpp
 	BAN/Time.cpp
 )
 
-add_custom_target(ban-headers
-	COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different ${CMAKE_CURRENT_SOURCE_DIR}/include/ ${BANAN_INCLUDE}/
-	DEPENDS sysroot
-)
-
 add_library(ban ${BAN_SOURCES})
-add_dependencies(ban headers libc-install)
+target_link_options(ban PRIVATE -nolibc)
+banan_link_library(ban libc)
 
-add_custom_target(ban-install
+set_target_properties(ban PROPERTIES OUTPUT_NAME libban)
-	COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_BINARY_DIR}/libban.a ${BANAN_LIB}/
+
-	DEPENDS ban
+# set SONAME as cmake doesn't set it for some reason??
-	BYPRODUCTS ${BANAN_LIB}/libban.a
+set_target_properties(ban PROPERTIES LINK_FLAGS "-Wl,-soname,libban.so")
-)
+
+banan_install_headers(ban)
+install(TARGETS ban OPTIONAL)

BAN/include/BAN/Array.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <BAN/Errors.h>
 #include <BAN/Iterators.h>
 #include <BAN/Span.h>
 
@@ -19,85 +18,78 @@ namespace BAN
 		using const_iterator = ConstIteratorSimple<T, Array>;
 
 	public:
-		Array();
+		constexpr Array() = default;
-		Array(const T&);
+		constexpr Array(const T&);
 
 		iterator begin() { return iterator(m_data); }
 		iterator end() { return iterator(m_data + size()); }
 		const_iterator begin() const { return const_iterator(m_data); }
 		const_iterator end() const { return const_iterator(m_data + size()); }
 
-		const T& operator[](size_type) const;
+		constexpr const T& operator[](size_type) const;
-		T& operator[](size_type);
+		constexpr T& operator[](size_type);
 
-		const T& back() const;
+		constexpr const T& back() const;
-		T& back();
+		constexpr T& back();
-		const T& front() const;
+		constexpr const T& front() const;
-		T& front();
+		constexpr T& front();
 
 		Span<T> span() { return Span(m_data, size()); }
-		const Span<T> span() const { return Span(m_data, size()); }
+		Span<const T> span() const { return Span(m_data, size()); }
 
 		constexpr size_type size() const;
 
-		const T* data() const { return m_data; }
+		constexpr const T* data() const { return m_data; }
-		T* data() { return m_data; }
+		constexpr T* data() { return m_data; }
 
 	private:
-		T m_data[S];
+		T m_data[S] {};
 	};
 
 	template<typename T, size_t S>
-	Array<T, S>::Array()
+	constexpr Array<T, S>::Array(const T& value)
-	{
-		for (size_type i = 0; i < S; i++)
-			m_data[i] = T();
-	}
-
-	template<typename T, size_t S>
-	Array<T, S>::Array(const T& value)
 	{
 		for (size_type i = 0; i < S; i++)
 			m_data[i] = value;
 	}
 
 	template<typename T, size_t S>
-	const T& Array<T, S>::operator[](size_type index) const
+	constexpr const T& Array<T, S>::operator[](size_type index) const
 	{
 		ASSERT(index < S);
 		return m_data[index];
 	}
 
 	template<typename T, size_t S>
-	T& Array<T, S>::operator[](size_type index)
+	constexpr T& Array<T, S>::operator[](size_type index)
 	{
 		ASSERT(index < S);
 		return m_data[index];
 	}
 
 	template<typename T, size_t S>
-	const T& Array<T, S>::back() const
+	constexpr const T& Array<T, S>::back() const
 	{
 		ASSERT(S != 0);
 		return m_data[S - 1];
 	}
 
 	template<typename T, size_t S>
-	T& Array<T, S>::back()
+	constexpr T& Array<T, S>::back()
 	{
 		ASSERT(S != 0);
 		return m_data[S - 1];
 	}
 
 	template<typename T, size_t S>
-	const T& Array<T, S>::front() const
+	constexpr const T& Array<T, S>::front() const
 	{
 		ASSERT(S != 0);
 		return m_data[0];
 	}
 
 	template<typename T, size_t S>
-	T& Array<T, S>::front()
+	constexpr T& Array<T, S>::front()
 	{
 		ASSERT(S != 0);
 		return m_data[0];

BAN/include/BAN/Assert.h

@@ -1,33 +1,14 @@
 #pragma once
 
-#include <BAN/Traits.h>
+#define __ban_assert_stringify_helper(s) #s
-
+#define __ban_assert_stringify(s) __ban_assert_stringify_helper(s)
-#if defined(__is_kernel)
-	#include <kernel/Panic.h>
 
 #define ASSERT(cond)																						\
-		do {												\
+	(__builtin_expect(!(cond), 0)																			\
-			if (!(cond))									\
+		? __ban_assertion_failed(__FILE__ ":" __ban_assert_stringify(__LINE__), "ASSERT(" #cond ") failed")	\
-				Kernel::panic("ASSERT(" #cond ") failed");	\
+		: (void)0)
-		} while (false)
 
-	#define __ASSERT_BIN_OP(lhs, rhs, name, op)														\
+#define ASSERT_NOT_REACHED()																				\
-		do {																						\
+	__ban_assertion_failed(__FILE__ ":" __ban_assert_stringify(__LINE__), "ASSERT_NOT_REACHED() reached")
-			auto&& _lhs = lhs;																		\
-			auto&& _rhs = rhs;																		\
-			if (!(_lhs op _rhs))																	\
-					Kernel::panic(name "(" #lhs ", " #rhs ") ({} " #op " {}) failed", _lhs, _rhs);	\
-		} while (false)
 
-	#define ASSERT_LT(lhs, rhs)		__ASSERT_BIN_OP(lhs, rhs, "ASSERT_LT",	<)
+[[noreturn]] void __ban_assertion_failed(const char* location, const char* msg);
-	#define ASSERT_LTE(lhs, rhs)	__ASSERT_BIN_OP(lhs, rhs, "ASSERT_LTE",	<=)
-	#define ASSERT_GT(lhs, rhs)		__ASSERT_BIN_OP(lhs, rhs, "ASSERT_GT",	>)
-	#define ASSERT_GTE(lhs, rhs)	__ASSERT_BIN_OP(lhs, rhs, "ASSERT_GTE",	>=)
-	#define ASSERT_EQ(lhs, rhs)		__ASSERT_BIN_OP(lhs, rhs, "ASSERT_EQ",	==)
-	#define ASSERT_NEQ(lhs, rhs)	__ASSERT_BIN_OP(lhs, rhs, "ASSERT_NEQ",	!=)
-	#define ASSERT_NOT_REACHED() Kernel::panic("ASSERT_NOT_REACHED() failed")
-#else
-	#include <assert.h>
-	#define ASSERT(cond) assert((cond) && "ASSERT("#cond") failed")
-	#define ASSERT_NOT_REACHED() do { assert(false && "ASSERT_NOT_REACHED() failed"); __builtin_unreachable(); } while (false)
-#endif

BAN/include/BAN/Atomic.h

@@ -0,0 +1,99 @@
+#pragma once
+
+#include <BAN/Traits.h>
+
+namespace BAN
+{
+
+	enum MemoryOrder
+	{
+		memory_order_relaxed = __ATOMIC_RELAXED,
+		memory_order_consume = __ATOMIC_CONSUME,
+		memory_order_acquire = __ATOMIC_ACQUIRE,
+		memory_order_release = __ATOMIC_RELEASE,
+		memory_order_acq_rel = __ATOMIC_ACQ_REL,
+		memory_order_seq_cst = __ATOMIC_SEQ_CST,
+	};
+
+	template<typename T> concept atomic_c = is_integral_v<T> || is_pointer_v<T>;
+	template<typename T> concept atomic_lockfree_c = (is_integral_v<T> || is_pointer_v<T>) && __atomic_always_lock_free(sizeof(T), 0);
+
+	template<atomic_lockfree_c T, atomic_c U>
+	inline void atomic_store(T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { __atomic_store_n(&obj, value, mem_order); }
+	template<atomic_lockfree_c T>
+	inline T atomic_load(T& obj, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_load_n(&obj, mem_order); }
+
+	template<atomic_lockfree_c T, atomic_c U>
+	inline T atomic_exchange(T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_exchange_n(&obj, value, mem_order); }
+	template<atomic_lockfree_c T, atomic_lockfree_c U, atomic_c V>
+	inline bool atomic_compare_exchange(T& obj, U& expected, V value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_compare_exchange_n(&obj, &expected, value, false, mem_order, mem_order); }
+
+#define DECL_ATOMIC_INLINE template<atomic_lockfree_c T, atomic_c U> inline
+	DECL_ATOMIC_INLINE T atomic_add_fetch (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_add_fetch (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_sub_fetch (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_sub_fetch (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_and_fetch (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_and_fetch (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_xor_fetch (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_xor_fetch (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_or_fetch  (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_or_fetch  (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_nand_fetch(T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_nand_fetch(&obj, value, mem_order); }
+
+	DECL_ATOMIC_INLINE T atomic_fetch_add (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_fetch_add (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_fetch_sub (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_fetch_sub (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_fetch_and (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_fetch_and (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_fetch_xor (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_fetch_xor (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_fetch_or  (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_fetch_or  (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_fetch_nand(T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_fetch_nand(&obj, value, mem_order); }
+#undef DECL_ATOMIC_INLINE
+
+	template<atomic_lockfree_c T, MemoryOrder MEM_ORDER = MemoryOrder::memory_order_seq_cst>
+	class Atomic
+	{
+		Atomic(const Atomic&) = delete;
+		Atomic(Atomic&&) = delete;
+		Atomic& operator=(const Atomic&) volatile = delete;
+		Atomic& operator=(Atomic&&) volatile = delete;
+
+	public:
+		constexpr Atomic() : m_value(0) {}
+		constexpr Atomic(T val) : m_value(val) {}
+
+		inline T load(MemoryOrder mem_order = MEM_ORDER) const volatile			{ return atomic_load(m_value, mem_order); }
+		inline void store(T val, MemoryOrder mem_order = MEM_ORDER) volatile	{ atomic_store(m_value, val, mem_order); }
+
+		inline T operator=(T val) volatile { store(val); return val; }
+
+		inline operator T() const volatile { return load(); }
+
+		inline T operator+=(T val) volatile { return atomic_add_fetch(m_value, val, MEM_ORDER); }
+		inline T operator-=(T val) volatile { return atomic_sub_fetch(m_value, val, MEM_ORDER); }
+		inline T operator&=(T val) volatile { return atomic_and_fetch(m_value, val, MEM_ORDER); }
+		inline T operator^=(T val) volatile { return atomic_xor_fetch(m_value, val, MEM_ORDER); }
+		inline T operator|=(T val) volatile { return atomic_or_fetch(m_value, val, MEM_ORDER); }
+
+		inline T operator--() volatile { return atomic_sub_fetch(m_value, 1, MEM_ORDER); }
+		inline T operator++() volatile { return atomic_add_fetch(m_value, 1, MEM_ORDER); }
+
+		inline T operator--(int) volatile { return atomic_fetch_sub(m_value, 1, MEM_ORDER); }
+		inline T operator++(int) volatile { return atomic_fetch_add(m_value, 1, MEM_ORDER); }
+
+		inline bool compare_exchange(T& expected, T desired, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_compare_exchange(m_value, expected, desired, mem_order); }
+		inline T exchange(T desired, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_exchange(m_value, desired, mem_order); };
+
+		inline T add_fetch (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_add_fetch (m_value, val, mem_order); }
+		inline T sub_fetch (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_sub_fetch (m_value, val, mem_order); }
+		inline T and_fetch (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_and_fetch (m_value, val, mem_order); }
+		inline T xor_fetch (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_xor_fetch (m_value, val, mem_order); }
+		inline T or_fetch  (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_or_fetch  (m_value, val, mem_order); }
+		inline T nand_fetch(T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_nand_fetch(m_value, val, mem_order); }
+
+		inline T fetch_add (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_fetch_add (m_value, val, mem_order); }
+		inline T fetch_sub (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_fetch_sub (m_value, val, mem_order); }
+		inline T fetch_and (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_fetch_and (m_value, val, mem_order); }
+		inline T fetch_xor (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_fetch_xor (m_value, val, mem_order); }
+		inline T fetch_or  (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_fetch_or  (m_value, val, mem_order); }
+		inline T fetch_nand(T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_fetch_nand(m_value, val, mem_order); }
+
+	private:
+		T m_value;
+	};
+
+}

BAN/include/BAN/Bitcast.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace BAN
+{
+
+	template<typename To, typename From>
+	constexpr To bit_cast(const From& from)
+	{
+		return __builtin_bit_cast(To, from);
+	}
+
+}

BAN/include/BAN/ByteSpan.h

@@ -2,6 +2,8 @@
 
 #include <BAN/Span.h>
 
+#include <stdint.h>
+
 namespace BAN
 {
 
@@ -19,60 +21,56 @@ namespace BAN
 			, m_size(size)
 		{ }
 
-		ByteSpanGeneral(ByteSpanGeneral& other)
+		template<bool SRC_CONST>
+		ByteSpanGeneral(const ByteSpanGeneral<SRC_CONST>& other) requires(CONST || !SRC_CONST)
 			: m_data(other.data())
 			, m_size(other.size())
 		{ }
-		template<bool C2>
+		template<bool SRC_CONST>
-		ByteSpanGeneral(const ByteSpanGeneral<C2>& other) requires(CONST)
+		ByteSpanGeneral(ByteSpanGeneral<SRC_CONST>&& other) requires(CONST || !SRC_CONST)
 			: m_data(other.data())
 			, m_size(other.size())
-		{ }
+		{
-		ByteSpanGeneral(Span<uint8_t> other)
+			other.clear();
-			: m_data(other.data())
+		}
-			, m_size(other.size())
-		{ }
-		ByteSpanGeneral(const Span<const uint8_t>& other) requires(CONST)
-			: m_data(other.data())
-			, m_size(other.size())
-		{ }
 
-		ByteSpanGeneral& operator=(ByteSpanGeneral other)
+		template<typename T>
+		ByteSpanGeneral(const Span<T>& other) requires(is_same_v<T, uint8_t> || (is_same_v<T, const uint8_t> && CONST))
+			: m_data(other.data())
+			, m_size(other.size())
+		{ }
+		template<typename T>
+		ByteSpanGeneral(Span<T>&& other) requires(is_same_v<T, uint8_t> || (is_same_v<T, const uint8_t> && CONST))
+			: m_data(other.data())
+			, m_size(other.size())
+		{
+			other.clear();
+		}
+
+		template<bool SRC_CONST>
+		ByteSpanGeneral& operator=(const ByteSpanGeneral<SRC_CONST>& other) requires(CONST || !SRC_CONST)
 		{
 			m_data = other.data();
 			m_size = other.size();
 			return *this;
 		}
-		template<bool C2>
+		template<bool SRC_CONST>
-		ByteSpanGeneral& operator=(const ByteSpanGeneral<C2>& other) requires(CONST)
+		ByteSpanGeneral& operator=(ByteSpanGeneral<SRC_CONST>&& other) requires(CONST || !SRC_CONST)
-		{
-			m_data = other.data();
-			m_size = other.size();
-			return *this;
-		}
-		ByteSpanGeneral& operator=(Span<uint8_t> other)
-		{
-			m_data = other.data();
-			m_size = other.size();
-			return *this;
-		}
-		ByteSpanGeneral& operator=(const Span<const uint8_t>& other) requires(CONST)
 		{
 			m_data = other.data();
 			m_size = other.size();
+			other.clear();
 			return *this;
 		}
 
 		template<typename S>
-		requires(CONST || !is_const_v<S>)
+		static ByteSpanGeneral from(S& value) requires(CONST || !is_const_v<S>)
-		static ByteSpanGeneral from(S& value)
 		{
 			return ByteSpanGeneral(reinterpret_cast<value_type*>(&value), sizeof(S));
 		}
 
 		template<typename S>
-		requires(!CONST && !is_const_v<S>)
+		S& as() const requires(!CONST || is_const_v<S>)
-		S& as()
 		{
 			ASSERT(m_data);
 			ASSERT(m_size >= sizeof(S));
@@ -80,30 +78,13 @@ namespace BAN
 		}
 
 		template<typename S>
-		requires(is_const_v<S>)
+		Span<S> as_span() const requires(!CONST || is_const_v<S>)
-		S& as() const
-		{
-			ASSERT(m_data);
-			ASSERT(m_size >= sizeof(S));
-			return *reinterpret_cast<S*>(m_data);
-		}
-
-		template<typename S>
-		requires(!CONST && !is_const_v<S>)
-		Span<S> as_span()
 		{
 			ASSERT(m_data);
 			return Span<S>(reinterpret_cast<S*>(m_data), m_size / sizeof(S));
 		}
 
-		template<typename S>
+		[[nodiscard]] ByteSpanGeneral slice(size_type offset, size_type length = size_type(-1)) const
-		const Span<S> as_span() const
-		{
-			ASSERT(m_data);
-			return Span<S>(reinterpret_cast<S*>(m_data), m_size / sizeof(S));
-		}
-
-		ByteSpanGeneral slice(size_type offset, size_type length = size_type(-1))
 		{
 			ASSERT(m_data);
 			ASSERT(m_size >= offset);
@@ -113,25 +94,28 @@ namespace BAN
 			return ByteSpanGeneral(m_data + offset, length);
 		}
 
-		value_type& operator[](size_type offset)
+		value_type& operator[](size_type offset) const
-		{
-			ASSERT(offset < m_size);
-			return m_data[offset];
-		}
-		const value_type& operator[](size_type offset) const
 		{
 			ASSERT(offset < m_size);
 			return m_data[offset];
 		}
 
-		value_type* data() { return m_data; }
+		value_type* data() const { return m_data; }
-		const value_type* data() const { return m_data; } 
 
+		bool empty() const { return m_size == 0; }
 		size_type size() const { return m_size; }
 
+		void clear()
+		{
+			m_data = nullptr;
+			m_size = 0;
+		}
+
 	private:
 		value_type* m_data { nullptr };
 		size_type m_size { 0 };
+
+		friend class ByteSpanGeneral<!CONST>;
 	};
 
 	using ByteSpan = ByteSpanGeneral<false>;

BAN/include/BAN/CircularQueue.h

@@ -1,6 +1,8 @@
 #pragma once
 
 #include <BAN/Assert.h>
+#include <BAN/Move.h>
+#include <BAN/PlacementNew.h>
 
 #include <stdint.h>
 #include <stddef.h>
@@ -22,13 +24,21 @@ namespace BAN
 		void push(const T&);
 		void push(T&&);
 		template<typename... Args>
-		void emplace(Args&&... args);
+		void emplace(Args&&... args) requires is_constructible_v<T, Args...>;
 
 		void pop();
 
 		const T& front() const;
 		T& front();
 
+		const T& back() const;
+		T& back();
+
+		const T& operator[](size_t index) const;
+		T& operator[](size_t index);
+
+		void clear();
+
 		size_type size() const { return m_size; }
 		bool empty() const { return size() == 0; }
 		bool full() const { return size() == capacity(); }
@@ -48,8 +58,7 @@ namespace BAN
 	template<typename T, size_t S>
 	CircularQueue<T, S>::~CircularQueue()
 	{
-		for (size_type i = 0; i < m_size; i++)
+		clear();
-			element_at((m_first + i) % capacity())->~T();
 	}
 
 	template<typename T, size_t S>
@@ -66,7 +75,7 @@ namespace BAN
 
 	template<typename T, size_t S>
 	template<typename... Args>
-	void CircularQueue<T, S>::emplace(Args&&... args)
+	void CircularQueue<T, S>::emplace(Args&&... args) requires is_constructible_v<T, Args...>
 	{
 		ASSERT(!full());
 		new (element_at(((m_first + m_size) % capacity()))) T(BAN::forward<Args>(args)...);
@@ -96,6 +105,42 @@ namespace BAN
 		return *element_at(m_first);
 	}
 
+	template<typename T, size_t S>
+	const T& CircularQueue<T, S>::back() const
+	{
+		ASSERT(!empty());
+		return *element_at((m_first + m_size - 1) % capacity());
+	}
+
+	template<typename T, size_t S>
+	T& CircularQueue<T, S>::back()
+	{
+		ASSERT(!empty());
+		return *element_at((m_first + m_size - 1) % capacity());
+	}
+
+	template<typename T, size_t S>
+	const T& CircularQueue<T, S>::operator[](size_t index) const
+	{
+		ASSERT(index < m_size);
+		return *element_at((m_first + index) % capacity());
+	}
+
+	template<typename T, size_t S>
+	T& CircularQueue<T, S>::operator[](size_t index)
+	{
+		ASSERT(index < m_size);
+		return *element_at((m_first + index) % capacity());
+	}
+
+	template<typename T, size_t S>
+	void CircularQueue<T, S>::clear()
+	{
+		for (size_type i = 0; i < m_size; i++)
+			element_at((m_first + i) % capacity())->~T();
+		m_size = 0;
+	}
+
 	template<typename T, size_t S>
 	const T* CircularQueue<T, S>::element_at(size_type index) const
 	{

BAN/include/BAN/Debug.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#if __is_kernel
+
+#include <kernel/Debug.h>
+
+#else
+
+#include <BAN/Formatter.h>
+#include <stdio.h>
+
+#define __debug_putchar [](int c) { putc_unlocked(c, stddbg); }
+
+#define dprintln(...)											\
+	do {														\
+		flockfile(stddbg);										\
+		BAN::Formatter::print(__debug_putchar, __VA_ARGS__);	\
+		BAN::Formatter::print(__debug_putchar,"\n");			\
+		fflush(stddbg);											\
+		funlockfile(stddbg);									\
+	} while (false)
+
+#define dwarnln(...)											\
+	do {														\
+		flockfile(stddbg);										\
+		BAN::Formatter::print(__debug_putchar, "\e[33m");		\
+		BAN::Formatter::print(__debug_putchar, __VA_ARGS__);	\
+		BAN::Formatter::print(__debug_putchar, "\e[m\n");		\
+		fflush(stddbg);											\
+		funlockfile(stddbg);									\
+	} while(false)
+
+#define derrorln(...)											\
+	do {														\
+		flockfile(stddbg);										\
+		BAN::Formatter::print(__debug_putchar, "\e[31m");		\
+		BAN::Formatter::print(__debug_putchar, __VA_ARGS__);	\
+		BAN::Formatter::print(__debug_putchar, "\e[m\n");		\
+		fflush(stddbg);											\
+		funlockfile(stddbg);									\
+	} while(false)
+
+#define dprintln_if(cond, ...)		\
+	do {							\
+		if constexpr(cond)			\
+			dprintln(__VA_ARGS__);	\
+	} while(false)
+
+#define dwarnln_if(cond, ...)		\
+	do {							\
+		if constexpr(cond)			\
+			dwarnln(__VA_ARGS__);	\
+	} while(false)
+
+#define derrorln_if(cond, ...)		\
+	do {							\
+		if constexpr(cond)			\
+			derrorln(__VA_ARGS__);	\
+	} while(false)
+
+#endif

BAN/include/BAN/Endianness.h

@@ -45,6 +45,12 @@ namespace BAN
 #endif
 	}
 
+	template<integral T>
+	constexpr T little_endian_to_host(T value)
+	{
+		return host_to_little_endian(value);
+	}
+
 	template<integral T>
 	constexpr T host_to_big_endian(T value)
 	{
@@ -55,13 +61,28 @@ namespace BAN
 #endif
 	}
 
+	template<integral T>
+	constexpr T big_endian_to_host(T value)
+	{
+		return host_to_big_endian(value);
+	}
+
 	template<integral T>
 	struct LittleEndian
 	{
+		constexpr LittleEndian()
+			: raw(0)
+		{ }
+
+		constexpr LittleEndian(T value)
+			: raw(host_to_little_endian(value))
+		{ }
+
 		constexpr operator T() const
 		{
 			return host_to_little_endian(raw);
 		}
+
 	private:
 		T raw;
 	};
@@ -69,12 +90,36 @@ namespace BAN
 	template<integral T>
 	struct BigEndian
 	{
+		constexpr BigEndian()
+			: raw(0)
+		{ }
+
+		constexpr BigEndian(T value)
+			: raw(host_to_big_endian(value))
+		{ }
+
 		constexpr operator T() const
 		{
 			return host_to_big_endian(raw);
 		}
+
 	private:
 		T raw;
 	};
 
+	template<integral T>
+	using NetworkEndian = BigEndian<T>;
+
+	template<integral T>
+	constexpr T host_to_network_endian(T value)
+	{
+		return host_to_big_endian(value);
+	}
+
+	template<integral T>
+	constexpr T network_endian_to_host(T value)
+	{
+		return big_endian_to_host(value);
+	}
+
 }

BAN/include/BAN/Errors.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <BAN/Formatter.h>
-#include <BAN/StringView.h>
+#include <BAN/NoCopyMove.h>
 #include <BAN/Variant.h>
 
 #include <errno.h>
@@ -10,16 +10,16 @@
 #ifdef __is_kernel
 	#include <kernel/Panic.h>
 	#include <kernel/Errors.h>
-	#define MUST(expr)		 ({ auto&& e = expr; if (e.is_error()) Kernel::panic("{}", e.error()); e.release_value(); })
+	#define MUST(...)		 ({ auto&& e = (__VA_ARGS__); if (e.is_error()) Kernel::panic("{}", e.error()); e.release_value(); })
-	#define MUST_REF(expr)	*({ auto&& e = expr; if (e.is_error()) Kernel::panic("{}", e.error()); &e.release_value(); })
+	#define MUST_REF(...)	*({ auto&& e = (__VA_ARGS__); if (e.is_error()) Kernel::panic("{}", e.error()); &e.release_value(); })
 #else
-	#include <assert.h>
+	#include <BAN/Debug.h>
-	#define MUST(expr)		 ({ auto&& e = expr; assert(!e.is_error()); e.release_value(); })
+	#define MUST(...)		 ({ auto&& e = (__VA_ARGS__); if (e.is_error()) { derrorln("MUST(" #__VA_ARGS__ "): {}", e.error()); __builtin_trap(); } e.release_value(); })
-	#define MUST_REF(expr)	*({ auto&& e = expr; assert(!e.is_error()); &e.release_value(); })
+	#define MUST_REF(...)	*({ auto&& e = (__VA_ARGS__); if (e.is_error()) { derrorln("MUST(" #__VA_ARGS__ "): {}", e.error()); __builtin_trap(); } &e.release_value(); })
 #endif
 
-#define TRY(expr)		 ({ auto&& e = expr; if (e.is_error()) return e.release_error(); e.release_value(); })
+#define TRY(...)		 ({ auto&& e = (__VA_ARGS__); if (e.is_error()) return e.release_error(); e.release_value(); })
-#define TRY_REF(expr)	*({ auto&& e = expr; if (e.is_error()) return e.release_error(); &e.release_value(); })
+#define TRY_REF(...)	*({ auto&& e = (__VA_ARGS__); if (e.is_error()) return e.release_error(); &e.release_value(); })
 
 namespace BAN
 {
@@ -37,7 +37,14 @@ namespace BAN
 		{
 			return Error((uint64_t)error | kernel_error_mask);
 		}
+#else
+		template<size_t N>
+		consteval static Error from_literal(const char (&message)[N])
+		{
+			return Error(message);
+		}
 #endif
+
 		static Error from_errno(int error)
 		{
 			return Error(error);
@@ -55,27 +62,43 @@ namespace BAN
 		}
 #endif
 
-		uint64_t get_error_code() const { return m_error_code; }
+		constexpr uint64_t get_error_code() const { return m_error_code; }
-		BAN::StringView get_message() const
+		const char* get_message() const
 		{
 #ifdef __is_kernel
 			if (m_error_code & kernel_error_mask)
 				return Kernel::error_string(kernel_error());
+#else
+			if (m_message)
+				return m_message;
 #endif
-			return strerror(m_error_code);
+			if (auto* desc = strerrordesc_np(m_error_code))
+				return desc;
+			return "Unknown error";
 		}
 
 	private:
-		Error(uint64_t error)
+		constexpr Error(uint64_t error)
 			: m_error_code(error)
 		{}
 
-		uint64_t m_error_code;
+#ifndef __is_kernel
+		constexpr Error(const char* message)
+			: m_message(message)
+		{}
+#endif
+
+		uint64_t m_error_code { 0 };
+
+#ifndef __is_kernel
+		const char* m_message { nullptr };
+#endif
 	};
 
 	template<typename T>
 	class [[nodiscard]] ErrorOr
 	{
+		BAN_NON_COPYABLE(ErrorOr);
 	public:
 		ErrorOr(const T& value)
 			: m_data(value)
@@ -89,6 +112,14 @@ namespace BAN
 		ErrorOr(Error&& error)
 			: m_data(move(error))
 		{}
+		ErrorOr(ErrorOr&& other)
+			: m_data(move(other.m_data))
+		{}
+		ErrorOr& operator=(ErrorOr&& other)
+		{
+			m_data = move(other.m_data);
+			return *this;
+		}
 
 		bool is_error() const			{ return m_data.template has<Error>(); }
 		const Error& error() const		{ return m_data.template get<Error>(); }

BAN/include/BAN/Formatter.h

@@ -10,22 +10,19 @@ namespace BAN::Formatter
 
 	struct ValueFormat;
 
-	template<typename F>
-	static void print(F putc, const char* format);
-
-	template<typename F, typename Arg, typename... Args>
-	static void print(F putc, const char* format, Arg&& arg, Args&&... args);
-
 	template<typename F, typename... Args>
-	static void println(F putc, const char* format, Args&&... args);
+	concept PrintableArguments = requires(F putc, Args&&... args, const ValueFormat& format)
+	{
+		(print_argument(putc, BAN::forward<Args>(args), format), ...);
+	};
 
 	template<typename F, typename T>
-	static void print_argument(F putc, T value, const ValueFormat& format);
+	inline void print_argument(F putc, T value, const ValueFormat& format);
 
 	namespace detail
 	{
 		template<typename F, typename T>
-		static size_t parse_format_and_print_argument(F putc, const char* format, T&& arg);
+		inline size_t parse_format_and_print_argument(F putc, const char* format, T&& arg);
 	}
 
 	/*
@@ -39,11 +36,12 @@ namespace BAN::Formatter
 		int base		= 10;
 		int percision	= 3;
 		int fill		= 0;
+		char fill_char  = '0';
 		bool upper		= false;
 	};
 
 	template<typename F>
-	void print(F putc, const char* format)
+	inline void print(F putc, const char* format)
 	{
 		while (*format)
 		{
@@ -52,8 +50,8 @@ namespace BAN::Formatter
 		}
 	}
 
-	template<typename F, typename Arg, typename... Args>
+	template<typename F, typename Arg, typename... Args> requires PrintableArguments<F, Arg, Args...>
-	void print(F putc, const char* format, Arg&& arg, Args&&... args)
+	inline void print(F putc, const char* format, Arg&& arg, Args&&... args)
 	{
 		while (*format && *format != '{')
 		{
@@ -71,7 +69,7 @@ namespace BAN::Formatter
 	}
 
 	template<typename F, typename... Args>
-	void println(F putc, const char* format, Args&&... args)
+	inline void println(F putc, const char* format, Args&&... args)
 	{
 		print(putc, format, args...);
 		putc('\n');
@@ -81,7 +79,7 @@ namespace BAN::Formatter
 	{
 
 		template<typename F, typename Arg>
-		size_t parse_format_and_print_argument(F putc, const char* format, Arg&& argument)
+		inline size_t parse_format_and_print_argument(F putc, const char* format, Arg&& argument)
 		{
 			ValueFormat value_format;
 
@@ -94,6 +92,12 @@ namespace BAN::Formatter
 				if (!format[i] || format[i] == '}')
 					break;
 
+				if (format[i] == ' ')
+				{
+					value_format.fill_char = ' ';
+					i++;
+				}
+
 				if ('0' <= format[i] && format[i] <= '9')
 				{
 					int fill = 0;
@@ -143,7 +147,7 @@ namespace BAN::Formatter
 			return i + 1;
 		}
 
-		static char value_to_base_char(uint8_t value, int base, bool upper)
+		inline char value_to_base_char(uint8_t value, int base, bool upper)
 		{
 			if (base <= 10)
 				return value + '0';
@@ -157,11 +161,12 @@ namespace BAN::Formatter
 		}
 
 		template<typename F, typename T>
-		void print_integer(F putc, T value, const ValueFormat& format)
+		inline void print_integer(F putc, T value, const ValueFormat& format)
 		{
 			if (value == 0)
 			{
-				for (int i = 0; i < format.fill || i < 1; i++)
+				for (int i = 0; i < format.fill - 1; i++)
+					putc(format.fill_char);
 				putc('0');
 				return;
 			}
@@ -188,7 +193,7 @@ namespace BAN::Formatter
 			}
 
 			while (ptr >= buffer + sizeof(buffer) - format.fill)
-				*(--ptr) = '0';
+				*(--ptr) = format.fill_char;
 
 			if (sign)
 				*(--ptr) = '-';
@@ -197,12 +202,16 @@ namespace BAN::Formatter
 		}
 
 		template<typename F, typename T>
-		void print_floating(F putc, T value, const ValueFormat& format)
+		inline void print_floating(F putc, T value, const ValueFormat& format)
 		{
+			if (value < 0)
+			{
+				putc('-');
+				return print_floating(putc, -value, format);
+			}
+
 			int64_t int_part = (int64_t)value;
 			T frac_part = value - (T)int_part;
-			if (frac_part < 0)
-				frac_part = -frac_part;
 
 			print_integer(putc, int_part, format);
 
@@ -220,7 +229,7 @@ namespace BAN::Formatter
 		}
 
 		template<typename F>
-		void print_pointer(F putc, void* ptr, const ValueFormat& format)
+		inline void print_pointer(F putc, void* ptr, const ValueFormat& format)
 		{
 			uintptr_t value = (uintptr_t)ptr;
 			print(putc, "0x");
@@ -236,13 +245,13 @@ namespace BAN::Formatter
 
 	*/
 
-	template<typename F, integral		T> void print_argument(F putc, T value, const ValueFormat& format) { detail::print_integer(putc, value, format); }
+	template<typename F, integral		T> inline void print_argument(F putc, T value, const ValueFormat& format) { detail::print_integer(putc, value, format); }
-	template<typename F, floating_point	T> void print_argument(F putc, T value, const ValueFormat& format) { detail::print_floating(putc, value, format); }
+	template<typename F, floating_point	T> inline void print_argument(F putc, T value, const ValueFormat& format) { detail::print_floating(putc, value, format); }
-	template<typename F, pointer		T> void print_argument(F putc, T value, const ValueFormat& format) { detail::print_pointer(putc, (void*)value, format); }
+	template<typename F, pointer		T> inline void print_argument(F putc, T value, const ValueFormat& format) { detail::print_pointer(putc, (void*)value, format); }
 
-	template<typename F> void print_argument(F putc, char			value, const ValueFormat&)	{ putc(value); }
+	template<typename F> inline void print_argument(F putc, char			value, const ValueFormat&)	{ putc(value); }
-	template<typename F> void print_argument(F putc, bool			value, const ValueFormat&)	{ print(putc, value ? "true" : "false"); }
+	template<typename F> inline void print_argument(F putc, bool			value, const ValueFormat&)	{ print(putc, value ? "true" : "false"); }
-	template<typename F> void print_argument(F putc, const char*	value, const ValueFormat&)	{ print(putc, value); }
+	template<typename F> inline void print_argument(F putc, const char*	value, const ValueFormat&)	{ print(putc, value); }
-	template<typename F> void print_argument(F putc, char*			value, const ValueFormat&)	{ print(putc, value); }
+	template<typename F> inline void print_argument(F putc, char*			value, const ValueFormat&)	{ print(putc, value); }
 
 }

BAN/include/BAN/Function.h

@@ -2,7 +2,7 @@
 
 #include <BAN/Errors.h>
 #include <BAN/Move.h>
-#include <BAN/New.h>
+#include <BAN/PlacementNew.h>
 
 namespace BAN
 {
@@ -20,19 +20,19 @@ namespace BAN
 			new (m_storage) CallablePointer(function);
 		}
 		template<typename Own>
-		Function(Ret(Own::*function)(Args...), Own* owner)
+		Function(Ret(Own::*function)(Args...), Own& owner)
 		{
 			static_assert(sizeof(CallableMember<Own>) <= m_size);
 			new (m_storage) CallableMember<Own>(function, owner);
 		}
 		template<typename Own>
-		Function(Ret(Own::*function)(Args...) const, const Own* owner)
+		Function(Ret(Own::*function)(Args...) const, const Own& owner)
 		{
 			static_assert(sizeof(CallableMemberConst<Own>) <= m_size);
 			new (m_storage) CallableMemberConst<Own>(function, owner);
 		}
 		template<typename Lambda>
-		Function(Lambda lambda)
+		Function(Lambda lambda) requires requires(Lambda lamda, Args&&... args) { { lambda(forward<Args>(args)...) } -> BAN::same_as<Ret>; }
 		{
 			static_assert(sizeof(CallableLambda<Lambda>) <= m_size);
 			new (m_storage) CallableLambda<Lambda>(lambda);
@@ -91,36 +91,36 @@ namespace BAN
 		template<typename Own>
 		struct CallableMember : public CallableBase
 		{
-			CallableMember(Ret(Own::*function)(Args...), Own* owner)
+			CallableMember(Ret(Own::*function)(Args...), Own& owner)
 				: m_owner(owner)
 				, m_function(function)
 			{ }
 
 			virtual Ret call(Args... args) const override
 			{
-				return (m_owner->*m_function)(forward<Args>(args)...);
+				return (m_owner.*m_function)(forward<Args>(args)...);
 			}
 
 		private:
-			Own* m_owner = nullptr;
+			Own& m_owner;
 			Ret(Own::*m_function)(Args...) = nullptr;
 		};
 
 		template<typename Own>
 		struct CallableMemberConst : public CallableBase
 		{
-			CallableMemberConst(Ret(Own::*function)(Args...) const, const Own* owner)
+			CallableMemberConst(Ret(Own::*function)(Args...) const, const Own& owner)
 				: m_owner(owner)
 				, m_function(function)
 			{ }
 
 			virtual Ret call(Args... args) const override
 			{
-				return (m_owner->*m_function)(forward<Args>(args)...);
+				return (m_owner.*m_function)(forward<Args>(args)...);
 			}
 
 		private:
-			const Own* m_owner = nullptr;
+			const Own& m_owner;
 			Ret(Own::*m_function)(Args...) const = nullptr;
 		};
 
@@ -141,7 +141,7 @@ namespace BAN
 		};
 
 	private:
-		static constexpr size_t m_size = sizeof(void*) * 5;
+		static constexpr size_t m_size = sizeof(void*) * 8;
 		alignas(CallableBase) uint8_t m_storage[m_size] { 0 };
 	};
 

BAN/include/BAN/GUID.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <BAN/Optional.h>
-#include <BAN/StringView.h>
+#include <BAN/String.h>
 
 #include <string.h>
 
@@ -19,6 +19,54 @@ namespace BAN
 		{
 			return memcmp(this, &other, sizeof(GUID)) == 0;
 		}
+
+		BAN::ErrorOr<BAN::String> to_string() const
+		{
+			char buffer[37];
+			char* ptr = buffer;
+
+			const auto append_hex_nibble =
+				[&ptr](uint8_t nibble)
+				{
+					if (nibble < 10)
+						*ptr++ = '0' + nibble;
+					else
+						*ptr++ = 'A' + nibble - 10;
+				};
+
+			const auto append_hex_byte =
+				[&append_hex_nibble](uint8_t byte)
+				{
+					append_hex_nibble(byte >> 4);
+					append_hex_nibble(byte & 0xF);
+				};
+
+			append_hex_byte((component1 >> 24) & 0xFF);
+			append_hex_byte((component1 >> 16) & 0xFF);
+			append_hex_byte((component1 >>  8) & 0xFF);
+			append_hex_byte((component1 >>  0) & 0xFF);
+			*ptr++ = '-';
+			append_hex_byte((component2 >>  8) & 0xFF);
+			append_hex_byte((component2 >>  0) & 0xFF);
+			*ptr++ = '-';
+			append_hex_byte((component3 >>  8) & 0xFF);
+			append_hex_byte((component3 >>  0) & 0xFF);
+			*ptr++ = '-';
+			append_hex_byte(component45[0]);
+			append_hex_byte(component45[1]);
+			*ptr++ = '-';
+			append_hex_byte(component45[2]);
+			append_hex_byte(component45[3]);
+			append_hex_byte(component45[4]);
+			append_hex_byte(component45[5]);
+			append_hex_byte(component45[6]);
+			append_hex_byte(component45[7]);
+			*ptr = '\0';
+
+			BAN::String guid;
+			TRY(guid.append(buffer));
+			return BAN::move(guid);
+		}
 	};
 	static_assert(sizeof(GUID) == 16);
 

BAN/include/BAN/HashMap.h

@@ -1,270 +1,261 @@
 #pragma once
 
-#include <BAN/Hash.h>
+#include <BAN/HashSet.h>
-#include <BAN/LinkedList.h>
-#include <BAN/Vector.h>
 
 namespace BAN
 {
 
-	template<typename Key, typename T, typename HASH = BAN::hash<Key>, bool STABLE = true>
+	template<typename HashSetIt, typename HashMap, typename Entry>
+	class HashMapIterator
+	{
+	public:
+		HashMapIterator() = default;
+
+		Entry& operator*()
+		{
+			return const_cast<Entry&>(m_iterator.operator*());
+		}
+		const Entry& operator*() const
+		{
+			return m_iterator.operator*();
+		}
+
+		Entry* operator->()
+		{
+			return const_cast<Entry*>(m_iterator.operator->());
+		}
+		const Entry* operator->() const
+		{
+			return m_iterator.operator->();
+		}
+
+		HashMapIterator& operator++()
+		{
+			++m_iterator;
+			return *this;
+		}
+		HashMapIterator operator++(int)
+		{
+			auto temp = *this;
+			++(*this);
+			return temp;
+		}
+
+		bool operator==(HashMapIterator other) const
+		{
+			return m_iterator == other.m_iterator;
+		}
+		bool operator!=(HashMapIterator other) const
+		{
+			return m_iterator != other.m_iterator;
+		}
+
+	private:
+		explicit HashMapIterator(HashSetIt it)
+			: m_iterator(it)
+		{ }
+
+	private:
+		HashSetIt m_iterator;
+		friend HashMap;
+	};
+
+	namespace detail
+	{
+		template<typename T, typename Key, typename HASH, typename COMP>
+		concept HashMapFindable = requires(const Key& a, const T& b) { COMP()(a, b); HASH()(b); };
+	}
+
+	template<typename Key, typename T, typename HASH = BAN::hash<Key>, typename COMP = BAN::equal<Key>>
 	class HashMap
 	{
 	public:
 		struct Entry
 		{
-			template<typename... Args>
+			const Key key;
-			Entry(const Key& key, Args&&... args)
+			T value;
-				: key(key)
+
-				, value(forward<Args>(args)...)
+			Entry() = delete;
+			Entry& operator=(const Entry&) = delete;
+			Entry& operator=(Entry&&) = delete;
+
+			Entry(const Entry& other)
+				: key(other.key)
+				, value(other.value)
 			{ }
 
-			Key key;
+			Entry(Entry&& other)
-			T value;
+				: key(BAN::move(const_cast<Key&>(other.key)))
+				, value(BAN::move(other.value))
+			{ }
+
+			template<typename... Args>
+			Entry(Key&& key, Args&&... args)
+				: key(BAN::move(key))
+				, value(BAN::forward<Args>(args)...)
+			{ }
+		};
+
+		struct EntryHash
+		{
+			constexpr bool operator()(const Key& a)
+			{
+				return HASH()(a);
+			}
+			constexpr bool operator()(const Entry& a)
+			{
+				return HASH()(a.key);
+			}
+		};
+
+		struct EntryComp
+		{
+			constexpr bool operator()(const Entry& a, const Key& b)
+			{
+				return COMP()(a.key, b);
+			}
+			constexpr bool operator()(const Entry& a, const Entry& b)
+			{
+				return COMP()(a.key, b.key);
+			}
 		};
 
 	public:
 		using size_type      = size_t;
 		using key_type       = Key;
 		using value_type     = T;
-		using iterator = IteratorDouble<Entry, Vector, LinkedList, HashMap>;
+		using iterator       = HashMapIterator<typename HashSet<Entry, EntryHash, EntryComp>::iterator,       HashMap, Entry>;
-		using const_iterator = ConstIteratorDouble<Entry, Vector, LinkedList, HashMap>;
+		using const_iterator = HashMapIterator<typename HashSet<Entry, EntryHash, EntryComp>::const_iterator, HashMap, const Entry>;
 
 	public:
 		HashMap() = default;
-		HashMap(const HashMap<Key, T, HASH, STABLE>&);
+		~HashMap() { clear(); }
-		HashMap(HashMap<Key, T, HASH, STABLE>&&);
-		~HashMap();
 
-		HashMap<Key, T, HASH, STABLE>& operator=(const HashMap<Key, T, HASH, STABLE>&);
+		HashMap(const HashMap& other) { *this = other; }
-		HashMap<Key, T, HASH, STABLE>& operator=(HashMap<Key, T, HASH, STABLE>&&);
+		HashMap& operator=(const HashMap& other)
-
-		ErrorOr<void> insert(const Key&, const T&);
-		ErrorOr<void> insert(const Key&, T&&);
-		template<typename... Args>
-		ErrorOr<void> emplace(const Key&, Args&&...);
-
-		iterator begin() { return iterator(m_buckets.end(), m_buckets.begin()); }
-		iterator end()   { return iterator(m_buckets.end(), m_buckets.end()); }
-		const_iterator begin() const { return const_iterator(m_buckets.end(), m_buckets.begin()); }
-		const_iterator end() const   { return const_iterator(m_buckets.end(), m_buckets.end()); }
-
-		ErrorOr<void> reserve(size_type);
-
-		void remove(const Key&);
-		void clear();
-
-		T& operator[](const Key&);
-		const T& operator[](const Key&) const;
-
-		bool contains(const Key&) const;
-
-		bool empty() const;
-		size_type size() const;
-
-	private:
-		ErrorOr<void> rebucket(size_type);
-		LinkedList<Entry>& get_bucket(const Key&);
-		const LinkedList<Entry>& get_bucket(const Key&) const;
-		
-	private:
-		Vector<LinkedList<Entry>> m_buckets;
-		size_type m_size = 0;
-
-		friend iterator;
-	};
-
-	template<typename Key, typename T, typename HASH, bool STABLE>
-	HashMap<Key, T, HASH, STABLE>::HashMap(const HashMap<Key, T, HASH, STABLE>& other)
 		{
-		*this = other;
+			m_hash_set = other.m_hash_set;
-	}
-
-	template<typename Key, typename T, typename HASH, bool STABLE>
-	HashMap<Key, T, HASH, STABLE>::HashMap(HashMap<Key, T, HASH, STABLE>&& other)
-	{
-		*this = move(other);
-	}
-
-	template<typename Key, typename T, typename HASH, bool STABLE>
-	HashMap<Key, T, HASH, STABLE>::~HashMap()
-	{
-		clear();
-	}
-
-	template<typename Key, typename T, typename HASH, bool STABLE>
-	HashMap<Key, T, HASH, STABLE>& HashMap<Key, T, HASH, STABLE>::operator=(const HashMap<Key, T, HASH, STABLE>& other)
-	{
-		clear();
-		m_buckets = other.m_buckets;
-		m_size = other.m_size;
 			return *this;
 		}
 
-	template<typename Key, typename T, typename HASH, bool STABLE>
+		HashMap(HashMap&& other) { *this = BAN::move(other); }
-	HashMap<Key, T, HASH, STABLE>& HashMap<Key, T, HASH, STABLE>::operator=(HashMap<Key, T, HASH, STABLE>&& other)
+		HashMap& operator=(HashMap&& other)
 		{
-		clear();
+			m_hash_set = BAN::move(other.m_hash_set);
-		m_buckets = move(other.m_buckets);
-		m_size = other.m_size;
-		other.m_size = 0;
 			return *this;
 		}
 
-	template<typename Key, typename T, typename HASH, bool STABLE>
+		iterator begin()             { return iterator(m_hash_set.begin()); }
-	ErrorOr<void> HashMap<Key, T, HASH, STABLE>::insert(const Key& key, const T& value)
+		iterator end()               { return iterator(m_hash_set.end()); }
-	{
+		const_iterator begin() const { return const_iterator(m_hash_set.begin()); }
-		return insert(key, move(T(value)));
+		const_iterator end() const   { return const_iterator(m_hash_set.end()); }
-	}
 
-	template<typename Key, typename T, typename HASH, bool STABLE>
+		ErrorOr<iterator> insert(const Key& key, const T& value)           { return emplace(key, value); }
-	ErrorOr<void> HashMap<Key, T, HASH, STABLE>::insert(const Key& key, T&& value)
+		ErrorOr<iterator> insert(const Key& key, T&& value)                { return emplace(key, move(value)); }
-	{
+		ErrorOr<iterator> insert(Key&& key, const T& value)                { return emplace(move(key), value); }
-		return emplace(key, move(value));
+		ErrorOr<iterator> insert(Key&& key, T&& value)                     { return emplace(move(key), move(value)); }
-	}
+
+		ErrorOr<iterator> insert_or_assign(const Key& key, const T& value) { return emplace_or_assign(key, value); }
+		ErrorOr<iterator> insert_or_assign(const Key& key, T&& value)      { return emplace_or_assign(key, move(value)); }
+		ErrorOr<iterator> insert_or_assign(Key&& key, const T& value)      { return emplace_or_assign(move(key), value); }
+		ErrorOr<iterator> insert_or_assign(Key&& key, T&& value)           { return emplace_or_assign(move(key), move(value)); }
 
-	template<typename Key, typename T, typename HASH, bool STABLE>
 		template<typename... Args>
-	ErrorOr<void> HashMap<Key, T, HASH, STABLE>::emplace(const Key& key, Args&&... args)
+		ErrorOr<iterator> emplace(const Key& key, Args&&... args) requires is_constructible_v<T, Args...>
+		{ return emplace(Key(key), BAN::forward<Args>(args)...); }
+		template<typename... Args>
+		ErrorOr<iterator> emplace(Key&& key, Args&&... args) requires is_constructible_v<T, Args...>
 		{
 			ASSERT(!contains(key));
-		TRY(rebucket(m_size + 1));
+			auto it = TRY(m_hash_set.insert(Entry { BAN::move(key), T(BAN::forward<Args>(args)...) }));
-		auto& bucket = get_bucket(key);
+			return iterator(it);
-		auto result = bucket.emplace_back(key, forward<Args>(args)...);
-		if (result.is_error())
-			return Error::from_errno(ENOMEM);
-		m_size++;
-		return {};
 		}
 
-	template<typename Key, typename T, typename HASH, bool STABLE>
+		template<typename... Args>
-	ErrorOr<void> HashMap<Key, T, HASH, STABLE>::reserve(size_type size)
+		ErrorOr<iterator> emplace_or_assign(const Key& key, Args&&... args) requires is_constructible_v<T, Args...>
+		{ return emplace_or_assign(Key(key), BAN::forward<Args>(args)...); }
+		template<typename... Args>
+		ErrorOr<iterator> emplace_or_assign(Key&& key, Args&&... args) requires is_constructible_v<T, Args...>
 		{
-		TRY(rebucket(size));
+			if (auto it = m_hash_set.find(key); it != m_hash_set.end())
-		return {};
+			{
+				const_cast<T&>(it->value) = T(BAN::forward<Args>(args)...);
+				return iterator(it);
 			}
 
-	template<typename Key, typename T, typename HASH, bool STABLE>
+			auto it = TRY(m_hash_set.insert(Entry { BAN::move(key), T(BAN::forward<Args>(args)...) }));
-	void HashMap<Key, T, HASH, STABLE>::remove(const Key& key)
+			return iterator(it);
-	{
-		if (empty()) return;
-		auto& bucket = get_bucket(key);
-		for (auto it = bucket.begin(); it != bucket.end(); it++)
-		{
-			if (it->key == key)
-			{
-				bucket.remove(it);
-				m_size--;
-				return;
-			}
-		}
 		}
 
-	template<typename Key, typename T, typename HASH, bool STABLE>
+		template<detail::HashMapFindable<Key, HASH, COMP> U>
-	void HashMap<Key, T, HASH, STABLE>::clear()
+		void remove(const U& key)
 		{
-		m_buckets.clear();
+			if (auto it = find(key); it != end())
-		m_size = 0;
+				remove(it);
 		}
 
-	template<typename Key, typename T, typename HASH, bool STABLE>
+		iterator remove(iterator it)
-	T& HashMap<Key, T, HASH, STABLE>::operator[](const Key& key)
 		{
-		ASSERT(!empty());
+			return iterator(m_hash_set.remove(it.m_iterator));
-		auto& bucket = get_bucket(key);
-		for (Entry& entry : bucket)
-			if (entry.key == key)
-				return entry.value;
-		ASSERT(false);
 		}
 
-	template<typename Key, typename T, typename HASH, bool STABLE>
+		template<detail::HashMapFindable<Key, HASH, COMP> U>
-	const T& HashMap<Key, T, HASH, STABLE>::operator[](const Key& key) const
+		iterator find(const U& key)
 		{
-		ASSERT(!empty());
+			return iterator(m_hash_set.find(key));
-		const auto& bucket = get_bucket(key);
-		for (const Entry& entry : bucket)
-			if (entry.key == key)
-				return entry.value;
-		ASSERT(false);
 		}
 
-	template<typename Key, typename T, typename HASH, bool STABLE>
+		template<detail::HashMapFindable<Key, HASH, COMP> U>
-	bool HashMap<Key, T, HASH, STABLE>::contains(const Key& key) const
+		const_iterator find(const U& key) const
 		{
-		if (empty()) return false;
+			return const_iterator(m_hash_set.find(key));
-		const auto& bucket = get_bucket(key);
-		for (const Entry& entry : bucket)
-			if (entry.key == key)
-				return true;
-		return false;
 		}
 
-	template<typename Key, typename T, typename HASH, bool STABLE>
+		void clear()
-	bool HashMap<Key, T, HASH, STABLE>::empty() const
 		{
-		return m_size == 0;
+			m_hash_set.clear();
 		}
 
-	template<typename Key, typename T, typename HASH, bool STABLE>
+		ErrorOr<void> reserve(size_type size)
-	typename HashMap<Key, T, HASH, STABLE>::size_type HashMap<Key, T, HASH, STABLE>::size() const
 		{
-		return m_size;
+			return m_hash_set.reserve(size);
 		}
 
-	template<typename Key, typename T, typename HASH, bool STABLE>
+		template<detail::HashMapFindable<Key, HASH, COMP> U>
-	ErrorOr<void> HashMap<Key, T, HASH, STABLE>::rebucket(size_type bucket_count)
+		T& operator[](const U& key)
 		{
-		if (m_buckets.size() >= bucket_count)
+			return find(key)->value;
-			return {};
+		}
 
-		size_type new_bucket_count = BAN::Math::max<size_type>(bucket_count, m_buckets.size() * 2);
+		template<detail::HashMapFindable<Key, HASH, COMP> U>
-		Vector<LinkedList<Entry>> new_buckets;
+		const T& operator[](const U& key) const
-		if (new_buckets.resize(new_bucket_count).is_error())
-			return Error::from_errno(ENOMEM);
-
-		if constexpr(STABLE)
 		{
-			// NOTE: We have to copy the old entries to the new entries and not move
+			return find(key)->value;
-			//       since we might run out of memory half way through.
+		}
-			for (auto& bucket : m_buckets)
+
+		template<detail::HashMapFindable<Key, HASH, COMP> U>
+		bool contains(const U& key) const
 		{
-				for (Entry& entry : bucket)
+			return find(key) != end();
+		}
+
+		size_type capacity() const
 		{
-					size_type bucket_index = HASH()(entry.key) % new_buckets.size();
+			return m_hash_set.capacity();
-					if constexpr(STABLE)
-						TRY(new_buckets[bucket_index].push_back(entry));
-					else
-						TRY(new_buckets[bucket_index].push_back(BAN::move(entry)));
-				}
-			}
 		}
 
-		m_buckets = move(new_buckets);
+		size_type size() const
-		return {};
-	}
-
-	template<typename Key, typename T, typename HASH, bool STABLE>
-	LinkedList<typename HashMap<Key, T, HASH, STABLE>::Entry>& HashMap<Key, T, HASH, STABLE>::get_bucket(const Key& key)
 		{
-		ASSERT(!m_buckets.empty());
+			return m_hash_set.size();
-		auto index = HASH()(key) % m_buckets.size();
-		return m_buckets[index];
 		}
 
-	template<typename Key, typename T, typename HASH, bool STABLE>
+		bool empty() const
-	const LinkedList<typename HashMap<Key, T, HASH, STABLE>::Entry>& HashMap<Key, T, HASH, STABLE>::get_bucket(const Key& key) const
 		{
-		ASSERT(!m_buckets.empty());
+			return m_hash_set.empty();
-		auto index = HASH()(key) % m_buckets.size();
-		return m_buckets[index];
 		}
 
-	// Unstable hash map moves values between container during rebucketing.
+	private:
-	// This means that if insertion to map fails, elements could be in invalid state
+		HashSet<Entry, EntryHash, EntryComp> m_hash_set;
-	// and that container is no longer usable. This is better if either way you are
+	};
-	// going to stop using the hash map after insertion fails.
-	template<typename Key, typename T, typename HASH = BAN::hash<Key>>
-	using HashMapUnstable = HashMap<Key, T, HASH, false>;
 
 }

BAN/include/BAN/HashSet.h

@@ -4,301 +4,356 @@
 #include <BAN/Hash.h>
 #include <BAN/Math.h>
 #include <BAN/Move.h>
-#include <BAN/Vector.h>
+#include <BAN/New.h>
 
 namespace BAN
 {
 
-	template<typename T, typename HASH>
+	template<typename HashSet, typename Bucket, typename T>
-	class HashSetIterator;
-
-	template<typename T, typename HASH = hash<T>>
-	class HashSet
-	{
-	public:
-		using value_type = T;
-		using size_type = hash_t;
-		using const_iterator = HashSetIterator<T, HASH>;
-		
-	public:
-		HashSet() = default;
-		HashSet(const HashSet<T, HASH>&);
-		HashSet(HashSet<T, HASH>&&);
-
-		HashSet<T, HASH>& operator=(const HashSet<T, HASH>&);
-		HashSet<T, HASH>& operator=(HashSet<T, HASH>&&);
-
-		ErrorOr<void> insert(const T&);
-		ErrorOr<void> insert(T&&);
-		void remove(const T&);
-		void clear();
-
-		ErrorOr<void> reserve(size_type);
-
-		const_iterator begin() const { return const_iterator(this, m_buckets.begin()); }
-		const_iterator end() const   { return const_iterator(this, m_buckets.end()); }
-
-		bool contains(const T&) const;
-
-		size_type size() const;
-		bool empty() const;
-
-	private:
-		ErrorOr<void> rebucket(size_type);
-		Vector<T>& get_bucket(const T&);
-		const Vector<T>& get_bucket(const T&) const;
-
-	private:
-		Vector<Vector<T>> m_buckets;
-		size_type m_size = 0;
-
-		friend class HashSetIterator<T, HASH>;
-	};
-
-	template<typename T, typename HASH>
 	class HashSetIterator
 	{
 	public:
 		HashSetIterator() = default;
-		HashSetIterator(const HashSetIterator<T, HASH>&);
 
-		HashSetIterator<T, HASH>& operator++();
+		const T& operator*() const
-		HashSetIterator<T, HASH> operator++(int);
-
-		const T& operator*() const;
-		const T* operator->() const;
-
-		bool operator==(const HashSetIterator<T, HASH>&) const;
-		bool operator!=(const HashSetIterator<T, HASH>&) const;
-
-		operator bool() const { return m_owner && m_current_bucket; }
-
-	private:
-		HashSetIterator(const HashSet<T, HASH>* owner, Vector<Vector<T>>::const_iterator bucket);
-		void find_next();
-
-	private:
-		const HashSet<T, HASH>*				m_owner = nullptr;
-		Vector<Vector<T>>::const_iterator	m_current_bucket;
-		Vector<T>::const_iterator			m_current_key;
-
-		friend class HashSet<T, HASH>;
-	};
-
-	template<typename T, typename HASH>
-	HashSet<T, HASH>::HashSet(const HashSet<T, HASH>& other)
-		: m_buckets(other.m_buckets)
-		, m_size(other.m_size)
 		{
+			ASSERT(m_bucket);
+			return *m_bucket->element();
 		}
 
-	template<typename T, typename HASH>
+		const T* operator->() const
-	HashSet<T, HASH>::HashSet(HashSet<T, HASH>&& other)
-		: m_buckets(move(other.m_buckets))
-		, m_size(other.m_size)
 		{
-		other.clear();
+			ASSERT(m_bucket);
+			return m_bucket->element();
 		}
 
-	template<typename T, typename HASH>
+		HashSetIterator& operator++()
-	HashSet<T, HASH>& HashSet<T, HASH>::operator=(const HashSet<T, HASH>& other)
 		{
-		clear();
+			ASSERT(m_bucket);
-		m_buckets = other.m_buckets;
+			m_bucket++;
-		m_size = other.m_size;
+			skip_to_valid_bucket();
 			return *this;
 		}
-
+		HashSetIterator operator++(int)
-	template<typename T, typename HASH>
-	HashSet<T, HASH>& HashSet<T, HASH>::operator=(HashSet<T, HASH>&& other)
-	{
-		clear();
-		m_buckets = move(other.m_buckets);
-		m_size = other.m_size;
-		other.clear();
-		return *this;
-	}
-
-	template<typename T, typename HASH>
-	ErrorOr<void> HashSet<T, HASH>::insert(const T& key)
-	{
-		return insert(move(T(key)));
-	}
-
-	template<typename T, typename HASH>
-	ErrorOr<void> HashSet<T, HASH>::insert(T&& key)
-	{
-		if (!empty() && get_bucket(key).contains(key))
-			return {};
-
-		TRY(rebucket(m_size + 1));
-		TRY(get_bucket(key).push_back(move(key)));
-		m_size++;
-		return {};
-	}
-
-	template<typename T, typename HASH>
-	void HashSet<T, HASH>::remove(const T& key)
-	{
-		if (empty()) return;
-		Vector<T>& bucket = get_bucket(key);
-		for (size_type i = 0; i < bucket.size(); i++)
-		{
-			if (bucket[i] == key)
-			{
-				bucket.remove(i);
-				m_size--;
-				break;
-			}	
-		}
-	}
-
-	template<typename T, typename HASH>
-	void HashSet<T, HASH>::clear()
-	{
-		m_buckets.clear();
-		m_size = 0;
-	}
-
-	template<typename T, typename HASH>
-	ErrorOr<void> HashSet<T, HASH>::reserve(size_type size)
-	{
-		TRY(rebucket(size));
-		return {};
-	}
-
-	template<typename T, typename HASH>
-	bool HashSet<T, HASH>::contains(const T& key) const
-	{
-		if (empty()) return false;
-		return get_bucket(key).contains(key);
-	}
-
-	template<typename T, typename HASH>
-	typename HashSet<T, HASH>::size_type HashSet<T, HASH>::size() const
-	{
-		return m_size;
-	}
-
-	template<typename T, typename HASH>
-	bool HashSet<T, HASH>::empty() const
-	{
-		return m_size == 0;
-	}
-
-	template<typename T, typename HASH>
-	ErrorOr<void> HashSet<T, HASH>::rebucket(size_type bucket_count)
-	{
-		if (m_buckets.size() >= bucket_count)
-			return {};
-
-		size_type new_bucket_count = BAN::Math::max<size_type>(bucket_count, m_buckets.size() * 2);
-		Vector<Vector<T>> new_buckets;
-		if (new_buckets.resize(new_bucket_count).is_error())
-			return Error::from_errno(ENOMEM);
-		
-		// NOTE: We have to copy the old keys to the new keys and not move
-		//       since we might run out of memory half way through.
-		for (Vector<T>& bucket : m_buckets)
-		{
-			for (T& key : bucket)
-			{
-				size_type bucket_index = HASH()(key) % new_buckets.size();
-				if (new_buckets[bucket_index].push_back(key).is_error())
-					return Error::from_errno(ENOMEM);
-			}
-		}
-
-		m_buckets = move(new_buckets);
-		return {};
-	}
-
-	template<typename T, typename HASH>
-	Vector<T>& HashSet<T, HASH>::get_bucket(const T& key)
-	{
-		ASSERT(!m_buckets.empty());
-		size_type index = HASH()(key) % m_buckets.size();
-		return m_buckets[index];
-	}
-
-	template<typename T, typename HASH>
-	const Vector<T>& HashSet<T, HASH>::get_bucket(const T& key) const
-	{
-		ASSERT(!m_buckets.empty());
-		size_type index = HASH()(key) % m_buckets.size();
-		return m_buckets[index];
-	}
-
-	template<typename T, typename HASH>
-	HashSetIterator<T, HASH>& HashSetIterator<T, HASH>::operator++()
-	{
-		ASSERT(*this);
-		if (m_current_key == m_current_bucket->end())
-			m_current_bucket++;
-		else
-			m_current_key++;
-		find_next();
-		return *this;
-	}
-
-	template<typename T, typename HASH>
-	HashSetIterator<T, HASH> HashSetIterator<T, HASH>::operator++(int)
 		{
 			auto temp = *this;
 			++(*this);
 			return temp;
 		}
 
-	template<typename T, typename HASH>
+		bool operator==(HashSetIterator other) const
-	const T& HashSetIterator<T, HASH>::operator*() const
 		{
-		ASSERT(m_owner && m_current_bucket && m_current_key);
+			return m_bucket == other.m_bucket;
-		return *m_current_key;
+		}
+		bool operator!=(HashSetIterator other) const
+		{
+			return m_bucket != other.m_bucket;
 		}
 
-	template<typename T, typename HASH>
+	private:
-	const T* HashSetIterator<T, HASH>::operator->() const
+		explicit HashSetIterator(Bucket* bucket)
+			: m_bucket(bucket)
 		{
-		return &**this;
+			if (m_bucket != nullptr)
+				skip_to_valid_bucket();
 		}
 
-	template<typename T, typename HASH>
+		void skip_to_valid_bucket()
-	bool HashSetIterator<T, HASH>::operator==(const HashSetIterator<T, HASH>& other) const
 		{
-		if (!m_owner || m_owner != other.m_owner)
+			while (m_bucket->state != Bucket::USED && !m_bucket->end)
-			return false;
+				m_bucket++;
-		return m_current_bucket == other.m_current_bucket
+			if (m_bucket->end)
-			&& m_current_key    == other.m_current_key;
+				m_bucket = nullptr;
 		}
 
-	template<typename T, typename HASH>
+	private:
-	bool HashSetIterator<T, HASH>::operator!=(const HashSetIterator<T, HASH>& other) const
+		Bucket* m_bucket { nullptr };
+		friend HashSet;
+	};
+
+	namespace detail
 	{
-		return !(*this == other);
+		template<typename T, typename U, typename HASH, typename COMP>
+		concept HashSetFindable = requires(const U& a, const T& b) { COMP()(a, b); HASH()(b); };
 	}
 
-	template<typename T, typename HASH>
+	template<typename T, typename HASH = BAN::hash<T>, typename COMP = BAN::equal<T>>
-	HashSetIterator<T, HASH>::HashSetIterator(const HashSet<T, HASH>* owner, Vector<Vector<T>>::const_iterator bucket)
+	class HashSet
-		: m_owner(owner)
-		, m_current_bucket(bucket)
 	{
-		if (m_current_bucket != m_owner->m_buckets.end())
+	private:
-			m_current_key = m_current_bucket->begin();
+		struct Bucket
-		find_next();
+		{
+			static constexpr uint8_t UNUSED  = 0;
+			static constexpr uint8_t USED    = 1;
+			static constexpr uint8_t REMOVED = 2;
+
+			alignas(T) uint8_t storage[sizeof(T)];
+			hash_t hash;
+			uint8_t state       : 2;
+			uint8_t chain_start : 1;
+			uint8_t end         : 1;
+
+			T* element() { return reinterpret_cast<T*>(storage); }
+			const T* element() const { return reinterpret_cast<const T*>(storage); }
+		};
+
+	public:
+		using value_type     = T;
+		using size_type      = size_t;
+		using iterator       = HashSetIterator<HashSet,       Bucket,       T>;
+		using const_iterator = HashSetIterator<HashSet, const Bucket, const T>;
+
+	public:
+		HashSet() = default;
+		~HashSet() { clear(); }
+
+		HashSet(const HashSet& other) { *this = other; }
+		HashSet& operator=(const HashSet& other)
+		{
+			clear();
+
+			MUST(reserve(other.size()));
+			for (auto& bucket : other)
+				MUST(insert(bucket));
+
+			return *this;
 		}
 
-	template<typename T, typename HASH>
+		HashSet(HashSet&& other) { *this = BAN::move(other); }
-	void HashSetIterator<T, HASH>::find_next()
+		HashSet& operator=(HashSet&& other)
 		{
-		ASSERT(m_owner && m_current_bucket);
+			clear();
-		while (m_current_bucket != m_owner->m_buckets.end())
+
+			m_buckets  = other.m_buckets;
+			m_capacity = other.m_capacity;
+			m_size     = other.m_size;
+			m_removed  = other.m_removed;
+
+			other.m_buckets  = nullptr;
+			other.m_capacity = 0;
+			other.m_size     = 0;
+			other.m_removed  = 0;
+
+			return *this;
+		}
+
+		iterator begin()             { return iterator(m_buckets); }
+		iterator end()               { return iterator(nullptr); }
+		const_iterator begin() const { return const_iterator(m_buckets); }
+		const_iterator end() const   { return const_iterator(nullptr); }
+
+		ErrorOr<iterator> insert(const T& value)
 		{
-			if (m_current_key && m_current_key != m_current_bucket->end())
+			return insert(T(value));
+		}
+
+		ErrorOr<iterator> insert(T&& value)
+		{
+			if (should_rehash_with_size(m_size + 1))
+				TRY(rehash(m_size * 2));
+			return insert_impl(BAN::move(value), HASH()(value));
+		}
+
+		template<detail::HashSetFindable<T, HASH, COMP> U>
+		void remove(const U& value)
+		{
+			if (auto it = find(value); it != end())
+				remove(it);
+		}
+
+		iterator remove(iterator it)
+		{
+			auto& bucket = *it.m_bucket;
+			bucket.element()->~T();
+			bucket.state = Bucket::REMOVED;
+			m_size--;
+			m_removed++;
+			return iterator(&bucket);
+		}
+
+		template<detail::HashSetFindable<T, HASH, COMP> U>
+		iterator find(const U& value)
+		{
+			return iterator(const_cast<Bucket*>(find_impl(value).m_bucket));
+		}
+
+		template<detail::HashSetFindable<T, HASH, COMP> U>
+		const_iterator find(const U& value) const
+		{
+			return find_impl(value);
+		}
+
+		void clear()
+		{
+			if (m_buckets == nullptr)
 				return;
-			m_current_bucket++;
+
-			m_current_key = m_current_bucket->begin();
+			for (size_type i = 0; i < m_capacity; i++)
-		}
+				if (m_buckets[i].state == Bucket::USED)
-		m_current_key = typename Vector<T>::const_iterator();
+					m_buckets[i].element()->~T();
+
+			BAN::deallocator(m_buckets);
+			m_buckets  = nullptr;
+			m_capacity = 0;
+			m_size     = 0;
+			m_removed  = 0;
 		}
 
+		ErrorOr<void> reserve(size_type size)
+		{
+			if (should_rehash_with_size(size))
+				TRY(rehash(size * 2));
+			return {};
+		}
+
+		template<detail::HashSetFindable<T, HASH, COMP> U>
+		bool contains(const U& value) const
+		{
+			return find(value) != end();
+		}
+
+		size_type capacity() const
+		{
+			return m_capacity;
+		}
+
+		size_type size() const
+		{
+			return m_size;
+		}
+
+		bool empty() const
+		{
+			return m_size == 0;
+		}
+
+	private:
+		ErrorOr<void> rehash(size_type new_capacity)
+		{
+			new_capacity = BAN::Math::max<size_t>(16, BAN::Math::max(new_capacity, m_size + 1));
+			new_capacity = BAN::Math::round_up_to_power_of_two(new_capacity);
+
+			void* new_buckets = BAN::allocator((new_capacity + 1) * sizeof(Bucket));
+			if (new_buckets == nullptr)
+				return BAN::Error::from_errno(ENOMEM);
+			memset(new_buckets, 0, (new_capacity + 1) * sizeof(Bucket));
+
+			Bucket* old_buckets = m_buckets;
+			const size_type old_capacity = m_capacity;
+
+			m_buckets  = static_cast<Bucket*>(new_buckets);
+			m_capacity = new_capacity;
+			m_size     = 0;
+			m_removed  = 0;
+
+			for (size_type i = 0; i < old_capacity; i++)
+			{
+				auto& old_bucket = old_buckets[i];
+				if (old_bucket.state != Bucket::USED)
+					continue;
+				insert_impl(BAN::move(*old_bucket.element()), old_bucket.hash);
+				old_bucket.element()->~T();
+			}
+
+			m_buckets[m_capacity].end = true;
+
+			BAN::deallocator(old_buckets);
+
+			return {};
+		}
+
+		template<detail::HashSetFindable<T, HASH, COMP> U>
+		const_iterator find_impl(const U& value) const
+		{
+			if (m_capacity == 0)
+				return end();
+
+			bool first = true;
+			const hash_t orig_hash = HASH()(value);
+			for (auto hash = orig_hash;; hash = get_next_hash_in_chain(hash, orig_hash), first = false)
+			{
+				auto& bucket = m_buckets[hash & (m_capacity - 1)];
+				if (bucket.state == Bucket::USED && bucket.hash == orig_hash && COMP()(*bucket.element(), value))
+					return const_iterator(&bucket);
+				if (bucket.state == Bucket::UNUSED)
+					return end();
+				if (!first && bucket.chain_start)
+					return end();
+			}
+		}
+
+		iterator insert_impl(T&& value, hash_t orig_hash)
+		{
+			ASSERT(!should_rehash_with_size(m_size + 1));
+
+			Bucket* target = nullptr;
+
+			bool first = true;
+			for (auto hash = orig_hash;; hash = get_next_hash_in_chain(hash, orig_hash), first = false)
+			{
+				auto& bucket = m_buckets[hash & (m_capacity - 1)];
+
+				if (!first)
+					bucket.chain_start = false;
+
+				if (bucket.state == Bucket::USED)
+				{
+					if (bucket.hash != orig_hash || !COMP()(*bucket.element(), value))
+						continue;
+					target = &bucket;
+					break;
+				}
+
+				if (target == nullptr)
+					target = &bucket;
+
+				if (bucket.state == Bucket::UNUSED)
+					break;
+			}
+
+			switch (target->state)
+			{
+				case Bucket::USED:
+					target->element()->~T();
+					break;
+				case Bucket::REMOVED:
+					m_removed--;
+					[[fallthrough]];
+				case Bucket::UNUSED:
+					m_size++;
+					break;
+			}
+
+			target->chain_start = first && target->state == Bucket::UNUSED;
+			target->hash = orig_hash;
+			target->state = Bucket::USED;
+
+			new (target->element()) T(BAN::move(value));
+
+			return iterator(target);
+		}
+
+		bool should_rehash_with_size(size_type size) const
+		{
+			if (m_capacity < 16)
+				return true;
+			if (size + m_removed > m_capacity / 4 * 3)
+				return true;
+			return false;
+		}
+
+		hash_t get_next_hash_in_chain(hash_t prev_hash, hash_t orig_hash) const
+		{
+			// TODO: does this even provide better performance than `return prev_hash + 1`
+			//       when using "good" hash functions
+			return prev_hash * 1103515245 + (orig_hash | 1);
+		}
+
+	private:
+		Bucket* m_buckets { nullptr };
+		size_type m_capacity { 0 };
+		size_type m_size     { 0 };
+		size_type m_removed  { 0 };
+	};
+
 }

BAN/include/BAN/Heap.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include <BAN/Iterators.h>
+#include <BAN/Swap.h>
+#include <BAN/Traits.h>
+
+namespace BAN
+{
+
+	namespace detail
+	{
+
+		template<typename It, typename Comp>
+		void heapify_up(It begin, size_t index, Comp comp)
+		{
+			size_t parent = (index - 1) / 2;
+			while (parent < index)
+			{
+				if (comp(*(begin + index), *(begin + parent)))
+					break;
+				swap(*(begin + parent), *(begin + index));
+				index = parent;
+				parent = (index - 1) / 2;
+			}
+		}
+
+		template<typename It, typename Comp>
+		void heapify_down(It begin, size_t index, size_t len, Comp comp)
+		{
+			for (;;)
+			{
+				const size_t lchild = 2 * index + 1;
+				const size_t rchild = 2 * index + 2;
+
+				size_t child = 0;
+				if (lchild < len && !comp(*(begin + lchild), *(begin + index)))
+				{
+					if (rchild < len && !comp(*(begin + rchild), *(begin + lchild)))
+						child = rchild;
+					else
+						child = lchild;
+				}
+				else if (rchild < len && !comp(*(begin + rchild), *(begin + index)))
+					child = rchild;
+				else
+					break;
+
+				swap(*(begin + child), *(begin + index));
+				index = child;
+			}
+		}
+
+	}
+
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
+	void make_heap(It begin, It end, Comp comp = {})
+	{
+		const size_t len = distance(begin, end);
+		if (len <= 1)
+			return;
+
+		size_t index = (len - 2) / 2;
+		while (index < len)
+			detail::heapify_down(begin, index--, len, comp);
+	}
+
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
+	void push_heap(It begin, It end, Comp comp = {})
+	{
+		const size_t len = distance(begin, end);
+		detail::heapify_up(begin, len - 1, comp);
+	}
+
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
+	void pop_heap(It begin, It end, Comp comp = {})
+	{
+		const size_t len = distance(begin, end);
+		swap(*begin, *(begin + len - 1));
+		detail::heapify_down(begin, 0, len - 1, comp);
+	}
+
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
+	void sort_heap(It begin, It end, Comp comp = {})
+	{
+		while (begin != end)
+			pop_heap(begin, end--, comp);
+	}
+
+}

BAN/include/BAN/IPv4.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <BAN/Endianness.h>
+#include <BAN/Formatter.h>
+#include <BAN/Hash.h>
+
+namespace BAN
+{
+
+	struct IPv4Address
+	{
+		constexpr IPv4Address()
+			: IPv4Address(0)
+		{ }
+
+		constexpr IPv4Address(uint32_t u32_address)
+		{
+			raw = u32_address;
+		}
+
+		constexpr IPv4Address(uint8_t oct1, uint8_t oct2, uint8_t oct3, uint8_t oct4)
+		{
+			octets[0] = oct1;
+			octets[1] = oct2;
+			octets[2] = oct3;
+			octets[3] = oct4;
+		}
+
+		constexpr bool operator==(const IPv4Address& other) const
+		{
+			return raw == other.raw;
+		}
+
+		constexpr IPv4Address mask(const IPv4Address& other) const
+		{
+			return IPv4Address(raw & other.raw);
+		}
+
+		union
+		{
+			uint8_t octets[4];
+			uint32_t raw;
+		} __attribute__((packed));
+	};
+	static_assert(sizeof(IPv4Address) == 4);
+
+	template<>
+	struct hash<IPv4Address>
+	{
+		constexpr hash_t operator()(IPv4Address ipv4) const
+		{
+			return hash<uint32_t>()(ipv4.raw);
+		}
+	};
+
+}
+
+namespace BAN::Formatter
+{
+
+	template<typename F>
+	void print_argument(F putc, const IPv4Address& ipv4, const ValueFormat&)
+	{
+		ValueFormat format {
+			.base = 10,
+			.percision = 0,
+			.fill = 0,
+			.upper = false,
+		};
+
+		print_argument(putc, ipv4.octets[0], format);
+		for (size_t i = 1; i < 4; i++)
+		{
+			putc('.');
+			print_argument(putc, ipv4.octets[i], format);
+		}
+	}
+
+}

BAN/include/BAN/Iterators.h

@@ -3,11 +3,13 @@
 #include <BAN/Assert.h>
 #include <BAN/Traits.h>
 
+#include <stddef.h>
+
 namespace BAN
 {
 
 	template<typename It>
-	It next(It it, size_t count)
+	constexpr It next(It it, size_t count)
 	{
 		for (size_t i = 0; i < count; i++)
 			++it;
@@ -16,13 +18,13 @@ namespace BAN
 
 	template<typename It>
 	requires requires(It it, size_t n) { requires is_same_v<decltype(it + n), It>; }
-	It next(It it, size_t count)
+	constexpr It next(It it, size_t count)
 	{
 		return it + count;
 	}
 
 	template<typename It>
-	It prev(It it, size_t count)
+	constexpr It prev(It it, size_t count)
 	{
 		for (size_t i = 0; i < count; i++)
 			--it;
@@ -31,13 +33,13 @@ namespace BAN
 
 	template<typename It>
 	requires requires(It it, size_t n) { requires is_same_v<decltype(it - n), It>; }
-	It prev(It it, size_t count)
+	constexpr It prev(It it, size_t count)
 	{
 		return it - count;
 	}
 
 	template<typename It>
-	size_t distance(It it1, It it2)
+	constexpr size_t distance(It it1, It it2)
 	{
 		size_t dist = 0;
 		while (it1 != it2)
@@ -50,7 +52,7 @@ namespace BAN
 
 	template<typename It>
 	requires requires(It it1, It it2) { requires is_integral_v<decltype(it2 - it1)>; }
-	size_t distance(It it1, It it2)
+	constexpr size_t distance(It it1, It it2)
 	{
 		return it2 - it1;
 	}
@@ -62,106 +64,117 @@ namespace BAN
 		using value_type = T;
 
 	public:
-		IteratorSimpleGeneral() = default;
+		constexpr IteratorSimpleGeneral() = default;
 		template<bool CONST2, typename = enable_if_t<CONST2 == CONST || CONST>>
-		IteratorSimpleGeneral(const IteratorSimpleGeneral<T, Container, CONST2>& other)
+		constexpr IteratorSimpleGeneral(const IteratorSimpleGeneral<T, Container, CONST2>& other)
 			: m_pointer(other.m_pointer)
+			, m_valid(other.m_valid)
 		{
 		}
 
-		const T& operator*() const
+		constexpr const T& operator*() const
 		{
 			ASSERT(m_pointer);
 			return *m_pointer;
 		}
 		template<bool CONST2 = CONST>
-		enable_if_t<!CONST2, T&> operator*()
+		constexpr enable_if_t<!CONST2, T&> operator*()
 		{
+			ASSERT(*this);
 			ASSERT(m_pointer);
 			return *m_pointer;
 		}
 
-		const T* operator->() const
+		constexpr const T* operator->() const
 		{
+			ASSERT(*this);
 			ASSERT(m_pointer);
 			return m_pointer;
 		}
 		template<bool CONST2 = CONST>
-		enable_if_t<!CONST2, T*> operator->()
+		constexpr enable_if_t<!CONST2, T*> operator->()
 		{
+			ASSERT(*this);
 			ASSERT(m_pointer);
 			return m_pointer;
 		}
 
-		IteratorSimpleGeneral& operator++()
+		constexpr IteratorSimpleGeneral& operator++()
 		{
+			ASSERT(*this);
 			ASSERT(m_pointer);
 			++m_pointer;
 			return *this;
 		}
-		IteratorSimpleGeneral operator++(int)
+		constexpr IteratorSimpleGeneral operator++(int)
 		{
 			auto temp = *this;
 			++(*this);
 			return temp;
 		}
 
-		IteratorSimpleGeneral& operator--()
+		constexpr IteratorSimpleGeneral& operator--()
 		{
+			ASSERT(*this);
 			ASSERT(m_pointer);
 			--m_pointer;
 			return *this;
 		}
-		IteratorSimpleGeneral operator--(int)
+		constexpr IteratorSimpleGeneral operator--(int)
 		{
 			auto temp = *this;
 			--(*this);
 			return temp;
 		}
 
-		size_t operator-(const IteratorSimpleGeneral& other) const
+		constexpr size_t operator-(const IteratorSimpleGeneral& other) const
 		{
-			ASSERT(m_pointer);
+			ASSERT(*this && other);
 			return m_pointer - other.m_pointer;
 		}
 
-		IteratorSimpleGeneral operator+(size_t offset) const
+		constexpr IteratorSimpleGeneral operator+(size_t offset) const
 		{
 			return IteratorSimpleGeneral(m_pointer + offset);
 		}
 
-		IteratorSimpleGeneral operator-(size_t offset) const
+		constexpr IteratorSimpleGeneral operator-(size_t offset) const
 		{
 			return IteratorSimpleGeneral(m_pointer - offset);
 		}
 
-		bool operator<(const IteratorSimpleGeneral& other) const
+		constexpr bool operator<(const IteratorSimpleGeneral& other) const
 		{
+			ASSERT(*this);
 			return m_pointer < other.m_pointer;
 		}
 
-		bool operator==(const IteratorSimpleGeneral& other) const
+		constexpr bool operator==(const IteratorSimpleGeneral& other) const
 		{
+			ASSERT(*this);
 			return m_pointer == other.m_pointer;
 		}
-		bool operator!=(const IteratorSimpleGeneral& other) const
+		constexpr bool operator!=(const IteratorSimpleGeneral& other) const
 		{
+			ASSERT(*this);
 			return !(*this == other);
 		}
 
-		explicit operator bool() const
+		constexpr explicit operator bool() const
 		{
-			return m_pointer;
+			return m_valid;
 		}
 
 	private:
-		IteratorSimpleGeneral(maybe_const_t<CONST, T>* pointer)
+		constexpr IteratorSimpleGeneral(maybe_const_t<CONST, T>* pointer)
 			: m_pointer(pointer)
+			, m_valid(true)
 		{
 		}
 
 	private:
 		maybe_const_t<CONST, T>* m_pointer = nullptr;
+		bool m_valid = false;
 
 		friend IteratorSimpleGeneral<T, Container, !CONST>;
 		friend Container;
@@ -180,16 +193,16 @@ namespace BAN
 		using value_type = T;
 
 	public:
-		IteratorDoubleGeneral() = default;
+		constexpr IteratorDoubleGeneral() = default;
 		template<bool CONST2, typename = enable_if_t<CONST2 == CONST || CONST>>
-		IteratorDoubleGeneral(const IteratorDoubleGeneral<T, OuterContainer, InnerContainer, Container, CONST2>& other)
+		constexpr IteratorDoubleGeneral(const IteratorDoubleGeneral<T, OuterContainer, InnerContainer, Container, CONST2>& other)
 			: m_outer_end(other.m_outer_end)
 			, m_outer_current(other.m_outer_current)
 			, m_inner_current(other.m_inner_current)
 		{
 		}
 
-		const T& operator*() const
+		constexpr const T& operator*() const
 		{
 			ASSERT(*this);
 			ASSERT(m_outer_current != m_outer_end);
@@ -197,7 +210,7 @@ namespace BAN
 			return m_inner_current.operator*();
 		}
 		template<bool CONST2 = CONST>
-		enable_if_t<!CONST2, T&> operator*()
+		constexpr enable_if_t<!CONST2, T&> operator*()
 		{
 			ASSERT(*this);
 			ASSERT(m_outer_current != m_outer_end);
@@ -205,7 +218,7 @@ namespace BAN
 			return m_inner_current.operator*();
 		}
 
-		const T* operator->() const
+		constexpr const T* operator->() const
 		{
 			ASSERT(*this);
 			ASSERT(m_outer_current != m_outer_end);
@@ -213,7 +226,7 @@ namespace BAN
 			return m_inner_current.operator->();
 		}
 		template<bool CONST2 = CONST>
-		enable_if_t<!CONST2, T*> operator->()
+		constexpr enable_if_t<!CONST2, T*> operator->()
 		{
 			ASSERT(*this);
 			ASSERT(m_outer_current != m_outer_end);
@@ -221,7 +234,7 @@ namespace BAN
 			return m_inner_current.operator->();
 		}
 
-		IteratorDoubleGeneral& operator++()
+		constexpr IteratorDoubleGeneral& operator++()
 		{
 			ASSERT(*this);
 			ASSERT(m_outer_current != m_outer_end);
@@ -230,37 +243,37 @@ namespace BAN
 			find_valid_or_end();
 			return *this;
 		}
-		IteratorDoubleGeneral operator++(int)
+		constexpr IteratorDoubleGeneral operator++(int)
 		{
 			auto temp = *this;
 			++(*this);
 			return temp;
 		}
 
-		bool operator==(const IteratorDoubleGeneral& other) const
+		constexpr bool operator==(const IteratorDoubleGeneral& other) const
 		{
-			if (!*this || !other)
+			ASSERT(*this && other);
-				return false;
 			if (m_outer_end != other.m_outer_end)
 				return false;
 			if (m_outer_current != other.m_outer_current)
 				return false;
 			if (m_outer_current == m_outer_end)
 				return true;
+			ASSERT(m_inner_current && other.m_inner_current);
 			return m_inner_current == other.m_inner_current;
 		}
-		bool operator!=(const IteratorDoubleGeneral& other) const
+		constexpr bool operator!=(const IteratorDoubleGeneral& other) const
 		{
 			return !(*this == other);
 		}
 
-		explicit operator bool() const
+		constexpr explicit operator bool() const
 		{
-			return m_outer_end && m_outer_current;
+			return !!m_outer_current;
 		}
 
 	private:
-		IteratorDoubleGeneral(const OuterIterator& outer_end, const OuterIterator& outer_current)
+		constexpr IteratorDoubleGeneral(const OuterIterator& outer_end, const OuterIterator& outer_current)
 			: m_outer_end(outer_end)
 			, m_outer_current(outer_current)
 		{
@@ -271,7 +284,15 @@ namespace BAN
 			}
 		}
 
-		void find_valid_or_end()
+		constexpr IteratorDoubleGeneral(const OuterIterator& outer_end, const OuterIterator& outer_current, const InnerIterator& inner_current)
+			: m_outer_end(outer_end)
+			, m_outer_current(outer_current)
+			, m_inner_current(inner_current)
+		{
+			find_valid_or_end();
+		}
+
+		constexpr void find_valid_or_end()
 		{
 			while (m_inner_current == m_outer_current->end())
 			{
@@ -282,6 +303,9 @@ namespace BAN
 			}
 		}
 
+		constexpr OuterIterator outer_current() { return m_outer_current; }
+		constexpr InnerIterator inner_current() { return m_inner_current; }
+
 	private:
 		OuterIterator m_outer_end;
 		OuterIterator m_outer_current;

BAN/include/BAN/Limits.h

@@ -0,0 +1,156 @@
+#pragma once
+
+#include <BAN/Traits.h>
+
+#include <stdint.h>
+
+namespace BAN
+{
+
+	template<typename T>
+	class numeric_limits
+	{
+	public:
+		numeric_limits() = delete;
+
+		static inline constexpr T max()
+		{
+			if constexpr(is_same_v<T, char>)
+				return __SCHAR_MAX__;
+			if constexpr(is_same_v<T, signed char>)
+				return __SCHAR_MAX__;
+			if constexpr(is_same_v<T, unsigned char>)
+				return (T)__SCHAR_MAX__ * 2 + 1;
+
+			if constexpr(is_same_v<T, short>)
+				return __SHRT_MAX__;
+			if constexpr(is_same_v<T, int>)
+				return __INT_MAX__;
+			if constexpr(is_same_v<T, long>)
+				return __LONG_MAX__;
+			if constexpr(is_same_v<T, long long>)
+				return __LONG_LONG_MAX__;
+
+			if constexpr(is_same_v<T, unsigned short>)
+				return (T)__SHRT_MAX__ * 2 + 1;
+			if constexpr(is_same_v<T, unsigned int>)
+				return (T)__INT_MAX__ * 2 + 1;
+			if constexpr(is_same_v<T, unsigned long>)
+				return (T)__LONG_MAX__ * 2 + 1;
+			if constexpr(is_same_v<T, unsigned long long>)
+				return (T)__LONG_LONG_MAX__ * 2 + 1;
+
+			if constexpr(is_same_v<T, float>)
+				return __FLT_MAX__;
+			if constexpr(is_same_v<T, double>)
+				return __DBL_MAX__;
+			if constexpr(is_same_v<T, long double>)
+				return __LDBL_MAX__;
+		}
+
+		static inline constexpr T min()
+		{
+			if constexpr(is_signed_v<T> && is_integral_v<T>)
+				return -max() - 1;
+
+			if constexpr(is_unsigned_v<T> && is_integral_v<T>)
+				return 0;
+
+			if constexpr(is_same_v<T, float>)
+				return __FLT_MIN__;
+			if constexpr(is_same_v<T, double>)
+				return __DBL_MIN__;
+			if constexpr(is_same_v<T, long double>)
+				return __LDBL_MIN__;
+		}
+
+		static inline constexpr bool has_infinity()
+		{
+			if constexpr(is_same_v<T, float>)
+				return __FLT_HAS_INFINITY__;
+			if constexpr(is_same_v<T, double>)
+				return __DBL_HAS_INFINITY__;
+			if constexpr(is_same_v<T, long double>)
+				return __LDBL_HAS_INFINITY__;
+			return false;
+		}
+
+		static inline constexpr T infinity() requires(has_infinity())
+		{
+			if constexpr(is_same_v<T, float>)
+				return __builtin_inff();
+			if constexpr(is_same_v<T, double>)
+				return __builtin_inf();
+			if constexpr(is_same_v<T, long double>)
+				return __builtin_infl();
+		}
+
+		static inline constexpr bool has_quiet_NaN()
+		{
+			if constexpr(is_same_v<T, float>)
+				return __FLT_HAS_QUIET_NAN__;
+			if constexpr(is_same_v<T, double>)
+				return __DBL_HAS_QUIET_NAN__;
+			if constexpr(is_same_v<T, long double>)
+				return __LDBL_HAS_QUIET_NAN__;
+			return false;
+		}
+
+		static inline constexpr T quiet_NaN() requires(has_quiet_NaN())
+		{
+			if constexpr(is_same_v<T, float>)
+				return __builtin_nanf("");
+			if constexpr(is_same_v<T, double>)
+				return __builtin_nan("");
+			if constexpr(is_same_v<T, long double>)
+				return __builtin_nanl("");
+		}
+
+		static inline constexpr int max_exponent2()
+		{
+			static_assert(__FLT_RADIX__ == 2);
+			if constexpr(is_same_v<T, float>)
+				return __FLT_MAX_EXP__;
+			if constexpr(is_same_v<T, double>)
+				return __DBL_MAX_EXP__;
+			if constexpr(is_same_v<T, long double>)
+				return __LDBL_MAX_EXP__;
+			return 0;
+		}
+
+		static inline constexpr int max_exponent10()
+		{
+			if constexpr(is_same_v<T, float>)
+				return __FLT_MAX_10_EXP__;
+			if constexpr(is_same_v<T, double>)
+				return __DBL_MAX_10_EXP__;
+			if constexpr(is_same_v<T, long double>)
+				return __LDBL_MAX_10_EXP__;
+			return 0;
+		}
+
+		static inline constexpr int min_exponent2()
+		{
+			static_assert(__FLT_RADIX__ == 2);
+			if constexpr(is_same_v<T, float>)
+				return __FLT_MIN_EXP__;
+			if constexpr(is_same_v<T, double>)
+				return __DBL_MIN_EXP__;
+			if constexpr(is_same_v<T, long double>)
+				return __LDBL_MIN_EXP__;
+			return 0;
+		}
+
+		static inline constexpr int min_exponent10()
+		{
+			if constexpr(is_same_v<T, float>)
+				return __FLT_MIN_10_EXP__;
+			if constexpr(is_same_v<T, double>)
+				return __DBL_MIN_10_EXP__;
+			if constexpr(is_same_v<T, long double>)
+				return __LDBL_MIN_10_EXP__;
+			return 0;
+		}
+	};
+
+}

BAN/include/BAN/LinkedList.h

@@ -3,6 +3,7 @@
 #include <BAN/Errors.h>
 #include <BAN/Move.h>
 #include <BAN/New.h>
+#include <BAN/PlacementNew.h>
 
 namespace BAN
 {
@@ -21,11 +22,11 @@ namespace BAN
 
 	public:
 		LinkedList() = default;
-		LinkedList(const LinkedList<T>& other)	{ *this = other; }
+		LinkedList(const LinkedList<T>& other) requires is_copy_constructible_v<T> { *this = other; }
 		LinkedList(LinkedList<T>&& other)		{ *this = move(other); }
 		~LinkedList()							{ clear(); }
 
-		LinkedList<T>& operator=(const LinkedList<T>&);
+		LinkedList<T>& operator=(const LinkedList<T>&) requires is_copy_constructible_v<T>;
 		LinkedList<T>& operator=(LinkedList<T>&&);
 
 		ErrorOr<void> push_back(const T&);
@@ -33,14 +34,16 @@ namespace BAN
 		ErrorOr<void> insert(iterator, const T&);
 		ErrorOr<void> insert(iterator, T&&);
 		template<typename... Args>
-		ErrorOr<void> emplace_back(Args&&...);
+		ErrorOr<void> emplace_back(Args&&...) requires is_constructible_v<T, Args...>;
 		template<typename... Args>
-		ErrorOr<void> emplace(iterator, Args&&...);
+		ErrorOr<void> emplace(iterator, Args&&...) requires is_constructible_v<T, Args...>;
 
 		void pop_back();
 		iterator remove(iterator);
 		void clear();
 
+		iterator move_element_to_other_linked_list(LinkedList& dest_list, iterator dest_iter, iterator src_iter);
+
 		iterator begin()				{ return iterator(m_data, empty()); }
 		const_iterator begin() const	{ return const_iterator(m_data, empty()); }
 		iterator end()					{ return iterator(m_last, true); }
@@ -64,7 +67,11 @@ namespace BAN
 			Node* prev;
 		};
 
-		ErrorOr<Node*> allocate_node() const;
+		template<typename... Args>
+		ErrorOr<Node*> allocate_node(Args&&...) const;
+
+		Node* remove_node(iterator);
+		void insert_node(iterator, Node*);
 
 		Node* m_data = nullptr;
 		Node* m_last = nullptr;
@@ -115,7 +122,7 @@ namespace BAN
 	};
 
 	template<typename T>
-	LinkedList<T>& LinkedList<T>::operator=(const LinkedList<T>& other)
+	LinkedList<T>& LinkedList<T>::operator=(const LinkedList<T>& other) requires is_copy_constructible_v<T>
 	{
 		clear();
 		for (const T& elem : other)
@@ -136,6 +143,31 @@ namespace BAN
 		return *this;
 	}
 
+	template<typename T>
+	LinkedList<T>::Node* LinkedList<T>::remove_node(iterator iter)
+	{
+		ASSERT(!empty() && iter);
+		Node* node = iter.m_current;
+		Node* prev = node->prev;
+		Node* next = node->next;
+		(prev ? prev->next : m_data) = next;
+		(next ? next->prev : m_last) = prev;
+		m_size--;
+		return node;
+	}
+
+	template<typename T>
+	void LinkedList<T>::insert_node(iterator iter, Node* node)
+	{
+		Node* next = iter.m_past_end ? nullptr : iter.m_current;
+		Node* prev = next ? next->prev : m_last;
+		node->next = next;
+		node->prev = prev;
+		(prev ? prev->next : m_data) = node;
+		(next ? next->prev : m_last) = node;
+		m_size++;
+	}
+
 	template<typename T>
 	ErrorOr<void> LinkedList<T>::push_back(const T& value)
 	{
@@ -157,44 +189,31 @@ namespace BAN
 	template<typename T>
 	ErrorOr<void> LinkedList<T>::insert(iterator iter, T&& value)
 	{
-		Node* next = iter.m_past_end ? nullptr : iter.m_current;
+		Node* new_node = TRY(allocate_node(move(value)));
-		Node* prev = next ? next->prev : m_last;
+		insert_node(iter, new_node);
-		Node* new_node = TRY(allocate_node());
-		new (&new_node->value) T(move(value));
-		new_node->next = next;
-		new_node->prev = prev;
-		(prev ? prev->next : m_data) = new_node;
-		(next ? next->prev : m_last) = new_node;
-		m_size++;
 		return {};
 	}
 
 	template<typename T>
 	template<typename... Args>
-	ErrorOr<void> LinkedList<T>::emplace_back(Args&&... args)
+	ErrorOr<void> LinkedList<T>::emplace_back(Args&&... args) requires is_constructible_v<T, Args...>
 	{
 		return emplace(end(), forward<Args>(args)...);
 	}
 
 	template<typename T>
 	template<typename... Args>
-	ErrorOr<void> LinkedList<T>::emplace(iterator iter, Args&&... args)
+	ErrorOr<void> LinkedList<T>::emplace(iterator iter, Args&&... args) requires is_constructible_v<T, Args...>
 	{
-		Node* next = iter.m_past_end ? nullptr : iter.m_current;
+		Node* new_node = TRY(allocate_node(forward<Args>(args)...));
-		Node* prev = next ? next->prev : m_last;
+		insert_node(iter, new_node);
-		Node* new_node = TRY(allocate_node());
-		new (&new_node->value) T(forward<Args>(args)...);
-		new_node->next = next;
-		new_node->prev = prev;
-		(prev ? prev->next : m_data) = new_node;
-		(next ? next->prev : m_last) = new_node;
-		m_size++;
 		return {};
 	}
 
 	template<typename T>
 	void LinkedList<T>::pop_back()
 	{
+		ASSERT(!empty());
 		remove(iterator(m_last, false));
 	}
 
@@ -202,14 +221,10 @@ namespace BAN
 	LinkedList<T>::iterator LinkedList<T>::remove(iterator iter)
 	{
 		ASSERT(!empty() && iter);
-		Node* node = iter.m_current;
+		Node* node = remove_node(iter);
-		Node* prev = node->prev;
 		Node* next = node->next;
 		node->value.~T();
 		BAN::deallocator(node);
-		(prev ? prev->next : m_data) = next;
-		(next ? next->prev : m_last) = prev;
-		m_size--;
 		return next ? iterator(next, false) : iterator(m_last, true);
 	}
 
@@ -229,6 +244,16 @@ namespace BAN
 		m_size = 0;
 	}
 
+	template<typename T>
+	LinkedList<T>::iterator LinkedList<T>::move_element_to_other_linked_list(LinkedList& dest_list, iterator dest_iter, iterator src_iter)
+	{
+		ASSERT(!empty() && src_iter);
+		Node* node = remove_node(src_iter);
+		iterator ret = node->next ? iterator(node->next, false) : iterator(m_last, true);
+		dest_list.insert_node(dest_iter, node);
+		return ret;
+	}
+
 	template<typename T>
 	const T& LinkedList<T>::back() const
 	{
@@ -283,11 +308,13 @@ namespace BAN
 	}
 
 	template<typename T>
-	ErrorOr<typename LinkedList<T>::Node*> LinkedList<T>::allocate_node() const
+	template<typename... Args>
+	ErrorOr<typename LinkedList<T>::Node*> LinkedList<T>::allocate_node(Args&&... args) const
 	{
 		Node* node = (Node*)BAN::allocator(sizeof(Node));
 		if (node == nullptr)
 			return Error::from_errno(ENOMEM);
+		new (&node->value) T(forward<Args>(args)...);
 		return node;
 	}
 

BAN/include/BAN/MAC.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <BAN/Formatter.h>
+
+namespace BAN
+{
+
+	struct MACAddress
+	{
+		uint8_t address[6];
+
+		constexpr bool operator==(const MACAddress& other) const
+		{
+			return
+				address[0] == other.address[0] &&
+				address[1] == other.address[1] &&
+				address[2] == other.address[2] &&
+				address[3] == other.address[3] &&
+				address[4] == other.address[4] &&
+				address[5] == other.address[5];
+		}
+	};
+
+}
+
+namespace BAN::Formatter
+{
+
+	template<typename F>
+	void print_argument(F putc, const MACAddress& mac, const ValueFormat&)
+	{
+		ValueFormat format {
+			.base = 16,
+			.percision = 0,
+			.fill = 2,
+			.upper = true,
+		};
+
+		print_argument(putc, mac.address[0], format);
+		for (size_t i = 1; i < 6; i++)
+		{
+			putc(':');
+			print_argument(putc, mac.address[i], format);
+		}
+	}
+
+}

BAN/include/BAN/MacroUtils.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#define _ban_count_args_impl(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, ...) _9
+#define _ban_count_args(...) _ban_count_args_impl(__VA_ARGS__ __VA_OPT__(,) 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+
+#define _ban_concat_impl(a, b) a##b
+#define _ban_concat(a, b) _ban_concat_impl(a, b)
+
+#define _ban_stringify_impl(x) #x
+#define _ban_stringify(x) _ban_stringify_impl(x)
+
+#define _ban_fe_0(f)
+#define _ban_fe_1(f, _0)                                 f(0, _0)
+#define _ban_fe_2(f, _0, _1)                             f(0, _0) f(1, _1)
+#define _ban_fe_3(f, _0, _1, _2)                         f(0, _0) f(1, _1) f(2, _2)
+#define _ban_fe_4(f, _0, _1, _2, _3)                     f(0, _0) f(1, _1) f(2, _2) f(3, _3)
+#define _ban_fe_5(f, _0, _1, _2, _3, _4)                 f(0, _0) f(1, _1) f(2, _2) f(3, _3) f(4, _4)
+#define _ban_fe_6(f, _0, _1, _2, _3, _4, _5)             f(0, _0) f(1, _1) f(2, _2) f(3, _3) f(4, _4) f(5, _5)
+#define _ban_fe_7(f, _0, _1, _2, _3, _4, _5, _6)         f(0, _0) f(1, _1) f(2, _2) f(3, _3) f(4, _4) f(5, _5) f(6, _6)
+#define _ban_fe_8(f, _0, _1, _2, _3, _4, _5, _6, _7)     f(0, _0) f(1, _1) f(2, _2) f(3, _3) f(4, _4) f(5, _5) f(6, _6) f(7, _7)
+#define _ban_fe_9(f, _0, _1, _2, _3, _4, _5, _6, _7, _8) f(0, _0) f(1, _1) f(2, _2) f(3, _3) f(4, _4) f(5, _5) f(6, _6) f(7, _7) f(8, _8)
+#define _ban_for_each(f, ...) _ban_concat(_ban_fe_, _ban_count_args(__VA_ARGS__))(f __VA_OPT__(,) __VA_ARGS__)
+
+#define _ban_fe_comma_0(f)
+#define _ban_fe_comma_1(f, _0)                                 f(0, _0)
+#define _ban_fe_comma_2(f, _0, _1)                             f(0, _0), f(1, _1)
+#define _ban_fe_comma_3(f, _0, _1, _2)                         f(0, _0), f(1, _1), f(2, _2)
+#define _ban_fe_comma_4(f, _0, _1, _2, _3)                     f(0, _0), f(1, _1), f(2, _2), f(3, _3)
+#define _ban_fe_comma_5(f, _0, _1, _2, _3, _4)                 f(0, _0), f(1, _1), f(2, _2), f(3, _3), f(4, _4)
+#define _ban_fe_comma_6(f, _0, _1, _2, _3, _4, _5)             f(0, _0), f(1, _1), f(2, _2), f(3, _3), f(4, _4), f(5, _5)
+#define _ban_fe_comma_7(f, _0, _1, _2, _3, _4, _5, _6)         f(0, _0), f(1, _1), f(2, _2), f(3, _3), f(4, _4), f(5, _5), f(6, _6)
+#define _ban_fe_comma_8(f, _0, _1, _2, _3, _4, _5, _6, _7)     f(0, _0), f(1, _1), f(2, _2), f(3, _3), f(4, _4), f(5, _5), f(6, _6), f(7, _7)
+#define _ban_fe_comma_9(f, _0, _1, _2, _3, _4, _5, _6, _7, _8) f(0, _0), f(1, _1), f(2, _2), f(3, _3), f(4, _4), f(5, _5), f(6, _6), f(7, _7), f(8, _8)
+#define _ban_for_each_comma(f, ...) _ban_concat(_ban_fe_comma_, _ban_count_args(__VA_ARGS__))(f __VA_OPT__(,) __VA_ARGS__)
+
+#define _ban_get_0(a0, ...)                                     a0
+#define _ban_get_1(a0, a1, ...)                                 a1
+#define _ban_get_2(a0, a1, a2, ...)                             a2
+#define _ban_get_3(a0, a1, a2, a3, ...)                         a3
+#define _ban_get_4(a0, a1, a2, a3, a4, ...)                     a4
+#define _ban_get_5(a0, a1, a2, a3, a4, a5, ...)                 a5
+#define _ban_get_6(a0, a1, a2, a3, a4, a5, a6, ...)             a6
+#define _ban_get_7(a0, a1, a2, a3, a4, a5, a6, a7, ...)         a7
+#define _ban_get_8(a0, a1, a2, a3, a4, a5, a6, a7, a8, ...)     a8
+#define _ban_get_9(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, ...) a9
+#define _ban_get(n, ...) _ban_concat(_ban_get_, n)(__VA_ARGS__)

BAN/include/BAN/Math.h

@@ -1,13 +1,20 @@
 #pragma once
 
+#include <BAN/Limits.h>
+#include <BAN/Numbers.h>
 #include <BAN/Traits.h>
 
-#include <stddef.h>
+#include <float.h>
-#include <stdint.h>
 
 namespace BAN::Math
 {
 
+	template<typename T>
+	inline constexpr T abs(T x)
+	{
+		return x < 0 ? -x : x;
+	}
+
 	template<typename T>
 	inline constexpr T min(T a, T b)
 	{
@@ -29,12 +36,11 @@ namespace BAN::Math
 	template<integral T>
 	inline constexpr T gcd(T a, T b)
 	{
-		T t;
 		while (b)
 		{
-			t = b;
+			T temp = b;
 			b = a % b;
-			a = t;
+			a = temp;
 		}
 		return a;
 	}
@@ -52,65 +58,424 @@ namespace BAN::Math
 	}
 
 	template<integral T>
-	inline constexpr bool is_power_of_two(T value)
+	inline constexpr bool is_power_of_two(T x)
 	{
-		if (value == 0)
+		if (x == 0)
 			return false;
-		return (value & (value - 1)) == 0;
+		return (x & (x - 1)) == 0;
+	}
+
+	template<integral T> requires(sizeof(T) <= 8)
+	inline constexpr T round_up_to_power_of_two(T x)
+	{
+		x--;
+		x |= x >> 1;
+		x |= x >> 2;
+		x |= x >> 4;
+		if constexpr(sizeof(T) >= 2)
+			x |= x >> 8;
+		if constexpr(sizeof(T) >= 4)
+			x |= x >> 16;
+		if constexpr(sizeof(T) >= 8)
+			x |= x >> 32;
+		return x + 1;
+	}
+
+	template<integral T>
+	__attribute__((always_inline))
+	inline constexpr bool will_multiplication_overflow(T a, T b)
+	{
+		T dummy;
+		return __builtin_mul_overflow(a, b, &dummy);
+	}
+
+	template<integral T>
+	__attribute__((always_inline))
+	inline constexpr bool will_addition_overflow(T a, T b)
+	{
+		T dummy;
+		return __builtin_add_overflow(a, b, &dummy);
 	}
 
 	template<typename T>
 	requires is_same_v<T, unsigned int> || is_same_v<T, unsigned long> || is_same_v<T, unsigned long long>
-	inline constexpr T ilog2(T value)
+	inline constexpr T ilog2(T x)
 	{
 		if constexpr(is_same_v<T, unsigned int>)
-			return sizeof(T) * 8 - __builtin_clz(value) - 1;
+			return sizeof(T) * 8 - __builtin_clz(x) - 1;
 		if constexpr(is_same_v<T, unsigned long>)
-			return sizeof(T) * 8 - __builtin_clzl(value) - 1;
+			return sizeof(T) * 8 - __builtin_clzl(x) - 1;
-		return sizeof(T) * 8 - __builtin_clzll(value) - 1;
+		return sizeof(T) * 8 - __builtin_clzll(x) - 1;
+	}
+
+// This is ugly but my clangd does not like including
+// intrinsic headers at all
+#if !defined(__SSE__) || !defined(__SSE2__)
+#pragma GCC push_options
+#ifndef __SSE__
+#pragma GCC target("sse")
+#endif
+#ifndef __SSE2__
+#pragma GCC target("sse2")
+#endif
+#define BAN_MATH_POP_OPTIONS
+#endif
+
+	template<floating_point T>
+	inline constexpr T floor(T x)
+	{
+		if constexpr(is_same_v<T, float>)
+			return __builtin_floorf(x);
+		if constexpr(is_same_v<T, double>)
+			return __builtin_floor(x);
+		if constexpr(is_same_v<T, long double>)
+			return __builtin_floorl(x);
 	}
 
 	template<floating_point T>
-	inline constexpr T log2(T value)
+	inline constexpr T ceil(T x)
 	{
-		T result;
+		if constexpr(is_same_v<T, float>)
-		asm volatile("fyl2x" : "=t"(result) : "0"(value), "u"((T)1.0) : "st(1)");
+			return __builtin_ceilf(x);
-		return result;
+		if constexpr(is_same_v<T, double>)
+			return __builtin_ceil(x);
+		if constexpr(is_same_v<T, long double>)
+			return __builtin_ceill(x);
 	}
 
 	template<floating_point T>
-	inline constexpr T log10(T value)
+	inline constexpr T round(T x)
 	{
-		constexpr T INV_LOG_2_10 = 0.3010299956639811952137388947244930267681898814621085413104274611;
+		if (x == (T)0.0)
-		T result;
+			return x;
-		asm volatile("fyl2x" : "=t"(result) : "0"(value), "u"(INV_LOG_2_10) : "st(1)");
+		if (x > (T)0.0)
-		return result;
+			return floor<T>(x + (T)0.5);
+		return ceil<T>(x - (T)0.5);
 	}
 
 	template<floating_point T>
-	inline constexpr T log(T value, T base)
+	inline constexpr T trunc(T x)
 	{
-		return log2(value) / log2(base);
+		if constexpr(is_same_v<T, float>)
+			return __builtin_truncf(x);
+		if constexpr(is_same_v<T, double>)
+			return __builtin_trunc(x);
+		if constexpr(is_same_v<T, long double>)
+			return __builtin_truncl(x);
 	}
 
 	template<floating_point T>
-	inline constexpr T pow(T base, T exp)
+	inline constexpr T rint(T x)
 	{
-		T result;
+		asm("frndint" : "+t"(x));
-		asm volatile(
+		return x;
-			"fyl2x;"
+	}
+
+	template<floating_point T>
+	inline constexpr T fmod(T a, T b)
+	{
+		asm(
+			"1:"
+			"fprem;"
+			"fnstsw %%ax;"
+			"testb $4, %%ah;"
+			"jne 1b;"
+			: "+t"(a)
+			: "u"(b)
+			: "ax", "cc"
+		);
+		return a;
+	}
+
+	template<floating_point T>
+	inline constexpr T remainder(T a, T b)
+	{
+		asm(
+			"1:"
+			"fprem1;"
+			"fnstsw %%ax;"
+			"testb $4, %%ah;"
+			"jne 1b;"
+			: "+t"(a)
+			: "u"(b)
+			: "ax", "cc"
+		);
+		return a;
+	}
+
+	template<floating_point T>
+	static T modf(T x, T* iptr)
+	{
+		const T frac = BAN::Math::fmod<T>(x, (T)1.0);
+		*iptr = x - frac;
+		return frac;
+	}
+
+	template<floating_point T>
+	inline constexpr T frexp(T num, int* exp)
+	{
+		if (num == (T)0.0)
+		{
+			*exp = 0;
+			return (T)0.0;
+		}
+
+		T e;
+		asm("fxtract" : "+t"(num), "=u"(e));
+		*exp = (int)e + 1;
+		return num / (T)2.0;
+	}
+
+	template<floating_point T>
+	inline constexpr T copysign(T x, T y)
+	{
+		if ((x < (T)0.0) != (y < (T)0.0))
+			x = -x;
+		return x;
+	}
+
+	namespace detail
+	{
+
+		template<floating_point T>
+		inline constexpr T fyl2x(T x, T y)
+		{
+			asm("fyl2x" : "+t"(x) : "u"(y) : "st(1)");
+			return x;
+		}
+
+	}
+
+	template<floating_point T>
+	inline constexpr T log(T x)
+	{
+		return detail::fyl2x<T>(x, numbers::ln2_v<T>);
+	}
+
+	template<floating_point T>
+	inline constexpr T log2(T x)
+	{
+		return detail::fyl2x<T>(x, 1.0);
+	}
+
+	template<floating_point T>
+	inline constexpr T log10(T x)
+	{
+		return detail::fyl2x<T>(x, numbers::lg2_v<T>);
+	}
+
+	template<floating_point T>
+	inline constexpr T logb(T x)
+	{
+		static_assert(FLT_RADIX == 2);
+		return log2<T>(x);
+	}
+
+	template<floating_point T>
+	inline constexpr T exp2(T x)
+	{
+		if (abs(x) <= (T)1.0)
+		{
+			asm("f2xm1" : "+t"(x));
+			return x + (T)1.0;
+		}
+
+		asm(
 			"fld1;"
 			"fld %%st(1);"
 			"fprem;"
 			"f2xm1;"
 			"faddp;"
 			"fscale;"
-			"fxch %%st(1);"
+			"fstp %%st(1);"
-			"fstp %%st;"
+			: "+t"(x)
-			: "=t"(result)
-			: "0"(base), "u"(exp)
 		);
-		return result;
+
+		return x;
 	}
 
+	template<floating_point T>
+	inline constexpr T exp(T x)
+	{
+		return exp2<T>(x * numbers::log2e_v<T>);
+	}
+
+	template<floating_point T>
+	inline constexpr T pow(T x, T y)
+	{
+		if (x == (T)0.0)
+			return (T)0.0;
+		return exp2<T>(y * log2<T>(x));
+	}
+
+	template<floating_point T>
+	inline constexpr T scalbn(T x, int n)
+	{
+		asm("fscale" : "+t"(x) : "u"(static_cast<T>(n)));
+		return x;
+	}
+
+	template<floating_point T>
+	inline constexpr T ldexp(T x, int y)
+	{
+		const bool exp_sign = y < 0;
+		if (exp_sign)
+			y = -y;
+
+		T exp = (T)1.0;
+		T mult = (T)2.0;
+		while (y)
+		{
+			if (y & 1)
+				exp *= mult;
+			mult *= mult;
+			y >>= 1;
+		}
+
+		if (exp_sign)
+			exp = (T)1.0 / exp;
+
+		return x * exp;
+	}
+
+	template<floating_point T>
+	inline constexpr T sqrt(T x)
+	{
+		if constexpr(BAN::is_same_v<T, float>)
+		{
+			using v4sf = float __attribute__((vector_size(16)));
+			return __builtin_ia32_sqrtss((v4sf) { x, 0.0f, 0.0f, 0.0f })[0];
+		}
+		else if constexpr(BAN::is_same_v<T, double>)
+		{
+			using v2df = double __attribute__((vector_size(16)));
+			return __builtin_ia32_sqrtsd((v2df) { x, 0.0 })[0];
+		}
+		else if constexpr(BAN::is_same_v<T, long double>)
+		{
+			asm("fsqrt" : "+t"(x));
+			return x;
+		}
+	}
+
+	template<floating_point T>
+	inline constexpr T cbrt(T value)
+	{
+		return pow<T>(value, (T)1.0 / (T)3.0);
+	}
+
+	template<floating_point T>
+	inline constexpr T sin(T x)
+	{
+		asm("fsin" : "+t"(x));
+		return x;
+	}
+
+	template<floating_point T>
+	inline constexpr T cos(T x)
+	{
+		asm("fcos" : "+t"(x));
+		return x;
+	}
+
+	template<floating_point T>
+	inline constexpr void sincos(T x, T& sin, T& cos)
+	{
+		asm("fsincos" : "=t"(cos), "=u"(sin) : "0"(x));
+	}
+
+	template<floating_point T>
+	inline constexpr T tan(T x)
+	{
+		T one, ret;
+		asm("fptan" : "=t"(one), "=u"(ret) : "0"(x));
+		return ret;
+	}
+
+	template<floating_point T>
+	inline constexpr T atan2(T y, T x)
+	{
+		asm("fpatan" : "+t"(x) : "u"(y) : "st(1)");
+		return x;
+	}
+
+	template<floating_point T>
+	inline constexpr T atan(T x)
+	{
+		return atan2<T>(x, (T)1.0);
+	}
+
+	template<floating_point T>
+	inline constexpr T asin(T x)
+	{
+		if (x == (T)0.0)
+			return (T)0.0;
+		if (x == (T)1.0)
+			return +numbers::pi_v<T> / (T)2.0;
+		if (x == (T)-1.0)
+			return -numbers::pi_v<T> / (T)2.0;
+		return (T)2.0 * atan<T>(x / ((T)1.0 + sqrt<T>((T)1.0 - x * x)));
+	}
+
+	template<floating_point T>
+	inline constexpr T acos(T x)
+	{
+		if (x == (T)0.0)
+			return numbers::pi_v<T> / (T)2.0;
+		if (x == (T)1.0)
+			return (T)0.0;
+		if (x == (T)-1.0)
+			return numbers::pi_v<T>;
+		return (T)2.0 * atan<T>(sqrt<T>((T)1.0 - x * x) / ((T)1.0 + x));
+	}
+
+	template<floating_point T>
+	inline constexpr T sinh(T x)
+	{
+		return (exp<T>(x) - exp<T>(-x)) / (T)2.0;
+	}
+
+	template<floating_point T>
+	inline constexpr T cosh(T x)
+	{
+		return (exp<T>(x) + exp<T>(-x)) / (T)2.0;
+	}
+
+	template<floating_point T>
+	inline constexpr T tanh(T x)
+	{
+		const T exp_px = exp<T>(+x);
+		const T exp_nx = exp<T>(-x);
+		return (exp_px - exp_nx) / (exp_px + exp_nx);
+	}
+
+	template<floating_point T>
+	inline constexpr T asinh(T x)
+	{
+		return log<T>(x + sqrt<T>(x * x + (T)1.0));
+	}
+
+	template<floating_point T>
+	inline constexpr T acosh(T x)
+	{
+		return log<T>(x + sqrt<T>(x * x - (T)1.0));
+	}
+
+	template<floating_point T>
+	inline constexpr T atanh(T x)
+	{
+		return (T)0.5 * log<T>(((T)1.0 + x) / ((T)1.0 - x));
+	}
+
+	template<floating_point T>
+	inline constexpr T hypot(T x, T y)
+	{
+		return sqrt<T>(x * x + y * y);
+	}
+
+#ifdef BAN_MATH_POP_OPTIONS
+#undef BAN_MATH_POP_OPTIONS
+#pragma GCC pop_options
+#endif
+
 }

BAN/include/BAN/New.h

@@ -9,13 +9,12 @@
 namespace BAN
 {
 	#if defined(__is_kernel)
-		static constexpr void*(&allocator)(size_t) = kmalloc;
+		static constexpr void*(*allocator)(size_t) = kmalloc;
-		static constexpr void(&deallocator)(void*) = kfree;
+		static constexpr void*(*reallocator)(void*, size_t) = nullptr;
+		static constexpr void(*deallocator)(void*) = kfree;
 	#else
-		static constexpr void*(&allocator)(size_t) = malloc;
+		static constexpr void*(*allocator)(size_t) = malloc;
-		static constexpr void(&deallocator)(void*) = free;
+		static constexpr void*(*reallocator)(void*, size_t) = realloc;
+		static constexpr void(*deallocator)(void*) = free;
 	#endif
 }
-
-inline void* operator new(size_t, void* addr)	{ return addr; }
-inline void* operator new[](size_t, void* addr)	{ return addr; }

BAN/include/BAN/Numbers.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <BAN/Traits.h>
+
+namespace BAN::numbers
+{
+
+	template<floating_point T> inline constexpr T e_v      = 2.71828182845904523536;
+	template<floating_point T> inline constexpr T log2e_v  = 1.44269504088896340736;
+	template<floating_point T> inline constexpr T lge_v    = 0.43429448190325182765;
+	template<floating_point T> inline constexpr T lg2_v    = 0.30102999566398119521;
+	template<floating_point T> inline constexpr T ln2_v    = 0.69314718055994530942;
+	template<floating_point T> inline constexpr T ln10_v   = 2.30258509299404568402;
+	template<floating_point T> inline constexpr T pi_v     = 3.14159265358979323846;
+	template<floating_point T> inline constexpr T sqrt2_v  = 1.41421356237309504880;
+	template<floating_point T> inline constexpr T sqrt3_v  = 1.73205080756887729353;
+
+	inline constexpr double e      = e_v<double>;
+	inline constexpr double log2e  = log2e_v<double>;
+	inline constexpr double lge    = lge_v<double>;
+	inline constexpr double lg2    = lge_v<double>;
+	inline constexpr double ln2    = ln2_v<double>;
+	inline constexpr double ln10   = ln10_v<double>;
+	inline constexpr double pi     = pi_v<double>;
+	inline constexpr double sqrt2  = sqrt2_v<double>;
+	inline constexpr double sqrt3  = sqrt3_v<double>;
+
+}

BAN/include/BAN/Optional.h

@@ -2,6 +2,7 @@
 
 #include <BAN/Assert.h>
 #include <BAN/Move.h>
+#include <BAN/PlacementNew.h>
 
 #include <stdint.h>
 
@@ -12,48 +13,48 @@ namespace BAN
 	class Optional
 	{
 	public:
-		Optional();
+		constexpr Optional();
-		Optional(Optional&&);
+		constexpr Optional(Optional&&);
-		Optional(const Optional&);
+		constexpr Optional(const Optional&);
-		Optional(const T&);
+		constexpr Optional(const T&);
-		Optional(T&&);
+		constexpr Optional(T&&);
-		template<typename... Args>
-		Optional(Args&&...);
 
 		~Optional();
 
-		Optional& operator=(Optional&&);
+		constexpr Optional& operator=(Optional&&);
-		Optional& operator=(const Optional&);
+		constexpr Optional& operator=(const Optional&);
 
 		template<typename... Args>
-		Optional& emplace(Args&&...);
+		constexpr Optional& emplace(Args&&...) requires is_constructible_v<T, Args...>;
 
-		T* operator->();
+		constexpr T* operator->();
-		const T* operator->() const;
+		constexpr const T* operator->() const;
 
-		T& operator*();
+		constexpr T& operator*();
-		const T& operator*() const;
+		constexpr const T& operator*() const;
 
-		bool has_value() const;
+		constexpr bool has_value() const;
 
-		T release_value();
+		constexpr T release_value();
-		T& value();
+		constexpr T& value();
-		const T& value() const;
+		constexpr const T& value() const;
+		constexpr T& value_or(T&);
+		constexpr const T& value_or(const T&) const;
 
-		void clear();
+		constexpr void clear();
 
 	private:
-		alignas(T) uint8_t m_storage[sizeof(T)];
+		alignas(T) uint8_t m_storage[sizeof(T)] {};
 		bool m_has_value { false };
 	};
 
 	template<typename T>
-	Optional<T>::Optional()
+	constexpr Optional<T>::Optional()
 		: m_has_value(false)
 	{}
 
 	template<typename T>
-	Optional<T>::Optional(Optional<T>&& other)
+	constexpr Optional<T>::Optional(Optional<T>&& other)
 		: m_has_value(other.has_value())
 	{
 		if (other.has_value())
@@ -61,7 +62,7 @@ namespace BAN
 	}
 
 	template<typename T>
-	Optional<T>::Optional(const Optional<T>& other)
+	constexpr Optional<T>::Optional(const Optional<T>& other)
 		: m_has_value(other.has_value())
 	{
 		if (other.has_value())
@@ -69,27 +70,19 @@ namespace BAN
 	}
 
 	template<typename T>
-	Optional<T>::Optional(const T& value)
+	constexpr Optional<T>::Optional(const T& value)
 		: m_has_value(true)
 	{
 		new (m_storage) T(value);
 	}
 
 	template<typename T>
-	Optional<T>::Optional(T&& value)
+	constexpr Optional<T>::Optional(T&& value)
 		: m_has_value(true)
 	{
 		new (m_storage) T(move(value));
 	}
 
-	template<typename T>
-	template<typename... Args>
-	Optional<T>::Optional(Args&&... args)
-		: m_has_value(true)
-	{
-		new (m_storage) T(forward<Args>(args)...);
-	}
-
 	template<typename T>
 	Optional<T>::~Optional()
 	{
@@ -97,7 +90,7 @@ namespace BAN
 	}
 
 	template<typename T>
-	Optional<T>& Optional<T>::operator=(Optional&& other)
+	constexpr Optional<T>& Optional<T>::operator=(Optional&& other)
 	{
 		clear();
 		m_has_value = other.has_value();
@@ -107,18 +100,18 @@ namespace BAN
 	}
 
 	template<typename T>
-	Optional<T>& Optional<T>::operator=(const Optional& other)
+	constexpr Optional<T>& Optional<T>::operator=(const Optional& other)
 	{
 		clear();
 		m_has_value = other.has_value();
-		if (other.has_value)
+		if (other.has_value())
 			new (m_storage) T(other.value());
 		return *this;
 	}
 
 	template<typename T>
 	template<typename... Args>
-	Optional<T>& Optional<T>::emplace(Args&&... args)
+	constexpr Optional<T>& Optional<T>::emplace(Args&&... args) requires is_constructible_v<T, Args...>
 	{
 		clear();
 		m_has_value = true;
@@ -127,41 +120,41 @@ namespace BAN
 	}
 
 	template<typename T>
-	T* Optional<T>::operator->()
+	constexpr T* Optional<T>::operator->()
 	{
 		ASSERT(has_value());
 		return &value();
 	}
 
 	template<typename T>
-	const T* Optional<T>::operator->() const
+	constexpr const T* Optional<T>::operator->() const
 	{
 		ASSERT(has_value());
 		return &value();
 	}
 
 	template<typename T>
-	T& Optional<T>::operator*()
+	constexpr T& Optional<T>::operator*()
 	{
 		ASSERT(has_value());
 		return value();
 	}
 
 	template<typename T>
-	const T& Optional<T>::operator*() const
+	constexpr const T& Optional<T>::operator*() const
 	{
 		ASSERT(has_value());
 		return value();
 	}
 
 	template<typename T>
-	bool Optional<T>::has_value() const
+	constexpr bool Optional<T>::has_value() const
 	{
 		return m_has_value;
 	}
 
 	template<typename T>
-	T Optional<T>::release_value()
+	constexpr T Optional<T>::release_value()
 	{
 		ASSERT(has_value());
 		T released_value = move(value());
@@ -171,21 +164,37 @@ namespace BAN
 	}
 
 	template<typename T>
-	T& Optional<T>::value()
+	constexpr T& Optional<T>::value()
 	{
 		ASSERT(has_value());
-		return (T&)m_storage;
+		return *reinterpret_cast<T*>(&m_storage);
 	}
 
 	template<typename T>
-	const T& Optional<T>::value() const
+	constexpr const T& Optional<T>::value() const
 	{
 		ASSERT(has_value());
-		return (const T&)m_storage;
+		return *reinterpret_cast<const T*>(&m_storage);
 	}
 
 	template<typename T>
-	void Optional<T>::clear()
+	constexpr T& Optional<T>::value_or(T& empty)
+	{
+		if (!has_value())
+			return empty;
+		return value();
+	}
+
+	template<typename T>
+	constexpr const T& Optional<T>::value_or(const T& empty) const
+	{
+		if (!has_value())
+			return empty;
+		return value();
+	}
+
+	template<typename T>
+	constexpr void Optional<T>::clear()
 	{
 		if (m_has_value)
 			value().~T();

BAN/include/BAN/PlacementNew.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#if __has_include(<new>)
+	#include <new>
+#else
+	#include <stddef.h>
+
+	inline void* operator new(size_t, void* addr) { return addr; }
+	inline void* operator new[](size_t, void* addr) { return addr; }
+#endif

BAN/include/BAN/PriorityQueue.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include "BAN/Errors.h"
+#include <BAN/Vector.h>
+#include <BAN/Heap.h>
+
+namespace BAN
+{
+
+	template<typename T, typename Comp = less<T>>
+	class PriorityQueue
+	{
+	public:
+		PriorityQueue() = default;
+		PriorityQueue(Comp comp)
+			: m_comp(comp)
+		{ }
+
+		ErrorOr<void> push(const T& value)
+		{
+			TRY(m_data.push_back(value));
+			push_heap(m_data.begin(), m_data.end());
+			return {};
+		}
+
+		ErrorOr<void> push(T&& value)
+		{
+			TRY(m_data.push_back(move(value)));
+			push_heap(m_data.begin(), m_data.end());
+			return {};
+		}
+
+		template<typename... Args>
+		ErrorOr<void> emplace(Args&&... args) requires is_constructible_v<T, Args...>
+		{
+			TRY(m_data.emplace_back(forward<Args>(args)...));
+			push_heap(m_data.begin(), m_data.end());
+			return {};
+		}
+
+		void pop()
+		{
+			pop_heap(m_data.begin(), m_data.end());
+			m_data.pop_back();
+		}
+
+		BAN::ErrorOr<void> reserve(Vector<T>::size_type size)
+		{
+			return m_data.reserve(size);
+		}
+
+		T& top() { return m_data.front(); }
+		const T& top() const { return m_data.front(); }
+
+		bool empty() const { return m_data.empty(); }
+		Vector<T>::size_type size() const { return m_data.size(); }
+		Vector<T>::size_type capacity() const { return m_data.capacity(); }
+
+	private:
+		Comp m_comp;
+		Vector<T> m_data;
+	};
+
+}

BAN/include/BAN/Queue.h

@@ -5,6 +5,7 @@
 #include <BAN/Math.h>
 #include <BAN/Move.h>
 #include <BAN/New.h>
+#include <BAN/PlacementNew.h>
 
 namespace BAN
 {
@@ -30,7 +31,7 @@ namespace BAN
 		ErrorOr<void> push(T&&);
 		ErrorOr<void> push(const T&);
 		template<typename... Args>
-		ErrorOr<void> emplace(Args&&...);
+		ErrorOr<void> emplace(Args&&...) requires is_constructible_v<T, Args...>;
 
 		ErrorOr<void> reserve(size_type);
 		ErrorOr<void> shrink_to_fit();
@@ -44,6 +45,7 @@ namespace BAN
 		void clear();
 
 		bool empty() const;
+		size_type capacity() const;
 		size_type size() const;
 
 		const T& front() const;
@@ -129,7 +131,7 @@ namespace BAN
 
 	template<typename T>
 	template<typename... Args>
-	ErrorOr<void> Queue<T>::emplace(Args&&... args)
+	ErrorOr<void> Queue<T>::emplace(Args&&... args) requires is_constructible_v<T, Args...>
 	{
 		TRY(ensure_capacity(m_size + 1));
 		new (m_data + m_size) T(forward<Args>(args)...);
@@ -185,6 +187,12 @@ namespace BAN
 		return m_size == 0;
 	}
 
+	template<typename T>
+	typename Queue<T>::size_type Queue<T>::capacity() const
+	{
+		return m_capacity;
+	}
+
 	template<typename T>
 	typename Queue<T>::size_type Queue<T>::size() const
 	{

BAN/include/BAN/RefPtr.h

@@ -1,9 +1,10 @@
 #pragma once
 
+#include <BAN/Atomic.h>
 #include <BAN/Errors.h>
+#include <BAN/Hash.h>
 #include <BAN/Move.h>
 #include <BAN/NoCopyMove.h>
-#include <stdint.h>
 
 namespace BAN
 {
@@ -22,24 +23,36 @@ namespace BAN
 
 		void ref() const
 		{
-			ASSERT(m_ref_count > 0);
+			uint32_t old = m_ref_count.fetch_add(1, MemoryOrder::memory_order_relaxed);
-			m_ref_count++;
+			ASSERT(old > 0);
+		}
+
+		bool try_ref() const
+		{
+			uint32_t expected = m_ref_count.load(MemoryOrder::memory_order_relaxed);
+			for (;;)
+			{
+				if (expected == 0)
+					return false;
+				if (m_ref_count.compare_exchange(expected, expected + 1, MemoryOrder::memory_order_acquire))
+					return true;
+			}
 		}
 
 		void unref() const
 		{
-			ASSERT(m_ref_count > 0);
+			uint32_t old = m_ref_count.fetch_sub(1);
-			m_ref_count--;
+			ASSERT(old > 0);
-			if (m_ref_count == 0)
+			if (old == 1)
-				delete (const T*)this;
+				delete static_cast<const T*>(this);
 		}
 
 	protected:
 		RefCounted() = default;
-		~RefCounted() { ASSERT(m_ref_count == 0); }
+		virtual ~RefCounted() { ASSERT(m_ref_count == 0); }
 
 	private:
-		mutable uint32_t m_ref_count = 1;
+		mutable Atomic<uint32_t> m_ref_count = 1;
 	};
 
 	template<typename T>
@@ -63,8 +76,9 @@ namespace BAN
 			return ptr;
 		}
 
+		// NOTE: don't use is_constructible_v<T, Args...> as RefPtr<T> is allowed with friends
 		template<typename... Args>
-		static ErrorOr<RefPtr> create(Args&&... args)
+		static ErrorOr<RefPtr> create(Args&&... args) requires requires(Args&&... args) { T(forward<Args>(args)...); }
 		{
 			T* pointer = new T(forward<Args>(args)...);
 			if (pointer == nullptr)
@@ -115,17 +129,15 @@ namespace BAN
 			return *this;
 		}
 
-		T* ptr() { ASSERT(!empty()); return m_pointer; }
+		T* ptr() const { return m_pointer; }
-		const T* ptr() const { ASSERT(!empty()); return m_pointer; }
+		T& operator*() const { ASSERT(!empty()); return *ptr(); }
+		T* operator->() const { ASSERT(!empty()); return ptr(); }
 
-		T& operator*() { return *ptr(); }
+		bool operator==(RefPtr other) const { return m_pointer == other.m_pointer; }
-		const T& operator*() const { return *ptr(); }
+		bool operator!=(RefPtr other) const { return m_pointer != other.m_pointer; }
-
-		T* operator->() { return ptr(); }
-		const T* operator->() const { return ptr(); }
 
 		bool empty() const { return m_pointer == nullptr; }
-		operator bool() const { return m_pointer; }
+		explicit operator bool() const { return m_pointer; }
 
 		void clear()
 		{
@@ -141,4 +153,13 @@ namespace BAN
 		friend class RefPtr;
 	};
 
+	template<typename T>
+	struct hash<RefPtr<T>>
+	{
+		constexpr hash_t operator()(const RefPtr<T>& ptr) const
+		{
+			return hash<T*>()(ptr.ptr());
+		}
+	};
+
 }

BAN/include/BAN/Sort.h

@@ -1,13 +1,15 @@
 #pragma once
 
+#include <BAN/Heap.h>
+#include <BAN/Math.h>
 #include <BAN/Swap.h>
 #include <BAN/Traits.h>
-#include <BAN/Math.h>
+#include <BAN/Vector.h>
 
 namespace BAN::sort
 {
 
-	template<typename It, typename Comp = less<typename It::value_type>>
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
 	void exchange_sort(It begin, It end, Comp comp = {})
 	{
 		for (It lhs = begin; lhs != end; ++lhs)
@@ -41,7 +43,7 @@ namespace BAN::sort
 
 	}
 
-	template<typename It, typename Comp = less<typename It::value_type>>
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
 	void quick_sort(It begin, It end, Comp comp = {})
 	{
 		if (distance(begin, end) <= 1)
@@ -51,14 +53,14 @@ namespace BAN::sort
 		quick_sort(++mid, end, comp);
 	}
 
-	template<typename It, typename Comp = less<typename It::value_type>>
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
 	void insertion_sort(It begin, It end, Comp comp = {})
 	{
 		if (distance(begin, end) <= 1)
 			return;
 		for (It it1 = next(begin, 1); it1 != end; ++it1)
 		{
-			typename It::value_type x = move(*it1);
+			auto x = move(*it1);
 			It it2 = it1;
 			for (; it2 != begin && comp(x, *prev(it2, 1)); --it2)
 				*it2 = move(*prev(it2, 1));
@@ -66,83 +68,7 @@ namespace BAN::sort
 		}
 	}
 
-	namespace detail
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
-	{
-
-		template<typename It, typename Comp>
-		void push_heap(It begin, size_t hole_index, size_t top_index, typename It::value_type value, Comp comp)
-		{
-			size_t parent = (hole_index - 1) / 2;
-			while (hole_index > top_index && comp(*next(begin, parent), value))
-			{
-				*next(begin, hole_index) = move(*next(begin, parent));
-				hole_index = parent;
-				parent = (hole_index - 1) / 2;
-			}
-			*next(begin, hole_index) = move(value);
-		}
-
-		template<typename It, typename Comp>
-		void adjust_heap(It begin, size_t hole_index, size_t len, typename It::value_type value, Comp comp)
-		{
-			const size_t top_index = hole_index;
-			size_t child = hole_index;
-			while (child < (len - 1) / 2)
-			{
-				child = 2 * (child + 1);
-				if (comp(*next(begin, child), *next(begin, child - 1)))
-					child--;
-				*next(begin, hole_index) = move(*next(begin, child));
-				hole_index = child;
-			}
-			if (len % 2 == 0 && child == (len - 2) / 2)
-			{
-				child = 2 * (child + 1);
-				*next(begin, hole_index) = move(*next(begin, child - 1));
-				hole_index = child - 1;
-			}
-			push_heap(begin, hole_index, top_index, move(value), comp);
-		}
-
-	}
-
-	template<typename It, typename Comp = less<typename It::value_type>>
-	void make_heap(It begin, It end, Comp comp = {})
-	{
-		const size_t len = distance(begin, end);
-		if (len <= 1)
-			return;
-
-		size_t parent = (len - 2) / 2;
-		while (true)
-		{
-			detail::adjust_heap(begin, parent, len, move(*next(begin, parent)), comp);
-
-			if (parent == 0)
-				break;
-			
-			parent--;
-		}
-	}
-
-	template<typename It, typename Comp = less<typename It::value_type>>
-	void sort_heap(It begin, It end, Comp comp = {})
-	{
-		const size_t len = distance(begin, end);
-		if (len <= 1)
-			return;
-
-		size_t last = len;
-		while (last > 1)
-		{
-			last--;
-			typename It::value_type x = move(*next(begin, last));
-			*next(begin, last) = move(*begin);
-			detail::adjust_heap(begin, 0, last, move(x), comp);
-		}
-	}
-
-	template<typename It, typename Comp = less<typename It::value_type>>
 	void heap_sort(It begin, It end, Comp comp = {})
 	{
 		make_heap(begin, end, comp);
@@ -166,7 +92,7 @@ namespace BAN::sort
 
 	}
 
-	template<typename It, typename Comp = less<typename It::value_type>>
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
 	void intro_sort(It begin, It end, Comp comp = {})
 	{
 		const size_t len = distance(begin, end);
@@ -175,7 +101,62 @@ namespace BAN::sort
 		detail::intro_sort_impl(begin, end, 2 * Math::ilog2(len), comp);
 	}
 
-	template<typename It, typename Comp = less<typename It::value_type>>
+	namespace detail
+	{
+
+		template<unsigned_integral T>
+		consteval T lsb_index(T value)
+		{
+			for (T result = 0;; result++)
+				if (value & (1 << result))
+					return result;
+		}
+
+	}
+
+	template<typename It, size_t radix = 256>
+	requires is_unsigned_v<it_value_type_t<It>> && (radix > 0 && (radix & (radix - 1)) == 0)
+	BAN::ErrorOr<void> radix_sort(It begin, It end)
+	{
+		using value_type = it_value_type_t<It>;
+
+		const size_t len = distance(begin, end);
+		if (len <= 1)
+			return {};
+
+		Vector<value_type> temp;
+		TRY(temp.resize(len));
+
+		Vector<size_t> counts;
+		TRY(counts.resize(radix));
+
+		constexpr size_t mask  = radix - 1;
+		constexpr size_t shift = detail::lsb_index(radix);
+
+		for (size_t s = 0; s < sizeof(value_type) * 8; s += shift)
+		{
+			for (auto& cnt : counts)
+				cnt = 0;
+			for (It it = begin; it != end; ++it)
+				counts[(*it >> s) & mask]++;
+
+			for (size_t i = 0; i < radix - 1; i++)
+				counts[i + 1] += counts[i];
+
+			for (It it = end; it != begin;)
+			{
+				--it;
+				temp[--counts[(*it >> s) & mask]] = *it;
+			}
+
+			for (size_t j = 0; j < temp.size(); j++)
+				*next(begin, j) = temp[j];
+		}
+
+		return {};
+	}
+
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
 	void sort(It begin, It end, Comp comp = {})
 	{
 		return intro_sort(begin, end, comp);

BAN/include/BAN/Span.h

@@ -14,116 +14,75 @@ namespace BAN
 	public:
 		using value_type = T;
 		using size_type = size_t;
-		using iterator = IteratorSimple<T, Span>;
+		using iterator = IteratorSimple<value_type, Span>;
-		using const_iterator = ConstIteratorSimple<T, Span>;
+		using const_iterator = ConstIteratorSimple<value_type, Span>;
+
+	private:
+		template<typename S>
+		static inline constexpr bool can_init_from_v = is_same_v<value_type, const S> || is_same_v<value_type, S>;
 
 	public:
 		Span() = default;
-		Span(T*, size_type);
+		Span(value_type* data, size_type size)
-		Span(Span<T>&);
+			: m_data(data)
+			, m_size(size)
+		{ }
+
 		template<typename S>
-		requires(is_same_v<T, const S>)
+		Span(const Span<S>& other) requires can_init_from_v<S>
-		Span(const Span<S>&);
+			: m_data(other.m_data)
+			, m_size(other.m_size)
+		{ }
+		template<typename S>
+		Span(Span<S>&& other) requires can_init_from_v<S>
+			: m_data(other.m_data)
+			, m_size(other.m_size)
+		{
+			other.clear();
+		}
+
+		template<typename S>
+		Span& operator=(const Span<S>& other) requires can_init_from_v<S>
+		{
+			m_data = other.m_data;
+			m_size = other.m_size;
+			return *this;
+		}
+		template<typename S>
+		Span& operator=(Span<S>&& other) requires can_init_from_v<S>
+		{
+			m_data = other.m_data;
+			m_size = other.m_size;
+			return *this;
+		}
 
 		iterator begin() { return iterator(m_data); }
 		iterator end() { return iterator(m_data + m_size); }
 		const_iterator begin() const { return const_iterator(m_data); }
 		const_iterator end() const { return const_iterator(m_data + m_size); }
 
-		T& operator[](size_type);
+		value_type& operator[](size_type index) const
-		const T& operator[](size_type) const;
-
-		T* data();
-		const T* data() const;
-
-		bool empty() const;
-		size_type size() const;
-
-		void clear();
-
-		Span slice(size_type, size_type = ~size_type(0));
-
-		Span<const T> as_const() const { return Span<const T>(m_data, m_size); }
-
-	private:
-		T* m_data = nullptr;
-		size_type m_size = 0;
-	};
-
-	template<typename T>
-	Span<T>::Span(T* data, size_type size)
-		: m_data(data)
-		, m_size(size)
 		{
-	}
-
-	template<typename T>
-	Span<T>::Span(Span& other)
-		: m_data(other.data())
-		, m_size(other.size())
-	{
-	}
-
-	template<typename T>
-	template<typename S>
-	requires(is_same_v<T, const S>)
-	Span<T>::Span(const Span<S>& other)
-		: m_data(other.data())
-		, m_size(other.size())
-	{
-	}
-
-	template<typename T>
-	T& Span<T>::operator[](size_type index)
-	{
-		ASSERT(m_data);
 			ASSERT(index < m_size);
 			return m_data[index];
 		}
 
-	template<typename T>
+		value_type* data() const
-	const T& Span<T>::operator[](size_type index) const
-	{
-		ASSERT(m_data);
-		ASSERT(index < m_size);
-		return m_data[index];
-	}
-
-	template<typename T>
-	T* Span<T>::data()
 		{
 			return m_data;
 		}
 
-	template<typename T>
+		bool empty() const { return m_size == 0; }
-	const T* Span<T>::data() const
+		size_type size() const { return m_size; }
-	{
-		return m_data;
-	}
 
-	template<typename T>
+		void clear()
-	bool Span<T>::empty() const
-	{
-		return m_size == 0;
-	}
-
-	template<typename T>
-	typename Span<T>::size_type Span<T>::size() const
-	{
-		return m_size;
-	}
-
-	template<typename T>
-	void Span<T>::clear()
 		{
 			m_data = nullptr;
 			m_size = 0;
 		}
 
-	template<typename T>
+		Span slice(size_type start, size_type length = ~size_type(0)) const
-	Span<T> Span<T>::slice(size_type start, size_type length)
 		{
-		ASSERT(m_data);
 			ASSERT(start <= m_size);
 			if (length == ~size_type(0))
 				length = m_size - start;
@@ -131,4 +90,13 @@ namespace BAN
 			return Span(m_data + start, length);
 		}
 
+		Span<const value_type> as_const() const { return *this; }
+
+	private:
+		value_type* m_data = nullptr;
+		size_type m_size = 0;
+
+		friend class Span<const value_type>;
+	};
+
 }

BAN/include/BAN/String.h

@@ -2,9 +2,10 @@
 
 #include <BAN/Errors.h>
 #include <BAN/Formatter.h>
-#include <BAN/ForwardList.h>
 #include <BAN/Hash.h>
 #include <BAN/Iterators.h>
+#include <BAN/New.h>
+#include <BAN/StringView.h>
 
 namespace BAN
 {
@@ -13,33 +14,136 @@ namespace BAN
 	{
 	public:
 		using size_type = size_t;
+		using value_type = char;
 		using iterator = IteratorSimple<char, String>;
 		using const_iterator = ConstIteratorSimple<char, String>;
 		static constexpr size_type sso_capacity = 15;
 
 	public:
-		String();
+		String() {}
-		String(const String&);
+		String(const String& other) { *this = other; }
-		String(String&&);
+		String(String&& other) { *this = move(other); }
-		String(StringView);
+		String(StringView other) { *this = other; }
-		~String();
+		~String() { clear(); }
 
 		template<typename... Args>
-		static String formatted(const char* format, const Args&... args);
+		static BAN::ErrorOr<String> formatted(const char* format, Args&&... args)
+		{
+			size_type length = 0;
+			BAN::Formatter::print([&](char) { length++; }, format, BAN::forward<Args>(args)...);
 
-		String& operator=(const String&);
+			String result;
-		String& operator=(String&&);
+			TRY(result.reserve(length));
-		String& operator=(StringView);
+			BAN::Formatter::print([&](char c){ MUST(result.push_back(c)); }, format, BAN::forward<Args>(args)...);
 
-		ErrorOr<void> push_back(char);
+			return result;
-		ErrorOr<void> insert(char, size_type);
+		}
-		ErrorOr<void> insert(StringView, size_type);
-		ErrorOr<void> append(StringView);
 
-		void pop_back();
+		String& operator=(const String& other)
-		void remove(size_type);
+		{
+			clear();
+			MUST(ensure_capacity(other.size()));
+			memcpy(data(), other.data(), other.size() + 1);
+			m_size = other.size();
+			return *this;
+		}
 
-		void clear();
+		String& operator=(String&& other)
+		{
+			clear();
+
+			if (other.has_sso())
+				memcpy(data(), other.data(), other.size() + 1);
+			else
+			{
+				m_storage.general_storage = other.m_storage.general_storage;
+				m_has_sso = false;
+			}
+			m_size = other.m_size;
+
+			other.m_size = 0;
+			other.m_storage.sso_storage = SSOStorage();
+			other.m_has_sso = true;
+
+			return *this;
+		}
+
+		String& operator=(StringView other)
+		{
+			clear();
+			MUST(ensure_capacity(other.size()));
+			memcpy(data(), other.data(), other.size());
+			m_size = other.size();
+			data()[m_size] = '\0';
+			return *this;
+		}
+
+		ErrorOr<void> push_back(char c)
+		{
+			TRY(ensure_capacity(m_size + 1));
+			data()[m_size] = c;
+			m_size++;
+			data()[m_size] = '\0';
+			return {};
+		}
+
+		ErrorOr<void> insert(char c, size_type index)
+		{
+			ASSERT(index <= m_size);
+			TRY(ensure_capacity(m_size + 1));
+			memmove(data() + index + 1, data() + index, m_size - index);
+			data()[index] = c;
+			m_size++;
+			data()[m_size] = '\0';
+			return {};
+		}
+
+		ErrorOr<void> insert(StringView str, size_type index)
+		{
+			ASSERT(index <= m_size);
+			TRY(ensure_capacity(m_size + str.size()));
+			memmove(data() + index + str.size(), data() + index, m_size - index);
+			memcpy(data() + index, str.data(), str.size());
+			m_size += str.size();
+			data()[m_size] = '\0';
+			return {};
+		}
+
+		ErrorOr<void> append(StringView str)
+		{
+			TRY(ensure_capacity(m_size + str.size()));
+			memcpy(data() + m_size, str.data(), str.size());
+			m_size += str.size();
+			data()[m_size] = '\0';
+			return {};
+		}
+
+		void pop_back()
+		{
+			ASSERT(m_size > 0);
+			m_size--;
+			data()[m_size] = '\0';
+		}
+
+		void remove(size_type index)
+		{
+			ASSERT(index < m_size);
+			memmove(data() + index, data() + index + 1, m_size - index);
+			m_size--;
+			data()[m_size] = '\0';
+		}
+
+		void clear()
+		{
+			if (!has_sso())
+			{
+				deallocator(m_storage.general_storage.data);
+				m_storage.sso_storage = SSOStorage();
+				m_has_sso = true;
+			}
+			m_size = 0;
+			data()[m_size] = '\0';
+		}
 
 		const_iterator begin() const	{ return const_iterator(data()); }
 		iterator begin()				{ return iterator(data()); }
@@ -55,26 +159,151 @@ namespace BAN
 		char operator[](size_type index) const	{ ASSERT(index < m_size); return data()[index]; }
 		char& operator[](size_type index)		{ ASSERT(index < m_size); return data()[index]; }
 
-		bool operator==(StringView) const;
+		bool operator==(const String& str) const
-		bool operator==(const char*) const;
+		{
+			if (size() != str.size())
+				return false;
+			for (size_type i = 0; i < m_size; i++)
+				if (data()[i] != str.data()[i])
+					return false;
+			return true;
+		}
 
-		ErrorOr<void> resize(size_type, char = '\0');
+		bool operator==(StringView str) const
-		ErrorOr<void> reserve(size_type);
+		{
-		ErrorOr<void> shrink_to_fit();
+			if (size() != str.size())
+				return false;
+			for (size_type i = 0; i < m_size; i++)
+				if (data()[i] != str.data()[i])
+					return false;
+			return true;
+		}
+
+		bool operator==(const char* cstr) const
+		{
+			for (size_type i = 0; i < m_size; i++)
+				if (data()[i] != cstr[i])
+					return false;
+			if (cstr[size()] != '\0')
+				return false;
+			return true;
+		}
+
+		ErrorOr<void> resize(size_type new_size, char init_c = '\0')
+		{
+			if (m_size == new_size)
+				return {};
+
+			// expanding
+			if (m_size < new_size)
+			{
+				TRY(ensure_capacity(new_size));
+				memset(data() + m_size, init_c, new_size - m_size);
+				m_size = new_size;
+				data()[m_size] = '\0';
+				return {};
+			}
+
+			m_size = new_size;
+			data()[m_size] = '\0';
+			return {};
+		}
+
+		ErrorOr<void> reserve(size_type new_size)
+		{
+			TRY(ensure_capacity(new_size));
+			return {};
+		}
+
+		ErrorOr<void> shrink_to_fit()
+		{
+			if (has_sso())
+				return {};
+
+			if (fits_in_sso())
+			{
+				char* data = m_storage.general_storage.data;
+				m_storage.sso_storage = SSOStorage();
+				m_has_sso = true;
+				memcpy(this->data(), data, m_size + 1);
+				deallocator(data);
+				return {};
+			}
+
+			GeneralStorage& storage = m_storage.general_storage;
+			if (storage.capacity == m_size)
+				return {};
+
+			char* new_data = (char*)allocator(m_size + 1);
+			if (new_data == nullptr)
+				return Error::from_errno(ENOMEM);
+
+			memcpy(new_data, storage.data, m_size);
+			deallocator(storage.data);
+
+			storage.capacity = m_size;
+			storage.data = new_data;
+
+			return {};
+		}
 
 		StringView sv() const	{ return StringView(data(), size()); }
 
 		bool empty() const		{ return m_size == 0; }
 		size_type size() const	{ return m_size; }
-		size_type capacity() const;
 
-		char* data();
+		size_type capacity() const
-		const char* data() const;
+		{
+			if (has_sso())
+				return sso_capacity;
+			return m_storage.general_storage.capacity;
+		}
+
+		char* data()
+		{
+			if (has_sso())
+				return m_storage.sso_storage.data;
+			return m_storage.general_storage.data;
+		}
+
+		const char* data() const
+		{
+			if (has_sso())
+				return m_storage.sso_storage.data;
+			return m_storage.general_storage.data;
+		}
 
 	private:
-		ErrorOr<void> ensure_capacity(size_type);
+		ErrorOr<void> ensure_capacity(size_type new_size)
+		{
+			if (m_size >= new_size)
+				return {};
+			if (has_sso() && fits_in_sso(new_size))
+				return {};
 
-		bool has_sso() const;
+			char* new_data = (char*)allocator(new_size + 1);
+			if (new_data == nullptr)
+				return Error::from_errno(ENOMEM);
+
+			if (m_size)
+				memcpy(new_data, data(), m_size + 1);
+
+			if (has_sso())
+			{
+				m_storage.general_storage = GeneralStorage();
+				m_has_sso = false;
+			}
+			else
+				deallocator(m_storage.general_storage.data);
+
+			auto& storage = m_storage.general_storage;
+			storage.capacity = new_size;
+			storage.data = new_data;
+
+			return {};
+		}
+
+		bool has_sso() const { return m_has_sso; }
 
 		bool fits_in_sso() const { return fits_in_sso(m_size); }
 		static bool fits_in_sso(size_type size) { return size < sso_capacity; }
@@ -99,14 +328,6 @@ namespace BAN
 		size_type m_has_sso	: 1							{ true };
 	};
 
-	template<typename... Args>
-	String String::formatted(const char* format, const Args&... args)
-	{
-		String result;
-		BAN::Formatter::print([&](char c){ MUST(result.push_back(c)); }, format, args...);
-		return result;
-	}
-
 	template<>
 	struct hash<String>
 	{
@@ -132,10 +353,9 @@ namespace BAN::Formatter
 {
 
 	template<typename F>
-	void print_argument(F putc, const String& string, const ValueFormat&)
+	void print_argument(F putc, const String& string, const ValueFormat& format)
 	{
-		for (String::size_type i = 0; i < string.size(); i++)
+		print_argument(putc, string.sv(), format);
-			putc(string[i]);
 	}
 
 }

BAN/include/BAN/StringView.h

@@ -1,8 +1,11 @@
 #pragma once
 
-#include <BAN/ForwardList.h>
 #include <BAN/Formatter.h>
+#include <BAN/ForwardList.h>
+#include <BAN/Hash.h>
 #include <BAN/Iterators.h>
+#include <BAN/Optional.h>
+#include <BAN/Vector.h>
 
 namespace BAN
 {
@@ -11,55 +14,245 @@ namespace BAN
 	{
 	public:
 		using size_type = size_t;
+		using value_type = char;
 		using const_iterator = ConstIteratorSimple<char, StringView>;
 
 	public:
-		StringView();
+		constexpr StringView() {}
+		constexpr StringView(const char* string, size_type len = -1)
+		{
+			if (len == size_type(-1))
+				for (len = 0; string[len];)
+					len++;
+			m_data = string;
+			m_size = len;
+		}
 		StringView(const String&);
-		StringView(const char*, size_type = -1);
 
-		const_iterator begin() const { return const_iterator(m_data); }
+		constexpr const_iterator begin() const { return const_iterator(m_data); }
-		const_iterator end() const { return const_iterator(m_data + m_size); }
+		constexpr const_iterator end() const { return const_iterator(m_data + m_size); }
 
-		char operator[](size_type) const;
+		constexpr char operator[](size_type index) const
+		{
+			ASSERT(index < m_size);
+			return m_data[index];
+		}
 
-		bool operator==(const String&) const;
+		constexpr bool operator==(StringView other) const
-		bool operator==(StringView) const;
+		{
-		bool operator==(const char*) const;
+			if (m_size != other.m_size)
+				return false;
+			for (size_type i = 0; i < m_size; i++)
+				if (m_data[i] != other.m_data[i])
+					return false;
+			return true;
+		}
 
-		StringView substring(size_type, size_type = -1) const;
+		constexpr bool operator==(const char* other) const
+		{
+			for (size_type i = 0; i < m_size; i++)
+				if (m_data[i] != other[i])
+					return false;
+			return other[m_size] == '\0';
+		}
 
-		ErrorOr<Vector<StringView>> split(char, bool = false);
+		constexpr StringView substring(size_type index, size_type len = -1) const
-		ErrorOr<Vector<StringView>> split(bool(*comp)(char), bool = false);
+		{
+			ASSERT(index <= m_size);
+			if (len == size_type(-1))
+				len = m_size - index;
+			ASSERT(len <= m_size - index); // weird order to avoid overflow
+			StringView result;
+			result.m_data = m_data + index;
+			result.m_size = len;
+			return result;
+		}
 
-		char back() const;
+		ErrorOr<Vector<StringView>> split(char delim, bool allow_empties = false) const
-		char front() const;
+		{
+			size_type count = 0;
+			{
+				size_type start = 0;
+				for (size_type i = 0; i < m_size; i++)
+				{
+					if (m_data[i] == delim)
+					{
+						if (allow_empties || start != i)
+							count++;
+						start = i + 1;
+					}
+				}
+				if (start != m_size)
+					count++;
+			}
 
-		bool contains(char) const;
+			Vector<StringView> result;
-		size_type count(char) const;
+			TRY(result.reserve(count));
 
-		bool empty() const;
+			size_type start = 0;
-		size_type size() const;
+			for (size_type i = 0; i < m_size; i++)
+			{
+				if (m_data[i] == delim)
+				{
+					if (allow_empties || start != i)
+						TRY(result.push_back(this->substring(start, i - start)));
+					start = i + 1;
+				}
+			}
+			if (start < m_size || (start == m_size && allow_empties))
+				TRY(result.push_back(this->substring(start)));
+			return result;
+		}
 
-		const char* data() const;
+		ErrorOr<Vector<StringView>> split(bool(*comp)(char), bool allow_empties = false) const
+		{
+			size_type count = 0;
+			{
+				size_type start = 0;
+				for (size_type i = 0; i < m_size; i++)
+				{
+					if (comp(m_data[i]))
+					{
+						if (allow_empties || start != i)
+							count++;
+						start = i + 1;
+					}
+				}
+				if (start != m_size)
+					count++;
+			}
+
+			Vector<StringView> result;
+			TRY(result.reserve(count));
+
+			size_type start = 0;
+			for (size_type i = 0; i < m_size; i++)
+			{
+				if (comp(m_data[i]))
+				{
+					if (allow_empties || start != i)
+						TRY(result.push_back(this->substring(start, i - start)));
+					start = i + 1;
+				}
+			}
+			if (start < m_size || (start == m_size && allow_empties))
+				TRY(result.push_back(this->substring(start)));
+			return result;
+		}
+
+		constexpr char back() const
+		{
+			ASSERT(m_size > 0);
+			return m_data[m_size - 1];
+		}
+
+		constexpr char front() const
+		{
+			ASSERT(m_size > 0);
+			return m_data[0];
+		}
+
+		BAN::Optional<size_type> find(char ch) const
+		{
+			for (size_type i = 0; i < m_size; i++)
+				if (m_data[i] == ch)
+					return i;
+			return {};
+		}
+
+		BAN::Optional<size_type> find(bool(*comp)(char)) const
+		{
+			for (size_type i = 0; i < m_size; i++)
+				if (comp(m_data[i]))
+					return i;
+			return {};
+		}
+
+		BAN::Optional<size_type> rfind(char ch) const
+		{
+			for (size_type i = m_size; i > 0; i--)
+				if (m_data[i - 1] == ch)
+					return i - 1;
+			return {};
+		}
+
+		BAN::Optional<size_type> rfind(bool(*comp)(char)) const
+		{
+			for (size_type i = m_size; i > 0; i--)
+				if (comp(m_data[i - 1]))
+					return i - 1;
+			return {};
+		}
+
+		constexpr bool starts_with(BAN::StringView target) const
+		{
+			if (target.size() > m_size)
+				return false;
+			for (size_type i = 0; i < target.size(); i++)
+				if (m_data[i] != target[i])
+					return false;
+			return true;
+		}
+
+		constexpr bool contains(char ch) const
+		{
+			for (size_type i = 0; i < m_size; i++)
+				if (m_data[i] == ch)
+					return true;
+			return false;
+		}
+
+		constexpr size_type count(char ch) const
+		{
+			size_type result = 0;
+			for (size_type i = 0; i < m_size; i++)
+				if (m_data[i] == ch)
+					result++;
+			return result;
+		}
+
+		constexpr bool empty() const { return m_size == 0; }
+		constexpr size_type size() const { return m_size; }
+		constexpr const char* data() const { return m_data; }
 
 	private:
 		const char*	m_data = nullptr;
 		size_type	m_size = 0;
 	};
 
+	template<>
+	struct hash<StringView>
+	{
+		hash_t operator()(StringView string) const
+		{
+			constexpr hash_t FNV_offset_basis = 0x811c9dc5;
+			constexpr hash_t FNV_prime = 0x01000193;
+
+			hash_t hash = FNV_offset_basis;
+			for (StringView::size_type i = 0; i < string.size(); i++)
+			{
+				hash *= FNV_prime;
+				hash ^= (uint8_t)string[i];
 			}
 
-inline BAN::StringView operator""sv(const char* str, BAN::StringView::size_type len) { return BAN::StringView(str, len); }
+			return hash;
+		}
+	};
+
+}
+
+inline constexpr BAN::StringView operator""_sv(const char* str, BAN::StringView::size_type len) { return BAN::StringView(str, len); }
 
 namespace BAN::Formatter
 {
 
 	template<typename F>
-	void print_argument(F putc, const StringView& sv, const ValueFormat&)
+	void print_argument(F putc, const StringView& sv, const ValueFormat& format)
 	{
 		for (StringView::size_type i = 0; i < sv.size(); i++)
 			putc(sv[i]);
+		for (int i = sv.size(); i < format.fill; i++)
+			putc(' ');
 	}
 
 }

BAN/include/BAN/Traits.h

@@ -3,10 +3,10 @@
 namespace BAN
 {
 
-	template<typename T> struct remove_refenrece { using type = T; };
+	template<typename T> struct remove_reference { using type = T; };
-	template<typename T> struct remove_refenrece<T&> { using type =  T; };
+	template<typename T> struct remove_reference<T&> { using type =  T; };
-	template<typename T> struct remove_refenrece<T&&> { using type = T; };
+	template<typename T> struct remove_reference<T&&> { using type = T; };
-	template<typename T> using remove_reference_t = typename remove_refenrece<T>::type;
+	template<typename T> using remove_reference_t = typename remove_reference<T>::type;
 
 	template<typename T> struct remove_const { using type = T; };
 	template<typename T> struct remove_const<const T> { using type = T; };
@@ -34,18 +34,36 @@ namespace BAN
 	template<typename T1, typename T2> struct either_or<true, T1, T2> { using type = T1; };
 	template<bool B, typename T1, typename T2> using either_or_t = typename either_or<B, T1, T2>::type;
 
-	struct true_type { static constexpr bool value = true; };
+	template<typename T, T V> struct integral_constant { static constexpr T value = V; };
-	struct false_type { static constexpr bool value = false; };
+	template<typename T, T V > inline constexpr T integral_constant_v = integral_constant<T, V>::value;
+	using true_type = integral_constant<bool, true>;
+	using false_type = integral_constant<bool, false>;
 
 	template<typename T, typename S>	struct is_same			: false_type {};
 	template<typename T>				struct is_same<T, T>	: true_type {};
 	template<typename T, typename S> inline constexpr bool is_same_v = is_same<T, S>::value;
+	template<typename T, typename S> concept same_as = BAN::is_same_v<T, S>;
 
 	template<typename T> struct is_lvalue_reference		: false_type {};
 	template<typename T> struct is_lvalue_reference<T&>	: true_type {};
 	template<typename T> inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<T>::value;
 	template<typename T> concept lvalue_reference = is_lvalue_reference_v<T>;
 
+	template<typename T, typename... Args> struct is_constructible { static constexpr bool value = __is_constructible(T, Args...); };
+	template<typename T, typename... Args> inline constexpr bool is_constructible_v = is_constructible<T, Args...>::value;
+
+	template<typename T> struct is_default_constructible { static constexpr bool value = is_constructible_v<T>; };
+	template<typename T> inline constexpr bool is_default_constructible_v = is_default_constructible<T>::value;
+
+	template<typename T> struct is_copy_constructible { static constexpr bool value = is_constructible_v<T, const T&>; };
+	template<typename T> inline constexpr bool is_copy_constructible_v = is_copy_constructible<T>::value;
+
+	template<typename T> struct is_move_constructible { static constexpr bool value = is_constructible_v<T, T&&>; };
+	template<typename T> inline constexpr bool is_move_constructible_v = is_move_constructible<T>::value;
+
+	template<typename T> struct is_trivially_copyable { static constexpr bool value = __is_trivially_copyable(T); };
+	template<typename T> inline constexpr bool is_trivially_copyable_v = is_trivially_copyable<T>::value;
+
 	template<typename T> struct is_integral { static constexpr bool value = requires (T t, T* p, void (*f)(T)) { reinterpret_cast<T>(t); f(0); p + t; }; };
 	template<typename T> inline constexpr bool is_integral_v = is_integral<T>::value;
 	template<typename T> concept integral = is_integral_v<T>;
@@ -72,13 +90,61 @@ namespace BAN
 	template<typename T> struct is_arithmetic { static constexpr bool value = is_integral_v<T> || is_floating_point_v<T>; };
 	template<typename T> inline constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
 
+	template<typename Base, typename Derived> struct is_base_of { static constexpr bool value = __is_base_of(Base, Derived); };
+	template<typename Base, typename Derived> inline constexpr bool is_base_of_v = is_base_of<Base, Derived>::value;
+
+	template<typename T> struct is_pod { static constexpr bool value = __is_pod(T); };
+	template<typename T> inline constexpr bool is_pod_v = is_pod<T>::value;
+
 	namespace detail
 	{
 		template<typename T, bool = is_arithmetic_v<T>> struct is_signed { static constexpr bool value = T(-1) < T(0); };
 		template<typename T> struct is_signed<T, false> : false_type {};
+
+		template<typename T, bool = is_arithmetic_v<T>> struct is_unsigned { static constexpr bool value = T(0) < T(-1); };
+		template<typename T> struct is_unsigned<T, false> : false_type {};
 	}
 	template<typename T> struct is_signed : detail::is_signed<T> {};
 	template<typename T> inline constexpr bool is_signed_v = is_signed<T>::value;
+	template<typename T> concept signed_integral = is_signed_v<T> && is_integral_v<T>;
+
+	template<typename T> struct is_unsigned : detail::is_unsigned<T> {};
+	template<typename T> inline constexpr bool is_unsigned_v = is_unsigned<T>::value;
+	template<typename T> concept unsigned_integral = is_unsigned_v<T> && is_integral_v<T>;
+
+#define __BAN_TRAITS_MAKE_UNSIGNED_CV(__type)																	\
+	template<> struct make_unsigned<__type>					{ using type = unsigned __type; };					\
+	template<> struct make_unsigned<const __type>			{ using type = unsigned const __type; };			\
+	template<> struct make_unsigned<volatile __type>		{ using type = unsigned volatile __type; };			\
+	template<> struct make_unsigned<const volatile __type>	{ using type = unsigned const volatile __type; };
+
+	template<typename T> requires is_arithmetic_v<T> struct make_unsigned { using type = T; };
+	__BAN_TRAITS_MAKE_UNSIGNED_CV(char)
+	__BAN_TRAITS_MAKE_UNSIGNED_CV(short)
+	__BAN_TRAITS_MAKE_UNSIGNED_CV(int)
+	__BAN_TRAITS_MAKE_UNSIGNED_CV(long)
+	__BAN_TRAITS_MAKE_UNSIGNED_CV(long long)
+	template<typename T> using make_unsigned_t = typename make_unsigned<T>::type;
+#undef __BAN_TRAITS_MAKE_UNSIGNED_CV
+
+#define __BAN_TRAITS_MAKE_SIGNED_CV(__type)																		\
+	template<> struct make_signed<unsigned __type>					{ using type = __type; };					\
+	template<> struct make_signed<unsigned const __type>			{ using type = const __type; };				\
+	template<> struct make_signed<unsigned volatile __type>			{ using type = volatile __type; };			\
+	template<> struct make_signed<unsigned const volatile __type>	{ using type = const volatile __type; };
+
+	template<typename T> requires is_arithmetic_v<T> struct make_signed { using type = T; };
+	__BAN_TRAITS_MAKE_SIGNED_CV(char)
+	__BAN_TRAITS_MAKE_SIGNED_CV(short)
+	__BAN_TRAITS_MAKE_SIGNED_CV(int)
+	__BAN_TRAITS_MAKE_SIGNED_CV(long)
+	__BAN_TRAITS_MAKE_SIGNED_CV(long long)
+	template<typename T> using make_signed_t = typename make_signed<T>::type;
+#undef __BAN_TRAITS_MAKE_SIGNED_CV
+
+	template<typename T> struct it_value_type { using value_type = T::value_type; };
+	template<typename T> struct it_value_type<T*> { using value_type = T; };
+	template<typename T> using it_value_type_t = typename it_value_type<T>::value_type;
 
 	template<typename T> struct less	{ constexpr bool operator()(const T& lhs, const T& rhs) const { return lhs < rhs; } };
 	template<typename T> struct equal	{ constexpr bool operator()(const T& lhs, const T& rhs) const { return lhs == rhs; } };

BAN/include/BAN/UTF8.h

@@ -18,23 +18,24 @@ namespace BAN::UTF8
 			return 3;
 		if ((first_byte & 0xF8) == 0xF0)
 			return 4;
-		return 0;
+		return UTF8::invalid;
 	}
 
-	constexpr uint32_t to_codepoint(uint8_t* bytes)
+	template<typename T> requires (sizeof(T) == 1)
+	constexpr uint32_t to_codepoint(const T* bytes)
 	{
 		uint32_t length = byte_length(bytes[0]);
 
 		for (uint32_t i = 1; i < length; i++)
-			if ((bytes[i] & 0xC0) != 0x80)
+			if (((uint8_t)bytes[i] & 0xC0) != 0x80)
 				return UTF8::invalid;
 
 		switch (length)
 		{
-			case 1: return ((bytes[0] & 0x80) != 0x00) ? UTF8::invalid :   bytes[0];
+			case 1: return (((uint8_t)bytes[0] & 0x80) != 0x00) ? UTF8::invalid :   (uint8_t)bytes[0];
-			case 2: return ((bytes[0] & 0xE0) != 0xC0) ? UTF8::invalid : ((bytes[0] & 0x1F) <<  6) |  (bytes[1] & 0x3F);
+			case 2: return (((uint8_t)bytes[0] & 0xE0) != 0xC0) ? UTF8::invalid : (((uint8_t)bytes[0] & 0x1F) <<  6) |  ((uint8_t)bytes[1] & 0x3F);
-			case 3: return ((bytes[0] & 0xF0) != 0xE0) ? UTF8::invalid : ((bytes[0] & 0x0F) << 12) | ((bytes[1] & 0x3F) <<  6) |  (bytes[2] & 0x3F);
+			case 3: return (((uint8_t)bytes[0] & 0xF0) != 0xE0) ? UTF8::invalid : (((uint8_t)bytes[0] & 0x0F) << 12) | (((uint8_t)bytes[1] & 0x3F) <<  6) |  ((uint8_t)bytes[2] & 0x3F);
-			case 4: return ((bytes[0] & 0xF8) != 0xF0) ? UTF8::invalid : ((bytes[0] & 0x07) << 18) | ((bytes[1] & 0x3F) << 12) | ((bytes[2] & 0x3F) << 6) | (bytes[3] & 0x3F);
+			case 4: return (((uint8_t)bytes[0] & 0xF8) != 0xF0) ? UTF8::invalid : (((uint8_t)bytes[0] & 0x07) << 18) | (((uint8_t)bytes[1] & 0x3F) << 12) | (((uint8_t)bytes[2] & 0x3F) << 6) | ((uint8_t)bytes[3] & 0x3F);
 		}
 
 		return UTF8::invalid;
@@ -75,6 +76,8 @@ namespace BAN::UTF8
 			}
 		}
 
+		*ptr = '\0';
+
 		return true;
 	}
 

BAN/include/BAN/UniqPtr.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <BAN/Errors.h>
+#include <BAN/Hash.h>
 #include <BAN/NoCopyMove.h>
 
 namespace BAN
@@ -33,8 +34,9 @@ namespace BAN
 			return uniq;
 		}
 
+		// NOTE: don't use is_constructible_v<T, Args...> as UniqPtr<T> is allowed with friends
 		template<typename... Args>
-		static BAN::ErrorOr<UniqPtr> create(Args&&... args)
+		static BAN::ErrorOr<UniqPtr> create(Args&&... args) requires requires(Args&&... args) { T(forward<Args>(args)...); }
 		{
 			UniqPtr uniq;
 			uniq.m_pointer = new T(BAN::forward<Args>(args)...);
@@ -52,32 +54,12 @@ namespace BAN
 			return *this;
 		}
 
-		T& operator*()
+		T* ptr() const { return m_pointer; }
-		{
+		T& operator*() const { ASSERT(!empty()); return *ptr(); }
-			ASSERT(m_pointer);
+		T* operator->() const { ASSERT(!empty()); return ptr(); }
-			return *m_pointer;
-		}
 
-		const T& operator*() const
+		bool empty() const { return m_pointer == nullptr; }
-		{
+		explicit operator bool() const { return m_pointer; }
-			ASSERT(m_pointer);
-			return *m_pointer;
-		}
-
-		T* operator->()
-		{
-			ASSERT(m_pointer);
-			return m_pointer;	
-		}
-
-		const T* operator->() const
-		{
-			ASSERT(m_pointer);
-			return m_pointer;
-		}
-
-		T* ptr() { return m_pointer; }
-		const T* ptr() const { return m_pointer; }
 
 		void clear()
 		{
@@ -86,8 +68,6 @@ namespace BAN
 			m_pointer = nullptr;
 		}
 
-		operator bool() const { return m_pointer != nullptr; }
-
 	private:
 		T* m_pointer = nullptr;
 
@@ -95,4 +75,13 @@ namespace BAN
 		friend class UniqPtr;
 	};
 
+	template<typename T>
+	struct hash<UniqPtr<T>>
+	{
+		constexpr hash_t operator()(const UniqPtr<T>& ptr) const
+		{
+			return hash<T*>()(ptr.ptr());
+		}
+	};
+
 }

BAN/include/BAN/Variant.h

@@ -3,7 +3,7 @@
 #include <BAN/Assert.h>
 #include <BAN/Math.h>
 #include <BAN/Move.h>
-#include <BAN/New.h>
+#include <BAN/PlacementNew.h>
 
 #include <string.h>
 
@@ -126,6 +126,7 @@ namespace BAN
 		Variant(Variant&& other)
 			: m_index(other.m_index)
 		{
+			if (other.has_value())
 				detail::move_construct<Ts...>(other.m_index, other.m_storage, m_storage);
 			other.clear();
 		}
@@ -133,6 +134,7 @@ namespace BAN
 		Variant(const Variant& other)
 			: m_index(other.m_index)
 		{
+			if (other.has_value())
 				detail::copy_construct<Ts...>(other.m_index, other.m_storage, m_storage);
 		}
 
@@ -157,11 +159,12 @@ namespace BAN
 
 		Variant& operator=(Variant&& other)
 		{
-			if (m_index == other.m_index)
+			if (m_index == other.m_index && m_index != invalid_index())
 				detail::move_assign<Ts...>(m_index, other.m_storage, m_storage);
 			else
 			{
 				clear();
+				if (other.has_value())
 					detail::move_construct<Ts...>(other.m_index, other.m_storage, m_storage);
 				m_index = other.m_index;
 			}
@@ -171,11 +174,12 @@ namespace BAN
 
 		Variant& operator=(const Variant& other)
 		{
-			if (m_index == other.m_index)
+			if (m_index == other.m_index && m_index != invalid_index())
 				detail::copy_assign<Ts...>(m_index, other.m_storage, m_storage);
 			else
 			{
 				clear();
+				if (other.has_value())
 					detail::copy_construct<Ts...>(other.m_index, other.m_storage, m_storage);
 				m_index = other.m_index;
 			}
@@ -216,6 +220,14 @@ namespace BAN
 			return m_index == detail::index<T, Ts...>();
 		}
 
+		template<typename T, typename... Args>
+		void emplace(Args&&... args) requires (can_have<T>() && is_constructible_v<T, Args...>)
+		{
+			clear();
+			m_index = detail::index<T, Ts...>();
+			new (m_storage) T(BAN::forward<Args>(args)...);
+		}
+
 		template<typename T>
 		void set(T&& value) requires (can_have<T>() && !is_lvalue_reference_v<T>)
 		{
@@ -278,6 +290,16 @@ namespace BAN
 			return **reinterpret_cast<const remove_reference_t<T>**>(m_storage);
 		}
 
+		bool has_value() const
+		{
+			return m_index != invalid_index();
+		}
+
+		explicit operator bool() const
+		{
+			return has_value();
+		}
+
 		void clear()
 		{
 			if (m_index != invalid_index())

BAN/include/BAN/Vector.h

@@ -5,7 +5,9 @@
 #include <BAN/Math.h>
 #include <BAN/Move.h>
 #include <BAN/New.h>
+#include <BAN/PlacementNew.h>
 #include <BAN/Span.h>
+#include <BAN/Swap.h>
 
 namespace BAN
 {
@@ -33,9 +35,9 @@ namespace BAN
 		ErrorOr<void> push_back(T&&);
 		ErrorOr<void> push_back(const T&);
 		template<typename... Args>
-		ErrorOr<void> emplace_back(Args&&...);
+		ErrorOr<void> emplace_back(Args&&...) requires is_constructible_v<T, Args...>;
 		template<typename... Args>
-		ErrorOr<void> emplace(size_type, Args&&...);
+		ErrorOr<void> emplace(size_type, Args&&...) requires is_constructible_v<T, Args...>;
 		ErrorOr<void> insert(size_type, T&&);
 		ErrorOr<void> insert(size_type, const T&);
 
@@ -54,7 +56,7 @@ namespace BAN
 		bool contains(const T&) const;
 
 		Span<T> span() { return Span(m_data, m_size); }
-		const Span<T> span() const { return Span(m_data, m_size); }
+		Span<const T> span() const { return Span(m_data, m_size); }
 
 		const T& operator[](size_type) const;
 		T& operator[](size_type);
@@ -64,7 +66,10 @@ namespace BAN
 		const T& front() const;
 		T& front();
 
-		ErrorOr<void> resize(size_type, const T& = T());
+		void reverse();
+
+		ErrorOr<void> resize(size_type)				requires is_default_constructible_v<T>;
+		ErrorOr<void> resize(size_type, const T&)	requires is_copy_constructible_v<T>;
 		ErrorOr<void> reserve(size_type);
 		ErrorOr<void> shrink_to_fit();
 
@@ -136,10 +141,13 @@ namespace BAN
 	template<typename T>
 	Vector<T>& Vector<T>::operator=(const Vector<T>& other)
 	{
-		clear();
 		MUST(ensure_capacity(other.size()));
-		for (size_type i = 0; i < other.size(); i++)
+		for (size_type i = 0; i < BAN::Math::min(size(), other.size()); i++)
+			m_data[i] = other.m_data[i];
+		for (size_type i = size(); i < other.size(); i++)
 			new (m_data + i) T(other[i]);
+		for (size_type i = other.size(); i < size(); i++)
+			m_data[i].~T();
 		m_size = other.m_size;
 		return *this;
 	}
@@ -161,7 +169,7 @@ namespace BAN
 
 	template<typename T>
 	template<typename... Args>
-	ErrorOr<void> Vector<T>::emplace_back(Args&&... args)
+	ErrorOr<void> Vector<T>::emplace_back(Args&&... args) requires is_constructible_v<T, Args...>
 	{
 		TRY(ensure_capacity(m_size + 1));
 		new (m_data + m_size) T(forward<Args>(args)...);
@@ -171,7 +179,7 @@ namespace BAN
 
 	template<typename T>
 	template<typename... Args>
-	ErrorOr<void> Vector<T>::emplace(size_type index, Args&&... args)
+	ErrorOr<void> Vector<T>::emplace(size_type index, Args&&... args) requires is_constructible_v<T, Args...>
 	{
 		ASSERT(index <= m_size);
 		TRY(ensure_capacity(m_size + 1));
@@ -297,7 +305,28 @@ namespace BAN
 	}
 
 	template<typename T>
-	ErrorOr<void> Vector<T>::resize(size_type size, const T& value)
+	void Vector<T>::reverse()
+	{
+		for (size_type i = 0; i < m_size / 2; i++)
+			BAN::swap(m_data[i], m_data[m_size - i - 1]);
+	}
+
+	template<typename T>
+	ErrorOr<void> Vector<T>::resize(size_type size) requires is_default_constructible_v<T>
+	{
+		TRY(ensure_capacity(size));
+		if (size < m_size)
+			for (size_type i = size; i < m_size; i++)
+				m_data[i].~T();
+		if (size > m_size)
+			for (size_type i = m_size; i < size; i++)
+				new (m_data + i) T();
+		m_size = size;
+		return {};
+	}
+
+	template<typename T>
+	ErrorOr<void> Vector<T>::resize(size_type size, const T& value) requires is_copy_constructible_v<T>
 	{
 		TRY(ensure_capacity(size));
 		if (size < m_size)
@@ -352,10 +381,35 @@ namespace BAN
 	template<typename T>
 	ErrorOr<void> Vector<T>::ensure_capacity(size_type size)
 	{
+		static_assert(alignof(T) <= alignof(max_align_t), "over aligned types not supported");
+
 		if (m_capacity >= size)
 			return {};
-		size_type new_cap = BAN::Math::max<size_type>(size, m_capacity * 2);
+
-		T* new_data = (T*)BAN::allocator(new_cap * sizeof(T));
+		const size_type new_cap = BAN::Math::max<size_type>(size, m_capacity * 2);
+
+		if constexpr (BAN::is_trivially_copyable_v<T>)
+		{
+			if constexpr (BAN::reallocator)
+			{
+				auto* new_data = static_cast<T*>(BAN::reallocator(m_data, new_cap * sizeof(T)));
+				if (new_data == nullptr)
+					return Error::from_errno(ENOMEM);
+				m_data = new_data;
+			}
+			else
+			{
+				auto* new_data = static_cast<T*>(BAN::allocator(new_cap * sizeof(T)));
+				if (new_data == nullptr)
+					return Error::from_errno(ENOMEM);
+				memcpy(new_data, m_data, m_size * sizeof(T));
+				BAN::deallocator(m_data);
+				m_data = new_data;
+			}
+		}
+		else
+		{
+			auto* new_data = static_cast<T*>(BAN::allocator(new_cap * sizeof(T)));
 			if (new_data == nullptr)
 				return Error::from_errno(ENOMEM);
 			for (size_type i = 0; i < m_size; i++)
@@ -365,6 +419,8 @@ namespace BAN
 			}
 			BAN::deallocator(m_data);
 			m_data = new_data;
+		}
+
 		m_capacity = new_cap;
 		return {};
 	}

BAN/include/BAN/WeakPtr.h

@@ -2,6 +2,10 @@
 
 #include <BAN/RefPtr.h>
 
+#if __is_kernel
+#include <kernel/Lock/SpinLock.h>
+#endif
+
 namespace BAN
 {
 
@@ -11,22 +15,37 @@ namespace BAN
 	template<typename T>
 	class WeakPtr;
 
+	// FIXME: Write this without using locks...
 	template<typename T>
 	class WeakLink : public RefCounted<WeakLink<T>>
 	{
 	public:
-		RefPtr<T> lock() { ASSERT(m_ptr); return raw_ptr(); }
+		RefPtr<T> try_lock() const
-		T* raw_ptr() { return m_ptr; }
+		{
-
+#if __is_kernel
+			Kernel::SpinLockGuard _(m_weak_lock);
+#endif
+			if (m_ptr && m_ptr->try_ref())
+				return RefPtr<T>::adopt(m_ptr);
+			return nullptr;
+		}
 		bool valid() const { return m_ptr; }
-		void invalidate() { m_ptr = nullptr; }
+		void invalidate()
+		{
+#if __is_kernel
+			Kernel::SpinLockGuard _(m_weak_lock);
+#endif
+			m_ptr = nullptr;
+		}
 
 	private:
 		WeakLink(T* ptr) : m_ptr(ptr) {}
 
 	private:
 		T* m_ptr;
-
+#if __is_kernel
+		mutable Kernel::SpinLock m_weak_lock;
+#endif
 		friend class RefPtr<WeakLink<T>>;
 	};
 
@@ -34,7 +53,7 @@ namespace BAN
 	class Weakable
 	{
 	public:
-		~Weakable()
+		virtual ~Weakable()
 		{
 			if (m_link)
 				m_link->invalidate();
@@ -80,10 +99,10 @@ namespace BAN
 			return *this;
 		}
 
-		RefPtr<T> lock()
+		RefPtr<T> lock() const
 		{
-			if (m_link->valid())
+			if (m_link)
-				return m_link->lock();
+				return m_link->try_lock();
 			return nullptr;
 		}
 
@@ -91,6 +110,8 @@ namespace BAN
 
 		bool valid() const { return m_link && m_link->valid(); }
 
+		explicit operator bool() const { return valid(); }
+
 	private:
 		WeakPtr(const RefPtr<WeakLink<T>>& link)
 			: m_link(link)

CMakeLists.txt

@@ -4,42 +4,51 @@ if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "banan-os")
 	message(FATAL_ERROR "CMAKE_SYSTEM_NAME is not banan-os")
 endif ()
 
-add_compile_options(-mno-sse -mno-sse2)
-add_compile_definitions(__enable_sse=0)
-
 project(banan-os CXX C ASM)
 
-set(BANAN_BASE_SYSROOT ${CMAKE_SOURCE_DIR}/base-sysroot.tar.gz)
 set(BANAN_INCLUDE ${BANAN_SYSROOT}/usr/include)
 set(BANAN_LIB     ${BANAN_SYSROOT}/usr/lib)
 set(BANAN_BIN     ${BANAN_SYSROOT}/usr/bin)
+set(BANAN_ETC     ${BANAN_SYSROOT}/usr/etc)
 set(BANAN_SHARE   ${BANAN_SYSROOT}/usr/share)
 set(BANAN_BOOT    ${BANAN_SYSROOT}/boot)
 
+set(CMAKE_INSTALL_BINDIR     ${BANAN_BIN})
+set(CMAKE_INSTALL_SBINDIR    ${BANAN_BIN})
+set(CMAKE_INSTALL_LIBDIR     ${BANAN_LIB})
+set(CMAKE_INSTALL_INCLUDEDIR ${BANAN_INCLUDE})
+set(CMAKE_INSTALL_SYSCONF    ${BANAN_ETC})
+set(CMAKE_INSTALL_MESSAGE    NEVER)
+set(CMAKE_SKIP_INSTALL_ALL_DEPENDENCY True)
+
+set(CMAKE_STATIC_LIBRARY_PREFIX "")
+set(CMAKE_SHARED_LIBRARY_PREFIX "")
+set(BUILD_SHARED_LIBS True)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# include headers of ${library} to ${target}
+function(banan_include_headers target library)
+	target_include_directories(${target} PUBLIC $<TARGET_PROPERTY:${library},SOURCE_DIR>/include)
+endfunction()
+
+# include headers and link ${library} to ${target}
+function(banan_link_library target library)
+	target_link_libraries(${target} PUBLIC ${library})
+	banan_include_headers(${target} ${library})
+endfunction()
+
+# add install step for all header files of target
+function(banan_install_headers target)
+	file(GLOB_RECURSE headers RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/include *.h)
+	foreach(header ${headers})
+		get_filename_component(subdirectory ${header} DIRECTORY)
+		install(FILES include/${header} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${subdirectory})
+	endforeach()
+	target_include_directories(${target} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+endfunction()
+
 add_subdirectory(kernel)
 add_subdirectory(bootloader)
 add_subdirectory(BAN)
-add_subdirectory(libc)
-add_subdirectory(LibELF)
 add_subdirectory(userspace)
-
-add_custom_target(sysroot
-	COMMAND ${CMAKE_COMMAND} -E make_directory ${BANAN_SYSROOT}
-	COMMAND cd ${BANAN_SYSROOT} && tar xf ${BANAN_BASE_SYSROOT}
-)
-
-add_custom_target(headers
-	DEPENDS kernel-headers
-	DEPENDS ban-headers
-	DEPENDS libc-headers
-	DEPENDS libelf-headers
-)
-
-add_custom_target(install-sysroot
-	COMMAND cd ${BANAN_SYSROOT} && tar cf ${BANAN_SYSROOT_TAR} *
-	DEPENDS kernel-install
-	DEPENDS ban-install
-	DEPENDS libc-install
-	DEPENDS userspace-install
-	DEPENDS libelf-install
-)

LibELF/CMakeLists.txt

@@ -1,12 +0,0 @@
-cmake_minimum_required(VERSION 3.26)
-
-project(LibELF CXX)
-
-add_custom_target(libelf-headers
-	COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different ${CMAKE_CURRENT_SOURCE_DIR}/include/ ${BANAN_INCLUDE}/
-	DEPENDS sysroot
-)
-
-add_custom_target(libelf-install
-	DEPENDS libelf-headers
-)

LibELF/LibELF/ELF.cpp

@@ -1,406 +0,0 @@
-#include <BAN/ScopeGuard.h>
-#include <LibELF/ELF.h>
-#include <LibELF/Values.h>
-
-#ifdef __is_kernel
-#include <kernel/FS/VirtualFileSystem.h>
-#include <kernel/Memory/PageTableScope.h>
-#include <kernel/Process.h>
-#endif
-
-#include <fcntl.h>
-
-#define ELF_PRINT_HEADERS 0
-
-#ifdef __is_kernel
-extern uint8_t g_kernel_end[];
-using namespace Kernel;
-#endif
-
-namespace LibELF
-{
-
-#ifdef __is_kernel
-	BAN::ErrorOr<BAN::UniqPtr<ELF>> ELF::load_from_file(BAN::RefPtr<Inode> inode)
-	{
-		BAN::Vector<uint8_t> buffer;
-		TRY(buffer.resize(inode->size()));
-
-		TRY(inode->read(0, buffer.data(), inode->size()));
-
-		ELF* elf_ptr = new ELF(BAN::move(buffer));
-		if (elf_ptr == nullptr)
-			return BAN::Error::from_errno(ENOMEM);
-
-		auto elf = BAN::UniqPtr<ELF>::adopt(elf_ptr);
-		TRY(elf->load());
-
-		return BAN::move(elf);
-	}
-#else
-	BAN::ErrorOr<ELF*> ELF::load_from_file(BAN::StringView file_path)
-	{
-		ELF* elf = nullptr;
-
-		{
-			BAN::Vector<uint8_t> data;
-
-			int fd = TRY(Kernel::Process::current().open(file_path, O_RDONLY));
-			BAN::ScopeGuard _([fd] { MUST(Kernel::Process::current().close(fd)); });
-
-			struct stat st;
-			TRY(Kernel::Process::current().fstat(fd, &st));
-
-			TRY(data.resize(st.st_size));
-
-			TRY(Kernel::Process::current().read(fd, data.data(), data.size()));
-
-			elf = new ELF(BAN::move(data));
-			ASSERT(elf);
-		}
-
-		if (auto res = elf->load(); res.is_error())
-		{
-			delete elf;
-			return res.error();
-		}
-
-		return elf;
-	}
-#endif
-
-	BAN::ErrorOr<void> ELF::load()
-	{
-		if (m_data.size() < EI_NIDENT)
-		{
-			dprintln("Too small ELF file");
-			return BAN::Error::from_errno(EINVAL);
-		}
-
-		if (m_data[EI_MAG0] != ELFMAG0 || 
-			m_data[EI_MAG1] != ELFMAG1 ||
-			m_data[EI_MAG2] != ELFMAG2 ||
-			m_data[EI_MAG3] != ELFMAG3)
-		{
-			dprintln("Invalid ELF header");
-			return BAN::Error::from_errno(EINVAL);
-		}
-
-		if (m_data[EI_DATA] != ELFDATA2LSB)
-		{
-			dprintln("Only little-endian is supported");
-			return BAN::Error::from_errno(EINVAL);
-		}
-
-		if (m_data[EI_VERSION] != EV_CURRENT)
-		{
-			dprintln("Invalid ELF version");
-			return BAN::Error::from_errno(EINVAL);
-		}
-
-		if (m_data[EI_CLASS] == ELFCLASS64)
-		{
-			if (m_data.size() <= sizeof(Elf64FileHeader))
-			{
-				dprintln("Too small ELF file");
-				return BAN::Error::from_errno(EINVAL);
-			}
-
-			auto& header = file_header64();
-			if (!parse_elf64_file_header(header))
-				return BAN::Error::from_errno(EINVAL);
-
-			for (size_t i = 0; i < header.e_phnum; i++)
-			{
-				auto& program_header = program_header64(i);
-				if (!parse_elf64_program_header(program_header))
-					return BAN::Error::from_errno(EINVAL);
-			}
-
-			for (size_t i = 1; i < header.e_shnum; i++)
-			{
-				auto& section_header = section_header64(i);
-				if (!parse_elf64_section_header(section_header))
-					return BAN::Error::from_errno(EINVAL);
-			}
-		}
-		else if (m_data[EI_CLASS] == ELFCLASS32)
-		{
-			if (m_data.size() <= sizeof(Elf32FileHeader))
-			{
-				dprintln("Too small ELF file");
-				return BAN::Error::from_errno(EINVAL);
-			}
-
-			auto& header = file_header32();
-			if (!parse_elf32_file_header(header))
-				return BAN::Error::from_errno(EINVAL);
-
-			for (size_t i = 0; i < header.e_phnum; i++)
-			{
-				auto& program_header = program_header32(i);
-				if (!parse_elf32_program_header(program_header))
-					return BAN::Error::from_errno(EINVAL);
-			}
-
-			for (size_t i = 1; i < header.e_shnum; i++)
-			{
-				auto& section_header = section_header32(i);
-				if (!parse_elf32_section_header(section_header))
-					return BAN::Error::from_errno(EINVAL);
-			}
-		}
-
-		return {};
-	}
-
-	bool ELF::is_x86_32() const { return m_data[EI_CLASS] == ELFCLASS32; }
-	bool ELF::is_x86_64() const { return m_data[EI_CLASS] == ELFCLASS64; }
-
-	/*
-
-		64 bit ELF
-
-	*/
-
-	const char* ELF::lookup_section_name64(uint32_t offset) const
-	{
-		return lookup_string64(file_header64().e_shstrndx, offset);
-	}
-
-	const char* ELF::lookup_string64(size_t table_index, uint32_t offset) const
-	{
-		if (table_index == SHN_UNDEF)
-			return nullptr;
-		auto& section_header = section_header64(table_index);
-		return (const char*)m_data.data() + section_header.sh_offset + offset;
-	}
-
-	bool ELF::parse_elf64_file_header(const Elf64FileHeader& header)
-	{
-		if (header.e_type != ET_EXEC)
-		{
-			dprintln("Only executable files are supported");
-			return false;
-		}
-
-		if (header.e_version != EV_CURRENT)
-		{
-			dprintln("Invalid ELF version");
-			return false;
-		}
-
-		return true;
-	}
-
-	bool ELF::parse_elf64_program_header(const Elf64ProgramHeader& header)
-	{
-#if ELF_PRINT_HEADERS
-		dprintln("program header");
-		dprintln("  type   {H}", header.p_type);
-		dprintln("  flags  {H}", header.p_flags);
-		dprintln("  offset {H}", header.p_offset);
-		dprintln("  vaddr  {H}", header.p_vaddr);
-		dprintln("  paddr  {H}", header.p_paddr);
-		dprintln("  filesz {}", header.p_filesz);
-		dprintln("  memsz  {}", header.p_memsz);
-		dprintln("  align  {}", header.p_align);
-#endif
-		(void)header;
-		return true;
-	}
-
-	bool ELF::parse_elf64_section_header(const Elf64SectionHeader& header)
-	{
-#if ELF_PRINT_HEADERS
-		if (auto* name = lookup_section_name64(header.sh_name))
-			dprintln("{}", name);
-
-		switch (header.sh_type)
-		{
-			case SHT_NULL:
-				dprintln("  SHT_NULL");
-				break;
-			case SHT_PROGBITS:
-				dprintln("  SHT_PROGBITS");
-				break;
-			case SHT_SYMTAB:
-				for (size_t i = 1; i < header.sh_size / header.sh_entsize; i++)
-				{
-					auto& symbol = ((const Elf64Symbol*)(m_data.data() + header.sh_offset))[i];
-					if (auto* name = lookup_string64(header.sh_link, symbol.st_name))
-						dprintln("  {}", name);
-				}
-				break;
-			case SHT_STRTAB:
-				dprintln("  SHT_STRTAB");
-				break;
-			case SHT_RELA:
-				dprintln("  SHT_RELA");
-				break;
-			case SHT_NOBITS:
-				dprintln("  SHT_NOBITS");
-				break;
-			case SHT_REL:
-				dprintln("  SHT_REL");
-				break;
-			case SHT_SHLIB:
-				dprintln("  SHT_SHLIB");
-				break;
-			case SHT_DYNSYM:
-				dprintln("  SHT_DYNSYM");
-				break;
-			default:
-				ASSERT(false);
-		}	
-#endif
-		(void)header;
-		return true;
-	}
-
-	const Elf64FileHeader& ELF::file_header64() const
-	{
-		ASSERT(is_x86_64());
-		return *(const Elf64FileHeader*)m_data.data();
-	}
-
-	const Elf64ProgramHeader& ELF::program_header64(size_t index) const
-	{
-		ASSERT(is_x86_64());
-		const auto& file_header = file_header64();
-		ASSERT(index < file_header.e_phnum);
-		return *(const Elf64ProgramHeader*)(m_data.data() + file_header.e_phoff + file_header.e_phentsize * index);
-	}
-
-	const Elf64SectionHeader& ELF::section_header64(size_t index) const
-	{
-		ASSERT(is_x86_64());
-		const auto& file_header = file_header64();
-		ASSERT(index < file_header.e_shnum);
-		return *(const Elf64SectionHeader*)(m_data.data() + file_header.e_shoff + file_header.e_shentsize * index);
-	}
-
-	/*
-
-		32 bit ELF
-
-	*/
-
-	const char* ELF::lookup_section_name32(uint32_t offset) const
-	{
-		return lookup_string32(file_header32().e_shstrndx, offset);
-	}
-
-	const char* ELF::lookup_string32(size_t table_index, uint32_t offset) const
-	{
-		if (table_index == SHN_UNDEF)
-			return nullptr;
-		auto& section_header = section_header32(table_index);
-		return (const char*)m_data.data() + section_header.sh_offset + offset;
-	}
-
-	bool ELF::parse_elf32_file_header(const Elf32FileHeader& header)
-	{
-		if (header.e_type != ET_EXEC)
-		{
-			dprintln("Only executable files are supported");
-			return false;
-		}
-
-		if (header.e_version != EV_CURRENT)
-		{
-			dprintln("Invalid ELF version");
-			return false;
-		}
-
-		return true;
-	}
-
-	bool ELF::parse_elf32_program_header(const Elf32ProgramHeader& header)
-	{
-#if ELF_PRINT_HEADERS
-		dprintln("program header");
-		dprintln("  type   {H}", header.p_type);
-		dprintln("  flags  {H}", header.p_flags);
-		dprintln("  offset {H}", header.p_offset);
-		dprintln("  vaddr  {H}", header.p_vaddr);
-		dprintln("  paddr  {H}", header.p_paddr);
-		dprintln("  filesz {}", header.p_filesz);
-		dprintln("  memsz  {}", header.p_memsz);
-		dprintln("  align  {}", header.p_align);
-#endif
-		(void)header;
-		return true;
-	}
-
-	bool ELF::parse_elf32_section_header(const Elf32SectionHeader& header)
-	{
-#if ELF_PRINT_HEADERS
-		if (auto* name = lookup_section_name32(header.sh_name))
-			dprintln("{}", name);
-
-		switch (header.sh_type)
-		{
-			case SHT_NULL:
-				dprintln("  SHT_NULL");
-				break;
-			case SHT_PROGBITS:
-				dprintln("  SHT_PROGBITS");
-				break;
-			case SHT_SYMTAB:
-				for (size_t i = 1; i < header.sh_size / header.sh_entsize; i++)
-				{
-					auto& symbol = ((const Elf32Symbol*)(m_data.data() + header.sh_offset))[i];
-					if (auto* name = lookup_string32(header.sh_link, symbol.st_name))
-						dprintln("  {}", name);
-				}
-				break;
-			case SHT_STRTAB:
-				dprintln("  SHT_STRTAB");
-				break;
-			case SHT_RELA:
-				dprintln("  SHT_RELA");
-				break;
-			case SHT_NOBITS:
-				dprintln("  SHT_NOBITS");
-				break;
-			case SHT_REL:
-				dprintln("  SHT_REL");
-				break;
-			case SHT_SHLIB:
-				dprintln("  SHT_SHLIB");
-				break;
-			case SHT_DYNSYM:
-				dprintln("  SHT_DYNSYM");
-				break;
-			default:
-				ASSERT(false);
-		}	
-#endif
-		(void)header;
-		return true;
-	}
-
-	const Elf32FileHeader& ELF::file_header32() const
-	{
-		ASSERT(is_x86_32());
-		return *(const Elf32FileHeader*)m_data.data();
-	}
-
-	const Elf32ProgramHeader& ELF::program_header32(size_t index) const
-	{
-		ASSERT(is_x86_32());
-		const auto& file_header = file_header32();
-		ASSERT(index < file_header.e_phnum);
-		return *(const Elf32ProgramHeader*)(m_data.data() + file_header.e_phoff + file_header.e_phentsize * index);
-	}
-
-	const Elf32SectionHeader& ELF::section_header32(size_t index) const
-	{
-		ASSERT(is_x86_32());
-		const auto& file_header = file_header32();
-		ASSERT(index < file_header.e_shnum);
-		return *(const Elf32SectionHeader*)(m_data.data() + file_header.e_shoff + file_header.e_shentsize * index);
-	}
-
-}

LibELF/LibELF/LoadableELF.cpp

@@ -1,339 +0,0 @@
-#include <BAN/ScopeGuard.h>
-#include <kernel/CriticalScope.h>
-#include <kernel/Memory/Heap.h>
-#include <kernel/LockGuard.h>
-#include <LibELF/LoadableELF.h>
-#include <LibELF/Values.h>
-
-namespace LibELF
-{
-
-	using namespace Kernel;
-
-	BAN::ErrorOr<BAN::UniqPtr<LoadableELF>> LoadableELF::load_from_inode(PageTable& page_table, BAN::RefPtr<Inode> inode)
-	{
-		auto* elf_ptr = new LoadableELF(page_table, inode);
-		if (elf_ptr == nullptr)
-			return BAN::Error::from_errno(ENOMEM);
-		auto elf = BAN::UniqPtr<LoadableELF>::adopt(elf_ptr);
-		TRY(elf->initialize());
-		return BAN::move(elf);
-	}
-
-	LoadableELF::LoadableELF(PageTable& page_table, BAN::RefPtr<Inode> inode)
-		: m_inode(inode)
-		, m_page_table(page_table)
-	{
-	}
-
-	LoadableELF::~LoadableELF()
-	{
-		if (!m_loaded)
-			return;
-		for (const auto& program_header : m_program_headers)
-		{
-			switch (program_header.p_type)
-			{
-				case PT_NULL:
-					continue;
-				case PT_LOAD:
-				{
-					vaddr_t start = program_header.p_vaddr & PAGE_ADDR_MASK;
-					size_t pages = range_page_count(program_header.p_vaddr, program_header.p_memsz);
-					for (size_t i = 0; i < pages; i++)
-					{
-						paddr_t paddr = m_page_table.physical_address_of(start + i * PAGE_SIZE);
-						if (paddr != 0)
-							Heap::get().release_page(paddr);
-					}
-					m_page_table.unmap_range(start, pages * PAGE_SIZE);
-					break;
-				}
-				default:
-					ASSERT_NOT_REACHED();
-			}
-		}
-	}
-
-	BAN::ErrorOr<void> LoadableELF::initialize()
-	{
-		if ((size_t)m_inode->size() < sizeof(ElfNativeFileHeader))
-		{
-			dprintln("Too small file");
-			return BAN::Error::from_errno(ENOEXEC);
-		}
-
-		size_t nread = TRY(m_inode->read(0, BAN::ByteSpan::from(m_file_header)));
-		ASSERT(nread == sizeof(m_file_header));
-
-		if (m_file_header.e_ident[EI_MAG0] != ELFMAG0 || 
-			m_file_header.e_ident[EI_MAG1] != ELFMAG1 ||
-			m_file_header.e_ident[EI_MAG2] != ELFMAG2 ||
-			m_file_header.e_ident[EI_MAG3] != ELFMAG3)
-		{
-			dprintln("Invalid magic in header");
-			return BAN::Error::from_errno(ENOEXEC);
-		}
-
-		if (m_file_header.e_ident[EI_DATA] != ELFDATA2LSB)
-		{
-			dprintln("Only little-endian is supported");
-			return BAN::Error::from_errno(ENOEXEC);
-		}
-
-		if (m_file_header.e_ident[EI_VERSION] != EV_CURRENT)
-		{
-			dprintln("Invalid version");
-			return BAN::Error::from_errno(ENOEXEC);
-		}
-
-#if ARCH(i386)
-		if (m_file_header.e_ident[EI_CLASS] != ELFCLASS32)
-#elif ARCH(x86_64)
-		if (m_file_header.e_ident[EI_CLASS] != ELFCLASS64)
-#endif
-		{
-			dprintln("Not in native format");	
-			return BAN::Error::from_errno(EINVAL);
-		}
-
-		if (m_file_header.e_type != ET_EXEC)
-		{
-			dprintln("Only executable files are supported");
-			return BAN::Error::from_errno(EINVAL);
-		}
-
-		if (m_file_header.e_version != EV_CURRENT)
-		{
-			dprintln("Unsupported version");
-			return BAN::Error::from_errno(EINVAL);
-		}
-
-		ASSERT(m_file_header.e_phentsize <= sizeof(ElfNativeProgramHeader));
-
-		TRY(m_program_headers.resize(m_file_header.e_phnum));
-		for (size_t i = 0; i < m_file_header.e_phnum; i++)
-		{
-			TRY(m_inode->read(m_file_header.e_phoff + m_file_header.e_phentsize * i, BAN::ByteSpan::from(m_program_headers[i])));
-
-			const auto& pheader = m_program_headers[i];
-			if (pheader.p_type != PT_NULL && pheader.p_type != PT_LOAD)
-			{
-				dprintln("Unsupported program header type {}", pheader.p_type);
-				return BAN::Error::from_errno(ENOTSUP);
-			}
-			if (pheader.p_memsz < pheader.p_filesz)
-			{
-				dprintln("Invalid program header");
-				return BAN::Error::from_errno(EINVAL);
-			}
-
-			m_virtual_page_count += BAN::Math::div_round_up<size_t>((pheader.p_vaddr % PAGE_SIZE) + pheader.p_memsz, PAGE_SIZE);
-		}
-
-		return {};
-	}
-
-	vaddr_t LoadableELF::entry_point() const
-	{
-		return m_file_header.e_entry;
-	}
-
-	bool LoadableELF::contains(vaddr_t address) const
-	{
-		for (const auto& program_header : m_program_headers)
-		{
-			switch (program_header.p_type)
-			{
-				case PT_NULL:
-					continue;
-				case PT_LOAD:
-					if (program_header.p_vaddr <= address && address < program_header.p_vaddr + program_header.p_memsz)
-						return true;
-					break;
-				default:
-					ASSERT_NOT_REACHED();
-			}
-		}
-		return false;
-	}
-
-	bool LoadableELF::is_address_space_free() const
-	{
-		for (const auto& program_header : m_program_headers)
-		{
-			switch (program_header.p_type)
-			{
-				case PT_NULL:
-					break;
-				case PT_LOAD:
-				{
-					vaddr_t page_vaddr = program_header.p_vaddr & PAGE_ADDR_MASK;
-					size_t pages = range_page_count(program_header.p_vaddr, program_header.p_memsz);
-					if (!m_page_table.is_range_free(page_vaddr, pages * PAGE_SIZE))
-						return false;
-					break;
-				}
-				default:
-					ASSERT_NOT_REACHED();
-			}
-		}
-		return true;
-	}
-
-	void LoadableELF::reserve_address_space()
-	{
-		for (const auto& program_header : m_program_headers)
-		{
-			switch (program_header.p_type)
-			{
-				case PT_NULL:
-					break;
-				case PT_LOAD:
-				{
-					vaddr_t page_vaddr = program_header.p_vaddr & PAGE_ADDR_MASK;
-					size_t pages = range_page_count(program_header.p_vaddr, program_header.p_memsz);
-					ASSERT(m_page_table.reserve_range(page_vaddr, pages * PAGE_SIZE));
-					break;
-				}
-				default:
-					ASSERT_NOT_REACHED();
-			}
-		}
-		m_loaded = true;
-	}
-
-	void LoadableELF::update_suid_sgid(Kernel::Credentials& credentials)
-	{
-		if (m_inode->mode().mode & +Inode::Mode::ISUID)
-			credentials.set_euid(m_inode->uid());
-		if (m_inode->mode().mode & +Inode::Mode::ISGID)
-			credentials.set_egid(m_inode->gid());
-	}
-
-	BAN::ErrorOr<void> LoadableELF::load_page_to_memory(vaddr_t address)
-	{
-		for (const auto& program_header : m_program_headers)
-		{
-			switch (program_header.p_type)
-			{
-				case PT_NULL:
-					break;
-				case PT_LOAD:
-				{
-					if (!(program_header.p_vaddr <= address && address < program_header.p_vaddr + program_header.p_memsz))
-						continue;
-
-					PageTable::flags_t flags = PageTable::Flags::UserSupervisor | PageTable::Flags::Present;
-					if (program_header.p_flags & LibELF::PF_W)
-						flags |= PageTable::Flags::ReadWrite;
-					if (program_header.p_flags & LibELF::PF_X)
-						flags |= PageTable::Flags::Execute;
-
-					vaddr_t vaddr = address & PAGE_ADDR_MASK;
-					paddr_t paddr = Heap::get().take_free_page();
-					if (paddr == 0)
-						return BAN::Error::from_errno(ENOMEM);
-
-					// Temporarily map page as RW so kernel can write to it
-					m_page_table.map_page_at(paddr, vaddr, PageTable::Flags::ReadWrite | PageTable::Flags::Present);
-					m_physical_page_count++;
-
-					memset((void*)vaddr, 0x00, PAGE_SIZE);
-					
-					if (vaddr / PAGE_SIZE < BAN::Math::div_round_up<size_t>(program_header.p_vaddr + program_header.p_filesz, PAGE_SIZE))
-					{
-						size_t vaddr_offset = 0;
-						if (vaddr < program_header.p_vaddr)
-							vaddr_offset = program_header.p_vaddr - vaddr;
-						
-						size_t file_offset = 0;
-						if (vaddr > program_header.p_vaddr)
-							file_offset = vaddr - program_header.p_vaddr;
-
-						size_t bytes = BAN::Math::min<size_t>(PAGE_SIZE - vaddr_offset, program_header.p_filesz - file_offset);
-						TRY(m_inode->read(program_header.p_offset + file_offset, { (uint8_t*)vaddr + vaddr_offset, bytes }));
-					}
-
-					// Map page with the correct flags
-					m_page_table.map_page_at(paddr, vaddr, flags);
-
-					return {};
-				}
-				default:
-					ASSERT_NOT_REACHED();
-			}
-		}
-		ASSERT_NOT_REACHED();
-	}
-
-	
-	BAN::ErrorOr<BAN::UniqPtr<LoadableELF>> LoadableELF::clone(Kernel::PageTable& new_page_table)
-	{
-		auto* elf_ptr = new LoadableELF(new_page_table, m_inode);
-		if (elf_ptr == nullptr)
-			return BAN::Error::from_errno(ENOMEM);
-		auto elf = BAN::UniqPtr<LoadableELF>::adopt(elf_ptr);
-
-		memcpy(&elf->m_file_header, &m_file_header, sizeof(ElfNativeFileHeader));
-
-		TRY(elf->m_program_headers.resize(m_program_headers.size()));
-		memcpy(elf->m_program_headers.data(), m_program_headers.data(), m_program_headers.size() * sizeof(ElfNativeProgramHeader));
-
-		elf->reserve_address_space();
-
-		ASSERT(&PageTable::current() == &m_page_table);
-		LockGuard _(m_page_table);
-		ASSERT(m_page_table.is_page_free(0));
-
-		for (const auto& program_header : m_program_headers)
-		{
-			switch (program_header.p_type)
-			{
-				case PT_NULL:
-					break;
-				case PT_LOAD:
-				{
-					if (!(program_header.p_flags & LibELF::PF_W))
-						continue;
-
-					PageTable::flags_t flags = PageTable::Flags::UserSupervisor | PageTable::Flags::Present;
-					if (program_header.p_flags & LibELF::PF_W)
-						flags |= PageTable::Flags::ReadWrite;
-					if (program_header.p_flags & LibELF::PF_X)
-						flags |= PageTable::Flags::Execute;
-
-					vaddr_t start = program_header.p_vaddr & PAGE_ADDR_MASK;
-					size_t pages = range_page_count(program_header.p_vaddr, program_header.p_memsz);
-
-					for (size_t i = 0; i < pages; i++)
-					{
-						if (m_page_table.physical_address_of(start + i * PAGE_SIZE) == 0)
-							continue;
-
-						paddr_t paddr = Heap::get().take_free_page();
-						if (paddr == 0)
-							return BAN::Error::from_errno(ENOMEM);
-
-						{
-							CriticalScope _;
-							PageTable::map_fast_page(paddr);
-							memcpy(PageTable::fast_page_as_ptr(), (void*)(start + i * PAGE_SIZE), PAGE_SIZE);
-							PageTable::unmap_fast_page();
-						}
-
-						new_page_table.map_page_at(paddr, start + i * PAGE_SIZE, flags);
-						elf->m_physical_page_count++;
-					}
-
-					break;
-				}
-				default:
-					ASSERT_NOT_REACHED();
-			}
-		}
-
-		return elf;
-	}
-
-}

LibELF/include/LibELF/ELF.h

@@ -1,89 +0,0 @@
-#pragma once
-
-#ifdef __is_kernel
-#include <kernel/FS/Inode.h>
-#include <kernel/Memory/VirtualRange.h>
-#endif
-
-#include <BAN/StringView.h>
-#include <BAN/UniqPtr.h>
-#include <BAN/Vector.h>
-#include <kernel/Arch.h>
-#include "Types.h"
-
-namespace LibELF
-{
-
-	class ELF
-	{
-	public:
-#ifdef __is_kernel
-		static BAN::ErrorOr<BAN::UniqPtr<ELF>> load_from_file(BAN::RefPtr<Kernel::Inode>);
-#else
-		static BAN::ErrorOr<BAN::UniqPtr<ELF>> load_from_file(BAN::StringView);
-#endif
-
-		const Elf64FileHeader& file_header64() const;
-		const Elf64ProgramHeader& program_header64(size_t) const;
-		const Elf64SectionHeader& section_header64(size_t) const;
-		const char* lookup_section_name64(uint32_t) const;
-		const char* lookup_string64(size_t, uint32_t) const;
-#if ARCH(x86_64)
-		const Elf64FileHeader& file_header_native() const { return file_header64(); }
-		const Elf64ProgramHeader& program_header_native(size_t index) const { return program_header64(index); }
-		const Elf64SectionHeader& section_header_native(size_t index) const { return section_header64(index); }
-		const char* lookup_section_name_native(uint32_t offset) const { return lookup_section_name64(offset); }
-		const char* lookup_string_native(size_t table_index, uint32_t offset) const { return lookup_string64(table_index, offset); }
-		bool is_native() const { return is_x86_64(); }
-#endif
-
-		const Elf32FileHeader& file_header32() const;
-		const Elf32ProgramHeader& program_header32(size_t) const;
-		const Elf32SectionHeader& section_header32(size_t) const;
-		const char* lookup_section_name32(uint32_t) const;
-		const char* lookup_string32(size_t, uint32_t) const;
-#if ARCH(i386)
-		const Elf32FileHeader& file_header_native() const { return file_header32(); }
-		const Elf32ProgramHeader& program_header_native(size_t index) const { return program_header32(index); }
-		const Elf32SectionHeader& section_header_native(size_t index) const { return section_header32(index); }
-		const char* lookup_section_name_native(uint32_t offset) const { return lookup_section_name32(offset); }
-		const char* lookup_string_native(size_t table_index, uint32_t offset) const { return lookup_string32(table_index, offset); }
-		bool is_native() const { return is_x86_32(); }
-#endif
-
-		const uint8_t* data() const { return m_data.data(); }
-
-		bool is_x86_32() const;
-		bool is_x86_64() const;
-
-	private:
-//#ifdef __is_kernel
-//		ELF(BAN::UniqPtr<Kernel::VirtualRange>&& storage, size_t size)
-//			: m_storage(BAN::move(storage))
-//			, m_data((const uint8_t*)m_storage->vaddr(), size)
-//		{}
-//#else
-		ELF(BAN::Vector<uint8_t>&& data)
-			: m_data(BAN::move(data))
-		{}
-//#endif
-		BAN::ErrorOr<void> load();
-		
-		bool parse_elf64_file_header(const Elf64FileHeader&);
-		bool parse_elf64_program_header(const Elf64ProgramHeader&);
-		bool parse_elf64_section_header(const Elf64SectionHeader&);
-
-		bool parse_elf32_file_header(const Elf32FileHeader&);
-		bool parse_elf32_program_header(const Elf32ProgramHeader&);
-		bool parse_elf32_section_header(const Elf32SectionHeader&);
-
-	private:
-//#ifdef __is_kernel
-//		BAN::UniqPtr<Kernel::VirtualRange> m_storage;
-//		BAN::Span<const uint8_t> m_data;
-//#else
-		const BAN::Vector<uint8_t> m_data;
-//#endif
-	};
-
-}

LibELF/include/LibELF/LoadableELF.h

@@ -1,57 +0,0 @@
-#pragma once
-
-#ifndef __is_kernel
-#error "This is kernel only header"
-#endif
-
-#include <BAN/UniqPtr.h>
-#include <BAN/Vector.h>
-
-#include <kernel/Credentials.h>
-#include <kernel/FS/Inode.h>
-#include <kernel/Memory/PageTable.h>
-
-#include <LibELF/Types.h>
-
-namespace LibELF
-{
-
-	class LoadableELF
-	{
-		BAN_NON_COPYABLE(LoadableELF);
-		BAN_NON_MOVABLE(LoadableELF);
-
-	public:
-		static BAN::ErrorOr<BAN::UniqPtr<LoadableELF>> load_from_inode(Kernel::PageTable&, BAN::RefPtr<Kernel::Inode>);
-		~LoadableELF();
-
-		Kernel::vaddr_t entry_point() const;
-
-		bool contains(Kernel::vaddr_t address) const;
-		bool is_address_space_free() const;
-		void reserve_address_space();
-
-		void update_suid_sgid(Kernel::Credentials&);
-
-		BAN::ErrorOr<void> load_page_to_memory(Kernel::vaddr_t address);
-
-		BAN::ErrorOr<BAN::UniqPtr<LoadableELF>> clone(Kernel::PageTable&);
-
-		size_t virtual_page_count() const { return m_virtual_page_count; }
-		size_t physical_page_count() const { return m_physical_page_count; }
-
-	private:
-		LoadableELF(Kernel::PageTable&, BAN::RefPtr<Kernel::Inode>);
-		BAN::ErrorOr<void> initialize();
-
-	private:
-		BAN::RefPtr<Kernel::Inode>			m_inode;
-		Kernel::PageTable&					m_page_table;
-		ElfNativeFileHeader					m_file_header;
-		BAN::Vector<ElfNativeProgramHeader>	m_program_headers;
-		size_t m_virtual_page_count = 0;
-		size_t m_physical_page_count = 0;
-		bool m_loaded { false };
-	};
-
-}

LibELF/include/LibELF/Values.h

@@ -1,140 +0,0 @@
-#pragma once
-
-namespace LibELF
-{
-
-	enum ELF_Ident
-	{
-		ELFMAG0			= 0x7F,
-		ELFMAG1			= 'E',
-		ELFMAG2			= 'L',
-		ELFMAG3			= 'F',
-
-		ELFCLASSNONE	= 0,
-		ELFCLASS32		= 1,
-		ELFCLASS64		= 2,
-
-		ELFDATANONE		= 0,
-		ELFDATA2LSB		= 1,
-		ELFDATA2MSB		= 2,
-	};
-
-	enum ELF_EI
-	{
-		EI_MAG0			= 0,
-		EI_MAG1			= 1,
-		EI_MAG2			= 2,
-		EI_MAG3			= 3,
-		EI_CLASS		= 4,
-		EI_DATA			= 5,
-		EI_VERSION		= 6,
-		EI_OSABI		= 7,
-		EI_ABIVERSION	= 8,
-		EI_NIDENT		= 16,
-	};
-
-	enum ELF_ET
-	{
-		ET_NONE		= 0,
-		ET_REL		= 1,
-		ET_EXEC		= 2,
-		ET_DYN		= 3,
-		ET_CORE		= 4,
-		ET_LOOS		= 0xfe00,
-		ET_HIOS		= 0xfeff,
-		ET_LOPROC	= 0xff00,
-		ET_HIPROC	= 0xffff,
-	};
-
-	enum ELF_EV
-	{
-		EV_NONE		= 0,
-		EV_CURRENT	= 1,
-	};
-
-	enum ELF_SHT
-	{
-		SHT_NULL		= 0,
-		SHT_PROGBITS	= 1,
-		SHT_SYMTAB		= 2,
-		SHT_STRTAB		= 3,
-		SHT_RELA		= 4,
-		SHT_NOBITS		= 8,
-		SHT_REL			= 9,
-		SHT_SHLIB		= 10,
-		SHT_DYNSYM		= 11,
-		SHT_LOOS		= 0x60000000,
-		SHT_HIOS		= 0x6FFFFFFF,
-		SHT_LOPROC		= 0x70000000,
-		SHT_HIPROC		= 0x7FFFFFFF,
-	};
-
-	enum ELF_SHF
-	{
-		SHF_WRITE		= 0x1,
-		SHF_ALLOC		= 0x2,
-		SHF_EXECINSTR	= 0x4,
-		SHF_MASKOS		= 0x0F000000,
-		SHF_MASKPROC	= 0xF0000000,
-	};
-
-	enum ELF_SHN
-	{
-		SHN_UNDEF	= 0,
-		SHN_LOPROC	= 0xFF00,
-		SHN_HIPROC	= 0xFF1F,
-		SHN_LOOS	= 0xFF20,
-		SHN_HIOS	= 0xFF3F,
-		SHN_ABS		= 0xFFF1,
-		SHN_COMMON	= 0xFFF2,
-	};
-
-	enum ELF_STB
-	{
-		STB_LOCAL	= 0,
-		STB_GLOBAL	= 1,
-		STB_WEAK	= 2,
-		STB_LOOS	= 10,
-		STB_HIOS	= 12,
-		STB_LOPROC	= 13,
-		STB_HIPROC	= 15,
-	};
-
-	enum ELF_STT
-	{
-		STT_NOTYPE	= 0,
-		STT_OBJECT	= 1,
-		STT_FUNC	= 2,
-		STT_SECTION	= 3,
-		STT_FILE	= 4,
-		STT_LOOS	= 10,
-		STT_HIOS	= 12,
-		STT_LOPROC	= 13,
-		STT_HIPROC	= 15,
-	};
-
-	enum ELF_PT
-	{
-		PT_NULL		= 0,
-		PT_LOAD		= 1,
-		PT_DYNAMIC	= 2,
-		PT_INTERP	= 3,
-		PT_NOTE		= 4,
-		PT_SHLIB	= 5,
-		PT_PHDR		= 6,
-		PT_LOOS		= 0x60000000,
-		PT_HIOS		= 0x6FFFFFFF,
-		PT_LOPROC	= 0x70000000,
-		PT_HIPROC	= 0x7FFFFFFF,
-	};
-
-	enum ELF_PF
-	{
-		PF_X		= 0x1,
-		PF_W		= 0x2,
-		PF_R		= 0x4,
-		PF_MASKOS	= 0x00FF0000,
-		PF_MASKPROC	= 0xFF000000,
-	};
-
-}

README.md

@@ -1,8 +1,77 @@
-![license](https://img.shields.io/github/license/bananymous/banan-os)
+[![](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fbananymous.com%2Fbanan-os%2Ftokei.json&query=%24.lines&label=total%20lines)](https://git.bananymous.com/Bananymous/banan-os)
+[![](https://img.shields.io/github/commit-activity/m/Bananymous/banan-os)](https://git.bananymous.com/Bananymous/banan-os)
+[![](https://img.shields.io/github/license/bananymous/banan-os)](https://git.bananymous.com/Bananymous/banan-os/src/branch/main/LICENSE)
+[![](https://img.shields.io/discord/1242165176032297040?logo=discord&label=discord)](https://discord.gg/ehjGySwYdK)
 
 # banan-os
 
-This is my hobby operating system written in C++. Currently supports only x86\_64 architecture. We have a ext2 filesystem, basic ramfs, IDE disk drivers in ATA PIO mode, ATA AHCI drivers, userspace processes, executable loading from ELF format, linear VBE graphics and multithreaded processing on single core.
+This is my hobby operating system written in C++. Currently supports x86\_64 and i686 architectures.
+
+You can find a live demo [here](https://bananymous.com/banan-os)
+
+If you want to try out DOOM, you should first enter the GUI environment using the `start-gui` command. Then you can run `doom` in the GUI terminal.
+
+### Features
+
+#### General
+- [x] Ring3 userspace
+- [x] SMP (multiprocessing)
+- [x] Linear framebuffer (VESA and GOP)
+- [x] Network stack
+- [x] ELF executable loading
+- [x] AML interpreter (partial)
+- [x] Basic graphical environment
+  - [x] Terminal emulator
+  - [x] Status bar
+  - [x] Program launcher
+  - [ ] Some nice apps
+- [x] ELF dynamic linking
+- [x] copy-on-write memory
+  - [x] file mappings
+  - [ ] anonymous mappings
+
+#### Drivers
+- [x] NVMe disks
+- [x] ATA (IDE, SATA) disks
+- [x] E1000 and E1000E NICs
+- [x] RTL8111/8168/8211/8411 NICs
+- [x] PS2 keyboard (all scancode sets)
+- [x] PS2 mouse
+- [x] USB
+  - [x] xHCI
+  - [ ] EHCI
+  - [ ] OHCI
+  - [ ] UHCI
+  - [x] Keyboard
+  - [x] Mouse
+  - [x] Mass storage
+  - [x] Hubs
+  - [ ] ...
+- [ ] virtio devices (network, storage)
+
+#### Network
+- [x] ARP
+- [x] ICMP
+- [x] IPv4
+- [x] UDP
+- [x] TCP (partial and buggy)
+- [x] Unix domain sockets
+- [ ] SSL
+
+#### Filesystems
+- [x] Virtual filesystem
+- [x] Ext2
+- [x] FAT12/16/32
+- [x] Dev
+- [x] Ram
+- [x] Proc
+- [ ] Sys
+- [ ] 9P
+
+#### Bootloader support
+- [x] GRUB
+- [x] Custom BIOS bootloader
+- [ ] Custom UEFI bootloader
 
 ![screenshot from qemu running banan-os](assets/banan-os.png)
 
@@ -12,37 +81,61 @@ Each major component and library has its own subdirectory (kernel, userspace, li
 
 ## Building
 
-There does not exist a complete list of needed packages for building. From the top of my head I can say that *cmake*, *ninja*, *make*, *grub*, *rsync* and emulator (*qemu* or *bochs*) are needed.
+### Needed packages
+
+#### apt (tested on ubuntu 22.04)
+```# apt install build-essential git ninja-build texinfo bison flex libgmp-dev libmpfr-dev libmpc-dev parted qemu-system-x86 cpu-checker```
+
+#### pacman
+```# pacman -S --needed base-devel git wget cmake ninja parted qemu-system-x86```
+
+
+### Compilation
 
 To build the toolchain for this os. You can run the following command.
 > ***NOTE:*** The following step has to be done only once. This might take a long time since we are compiling binutils and gcc.
 ```sh
-./script/build.sh toolchain
+./bos toolchain
 ```
 
 To build the os itself you can run one of the following commands. You will need root access for disk image creation/modification.
 ```sh
-./script/build.sh qemu
+./bos qemu
-./script/build.sh qemu-nographic
+./bos qemu-nographic
-./script/build.sh qemu-debug
+./bos qemu-debug
-./script/build.sh bochs
+./bos bochs
 ```
 
 You can also build the kernel or disk image without running it:
 ```sh
-./script/build.sh kernel
+./bos kernel
-./script/build.sh image
+./bos image
 ```
 
+To build for other architectures set environment variable BANAN\_ARCH=*arch* (e.g. BANAN\_ARCH=i686).
+
+To change the bootloader you can set environment variable BANAN\_BOOTLOADER; supported values are BANAN (my custom bootloader) and GRUB.
+
+To run with UEFI set environment variable BANAN\_UEFI\_BOOT=1. You will also have to set OVMF\_PATH to the correct OVMF (default */usr/share/ovmf/x64/OVMF.fd*).
+
+To build an image with no physical root filesystem, but an initrd set environment variable BANAN\_INITRD=1. This can be used when testing on hardware with unsupported USB controller.
+
 If you have corrupted your disk image or want to create new one, you can either manually delete *build/banan-os.img* and build system will automatically create you a new one or you can run the following command.
 ```sh
-./script/build.sh image-full
+./bos image-full
 ```
 
-If you feel like ```./script/build.sh``` is too verbose, there exists a symlink _bos_ in this projects root directory. All build commands can be used with ```./bos args...``` instead.
-
 I have also created shell completion script for zsh. You can either copy the file in _script/shell-completion/zsh/\_bos_ to _/usr/share/zsh/site-functions/_ or add the _script/shell-completion/zsh_ to your fpath in _.zshrc_.
 
-### Contributing
+## Contributing
 
-Currently I don't accept contributions to this repository unless explicitly told otherwise. This is a learning project for me and I want to do everything myself. Feel free to fork/clone this repo and tinker with it yourself.
+As the upstream is hosted on my server https://git.bananymous.com/Bananymous/banan-os, merging contributions is not as trivial as it would be on GitHub. You can still send PRs in GitHub in which case I should be able to download the diff and apply it manually. If you want, I can also provide you an account to my git server. In this case please contact me ([email](mailto:oskari.alaranta@bananymous.com), [discord](https://discord.gg/ehjGySwYdK)).
+
+As this is mostly a learning experience for me, I would appreciate if you first contacted me about adding new features (email, discord, issue, ...). If you send a PR about something I was planning on doing myself and you didn't ask me, I will probably just close it. Bug fixes are always welcome!
+
+Commit message should be formatted followingly
+
+  1. First line is of the form "_Subject: Description_", where _Subject_ tells the area touched (Kernel, Shell, BuildSystem, ...) and _Description_ is brief description of the change done. First line should fit fully in 72 characters.
+  2. Body of the message should further describe the change and reasoning behind the change.
+
+All commits should pass the pre-commit hook defined in _.pre-commit-config.yaml_. For instructions on how to setup pre-commit, please see https://pre-commit.com/#install.

bootloader/bios/CMakeLists.txt

@@ -3,6 +3,7 @@ cmake_minimum_required(VERSION 3.26)
 project(bootloader ASM)
 
 set(BOOTLOADER_SOURCES
+	a20_line.S
 	boot.S
 	command_line.S
 	disk.S
@@ -14,5 +15,6 @@ set(BOOTLOADER_SOURCES
 )
 
 add_executable(bootloader ${BOOTLOADER_SOURCES})
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 target_link_options(bootloader PRIVATE LINKER:-T,${CMAKE_CURRENT_SOURCE_DIR}/linker.ld)
 target_link_options(bootloader PRIVATE -nostdlib)

bootloader/bios/a20_line.S

@@ -0,0 +1,168 @@
+.code16
+.section .stage2
+
+# checks whether A20 line is enabled or disabled
+# return
+#	ax: 1 if enabled, 0 otherwise
+check_a20:
+	pushf
+	pushw %si
+	pushw %di
+	pushw %ds
+	pushw %es
+
+	cli
+
+	xorw %ax, %ax
+	movw %ax, %es
+	notw %ax
+	movw %ax, %ds
+
+	movw $0x0500, %di
+	movw $0x0510, %si
+
+	movb %es:(%di), %al
+	pushw %ax
+
+	movb %ds:(%si), %al
+	pushw %ax
+
+	movb $0x00, %es:(%di)
+	movb $0xFF, %ds:(%si)
+
+	cmpb $0xFF, %es:(%di)
+
+	pop %ax
+	movb %al, %ds:(%si)
+
+	pop %ax
+	movb %al, %es:(%di)
+
+	movw $0, %ax
+	je .check_a20_done
+
+	movw $1, %ax
+
+ .check_a20_done:
+	popw %es
+	popw %ds
+	popw %di
+	popw %si
+	popf
+	ret
+
+
+# Try to enable A20 using PS2 controller
+enable_a20_ps2:
+	pushf
+	pushw %ax
+
+	cli
+
+	# disable first port
+	call .enable_a20_ps2_wait1
+	movb $0xAD, %al
+	outb %al, $0x64
+
+	# read controller output
+	call .enable_a20_ps2_wait1
+	movb $0xD0, %al
+	outb %al, $0x64
+
+	call .enable_a20_ps2_wait2
+	inb $0x60, %al
+	pushw %ax
+
+	# write controller output
+	call .enable_a20_ps2_wait1
+	movb $0xD1, %al
+	outb %al, $0x64
+
+	call .enable_a20_ps2_wait1
+	popw %ax
+	orw $2, %ax
+	outb %al, $0x60
+
+	# enable first port
+	call .enable_a20_ps2_wait1
+	movb $0xAE, %al
+	outb %al, $0x64
+
+	call .enable_a20_ps2_wait1
+
+	popw %ax
+	popf
+	ret
+
+ .enable_a20_ps2_wait1:
+	inb $0x64, %al
+	test $2, %al
+	jnz .enable_a20_ps2_wait1
+	ret
+
+ .enable_a20_ps2_wait2:
+	inb $0x64, %al
+	test $1, %al
+	jnz .enable_a20_ps2_wait1
+	ret
+
+
+# Check if A20 line is disabled. If it is, try to enable it
+.global enable_a20
+enable_a20:
+	pushw %ax
+	pushw %si
+
+	call check_a20
+	testw %ax, %ax
+	jnz .enable_a20_done
+
+	movw $a20_line_disabled_msg, %si
+	call puts; call print_newline
+
+	# Try to enable A20 line using bios interrupt
+	movw $0x2401, %ax
+	int $0x15
+	call check_a20
+	testw %ax, %ax
+	jnz .enable_a20_done
+
+	# Try to enable A20 line using ps2 controller
+	call enable_a20_ps2
+	call check_a20
+	testw %ax, %ax
+	jnz .enable_a20_done
+
+	# Try to enable A20 line using fast A20 gate
+	inb $0x92, %al
+	testb $2, %al
+	jnz .enable_a20_fast_done
+	orb $2, %al
+	outb %al, $0x92
+ .enable_a20_fast_done:
+
+	call check_a20
+	testw %ax, %ax
+	jnz .enable_a20_done
+
+	movw $a20_could_not_enable_msg, %si
+	call print_and_halt
+
+ .enable_a20_done:
+	movw $a20_line_enabled_msg, %si
+	call puts; call print_newline
+
+	popw %si
+	popw %ax
+	ret
+
+.section .data
+
+a20_line_disabled_msg:
+	.asciz "A20 line disabled. Trying to enable it"
+
+a20_line_enabled_msg:
+	.asciz "A20 line enabled"
+
+a20_could_not_enable_msg:
+	.asciz "Could not enable A20 line"

bootloader/bios/boot.S

@@ -1,3 +1,5 @@
+.include "common.S"
+
 .code16
 
 #########################################
@@ -13,12 +15,10 @@
 
 .global stage1_main
 stage1_main:
-	# setup segments
+	# setup segments and stack
-	movw $0, %ax
+	xorw %ax, %ax
 	movw %ax, %ds
 	movw %ax, %es
-
-	# setup stack
 	movw %ax, %ss
 	movl $0x7C00, %esp
 
@@ -53,11 +53,17 @@ stage2_main:
 	movw $hello_msg, %si
 	call puts; call print_newline
 
+	lgdt gdtr
+
 	call enter_unreal_mode
 	movw $unreal_enter_msg, %si
 	call puts; call print_newline
 
+	call enable_a20
+
 	call get_memory_map
+
+	call print_newline
 	call read_user_command_line
 
 	call print_newline
@@ -86,32 +92,32 @@ stage2_main:
 
 	cli
 
+	# kernel entry point
+	movl %eax, %ecx
+
+	# setup kernel parameters
+	movl $0xD3C60CFF, %eax
+	movl $banan_boot_info, %ebx
+
 	# setup protected mode
-	movl %cr0, %ebx
+	movl %cr0, %edx
-	orb $1, %bl
+	orb $1, %dl
-	movl %ebx, %cr0
+	movl %edx, %cr0
-
-	# jump to kernel in protected mode
-	ljmpl $0x18, $protected_mode
 
+	# jump to protected mode
+	ljmpl $GDT_CODE32, $protected_mode
 
 .code32
 protected_mode:
-	movw $0x10, %bx
+	# setup protected mode segments
-	movw %bx, %ds
+	movw $GDT_DATA32, %dx
-	movw %bx, %es
+	movw %dx, %ds
-	movw %bx, %fs
+	movw %dx, %es
-	movw %bx, %gs
+	movw %dx, %fs
-	movw %bx, %ss
+	movw %dx, %gs
-
+	movw %dx, %ss
-	movl %eax, %ecx
-
-	movl $0xD3C60CFF, %eax
-	movl $banan_boot_info, %ebx
-	xorl %edx, %edx
-	xorl %esi, %esi
-	xorl %edi, %edi
 
+	# jump to kernel entry
 	jmp *%ecx
 
 
@@ -120,20 +126,18 @@ enter_unreal_mode:
 	cli
 	pushw %ds
 
-	lgdt gdtr
-
 	movl %cr0, %eax
 	orb $1, %al
 	movl %eax, %cr0
-	ljmpl $0x8, $.enter_unreal_mode_pmode
+	ljmpl $GDT_CODE16, $.enter_unreal_mode_pmode
 
  .enter_unreal_mode_pmode:
-	movw $0x10, %bx
+	movw $GDT_DATA32, %bx
 	movw %bx, %ds
 
-	andb 0xFE, %al
+	andb $0xFE, %al
 	movl %eax, %cr0
-	ljmpl $0x0, $.enter_unreal_mode_unreal
+	ljmpl $0x00, $.enter_unreal_mode_unreal
 
  .enter_unreal_mode_unreal:
 	popw %ds
@@ -141,6 +145,8 @@ enter_unreal_mode:
 
 	ret
 
+.section .data
+
 hello_msg:
 	.asciz "This is banan-os bootloader"
 
@@ -152,12 +158,12 @@ start_kernel_load_msg:
 
 gdt:
 	.quad 0x0000000000000000
-	.quad 0x00009A000000FFFF
+	.quad 0x008F9A000000FFFF # 16-bit code
-	.quad 0x00CF92000000FFFF
+	.quad 0x00CF92000000FFFF # 32-bit data
-	.quad 0x00CF9A000000FFFF
+	.quad 0x00CF9A000000FFFF # 32-bit code
 gdtr:
 	.short . - gdt - 1
-	.quad gdt
+	.long gdt
 
 banan_boot_info:
 	boot_command_line:
@@ -166,3 +172,5 @@ banan_boot_info:
 		.long framebuffer
 	boot_memory_map:
 		.long memory_map
+	boot_kernel_paddr:
+		.long 0

bootloader/bios/command_line.S

@@ -26,6 +26,8 @@ read_user_command_line:
 
 	cmpb $'\b', %al
 	je .read_user_command_line_backspace
+	cmpb $0x7F, %al
+	je .read_user_command_line_backspace
 
 	# Not sure if some BIOSes return '\n' as enter, but check it just in case
 	cmpb $'\r', %al
@@ -72,6 +74,8 @@ read_user_command_line:
 	ret
 
 
+.section .data
+
 command_line_enter_msg:
 	.asciz "cmdline: "
 
@@ -80,4 +84,4 @@ command_line:
 # 100 character command line
 command_line_buffer:
 	.ascii "root=/dev/sda2"
-	.skip 100 - 28
+	.skip 100 - (. - command_line_buffer)

bootloader/bios/common.S

@@ -0,0 +1,3 @@
+.set GDT_CODE16, 0x08
+.set GDT_DATA32, 0x10
+.set GDT_CODE32, 0x18

bootloader/bios/disk.S

@@ -389,10 +389,8 @@ find_root_partition:
 
 	# increment 8 byte entry array lba
 	incl 0(%esp)
-	jnc .find_root_partition_no_overflow
+	adcl $0, 4(%esp)
-	incl 4(%esp)
 
- .find_root_partition_no_overflow:
 	# loop to read next section if entries remaining
 	cmpl $0, 12(%esp)
 	jnz .find_root_partition_read_entry_section
@@ -416,12 +414,10 @@ find_root_partition:
 
 	# ebx:eax -= first lba - 1
 	subl (root_partition_entry + 36), %ebx
-	movl (root_partition_entry + 32), %ecx;
+	movl (root_partition_entry + 32), %ecx
 	decl %ecx
 	subl %ecx, %eax
-	jnc .find_root_partition_count_sub_no_carry
+	sbbl $0, %ebx
-	decl %ebx
- .find_root_partition_count_sub_no_carry:
 
 	# ecx: min(partition count, 0xFFFFFFFF)
 	movl $0xFFFFFFFF, %edx
@@ -474,6 +470,7 @@ print_root_partition_info:
 	popw %ax
 	ret
 
+.section .data
 
 # These will be patched during bootloader installation
 root_disk_guid:

bootloader/bios/elf.S

@@ -5,15 +5,26 @@
 .set e_machine,		18
 .set e_version,		20
 .set e_entry,		24
-.set e_phoff,		32
+
-.set e_shoff,		40
+.set e32_phoff,		28
-.set e_flags,		48
+.set e32_shoff,		32
-.set e_ehsize,		52
+.set e32_flags,		36
-.set e_phentsize,	54
+.set e32_ehsize,	40
-.set e_phnum,		56
+.set e32_phentsize,	42
-.set e_shentsize,	58
+.set e32_phnum,		44
-.set e_shnum,		60
+.set e32_shentsize,	46
-.set e_shstrndx,	62
+.set e32_shnum,		48
+.set e32_shstrndx,	50
+
+.set e64_phoff,		32
+.set e64_shoff,		40
+.set e64_flags,		48
+.set e64_ehsize,	52
+.set e64_phentsize,	54
+.set e64_phnum,		56
+.set e64_shentsize,	58
+.set e64_shnum,		60
+.set e64_shstrndx,	62
 
 # e_ident offsets
 .set EI_CLASS,		4
@@ -22,6 +33,7 @@
 
 # e_ident constants
 .set ELFMAGIC,		0x464C457F
+.set ELFCLASS32,	1
 .set ELFCLASS64,	2
 .set ELFDATA2LSB,	1
 .set EV_CURRENT,	1
@@ -31,18 +43,30 @@
 
 # program header field offsets
 .set p_type,		0
-.set p_flags,		4
+
-.set p_offset,		8
+.set p32_offset,	4
-.set p_vaddr,		16
+.set p32_vaddr,		8
-.set p_paddr,		24
+.set p32_paddr,		12
-.set p_filesz,		32
+.set p32_filesz,	16
-.set p_memsz,		40
+.set p32_memsz,		20
-.set p_align,		48
+.set p32_flags,		24
+.set p32_align,		28
+
+.set p64_flags,		4
+.set p64_offset,	8
+.set p64_vaddr,		16
+.set p64_paddr,		24
+.set p64_filesz,	32
+.set p64_memsz,		40
+.set p64_align,		48
 
 # p_type constants
 .set PT_NULL,		0
 .set PT_LOAD,		1
 
+# mask for entry point and segment loading
+.set LOAD_MASK,		0x07FFFFFF
+
 .code16
 .section .stage2
 
@@ -52,8 +76,12 @@ elf_validate_file_header:
 	cmpl $ELFMAGIC, (elf_file_header)
 	jne .elf_validate_file_header_invalid_magic
 
+	cmpb $ELFCLASS32, (elf_file_header + EI_CLASS)
+	je .elf_validate_file_header_class_valid
 	cmpb $ELFCLASS64, (elf_file_header + EI_CLASS)
-	jne .elf_validate_file_header_only_64bit_supported
+	je .elf_validate_file_header_class_valid
+	jmp .elf_validate_file_header_invalid_class
+ .elf_validate_file_header_class_valid:
 
 	cmpb $ELFDATA2LSB, (elf_file_header + EI_DATA)
 	jne .elf_validate_file_header_only_little_endian_supported
@@ -72,8 +100,8 @@ elf_validate_file_header:
  .elf_validate_file_header_invalid_magic:
 	movw $elf_validate_file_header_invalid_magic_msg, %si
 	jmp print_and_halt
- .elf_validate_file_header_only_64bit_supported:
+ .elf_validate_file_header_invalid_class:
-	movw $elf_validate_file_header_only_64bit_supported_msg, %si
+	movw $elf_validate_file_header_invalid_class_msg, %si
 	jmp print_and_halt
  .elf_validate_file_header_only_little_endian_supported:
 	movw $elf_validate_file_header_only_little_endian_supported_msg, %si
@@ -85,6 +113,59 @@ elf_validate_file_header:
 	movw $elf_validate_file_header_not_executable_msg, %si
 	jmp print_and_halt
 
+# reads memory specified by 32 bit elf_program_header to memory
+elf_read_program_header32_to_memory:
+	pushal
+	pushl %ebp
+	movl %esp, %ebp
+
+	# memset p_filesz -> p_memsz to 0
+	movl (elf_program_header + p32_filesz), %ebx
+	movl (elf_program_header + p32_vaddr),  %edi
+	andl $LOAD_MASK, %edi
+	addl %ebx, %edi
+	movl (elf_program_header + p32_memsz),  %ecx
+	subl %ebx, %ecx
+	xorb %al, %al; call memset32
+
+	# read file specified in program header to memory
+	movl (elf_program_header + p32_offset), %eax
+	movl (elf_program_header + p32_vaddr),  %edi
+	andl $LOAD_MASK, %edi
+	movl (elf_program_header + p32_filesz), %ecx
+	call *%esi
+
+	leavel
+	popal
+	ret
+
+
+# reads memory specified by 64 bit elf_program_header to memory
+elf_read_program_header64_to_memory:
+	pushal
+	pushl %ebp
+	movl %esp, %ebp
+
+	# memset p_filesz -> p_memsz to 0
+	movl (elf_program_header + p64_filesz), %ebx
+	movl (elf_program_header + p64_vaddr),  %edi
+	andl $LOAD_MASK, %edi
+	addl %ebx, %edi
+	movl (elf_program_header + p64_memsz),  %ecx
+	subl %ebx, %ecx
+	xorb %al, %al; call memset32
+
+	# read file specified in program header to memory
+	movl (elf_program_header + p64_offset), %eax
+	movl (elf_program_header + p64_vaddr),  %edi
+	andl $LOAD_MASK, %edi
+	movl (elf_program_header + p64_filesz), %ecx
+	call *%esi
+
+	leavel
+	popal
+	ret
+
 
 # read callback format
 #	eax: first byte
@@ -104,42 +185,72 @@ elf_read_kernel_to_memory:
 	movl %esp, %ebp
 	subl $2, %esp
 
-	# read file header
+	# read start of file header
 	movl $0, %eax
-	movl $64, %ecx
+	movl $24, %ecx
 	movl $elf_file_header, %edi
 	call *%esi
 
 	call elf_validate_file_header
 
-	cmpl $0, (elf_file_header + e_phoff + 4)
+	# determine file header size
+	movl $52, %ecx
+	movl $64, %edx
+	cmpb $ELFCLASS64, (elf_file_header + EI_CLASS)
+	cmovel %edx, %ecx
+
+	# read full file header
+	movl $0, %eax
+	movl $elf_file_header, %edi
+	call *%esi
+
+	# verify that e_phoff fits in 32 bits
+	cmpb $ELFCLASS64, (elf_file_header + EI_CLASS)
+	jne .elf_read_kernel_to_memory_valid_offset
+	cmpl $0, (elf_file_header + e64_phoff + 4)
 	jnz .elf_read_kernel_to_memory_unsupported_offset
+ .elf_read_kernel_to_memory_valid_offset:
+
+	# read architecture phentsize and phnum to fixed locations
+	movw (elf_file_header + e32_phentsize), %ax
+	movw (elf_file_header + e32_phnum),     %bx
+	movl (elf_file_header + e32_phoff),     %ecx
+	cmpb $ELFCLASS64, (elf_file_header + EI_CLASS)
+	cmovew (elf_file_header + e64_phentsize), %ax
+	cmovew (elf_file_header + e64_phnum),     %bx
+	cmovel (elf_file_header + e64_phoff),     %ecx
+	movw %ax,  (elf_file_header_phentsize)
+	movw %bx,  (elf_file_header_phnum)
+	movl %ecx, (elf_file_header_phoff)
 
 	# current program header
 	movw $0, -2(%ebp)
 
  .elf_read_kernel_to_memory_loop_program_headers:
 	movw -2(%ebp), %cx
-	cmpw (elf_file_header + e_phnum), %cx
+	cmpw (elf_file_header_phnum), %cx
 	jae .elf_read_kernel_to_memory_done
 
 	# eax := program_header_index * e_phentsize + e_phoff
 	xorl %eax, %eax
 	movw %cx, %ax
 	xorl %ebx, %ebx
-	movw (elf_file_header + e_phentsize), %bx
+	movw (elf_file_header_phentsize), %bx
 	mull %ebx
-	addl (elf_file_header + e_phoff), %eax
+	addl (elf_file_header_phoff), %eax
 	jc .elf_read_kernel_to_memory_unsupported_offset
 
-	# setup program header size and address
+	# determine program header size
-	movl $56, %ecx
+	movl $32, %ecx
-	movl $elf_program_header, %edi
+	movl $56, %edx
+	cmpb $ELFCLASS64, (elf_file_header + EI_CLASS)
+	cmovel %edx, %ecx
 
-	# read the program header
+	# read program header
+	movl $elf_program_header, %edi
 	call *%esi
 
-	# test if program header is empty
+	# test if program header is NULL header
 	cmpl $PT_NULL, (elf_program_header + p_type)
 	je .elf_read_kernel_to_memory_null_program_header
 
@@ -147,33 +258,12 @@ elf_read_kernel_to_memory:
 	cmpl $PT_LOAD, (elf_program_header + p_type)
 	jne .elf_read_kernel_to_memory_not_loadable_header
 
-	# memset p_filesz -> p_memsz to 0
+	# read program header to memory
-	movl (elf_program_header + p_filesz), %ebx
+	movl $elf_read_program_header32_to_memory, %eax
-
+	movl $elf_read_program_header64_to_memory, %ebx
-	movl (elf_program_header + p_vaddr),  %edi
+	cmpb $ELFCLASS64, (elf_file_header + EI_CLASS)
-	andl $0x7FFFFFFF, %edi
+	cmovel %ebx, %eax
-	addl %ebx, %edi
+	call *%eax
-
-	movl (elf_program_header + p_memsz),  %ecx
-	subl %ebx, %ecx
-	jz .elf_read_kernel_to_memory_memset_done
-
- .elf_read_kernel_to_memory_memset:
-	movb $0, (%edi)
-	incl %edi
-	decl %ecx
-	jnz .elf_read_kernel_to_memory_memset
- .elf_read_kernel_to_memory_memset_done:
-
-	# read file specified in program header to memory
-	movl (elf_program_header + p_offset), %eax
-	movl (elf_program_header + p_vaddr),  %edi
-	andl $0x7FFFFFFF, %edi
-	movl (elf_program_header + p_filesz), %ecx
-
-	#call print_hex32; call print_newline
-
-	call *%esi
 
  .elf_read_kernel_to_memory_null_program_header:
 	incw -2(%ebp)
@@ -185,7 +275,7 @@ elf_read_kernel_to_memory:
 
 	# set kernel entry address
 	movl (elf_file_header + e_entry), %eax
-	andl $0x7FFFFF, %eax
+	andl $LOAD_MASK, %eax
 
 	ret
 
@@ -196,11 +286,12 @@ elf_read_kernel_to_memory:
 	movw $elf_read_kernel_to_memory_not_loadable_header_msg, %si
 	jmp print_and_halt
 
+.section .data
 
 elf_validate_file_header_invalid_magic_msg:
 	.asciz "ELF: file has invalid ELF magic"
-elf_validate_file_header_only_64bit_supported_msg:
+elf_validate_file_header_invalid_class_msg:
-	.asciz "ELF: file is not targettint 64 bit"
+	.asciz "ELF: file has invalid ELF class"
 elf_validate_file_header_only_little_endian_supported_msg:
 	.asciz "ELF: file is not in little endian format"
 elf_validate_file_header_not_current_version_msg:
@@ -218,5 +309,12 @@ elf_read_kernel_to_memory_not_loadable_header_msg:
 elf_file_header:
 	.skip 64
 
+elf_file_header_phentsize:
+	.skip 2
+elf_file_header_phnum:
+	.skip 2
+elf_file_header_phoff:
+	.skip 4 # NOTE: only 32 bit offsets are supported
+
 elf_program_header:
 	.skip 56

bootloader/bios/ext2.S

@@ -2,9 +2,7 @@
 .set SECTOR_SHIFT,	9
 .set SECTOR_SIZE,	1 << SECTOR_SHIFT
 
-# FIXME: don't assume 1024 byte blocks
+.set EXT2_MAX_BLOCK_SIZE,	4096
-.set EXT2_BLOCK_SHIFT,		10
-.set EXT2_BLOCK_SIZE,		1 << EXT2_BLOCK_SHIFT
 .set EXT2_SUPERBLOCK_SIZE,	264
 .set EXT2_BGD_SHIFT,		5
 .set EXT2_BGD_SIZE,			1 << EXT2_BGD_SHIFT
@@ -18,6 +16,7 @@
 .set EXT2_S_IFREG,			0x8000
 
 # superblock offsets
+.set s_first_data_block,	20
 .set s_log_block_size,		24
 .set s_inodes_per_group,	40
 .set s_magic,				56
@@ -66,9 +65,7 @@ has_ext2_filesystem:
 
 	# from byte offset 1024
 	addl $(1024 / SECTOR_SIZE), %eax
-	jnc .has_ext2_filesystem_no_overflow
+	adcw $0, %bx
-	incw %bx
- .has_ext2_filesystem_no_overflow:
 
 	# into sector buffer
 	movw $ext2_block_buffer, %di
@@ -90,11 +87,16 @@ has_ext2_filesystem:
 	movl (ext2_superblock_buffer + s_log_block_size), %ecx
 	testl $0xFFFFFF00, %ecx
 	jnz .has_ext2_filesystem_unsupported_block_size
-	  # verify 1024 << s_log_block_size == EXT2_BLOCK_SIZE
+	  # verify 1024 << s_log_block_size <= EXT2_MAX_BLOCK_SIZE
 	movl $1024, %eax
 	shll %cl, %eax
-	cmpl $EXT2_BLOCK_SIZE, %eax
+	cmpl $EXT2_MAX_BLOCK_SIZE, %eax
-	jne .has_ext2_filesystem_unsupported_block_size
+	ja .has_ext2_filesystem_unsupported_block_size
+
+	# fill block size and shift
+	movl %eax, (ext2_block_size)
+	addl $10, %ecx
+	movl %ecx, (ext2_block_shift)
 
 	# fill inode size
 	movl $128, %eax
@@ -130,38 +132,23 @@ has_ext2_filesystem:
 # reads block in to ext2_block_buffer
 #	eax:	block number
 ext2_read_block:
-	pushl %eax
+	pushal
-	pushl %ebx
-	pushw %cx
-	pushl %edx
-	pushw %di
 
-	# NOTE: this assumes 1024 block size
+	# ecx := sectors_per_block := block_size / sector_size
-	# eax := (block * block_size) / sector_size := (eax << EXT2_BLOCK_SHIFT) >> SECTOR_SHIFT
+	movl (ext2_block_size), %ecx
-	xorl %edx, %edx
+	shrl $SECTOR_SHIFT, %ecx
-	shll $EXT2_BLOCK_SHIFT, %eax
-	shrl $SECTOR_SHIFT, %eax
 
-	# ebx:eax := eax + (ext2_partition_first_sector)
+	# ebx:eax := block * sectors_per_block + (ext2_partition_first_sector)
-	movl (ext2_partition_first_sector + 4), %ebx
+	xorl %ebx, %ebx
+	mull %ecx
 	addl (ext2_partition_first_sector + 0), %eax
-	jnc .ext2_read_block_no_carry
+	adcl (ext2_partition_first_sector + 4), %ebx
-	incl %ebx
- .ext2_read_block_no_carry:
-
-	# sectors per block
-	movw $(EXT2_BLOCK_SIZE / SECTOR_SIZE), %cx
 
 	movw $ext2_block_buffer, %di
-
 	movb (ext2_drive_number), %dl
 	call read_from_disk
 
-	popw %di
+	popal
-	popl %edx
-	popw %cx
-	popl %ebx
-	popl %eax
 	ret
 
 
@@ -170,15 +157,23 @@ ext2_read_block:
 ext2_read_block_group_descriptor:
 	pushal
 
-	# eax := bgd_byte_offset := 2048 + EXT2_BGD_SIZE * eax := (eax << EXT2_BGD_SHIFT) + 2048
+	# ebx := bgd_block_byte_offset := (s_first_data_block + 1) * block_size
-	shll $EXT2_BGD_SHIFT, %eax
+	#                              := (s_first_data_block + 1) << ext2_block_shift
-	addl $2048, %eax
+	movl (ext2_superblock_buffer + s_first_data_block), %ebx
+	incl %ebx
+	movb (ext2_block_shift), %cl
+	shll %cl, %ebx
 
-	# eax: bgd_block  := bgd_byte_offset / EXT2_BLOCK_SIZE
+	# eax := bgd_byte_offset := bgd_block_byte_offset + EXT2_BGD_SIZE * block_group;
-	# ebx: bgd_offset := bgd_byte_offset % EXT2_BLOCK_SIZE
+	#                        := bgd_block_byte_offset + (block_group << EXT2_BGD_SHIFT)
+	movb $EXT2_BGD_SHIFT, %cl
+	shll %cl, %eax
+	addl %ebx, %eax
+
+	# eax: bgd_block  := bgd_byte_offset / block_size
+	# ebx: bgd_offset := bgd_byte_offset % block_size
 	xorl %edx, %edx
-	movl $EXT2_BLOCK_SIZE, %ebx
+	divl (ext2_block_size)
-	divl %ebx
 	movl %edx, %ebx
 
 	call ext2_read_block
@@ -204,23 +199,19 @@ ext2_read_inode:
 	# ebx := inode_index = (ino - 1) % s_inodes_per_group
 	xorl %edx, %edx
 	decl %eax
-	movl (ext2_superblock_buffer + s_inodes_per_group), %ebx
+	divl (ext2_superblock_buffer + s_inodes_per_group)
-	divl %ebx
 	movl %edx, %ebx
 
 	call ext2_read_block_group_descriptor
 
-	# eax := inode_table_block  := (inode_index * inode_size) / EXT2_BLOCK_SIZE
+	# eax := inode_table_block  := (inode_index * inode_size) / block_size
-	# ebx := inode_table_offset := (inode_index * inode_size) % EXT2_BLOCK_SIZE
+	# ebx := inode_table_offset := (inode_index * inode_size) % block_size
-	xorl %edx, %edx
 	movl %ebx, %eax
-	movl (ext2_inode_size), %ebx
+	mull (ext2_inode_size)
-	mull %ebx
+	divl (ext2_block_size)
-	movl $EXT2_BLOCK_SIZE, %ebx
-	divl %ebx
 	movl %edx, %ebx
 
-	# eax := file system block := eax + bg_inode_table
+	# eax := filesystem_block := eax + bg_inode_table
 	addl (ext2_block_group_descriptor_buffer + bg_inode_table), %eax
 
 	movb (ext2_drive_number), %dl
@@ -255,14 +246,17 @@ ext2_data_block_index:
 	pushl %esi
 	pushl %edi
 
-	# calculate max data blocks
+	# ebx := max_data_blocks := (file_size + block_size - 1) / block_size
-	movl (ext2_inode_buffer + i_size), %ecx
+	#                        := (i_size + ext2_block_size - 1) >> ext2_block_shift
-	addl (ext2_inode_size), %ecx
+	# cl  := ext2_block_shift
-	decl %ecx
+	movl (ext2_inode_buffer + i_size), %ebx
-	shll $EXT2_BLOCK_SHIFT, %ecx
+	addl (ext2_block_size), %ebx
+	decl %ebx
+	movb (ext2_block_shift), %cl
+	shrl %cl, %ebx
 
 	# verify data block is within bounds
-	cmpl %ecx, %eax
+	cmpl %ebx, %eax
 	jae .ext2_data_block_index_out_of_bounds
 
 	# check if this is direct block access
@@ -270,18 +264,26 @@ ext2_data_block_index:
 	jb .ext2_data_block_index_direct
 	subl $12, %eax
 
+	# cl  := indices_per_block_shift := ext2_block_shift - 2
+	# ebx := comp
+	subb $2, %cl
+	movl $1, %ebx
+	shll %cl, %ebx
+
 	# check if this is singly indirect block access
-	cmpl $(EXT2_BLOCK_SIZE / 4), %eax
+	cmpl %ebx, %eax
 	jb .ext2_data_block_index_singly_indirect
-	subl $(EXT2_BLOCK_SIZE / 4), %eax
+	subl %ebx, %eax
+	shll %cl, %ebx
 
 	# check if this is doubly indirect block access
-	cmpl $((EXT2_BLOCK_SIZE / 4) * (EXT2_BLOCK_SIZE / 4)), %eax
+	cmpl %ebx, %eax
 	jb .ext2_data_block_index_doubly_indirect
-	subl $((EXT2_BLOCK_SIZE / 4) * (EXT2_BLOCK_SIZE / 4)), %eax
+	subl %ebx, %eax
+	shll %cl, %ebx
 
 	# check if this is triply indirect block access
-	cmpl $((EXT2_BLOCK_SIZE / 4) * (EXT2_BLOCK_SIZE / 4) * (EXT2_BLOCK_SIZE / 4)), %eax
+	cmpl %ebx, %eax
 	jb .ext2_data_block_index_triply_indirect
 
 	# otherwise this is invalid access
@@ -314,9 +316,12 @@ ext2_data_block_index:
 	# ebx := index
 	# cx  := depth
  .ext2_data_block_index_indirect:
-	# calculate cache index ((index & 0xFF) | depth)
+	# edx := cache index := (index & ~(block_size / 4 - 1)) | depth
-	movl %ebx, %edx
+	#                    := (index & -(block_size >> 2)) | depth
-	andl $(~(EXT2_BLOCK_SIZE / 4 - 1)), %edx
+	movl (ext2_block_size), %edx
+	shrl $2, %edx
+	negl %edx
+	andl %ebx, %edx
 	orw %cx, %dx
 
 	# check whether this block is already cached
@@ -343,20 +348,21 @@ ext2_data_block_index:
 	jbe .ext2_data_block_index_no_shift
 
 	# cl := shift
-	movb $(EXT2_BLOCK_SHIFT - 2), %al
+	movb (ext2_block_shift), %al
+	subb $2, %al
 	decb %cl
 	mulb %cl
 	movb %al, %cl
 
-	# ebx := ebx >> cl
+	# ebx := ebx >> shift
 	shrl %cl, %ebx
 
  .ext2_data_block_index_no_shift:
-	# edx := index of next block
+	# edx := index of next block (ebx & (block_size / 4 - 1))
-	movl %ebx, %eax
+	movl (ext2_block_size), %edx
-	xorl %edx, %edx
+	shrl $2, %edx
-	movl $(EXT2_BLOCK_SIZE / 4), %ebx
+	decl %edx
-	divl %ebx
+	andl %ebx, %edx
 
 	# eax := next block
 	movl $ext2_block_buffer, %esi
@@ -371,7 +377,7 @@ ext2_data_block_index:
 	# cache last read block
 	movw $ext2_block_buffer, %si
 	movw $ext2_inode_indirect_buffer, %di
-	movw $EXT2_BLOCK_SIZE, %cx
+	movw (ext2_block_size), %cx
 	rep movsb
 
 	jmp .ext2_data_block_index_done
@@ -390,7 +396,10 @@ ext2_data_block_index:
 
  .ext2_data_block_index_indirect_cached:
 	movl $ext2_inode_indirect_buffer, %esi
-	andl $(EXT2_BLOCK_SIZE / 4 - 1), %ebx
+	movl (ext2_block_size), %edx
+	shrl $2, %edx
+	decl %edx
+	andl %edx, %ebx
 	movl (%esi, %ebx, 4), %eax
 
  .ext2_data_block_index_done:
@@ -410,6 +419,7 @@ ext2_data_block_index:
 .global ext2_inode_read_bytes
 ext2_inode_read_bytes:
 	pushal
+
 	pushl %ebp
 	movl %esp, %ebp
 	subl $8, %esp
@@ -418,11 +428,11 @@ ext2_inode_read_bytes:
 	movl %eax, 0(%esp)
 	movl %ecx, 4(%esp)
 
-	# check if eax % EXT2_BLOCK_SIZE != 0,
+	# eax := first_byte / block_size
-	# then we need to read a partial block starting from an offset
+	# edx := first_byte % block_size
+	# when edx == 0, no partial read needed
 	xorl %edx, %edx
-	movl $EXT2_BLOCK_SIZE, %ebx
+	divl (ext2_block_size)
-	divl %ebx
 	testl %edx, %edx
 	jz .ext2_inode_read_bytes_no_partial_start
 
@@ -431,7 +441,7 @@ ext2_inode_read_bytes:
 	call ext2_read_block
 
 	# ecx := byte count (min(block_size - edx, remaining_bytes))
-	movl $EXT2_BLOCK_SIZE, %ecx
+	movl (ext2_block_size), %ecx
 	subl %edx, %ecx
 	cmpl %ecx, 4(%esp)
 	cmovbl 4(%esp), %ecx
@@ -444,15 +454,7 @@ ext2_inode_read_bytes:
 	movl $ext2_block_buffer, %esi
 	addl %edx, %esi
 
-	# very dumb memcpy with 32 bit addresses
+	call memcpy32
-	movl $0, %ebx
- .ext2_inode_read_bytes_memcpy_partial:
-	movb (%esi, %ebx), %al
-	movb %al, (%edi, %ebx)
-	incl %ebx
-	decl %ecx
-	jnz .ext2_inode_read_bytes_memcpy_partial
-	addl %ebx, %edi
 
 	# check if all sectors are read
 	cmpl $0, 4(%esp)
@@ -461,14 +463,15 @@ ext2_inode_read_bytes:
  .ext2_inode_read_bytes_no_partial_start:
 	# eax := data block index (byte_start / block_size)
 	movl 0(%esp), %eax
-	shrl $(EXT2_BLOCK_SHIFT), %eax
+	movb (ext2_block_shift), %cl
+	shrl %cl, %eax
 
 	# get data block index and read block
 	call ext2_data_block_index
 	call ext2_read_block
 
 	# calculate bytes to copy (min(block_size, remaining_bytes))
-	movl $EXT2_BLOCK_SIZE, %ecx
+	movl (ext2_block_size), %ecx
 	cmpl %ecx, 4(%esp)
 	cmovbl 4(%esp), %ecx
 
@@ -476,16 +479,8 @@ ext2_inode_read_bytes:
 	addl %ecx, 0(%esp)
 	subl %ecx, 4(%esp)
 
-	# very dumb memcpy with 32 bit addresses
 	movl $ext2_block_buffer, %esi
-	movl $0, %ebx
+	call memcpy32
- .ext2_inode_read_bytes_memcpy:
-	movb (%esi, %ebx), %al
-	movb %al, (%edi, %ebx)
-	incl %ebx
-	decl %ecx
-	jnz .ext2_inode_read_bytes_memcpy
-	addl %ebx, %edi
 
 	# read next block if more sectors remaining
 	cmpl $0, 4(%esp)
@@ -524,11 +519,12 @@ ext2_directory_find_inode:
 	cmpw $0xFF, %cx
 	ja .ext2_directory_find_inode_not_found
 
-	# ebx := max data blocks: ceil(i_size / EXT2_BLOCK_SIZE)
+	# ebx := max data blocks: ceil(i_size / block_size)
 	movl (ext2_inode_buffer + i_size), %ebx
-	addl $EXT2_BLOCK_SHIFT, %ebx
+	addl (ext2_block_size), %ebx
 	decl %ebx
-	shrl $EXT2_BLOCK_SHIFT, %ebx
+	movb (ext2_block_shift), %cl
+	shrl %cl, %ebx
 	jz .ext2_directory_find_inode_not_found
 
 	# 4(%esp) := current block
@@ -575,7 +571,9 @@ ext2_directory_find_inode:
 
 	# go to next entry if this block contains one
 	addw 4(%si), %si
-	cmpw $(ext2_block_buffer + EXT2_BLOCK_SIZE), %si
+	movw $ext2_block_buffer, %di
+	addw (ext2_block_size), %di
+	cmpw %di, %si
 	jb .ext2_directory_find_inode_loop_entries
 
  .ext2_directory_find_inode_next_block:
@@ -584,7 +582,7 @@ ext2_directory_find_inode:
 	jb .ext2_directory_find_inode_block_read_loop
 
  .ext2_directory_find_inode_not_found:
-	movb $0, %al
+	xorb %al, %al
 	jmp .ext2_directory_find_inode_done
 
  .ext2_directory_find_inode_found:
@@ -678,6 +676,7 @@ ext2_find_kernel:
 	movw $ext2_kernel_not_reg_msg, %si
 	jmp print_and_halt
 
+.section .data
 
 kernel_path:
 	.short kernel_path1
@@ -690,13 +689,12 @@ kernel_path2:
 	.short 15
 	.asciz "banan-os.kernel"
 
-
 root_partition_does_not_fit_ext2_filesystem_msg:
 	.asciz "Root partition is too small to contain ext2 filesystem"
 root_partition_has_invalid_ext2_magic_msg:
 	.asciz "Root partition doesn't contain ext2 magic number"
 root_partition_has_unsupported_ext2_block_size_msg:
-	.asciz "Root partition has unsupported ext2 block size (only 1024 supported)"
+	.asciz "Root partition has unsupported ext2 block size (1 KiB, 2 KiB and 4 KiB are supported)"
 
 ext2_part_not_dir_msg:
 	.asciz "inode in root path is not directory"
@@ -717,12 +715,12 @@ ext2_looking_for_msg:
 
 .section .bss
 
-.align EXT2_BLOCK_SIZE
+.align SECTOR_SIZE
 ext2_block_buffer:
-	.skip EXT2_BLOCK_SIZE
+	.skip EXT2_MAX_BLOCK_SIZE
 
 ext2_inode_indirect_buffer:
-	.skip EXT2_BLOCK_SIZE
+	.skip EXT2_MAX_BLOCK_SIZE
 ext2_inode_indirect_number:
 	.skip 4
 
@@ -736,6 +734,10 @@ ext2_drive_number:
 # NOTE: fits in 2 bytes
 ext2_inode_size:
 	.skip 4
+ext2_block_size:
+	.skip 4
+ext2_block_shift:
+	.skip 4
 
 ext2_superblock_buffer:
 	.skip EXT2_SUPERBLOCK_SIZE

bootloader/bios/framebuffer.S

@@ -57,11 +57,7 @@ vesa_scan_kernel_image:
 
 # Find suitable video mode and save it in (vesa_target_mode)
 vesa_find_video_mode:
-	pushw %ax
+	pushal
-	pushw %bx
-	pushw %cx
-	pushw %di
-	pushl %esi
 
 	pushl %ebp
 	movl %esp, %ebp
@@ -87,7 +83,7 @@ vesa_find_video_mode:
 	# get vesa information
 	movw $0x4F00, %ax
 	movw $vesa_info_buffer, %di
-	int $0x10
+	pushl %ebp; int $0x10; popl %ebp	# BOCHS doesn't seem to reserve ebp
 	cmpb $0x4F, %al; jne .vesa_unsupported
 	cmpb $0x00, %ah; jne .vesa_error
 
@@ -99,8 +95,7 @@ vesa_find_video_mode:
 	cmpw $0x0200, (vesa_info_buffer + 0x04)
 	jb .vesa_unsupported_version
 
-	movl $(vesa_info_buffer + 0x0E), %esi
+	movl (vesa_info_buffer + 0x0E), %esi
-	movl (%esi), %esi
  .vesa_find_video_mode_loop_modes:
 	cmpw $0xFFFF, (%esi)
 	je .vesa_find_video_mode_loop_modes_done
@@ -109,7 +104,7 @@ vesa_find_video_mode:
 	movw $0x4F01, %ax
 	movw (%esi), %cx
 	movw $vesa_mode_info_buffer, %di
-	int $0x10
+	pushl %ebp; int $0x10; popl %ebp	# BOCHS doesn't seem to reserve ebp
 	cmpb $0x4F, %al; jne .vesa_unsupported
 	cmpb $0x00, %ah; jne .vesa_error
 
@@ -146,11 +141,7 @@ vesa_find_video_mode:
 
  .vesa_find_video_mode_loop_modes_done:
 	leavel
-	popl %esi
+	popal
-	popw %di
-	popw %cx
-	popw %bx
-	popw %ax
 	ret
 
  .vesa_unsupported:
@@ -180,20 +171,21 @@ vesa_set_video_mode:
 
 	movw $0x4F02, %ax
 	orw $0x4000, %bx
-	int $0x10
+	pushl %ebp; int $0x10; popl %ebp	# BOCHS doesn't seem to reserve ebp
 
 	jmp .set_video_done
 
  .vesa_set_target_mode_generic:
 	movb $0x03, %al
 	movb $0x00, %ah
-	int $0x10
+	pushl %ebp; int $0x10; popl %ebp	# BOCHS doesn't seem to reserve ebp
 
  .set_video_done:
 	popw %bx
 	popw %ax
 	ret
 
+.section .data
 
 vesa_error_msg:
 	.asciz "VESA error"

bootloader/bios/linker.ld

@@ -8,6 +8,8 @@ SECTIONS
 	. = ALIGN(512);
 	stage2_start = .;
 	.stage2 : { *(.stage2) }
+	. = ALIGN(512);
+	.data : { *(.data) }
 	stage2_end = .;
 
 	. = ALIGN(512);

bootloader/bios/memory_map.S

@@ -114,6 +114,7 @@ print_memory_map:
 
 	ret
 
+.section .data
 
 memory_map_msg:
 	.asciz "memmap:"

bootloader/bios/utils.S

@@ -1,3 +1,5 @@
+.include "common.S"
+
 .set SCREEN_WIDTH,	80
 .set SCREEN_HEIGHT,	25
 
@@ -273,6 +275,109 @@ isprint:
 	movb $0, %al
 	ret
 
+
+# memset with 32 bit registers
+#   edi:    destination address
+#   ecx:    bytes count
+#   al:     value to set
+# return:
+#   edi:    destination address + bytes count
+#   ecx:    0
+#   other:  preserved
+.global memset32
+memset32:
+	testl %ecx, %ecx
+	jz .memset32_done
+
+	pushf; cli
+	pushw %es
+	pushl %eax
+	pushl %ebx
+	pushl %edx
+
+	movl %cr0, %ebx
+	orb $1, %bl
+	movl %ebx, %cr0
+
+	ljmpl $GDT_CODE32, $.memset32_pmode32
+
+ .code32
+ .memset32_pmode32:
+	movw $GDT_DATA32, %dx
+	movw %dx, %es
+
+	rep stosb %es:(%edi)
+
+	ljmpl $GDT_CODE16, $.memset32_pmode16
+
+ .code16
+ .memset32_pmode16:
+	andb $0xFE, %bl
+	movl %ebx, %cr0
+	ljmpl $0x00, $.memset32_rmode16
+
+ .memset32_rmode16:
+	popl %edx
+	popl %ebx
+	popl %eax
+	popw %es
+	popf
+
+ .memset32_done:
+	ret
+
+# memcpy with 32 bit registers
+#   esi:    source address
+#   edi:    destination address
+#   ecx:    bytes count
+# return:
+#   esi:    source address + bytes count
+#   edi:    destination address + bytes count
+#   ecx:    0
+#   other:  preserved
+.global memcpy32
+memcpy32:
+	testl %ecx, %ecx
+	jz .memcpy32_done
+
+	pushf; cli
+	pushw %ds
+	pushw %es
+	pushl %ebx
+	pushl %edx
+
+	movl %cr0, %ebx
+	orb $1, %bl
+	movl %ebx, %cr0
+
+	ljmpl $GDT_CODE32, $.memcpy32_pmode32
+
+ .code32
+ .memcpy32_pmode32:
+	movw $GDT_DATA32, %dx
+	movw %dx, %ds
+	movw %dx, %es
+
+	rep movsb %ds:(%esi), %es:(%edi)
+
+	ljmpl $GDT_CODE16, $.memcpy32_pmode16
+
+ .code16
+ .memcpy32_pmode16:
+	andb $0xFE, %bl
+	movl %ebx, %cr0
+	ljmpl $0x00, $.memcpy32_rmode16
+
+ .memcpy32_rmode16:
+	popl %edx
+	popl %ebx
+	popw %es
+	popw %ds
+	popf
+
+ .memcpy32_done:
+	ret
+
 .section .bss
 
 # enough for base 2 printing

bootloader/installer/CMakeLists.txt

@@ -1,6 +1,11 @@
 cmake_minimum_required(VERSION 3.26)
 
-project(x86_64-banan_os-bootloader-installer CXX)
+if (NOT DEFINED ENV{BANAN_ARCH})
+	message(FATAL_ERROR "environment variable BANAN_ARCH not defined")
+endif ()
+set(BANAN_ARCH $ENV{BANAN_ARCH})
+
+project(banan_os-bootloader-installer CXX)
 
 set(SOURCES
     crc32.cpp
@@ -10,8 +15,8 @@ set(SOURCES
 	main.cpp
 )
 
-add_executable(x86_64-banan_os-bootloader-installer ${SOURCES})
+add_executable(banan_os-bootloader-installer ${SOURCES})
-target_compile_options(x86_64-banan_os-bootloader-installer PRIVATE -O2 -std=c++20)
+target_compile_options(banan_os-bootloader-installer PRIVATE -O2 -std=c++20)
-target_compile_definitions(x86_64-banan_os-bootloader-installer PRIVATE __arch=x86_64)
+target_compile_definitions(banan_os-bootloader-installer PRIVATE __arch=${BANAN_ARCH})
-target_include_directories(x86_64-banan_os-bootloader-installer PRIVATE ${CMAKE_SOURCE_DIR}/../../LibELF/include)
+target_include_directories(banan_os-bootloader-installer PRIVATE ${CMAKE_SOURCE_DIR}/../../userspace/libraries/LibELF/include)
-target_include_directories(x86_64-banan_os-bootloader-installer PRIVATE ${CMAKE_SOURCE_DIR}/../../kernel/include)
+target_include_directories(banan_os-bootloader-installer PRIVATE ${CMAKE_SOURCE_DIR}/../../kernel/include)

bootloader/installer/ELF.cpp

@@ -81,7 +81,7 @@ bool ELFFile::validate_elf_header() const
 
 #if ARCH(x86_64)
 	if (elf_header.e_ident[EI_CLASS] != ELFCLASS64)
-#elif ARCH(i386)
+#elif ARCH(i686)
 	if (elf_header.e_ident[EI_CLASS] != ELFCLASS32)
 #endif
 	{

bootloader/installer/GPT.cpp

@@ -99,33 +99,33 @@ bool GPTFile::install_stage1(std::span<const uint8_t> stage1)
 	return true;
 }
 
-bool GPTFile::install_stage2(std::span<const uint8_t> stage2, const GUID& root_partition_guid)
+bool GPTFile::install_stage2(std::span<const uint8_t> stage2, std::span<const uint8_t> data, const GUID& root_partition_guid)
 {
-	if (stage2.size() < 16)
+	if (data.size() < 16)
 	{
-		std::cerr << m_path << ": contains invalid .stage2 section, too small for patches" << std::endl;
+		std::cerr << m_path << ": contains invalid .data section, too small for patches" << std::endl;
 		return false;
 	}
 
 	// find GUID patch offsets
 	std::size_t disk_guid_offset(-1);
 	std::size_t part_guid_offset(-1);
-	for (std::size_t i = 0; i < stage2.size() - 16; i++)
+	for (std::size_t i = 0; i < data.size() - 16; i++)
 	{
-		if (memcmp(stage2.data() + i, "root disk guid  ", 16) == 0)
+		if (memcmp(data.data() + i, "root disk guid  ", 16) == 0)
 		{
 			if (disk_guid_offset != std::size_t(-1))
 			{
-				std::cerr << m_path << ": contains invalid .stage2 section, multiple patchable disk guids" << std::endl;
+				std::cerr << m_path << ": contains invalid .data section, multiple patchable disk guids" << std::endl;
 				return false;
 			}
 			disk_guid_offset = i;
 		}
-		if (memcmp(stage2.data() + i, "root part guid  ", 16) == 0)
+		if (memcmp(data.data() + i, "root part guid  ", 16) == 0)
 		{
 			if (part_guid_offset != std::size_t(-1))
 			{
-				std::cerr << m_path << ": contains invalid .stage2 section, multiple patchable partition guids" << std::endl;
+				std::cerr << m_path << ": contains invalid .data section, multiple patchable partition guids" << std::endl;
 				return false;
 			}
 			part_guid_offset = i;
@@ -133,16 +133,15 @@ bool GPTFile::install_stage2(std::span<const uint8_t> stage2, const GUID& root_p
 	}
 	if (disk_guid_offset == std::size_t(-1))
 	{
-		std::cerr << m_path << ": contains invalid .stage2 section, no patchable disk guid" << std::endl;
+		std::cerr << m_path << ": contains invalid .data section, no patchable disk guid" << std::endl;
 		return false;
 	}
 	if (part_guid_offset == std::size_t(-1))
 	{
-		std::cerr << m_path << ": contains invalid .stage2 section, no patchable partition guid" << std::endl;
+		std::cerr << m_path << ": contains invalid .data section, no patchable partition guid" << std::endl;
 		return false;
 	}
 
-
 	auto partition = find_partition_with_type(bios_boot_guid);
 	if (!partition.has_value())
 	{
@@ -152,23 +151,28 @@ bool GPTFile::install_stage2(std::span<const uint8_t> stage2, const GUID& root_p
 
 	const std::size_t partition_size = (partition->ending_lba - partition->starting_lba + 1) * SECTOR_SIZE;
 
-	if (stage2.size() > partition_size)
+	std::size_t data_offset = stage2.size();
+	if (std::size_t rem = data_offset % 512)
+		data_offset += 512 - rem;
+
+	if (data_offset + data.size() > partition_size)
 	{
-		std::cerr << m_path << ": can't fit " << stage2.size() << " bytes of data to partition of size " << partition_size << std::endl;
+		std::cerr << m_path << ": can't fit " << stage2.size() + data.size() << " bytes of data to partition of size " << partition_size << std::endl;
 		return false;
 	}
 
 	uint8_t* partition_start = m_mmap + partition->starting_lba * SECTOR_SIZE;
 	memcpy(partition_start, stage2.data(), stage2.size());
+	memcpy(partition_start + data_offset, data.data(), data.size());
 
 	// patch GUIDs
-	*reinterpret_cast<GUID*>(partition_start + disk_guid_offset) = gpt_header().disk_guid;
+	*reinterpret_cast<GUID*>(partition_start + data_offset + disk_guid_offset) = gpt_header().disk_guid;
-	*reinterpret_cast<GUID*>(partition_start + part_guid_offset) = root_partition_guid;
+	*reinterpret_cast<GUID*>(partition_start + data_offset + part_guid_offset) = root_partition_guid;
 
 	return true;
 }
 
-bool GPTFile::install_bootloader(std::span<const uint8_t> stage1, std::span<const uint8_t> stage2, const GUID& root_partition_guid)
+bool GPTFile::install_bootloader(std::span<const uint8_t> stage1, std::span<const uint8_t> stage2, std::span<const uint8_t> data, const GUID& root_partition_guid)
 {
 	if (!find_partition_with_guid(root_partition_guid).has_value())
 	{
@@ -177,7 +181,7 @@ bool GPTFile::install_bootloader(std::span<const uint8_t> stage1, std::span<cons
 	}
 	if (!install_stage1(stage1))
 		return false;
-	if (!install_stage2(stage2, root_partition_guid))
+	if (!install_stage2(stage2, data, root_partition_guid))
 		return false;
 	return true;
 }

bootloader/installer/GPT.h

@@ -65,7 +65,7 @@ public:
 	GPTFile(std::string_view path);
 	~GPTFile();
 
-	bool install_bootloader(std::span<const uint8_t> stage1, std::span<const uint8_t> stage2, const GUID& root_partition_guid);
+	bool install_bootloader(std::span<const uint8_t> stage1, std::span<const uint8_t> stage2, std::span<const uint8_t> data, const GUID& root_partition_guid);
 
 	const GPTHeader& gpt_header() const;
 
@@ -80,7 +80,7 @@ private:
 	std::optional<GPTPartitionEntry> find_partition_with_type(const GUID& type_guid) const;
 
 	bool install_stage1(std::span<const uint8_t> stage1);
-	bool install_stage2(std::span<const uint8_t> stage2, const GUID& root_partition_guid);
+	bool install_stage2(std::span<const uint8_t> stage2, std::span<const uint8_t> data, const GUID& root_partition_guid);
 
 private:
 	const std::string	m_path;

bootloader/installer/build.sh

@@ -1,3 +0,0 @@
-#!/bin/sh
-
-g++ -O2 -std=c++20 main.cpp crc32.cpp ELF.cpp GPT.cpp GUID.cpp -o install-bootloader

bootloader/installer/main.cpp

@@ -26,9 +26,10 @@ int main(int argc, char** argv)
 
 	auto stage1 = bootloader.find_section(".stage1"sv);
 	auto stage2 = bootloader.find_section(".stage2"sv);
-	if (!stage1.has_value() || !stage2.has_value())
+	auto data = bootloader.find_section(".data"sv);
+	if (!stage1.has_value() || !stage2.has_value() || !data.has_value())
 	{
-		std::cerr << bootloader.path() << " doesn't contain .stage1 and .stage2 sections" << std::endl;
+		std::cerr << bootloader.path() << " doesn't contain .stage1, .stage2 and .data sections" << std::endl;
 		return 1;
 	}
 
@@ -36,7 +37,7 @@ int main(int argc, char** argv)
 	if (!disk_image.success())
 		return 1;
 
-	if (!disk_image.install_bootloader(*stage1, *stage2, *root_partition_guid))
+	if (!disk_image.install_bootloader(*stage1, *stage2, *data, *root_partition_guid))
 		return 1;
 	std::cout << "bootloader installed" << std::endl;
 

kernel/CMakeLists.txt

@@ -1,41 +1,57 @@
-cmake_minimum_required(VERSION 3.26)
-
-project(kernel CXX C ASM)
-
-if("${BANAN_ARCH}" STREQUAL "x86_64")
-	set(ELF_FORMAT elf64-x86-64)
-elseif("${BANAN_ARCH}" STREQUAL "i386")
-	set(ELF_FORMAT elf32-i386)
-endif()
-
 set(KERNEL_SOURCES
 	font/prefs.psf.o
-	kernel/ACPI.cpp
+	kernel/ACPI/ACPI.cpp
+	kernel/ACPI/AML/Namespace.cpp
+	kernel/ACPI/AML/Node.cpp
+	kernel/ACPI/AML/OpRegion.cpp
+	kernel/ACPI/BatterySystem.cpp
+	kernel/ACPI/EmbeddedController.cpp
 	kernel/APIC.cpp
+	kernel/Audio/AC97/Controller.cpp
+	kernel/Audio/Controller.cpp
+	kernel/Audio/HDAudio/AudioFunctionGroup.cpp
+	kernel/Audio/HDAudio/Controller.cpp
 	kernel/BootInfo.cpp
 	kernel/CPUID.cpp
+	kernel/Credentials.cpp
 	kernel/Debug.cpp
+	kernel/Device/DebugDevice.cpp
 	kernel/Device/Device.cpp
 	kernel/Device/FramebufferDevice.cpp
 	kernel/Device/NullDevice.cpp
+	kernel/Device/RandomDevice.cpp
 	kernel/Device/ZeroDevice.cpp
+	kernel/ELF.cpp
+	kernel/Epoll.cpp
 	kernel/Errors.cpp
-	kernel/Font.cpp
 	kernel/FS/DevFS/FileSystem.cpp
+	kernel/FS/EventFD.cpp
 	kernel/FS/Ext2/FileSystem.cpp
 	kernel/FS/Ext2/Inode.cpp
+	kernel/FS/FAT/FileSystem.cpp
+	kernel/FS/FAT/Inode.cpp
+	kernel/FS/FileSystem.cpp
 	kernel/FS/Inode.cpp
 	kernel/FS/Pipe.cpp
 	kernel/FS/ProcFS/FileSystem.cpp
 	kernel/FS/ProcFS/Inode.cpp
 	kernel/FS/TmpFS/FileSystem.cpp
 	kernel/FS/TmpFS/Inode.cpp
+	kernel/FS/USTARModule.cpp
 	kernel/FS/VirtualFileSystem.cpp
-	kernel/Input/PS2Controller.cpp
+	kernel/GDT.cpp
-	kernel/Input/PS2Keyboard.cpp
+	kernel/IDT.cpp
-	kernel/Input/PS2Keymap.cpp
+	kernel/Input/InputDevice.cpp
+	kernel/Input/PS2/Controller.cpp
+	kernel/Input/PS2/Device.cpp
+	kernel/Input/PS2/Keyboard.cpp
+	kernel/Input/PS2/Keymap.cpp
+	kernel/Input/PS2/Mouse.cpp
+	kernel/Interruptable.cpp
 	kernel/InterruptController.cpp
 	kernel/kernel.cpp
+	kernel/Lock/SpinLock.cpp
+	kernel/Memory/ByteRingBuffer.cpp
 	kernel/Memory/DMARegion.cpp
 	kernel/Memory/FileBackedRegion.cpp
 	kernel/Memory/Heap.cpp
@@ -43,16 +59,29 @@ set(KERNEL_SOURCES
 	kernel/Memory/MemoryBackedRegion.cpp
 	kernel/Memory/MemoryRegion.cpp
 	kernel/Memory/PhysicalRange.cpp
+	kernel/Memory/SharedMemoryObject.cpp
 	kernel/Memory/VirtualRange.cpp
-	kernel/Networking/E1000.cpp
+	kernel/Networking/ARPTable.cpp
+	kernel/Networking/E1000/E1000.cpp
+	kernel/Networking/E1000/E1000E.cpp
+	kernel/Networking/IPv4Layer.cpp
+	kernel/Networking/Loopback.cpp
+	kernel/Networking/NetworkInterface.cpp
+	kernel/Networking/NetworkLayer.cpp
+	kernel/Networking/NetworkManager.cpp
+	kernel/Networking/NetworkSocket.cpp
+	kernel/Networking/RTL8169/RTL8169.cpp
+	kernel/Networking/TCPSocket.cpp
+	kernel/Networking/UDPSocket.cpp
+	kernel/Networking/UNIX/Socket.cpp
 	kernel/OpenFileDescriptorSet.cpp
 	kernel/Panic.cpp
 	kernel/PCI.cpp
 	kernel/PIC.cpp
 	kernel/Process.cpp
+	kernel/Processor.cpp
+	kernel/Random.cpp
 	kernel/Scheduler.cpp
-	kernel/Semaphore.cpp
-	kernel/SpinLock.cpp
 	kernel/SSP.cpp
 	kernel/Storage/ATA/AHCI/Controller.cpp
 	kernel/Storage/ATA/AHCI/Device.cpp
@@ -60,23 +89,42 @@ set(KERNEL_SOURCES
 	kernel/Storage/ATA/ATAController.cpp
 	kernel/Storage/ATA/ATADevice.cpp
 	kernel/Storage/DiskCache.cpp
+	kernel/Storage/NVMe/Controller.cpp
+	kernel/Storage/NVMe/Namespace.cpp
+	kernel/Storage/NVMe/Queue.cpp
 	kernel/Storage/Partition.cpp
+	kernel/Storage/SCSI.cpp
 	kernel/Storage/StorageDevice.cpp
 	kernel/Syscall.cpp
-	kernel/Syscall.S
 	kernel/Terminal/FramebufferTerminal.cpp
+	kernel/Terminal/PseudoTerminal.cpp
 	kernel/Terminal/Serial.cpp
+	kernel/Terminal/TerminalDriver.cpp
+	kernel/Terminal/TextModeTerminal.cpp
 	kernel/Terminal/TTY.cpp
 	kernel/Terminal/VirtualTTY.cpp
 	kernel/Thread.cpp
+	kernel/ThreadBlocker.cpp
 	kernel/Timer/HPET.cpp
 	kernel/Timer/PIT.cpp
 	kernel/Timer/RTC.cpp
 	kernel/Timer/Timer.cpp
+	kernel/USB/Controller.cpp
+	kernel/USB/Device.cpp
+	kernel/USB/HID/HIDDriver.cpp
+	kernel/USB/HID/Joystick.cpp
+	kernel/USB/HID/Keyboard.cpp
+	kernel/USB/HID/Mouse.cpp
+	kernel/USB/Hub/HubDriver.cpp
+	kernel/USB/MassStorage/MassStorageDriver.cpp
+	kernel/USB/MassStorage/SCSIDevice.cpp
+	kernel/USB/USBManager.cpp
+	kernel/USB/XHCI/Controller.cpp
+	kernel/USB/XHCI/Device.cpp
 	icxxabi.cpp
 )
 
-#set(ENABLE_KERNEL_UBSAN True)
+set(ENABLE_KERNEL_UBSAN False)
 
 if(ENABLE_KERNEL_UBSAN)
 	set(KERNEL_SOURCES ${KERNEL_SOURCES} ubsan.cpp)
@@ -86,102 +134,115 @@ if("${BANAN_ARCH}" STREQUAL "x86_64")
 	set(KERNEL_SOURCES
 		${KERNEL_SOURCES}
 		arch/x86_64/boot.S
-		arch/x86_64/GDT.cpp
-		arch/x86_64/IDT.cpp
 		arch/x86_64/interrupts.S
 		arch/x86_64/PageTable.cpp
 		arch/x86_64/Signal.S
+		arch/x86_64/Syscall.S
 		arch/x86_64/Thread.S
+		arch/x86_64/User.S
+		arch/x86_64/Yield.S
 	)
-elseif("${BANAN_ARCH}" STREQUAL "i386")
+elseif("${BANAN_ARCH}" STREQUAL "i686")
 	set(KERNEL_SOURCES
 		${KERNEL_SOURCES}
-		arch/i386/boot.S
+		arch/i686/boot.S
-		arch/i386/GDT.cpp
+		arch/i686/interrupts.S
-		arch/i386/IDT.cpp
+		arch/i686/PageTable.cpp
-		arch/i386/MMU.cpp
+		arch/i686/Signal.S
-		arch/i386/SpinLock.S
+		arch/i686/Syscall.S
-		arch/i386/Thread.S
+		arch/i686/Thread.S
+		arch/i686/User.S
+		arch/i686/Yield.S
 	)
 else()
 	message(FATAL_ERROR "unsupported architecure ${BANAN_ARCH}")
 endif()
 
-file(GLOB_RECURSE LAI_SOURCES
-	lai/*.c
-)
-set(LAI_SOURCES
-	${LAI_SOURCES}
-	kernel/lai_host.cpp
-)
-
 set(BAN_SOURCES
+	../BAN/BAN/Assert.cpp
 	../BAN/BAN/New.cpp
-	../BAN/BAN/String.cpp
 	../BAN/BAN/StringView.cpp
 	../BAN/BAN/Time.cpp
 )
 
-set(LIBC_SOURCES
+set(KLIBC_SOURCES
-	../libc/ctype.cpp
+	klibc/ctype.cpp
-	../libc/string.cpp
+	klibc/string.cpp
+	klibc/arch/${BANAN_ARCH}/string.S
 )
 
-set(LIBELF_SOURCES
+set(LIBDEFLATE_SOURCE
-	../LibELF/LibELF/LoadableELF.cpp
+	../userspace/libraries/LibDEFLATE/Compressor.cpp
+	../userspace/libraries/LibDEFLATE/Decompressor.cpp
+	../userspace/libraries/LibDEFLATE/HuffmanTree.cpp
+)
+
+set(LIBFONT_SOURCES
+	../userspace/libraries/LibFont/Font.cpp
+	../userspace/libraries/LibFont/PSF.cpp
+)
+
+set(LIBINPUT_SOURCE
+	../userspace/libraries/LibInput/KeyboardLayout.cpp
+	../userspace/libraries/LibInput/KeyEvent.cpp
+)
+
+set(LIBQR_SOURCE
+	../userspace/libraries/LibQR/QRCode.cpp
 )
 
 set(KERNEL_SOURCES
 	${KERNEL_SOURCES}
-	${LAI_SOURCES}
 	${BAN_SOURCES}
-	${LIBC_SOURCES}
+	${KLIBC_SOURCES}
-	${LIBELF_SOURCES}
+	${LIBDEFLATE_SOURCE}
+	${LIBFONT_SOURCES}
+	${LIBINPUT_SOURCE}
+	${LIBQR_SOURCE}
 )
 
 add_executable(kernel ${KERNEL_SOURCES})
-add_dependencies(kernel headers)
 
-target_compile_definitions(kernel PUBLIC __is_kernel)
+target_compile_definitions(kernel PRIVATE __is_kernel)
-target_compile_definitions(kernel PUBLIC __arch=${BANAN_ARCH})
+target_compile_definitions(kernel PRIVATE __arch=${BANAN_ARCH})
+target_compile_definitions(kernel PRIVATE LIBDEFLATE_AVOID_STACK=1)
 
-target_compile_options(kernel PUBLIC -O2 -g)
+target_compile_options(kernel PRIVATE
-target_compile_options(kernel PUBLIC $<$<COMPILE_LANGUAGE:CXX>:-Wno-literal-suffix -fno-rtti -fno-exceptions>)
+	-O2 -g
-target_compile_options(kernel PUBLIC -fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}=.)
+	-fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}=.
-target_compile_options(kernel PUBLIC -fstack-protector -ffreestanding -Wall -Wextra -Werror -Wstack-usage=1024 -fno-omit-frame-pointer -mgeneral-regs-only)
+	-fstack-protector
+	-ffreestanding
+	-fno-omit-frame-pointer
+	-fstrict-volatile-bitfields
+	-mgeneral-regs-only
+	-Wall -Wextra -Werror -Wstack-usage=1024
+)
 
-# This might not work with other toolchains
+# C++ specific
-target_compile_options(kernel PUBLIC $<$<COMPILE_LANGUAGE:CXX>:-Wno-invalid-offsetof>)
+target_compile_options(kernel PRIVATE
+	-Wno-literal-suffix
+	-Wno-invalid-offsetof
+	-fno-rtti
+	-fno-exceptions
+)
 
 if(ENABLE_KERNEL_UBSAN)
-	target_compile_options(kernel PUBLIC -fsanitize=undefined)
+	target_compile_options(kernel PRIVATE -fsanitize=undefined)
 endif()
 
 if("${BANAN_ARCH}" STREQUAL "x86_64")
-	target_compile_options(kernel PUBLIC -mcmodel=kernel -mno-red-zone -mno-mmx)
+	target_compile_options(kernel PRIVATE -mcmodel=kernel -mno-red-zone)
-	target_link_options(kernel PUBLIC LINKER:-z,max-page-size=4096)
+	target_link_options(kernel PRIVATE LINKER:-z,max-page-size=4096)
-	target_link_options(kernel PUBLIC LINKER:-T,${CMAKE_CURRENT_SOURCE_DIR}/arch/x86_64/linker.ld)
+	target_link_options(kernel PRIVATE LINKER:-T,${CMAKE_CURRENT_SOURCE_DIR}/arch/x86_64/linker.ld)
-elseif("${BANAN_ARCH}" STREQUAL "i386")
+elseif("${BANAN_ARCH}" STREQUAL "i686")
-	target_link_options(kernel PUBLIC LINKER:-T,${CMAKE_CURRENT_SOURCE_DIR}/arch/i386/linker.ld)
+	target_link_options(kernel PRIVATE LINKER:-T,${CMAKE_CURRENT_SOURCE_DIR}/arch/i686/linker.ld)
 endif()
 
-target_link_options(kernel PUBLIC -ffreestanding -nostdlib)
+target_link_options(kernel PRIVATE -ffreestanding -nostdlib -orphan-handling=error)
 
-set_source_files_properties(${LAI_SOURCES} PROPERTIES COMPILE_FLAGS -Wno-stack-usage)
+get_target_property(KERNEL_COMPILE_OPTIONS kernel COMPILE_OPTIONS)
-
+execute_process(COMMAND ${CMAKE_CXX_COMPILER} ${KERNEL_COMPILE_OPTIONS} -print-file-name=crtbegin.o OUTPUT_VARIABLE CRTBEGIN OUTPUT_STRIP_TRAILING_WHITESPACE)
-add_custom_target(kernel-headers
+execute_process(COMMAND ${CMAKE_CXX_COMPILER} ${KERNEL_COMPILE_OPTIONS} -print-file-name=crtend.o OUTPUT_VARIABLE CRTEND OUTPUT_STRIP_TRAILING_WHITESPACE)
-	COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different ${CMAKE_CURRENT_SOURCE_DIR}/include/ ${BANAN_INCLUDE}/
-	COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different ${CMAKE_CURRENT_SOURCE_DIR}/lai/include/ ${BANAN_INCLUDE}/
-	DEPENDS sysroot
-)
-
-add_custom_target(kernel-install
-	COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_BINARY_DIR}/kernel ${BANAN_BOOT}/banan-os.kernel
-	DEPENDS kernel
-)
-
-execute_process(COMMAND ${CMAKE_CXX_COMPILER} -print-file-name=crtbegin.o OUTPUT_VARIABLE CRTBEGIN OUTPUT_STRIP_TRAILING_WHITESPACE)
-execute_process(COMMAND ${CMAKE_CXX_COMPILER} -print-file-name=crtend.o OUTPUT_VARIABLE CRTEND OUTPUT_STRIP_TRAILING_WHITESPACE)
 
 add_custom_command(
 	TARGET kernel PRE_LINK
@@ -196,9 +257,27 @@ add_custom_command(
 #	COMMAND x86_64-banan_os-strip ${CMAKE_CURRENT_BINARY_DIR}/kernel
 #)
 
+banan_include_headers(kernel ban)
+banan_include_headers(kernel libc)
+banan_include_headers(kernel libdeflate)
+banan_include_headers(kernel libelf)
+banan_include_headers(kernel libfont)
+banan_include_headers(kernel libinput)
+banan_include_headers(kernel libqr)
+
+banan_install_headers(kernel)
+set_target_properties(kernel PROPERTIES OUTPUT_NAME banan-os.kernel)
+install(TARGETS kernel DESTINATION ${BANAN_BOOT} OPTIONAL)
+
+if("${BANAN_ARCH}" STREQUAL "x86_64")
+	set(ELF_FORMAT elf64-x86-64)
+elseif("${BANAN_ARCH}" STREQUAL "i686")
+	set(ELF_FORMAT elf32-i386)
+endif()
+
 add_custom_command(
 	OUTPUT font/prefs.psf.o
-	COMMAND cd ${CMAKE_CURRENT_SOURCE_DIR} && objcopy -O ${ELF_FORMAT} -B i386 -I binary font/prefs.psf ${CMAKE_CURRENT_BINARY_DIR}/font/prefs.psf.o
+	COMMAND cd ${CMAKE_CURRENT_SOURCE_DIR} && mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/font && objcopy -O ${ELF_FORMAT} -B i386 -I binary font/prefs.psf ${CMAKE_CURRENT_BINARY_DIR}/font/prefs.psf.o
 )
 
 set(CMAKE_CXX_LINK_EXECUTABLE "${CMAKE_CXX_COMPILER} <CMAKE_CXX_LINK_FLAGS> <FLAGS> <LINK_FLAGS> -o <TARGET> ${CMAKE_CURRENT_BINARY_DIR}/crti.o ${CMAKE_CURRENT_BINARY_DIR}/crtbegin.o <OBJECTS> ${CMAKE_CURRENT_BINARY_DIR}/crtend.o ${CMAKE_CURRENT_BINARY_DIR}/crtn.o -lgcc ")

kernel/arch/i386/GDT.cpp

@@ -1,147 +0,0 @@
-#include <BAN/Assert.h>
-#include <kernel/GDT.h>
-
-#include <string.h>
-
-extern "C" uintptr_t g_boot_stack_top[0];
-
-namespace Kernel::GDT
-{
-
-	struct TaskStateSegment
-	{
-		uint16_t link;
-		uint16_t reserved1;
-		uint32_t esp0;
-		uint16_t ss0;
-		uint16_t reserved2;
-		uint32_t esp1;
-		uint16_t ss1;
-		uint16_t reserved3;
-		uint32_t esp2;
-		uint16_t ss2;
-		uint16_t reserved4;
-		uint32_t cr3;
-		uint32_t eip;
-		uint32_t eflags;
-		uint32_t eax;
-		uint32_t ecx;
-		uint32_t edx;
-		uint32_t ebx;
-		uint32_t esp;
-		uint32_t ebp;
-		uint32_t esi;
-		uint32_t edi;
-		uint16_t es;
-		uint16_t reserved5;
-		uint16_t cs;
-		uint16_t reserved6;
-		uint16_t ss;
-		uint16_t reserved7;
-		uint16_t ds;
-		uint16_t reserved8;
-		uint16_t fs;
-		uint16_t reserved9;
-		uint16_t gs;
-		uint16_t reserved10;
-		uint16_t ldtr;
-		uint16_t reserved11;
-		uint16_t reserved12;
-		uint16_t iopb;
-		uint32_t ssp;
-	} __attribute__((packed));
-
-	union SegmentDescriptor
-	{
-		struct
-		{
-			uint16_t	limit1;
-			uint16_t	base1;
-			uint8_t		base2;
-			uint8_t		access;
-			uint8_t		limit2 : 4;
-			uint8_t		flags  : 4;
-			uint8_t		base3;
-		} __attribute__((packed));
-		
-		struct
-		{
-			uint32_t low;
-			uint32_t high;
-		} __attribute__((packed));
-
-	} __attribute__((packed));
-
-	struct GDTR
-	{
-		uint16_t size;
-		uint32_t address;
-	} __attribute__((packed));
-
-	static TaskStateSegment* s_tss = nullptr;
-	static SegmentDescriptor* s_gdt = nullptr;
-	static GDTR s_gdtr;
-
-	static void write_entry(uint8_t offset, uint32_t base, uint32_t limit, uint8_t access, uint8_t flags)
-	{
-		SegmentDescriptor& desc = *(SegmentDescriptor*)((uintptr_t)s_gdt + offset);
-		desc.base1 = base;
-		desc.base2 = base >> 16;
-		desc.base3 = base >> 24;
-
-		desc.limit1 = limit;
-		desc.limit2 = limit >> 16;
-
-		desc.access = access;
-
-		desc.flags = flags;
-	}
-
-	static void write_tss(uint8_t offset)
-	{
-		s_tss = new TaskStateSegment();
-		ASSERT(s_tss);
-		
-		memset(s_tss, 0x00, sizeof(TaskStateSegment));
-		s_tss->ss0 = 0x10;
-		s_tss->esp0 = (uintptr_t)g_boot_stack_top;
-
-		write_entry(offset, (uint32_t)s_tss, sizeof(TaskStateSegment), 0x89, 0x0);
-	}
-
-	void set_tss_stack(uintptr_t esp)
-	{
-		s_tss->esp0 = esp;
-	}
-
-	static void flush_gdt()
-	{
-		asm volatile("lgdt %0" :: "m"(s_gdtr));
-	}
-
-	extern "C" void flush_tss(uint16_t offset)
-	{
-		asm volatile("ltr %0" :: "m"(offset));
-	}
-
-	void initialize()
-	{
-		constexpr uint32_t descriptor_count = 6;
-		s_gdt = new SegmentDescriptor[descriptor_count]; 
-		ASSERT(s_gdt);
-
-		s_gdtr.address = (uint64_t)s_gdt;
-		s_gdtr.size = descriptor_count * sizeof(SegmentDescriptor) - 1;
-
-		write_entry(0x00, 0x00000000, 0x00000, 0x00, 0x0); // null
-		write_entry(0x08, 0x00000000, 0xFFFFF, 0x9A, 0xC); // kernel code
-		write_entry(0x10, 0x00000000, 0xFFFFF, 0x92, 0xC); // kernel data
-		write_entry(0x18, 0x00000000, 0xFFFFF, 0xFA, 0xC); // user code
-		write_entry(0x20, 0x00000000, 0xFFFFF, 0xF2, 0xC); // user data
-		write_tss(0x28);
-
-		flush_gdt();
-		flush_tss(0x28);
-	}
-
-}

kernel/arch/i386/IDT.cpp

@@ -1,270 +0,0 @@
-#include <BAN/Errors.h>
-#include <kernel/IDT.h>
-#include <kernel/InterruptController.h>
-#include <kernel/Memory/kmalloc.h>
-#include <kernel/Panic.h>
-#include <kernel/Scheduler.h>
-
-#define INTERRUPT_HANDLER____(i, msg)													\
-	static void interrupt ## i ()														\
-	{																					\
-		uint32_t eax, ebx, ecx, edx;													\
-		uint32_t esp, ebp;																\
-		uint32_t cr0, cr2, cr3, cr4;													\
-		asm volatile("":"=a"(eax),"=b"(ebx),"=c"(ecx),"=d"(edx));						\
-		asm volatile("movl %%esp, %%eax":"=a"(esp));									\
-		asm volatile("movl %%ebp, %%eax":"=a"(ebp));									\
-		asm volatile("movl %%cr0, %%eax":"=a"(cr0)); 									\
-		asm volatile("movl %%cr2, %%eax":"=a"(cr2)); 									\
-		asm volatile("movl %%cr3, %%eax":"=a"(cr3)); 									\
-		asm volatile("movl %%cr4, %%eax":"=a"(cr4)); 									\
-		Kernel::panic(msg "\r\nRegister dump\r\n"										\
-			"eax=0x{8H}, ebx=0x{8H}, ecx=0x{8H}, edx=0x{8H}\r\n" 						\
-			"esp=0x{8H}, ebp=0x{8H}\r\n" 												\
-			"CR0=0x{8H}, CR2=0x{8H}, CR3=0x{8H}, CR4=0x{8H}\r\n", 						\
-			eax, ebx, ecx, edx, esp, ebp, cr0, cr2, cr3, cr4);							\
-	}
-
-#define INTERRUPT_HANDLER_ERR(i, msg)													\
-	static void interrupt ## i ()														\
-	{																					\
-		uint32_t eax, ebx, ecx, edx;													\
-		uint32_t esp, ebp;																\
-		uint32_t cr0, cr2, cr3, cr4;													\
-		uint32_t error_code;															\
-		asm volatile("":"=a"(eax),"=b"(ebx),"=c"(ecx),"=d"(edx));						\
-		asm volatile("movl %%esp, %%eax":"=a"(esp));									\
-		asm volatile("movl %%ebp, %%eax":"=a"(ebp));									\
-		asm volatile("movl %%cr0, %%eax":"=a"(cr0)); 									\
-		asm volatile("movl %%cr2, %%eax":"=a"(cr2)); 									\
-		asm volatile("movl %%cr3, %%eax":"=a"(cr3)); 									\
-		asm volatile("movl %%cr4, %%eax":"=a"(cr4)); 									\
-		asm volatile("popl %%eax":"=a"(error_code));									\
-		Kernel::panic(msg " (error code: 0x{8H})\r\n"									\
-			"Register dump\r\n"															\
-			"eax=0x{8H}, ebx=0x{8H}, ecx=0x{8H}, edx=0x{8H}\r\n" 						\
-			"esp=0x{8H}, ebp=0x{8H}\r\n" 												\
-			"CR0=0x{8H}, CR2=0x{8H}, CR3=0x{8H}, CR4=0x{8H}\r\n", 						\
-			eax, ebx, ecx, edx, esp, ebp, cr0, cr2, cr3, cr4, error_code);				\
-	}
-
-#define REGISTER_HANDLER(i) register_interrupt_handler(i, interrupt ## i)
-
-namespace IDT
-{
-
-	struct GateDescriptor
-	{
-		uint16_t offset1;
-		uint16_t selector;
-		uint8_t reserved	: 5;
-		uint8_t zero1		: 3;
-		uint8_t type		: 4;
-		uint8_t zero2		: 1;
-		uint8_t DPL			: 2;
-		uint8_t present		: 1;
-		uint16_t offset2;
-	} __attribute__((packed));
-
-	struct IDTR
-	{
-		uint16_t size;
-		void* offset;
-	} __attribute((packed));
-
-	static IDTR				s_idtr;
-	static GateDescriptor*	s_idt = nullptr;
-
-	static void(*s_irq_handlers[16])() { nullptr };
-
-	INTERRUPT_HANDLER____(0x00, "Division Error")
-	INTERRUPT_HANDLER____(0x01, "Debug")
-	INTERRUPT_HANDLER____(0x02, "Non-maskable Interrupt")
-	INTERRUPT_HANDLER____(0x03, "Breakpoint")
-	INTERRUPT_HANDLER____(0x04, "Overflow")
-	INTERRUPT_HANDLER____(0x05, "Bound Range Exception")
-	INTERRUPT_HANDLER____(0x06, "Invalid Opcode")
-	INTERRUPT_HANDLER____(0x07, "Device Not Available")
-	INTERRUPT_HANDLER_ERR(0x08, "Double Fault")
-	INTERRUPT_HANDLER____(0x09, "Coprocessor Segment Overrun")
-	INTERRUPT_HANDLER_ERR(0x0A, "Invalid TSS")
-	INTERRUPT_HANDLER_ERR(0x0B, "Segment Not Present")
-	INTERRUPT_HANDLER_ERR(0x0C, "Stack-Segment Fault")
-	INTERRUPT_HANDLER_ERR(0x0D, "General Protection Fault")
-	INTERRUPT_HANDLER_ERR(0x0E, "Page Fault")
-	INTERRUPT_HANDLER____(0x0F, "Unknown Exception 0x0F")
-	INTERRUPT_HANDLER____(0x10, "x87 Floating-Point Exception")
-	INTERRUPT_HANDLER_ERR(0x11, "Alignment Check")
-	INTERRUPT_HANDLER____(0x12, "Machine Check")
-	INTERRUPT_HANDLER____(0x13, "SIMD Floating-Point Exception")
-	INTERRUPT_HANDLER____(0x14, "Virtualization Exception")
-	INTERRUPT_HANDLER_ERR(0x15, "Control Protection Exception")
-	INTERRUPT_HANDLER____(0x16, "Unknown Exception 0x16")
-	INTERRUPT_HANDLER____(0x17, "Unknown Exception 0x17")
-	INTERRUPT_HANDLER____(0x18, "Unknown Exception 0x18")
-	INTERRUPT_HANDLER____(0x19, "Unknown Exception 0x19")
-	INTERRUPT_HANDLER____(0x1A, "Unknown Exception 0x1A")
-	INTERRUPT_HANDLER____(0x1B, "Unknown Exception 0x1B")
-	INTERRUPT_HANDLER____(0x1C, "Hypervisor Injection Exception")
-	INTERRUPT_HANDLER_ERR(0x1D, "VMM Communication Exception")
-	INTERRUPT_HANDLER_ERR(0x1E, "Security Exception")
-	INTERRUPT_HANDLER____(0x1F, "Unkown Exception 0x1F")
-
-	extern "C" void handle_irq()
-	{
-		uint8_t irq;
-		for (uint32_t i = 0; i < 16; i++)
-		{
-			if (InterruptController::get().is_in_service(i))
-			{
-				irq = i;
-				goto found;
-			}
-		}
-
-		dprintln("Spurious irq");
-		return;	
-found:
-		if (s_irq_handlers[irq])
-			s_irq_handlers[irq]();
-		else
-			dprintln("no handler for irq 0x{2H}\n", irq);
-
-		// NOTE: Scheduler sends PIT eoi's
-		if (irq != PIT_IRQ)
-			InterruptController::get().eoi(irq);
-
-		Kernel::Scheduler::get().reschedule_if_idling();
-	}
-
-	extern "C" void handle_irq_common();
-	asm(
-	".globl handle_irq_common;"
-	"handle_irq_common:"
-		"pusha;"
-		"pushw %ds;"
-		"pushw %es;"
-		"pushw %ss;"
-		"pushw %ss;"
-		"popw %ds;"
-		"popw %es;"
-		"call handle_irq;"
-		"popw %es;"
-		"popw %ds;"
-		"popa;"
-		"iret;"
-	);
-
-	extern "C" void syscall_asm();
-	asm(
-	".global syscall_asm;"
-	"syscall_asm:"
-		"pusha;"
-		"pushw %ds;"
-		"pushw %es;"
-		"pushw %ss;"
-		"pushw %ss;"
-		"popw %ds;"
-		"popw %es;"
-		"pushl %edx;"
-		"pushl %ecx;"
-		"pushl %ebx;"
-		"pushl %eax;"
-		"call cpp_syscall_handler;"
-		"addl $16, %esp;"
-		"popw %es;"
-		"popw %ds;"
-		
-		// NOTE: following instructions are same as in 'popa', except we skip eax
-		//       since it holds the return value of the syscall.
-		"popl %edi;"
-		"popl %esi;"
-		"popl %ebp;"
-		"addl $4, %esp;"
-		"popl %ebx;"
-		"popl %edx;"
-		"popl %ecx;"
-		"addl $4, %esp;"
-		
-		"iret;"
-	);
-
-	static void flush_idt()
-	{
-		asm volatile("lidt %0"::"m"(s_idtr));
-	}
-
-	static void register_interrupt_handler(uint8_t index, void(*f)())
-	{
-		GateDescriptor& descriptor = s_idt[index];
-		descriptor.offset1 = (uint32_t)f & 0xFFFF;
-		descriptor.selector = 0x08;
-		descriptor.type = 0xE;
-		descriptor.DPL = 0;
-		descriptor.present = 1;
-		descriptor.offset2 = (uint32_t)f >> 16;
-	}
-
-	void register_irq_handler(uint8_t irq, void(*f)())
-	{
-		s_irq_handlers[irq] = f;
-		register_interrupt_handler(IRQ_VECTOR_BASE + irq, handle_irq_common);
-		flush_idt();
-	}
-
-	void register_syscall_handler(uint8_t offset, void(*handler)())
-	{
-		register_interrupt_handler(offset, handler);
-		s_idt[offset].DPL = 3;
-	}
-
-	void initialize()
-	{
-		constexpr size_t idt_size = 0x100 * sizeof(GateDescriptor);
-
-		s_idt = (GateDescriptor*)kmalloc(idt_size);
-		ASSERT(s_idt);
-		memset(s_idt, 0x00, idt_size);
-
-		s_idtr.offset = s_idt;
-		s_idtr.size = idt_size - 1;
-
-		REGISTER_HANDLER(0x00);
-		REGISTER_HANDLER(0x01);
-		REGISTER_HANDLER(0x02);
-		REGISTER_HANDLER(0x03);
-		REGISTER_HANDLER(0x04);
-		REGISTER_HANDLER(0x05);
-		REGISTER_HANDLER(0x06);
-		REGISTER_HANDLER(0x07);
-		REGISTER_HANDLER(0x08);
-		REGISTER_HANDLER(0x09);
-		REGISTER_HANDLER(0x0A);
-		REGISTER_HANDLER(0x0B);
-		REGISTER_HANDLER(0x0C);
-		REGISTER_HANDLER(0x0D);
-		REGISTER_HANDLER(0x0E);
-		REGISTER_HANDLER(0x0F);
-		REGISTER_HANDLER(0x10);
-		REGISTER_HANDLER(0x11);
-		REGISTER_HANDLER(0x12);
-		REGISTER_HANDLER(0x13);
-		REGISTER_HANDLER(0x14);
-		REGISTER_HANDLER(0x15);
-		REGISTER_HANDLER(0x16);
-		REGISTER_HANDLER(0x17);
-		REGISTER_HANDLER(0x18);
-		REGISTER_HANDLER(0x19);
-		REGISTER_HANDLER(0x1A);
-		REGISTER_HANDLER(0x1B);
-		REGISTER_HANDLER(0x1C);
-		REGISTER_HANDLER(0x1D);
-		REGISTER_HANDLER(0x1E);
-		REGISTER_HANDLER(0x1F);
-
-		register_syscall_handler(0x80, syscall_asm);
-
-		flush_idt();
-	}
-
-}

kernel/arch/i386/MMU.cpp

@@ -1,227 +0,0 @@
-#include <BAN/Errors.h>
-#include <kernel/Debug.h>
-#include <kernel/Memory/MMU.h>
-#include <kernel/Memory/kmalloc.h>
-
-#include <string.h>
-
-#define MMU_DEBUG_PRINT 0
-
-// bits 31-12 set
-#define PAGE_MASK  0xfffff000
-#define FLAGS_MASK 0x00000fff
-
-namespace Kernel
-{
-
-	static MMU* s_instance = nullptr;
-
-	void MMU::initialize()
-	{
-		ASSERT(s_instance == nullptr);
-		s_instance = new MMU();
-		ASSERT(s_instance);
-		s_instance->initialize_kernel();
-		s_instance->load();
-	}
-
-	MMU& MMU::get()
-	{
-		ASSERT(s_instance);
-		return *s_instance;
-	}
-
-	static uint64_t* allocate_page_aligned_page()
-	{
-		uint64_t* page = (uint64_t*)kmalloc(PAGE_SIZE, PAGE_SIZE);
-		ASSERT(page);
-		ASSERT(((uintptr_t)page % PAGE_SIZE) == 0);
-		memset(page, 0, PAGE_SIZE);
-		return page;
-	}
-
-	void MMU::initialize_kernel()
-	{
-		m_highest_paging_struct = (uint64_t*)kmalloc(sizeof(uint64_t) * 4, 32);
-		ASSERT(m_highest_paging_struct);
-		ASSERT(((uintptr_t)m_highest_paging_struct % 32) == 0);
-
-		// allocate all page directories
-		for (int i = 0; i < 4; i++)
-		{
-			uint64_t* page_directory = allocate_page_aligned_page();
-			m_highest_paging_struct[i] = (uint64_t)page_directory | Flags::Present;
-		}
-
-		// FIXME: We should just identity map until g_kernel_end
-
-		// create and identity map first 6 MiB
-		uint64_t* page_directory1 = (uint64_t*)(m_highest_paging_struct[0] & PAGE_MASK);
-		for (uint64_t i = 0; i < 3; i++)
-		{
-			uint64_t* page_table = allocate_page_aligned_page();
-			for (uint64_t j = 0; j < 512; j++)
-				page_table[j] = (i << 21) | (j << 12) | Flags::ReadWrite | Flags::Present;
-
-			page_directory1[i] = (uint64_t)page_table | Flags::ReadWrite | Flags::Present;
-		}
-
-		// dont map first page (0 -> 4 KiB) so that nullptr dereference
-		// causes page fault :)
-		uint64_t* page_table1 = (uint64_t*)(page_directory1[0] & PAGE_MASK);
-		page_table1[0] = 0;
-	}
-
-	MMU::MMU()
-	{
-		if (s_instance == nullptr)
-			return;
-		
-		// Here we copy the s_instances paging structs since they are
-		// global for every process
-
-		uint64_t* global_pdpt = s_instance->m_highest_paging_struct;
-
-		uint64_t* pdpt = (uint64_t*)kmalloc(sizeof(uint64_t) * 4, 32);
-		ASSERT(pdpt);
-		
-		for (uint32_t pdpte = 0; pdpte < 4; pdpte++)
-		{
-			if (!(global_pdpt[pdpte] & Flags::Present))
-				continue;
-
-			uint64_t* global_pd = (uint64_t*)(global_pdpt[pdpte] & PAGE_MASK);
-
-			uint64_t* pd = allocate_page_aligned_page();
-			pdpt[pdpte] = (uint64_t)pd | (global_pdpt[pdpte] & ~PAGE_MASK);
-
-			for (uint32_t pde = 0; pde < 512; pde++)
-			{
-				if (!(global_pd[pde] & Flags::Present))
-					continue;
-
-				uint64_t* global_pt = (uint64_t*)(global_pd[pde] & PAGE_MASK);
-
-				uint64_t* pt = allocate_page_aligned_page();
-				pd[pde] = (uint64_t)pt | (global_pd[pde] & ~PAGE_MASK);
-
-				memcpy(pt, global_pt, PAGE_SIZE);
-			}
-		}
-
-		m_highest_paging_struct = pdpt;
-	}
-
-	MMU::~MMU()
-	{
-		uint64_t* pdpt = m_highest_paging_struct;
-		for (uint32_t pdpte = 0; pdpte < 512; pdpte++)
-		{
-			if (!(pdpt[pdpte] & Flags::Present))
-				continue;
-			uint64_t* pd = (uint64_t*)(pdpt[pdpte] & PAGE_MASK);
-			for (uint32_t pde = 0; pde < 512; pde++)
-			{
-				if (!(pd[pde] & Flags::Present))
-					continue;
-				kfree((void*)(pd[pde] & PAGE_MASK));
-			}
-			kfree(pd);
-		}
-		kfree(pdpt);
-	}
-
-	void MMU::load()
-	{
-		asm volatile("movl %0, %%cr3" :: "r"(m_highest_paging_struct));
-	}
-
-	void MMU::map_page_at(paddr_t paddr, vaddr_t vaddr, uint8_t flags)
-	{
-	#if MMU_DEBUG_PRINT
-		dprintln("AllocatePage(0x{8H})", address);
-	#endif
-		ASSERT(flags & Flags::Present);
-
-		ASSERT(!(paddr & ~PAGE_MASK));
-		ASSERT(!(vaddr & ~PAGE_MASK));
-
-		uint32_t pdpte = (vaddr & 0xC0000000) >> 30;
-		uint32_t pde   = (vaddr & 0x3FE00000) >> 21;
-		uint32_t pte   = (vaddr & 0x001FF000) >> 12;
-
-		uint64_t* page_directory = (uint64_t*)(m_highest_paging_struct[pdpte] & PAGE_MASK);
-		if (!(page_directory[pde] & Flags::Present))
-		{
-			uint64_t* page_table = allocate_page_aligned_page();
-			page_directory[pde] = (uint64_t)page_table;
-		}
-		page_directory[pde] |= flags;
-
-		uint64_t* page_table = (uint64_t*)(page_directory[pde] & PAGE_MASK);
-		page_table[pte] = paddr | flags;
-	}
-
-	void MMU::identity_map_page(paddr_t address, uint8_t flags)
-	{
-		address &= PAGE_MASK;
-		map_page_at(address, address, flags);
-	}
-
-	void MMU::identity_map_range(paddr_t address, ptrdiff_t size, uint8_t flags)
-	{
-		paddr_t s_page = address & PAGE_MASK;
-		paddr_t e_page = (address + size - 1) & PAGE_MASK;
-		for (paddr_t page = s_page; page <= e_page; page += PAGE_SIZE)
-			identity_map_page(page, flags);
-	}
-
-	void MMU::unmap_page(vaddr_t address)
-	{
-	#if MMU_DEBUG_PRINT
-		dprintln("UnAllocatePage(0x{8H})", address & PAGE_MASK);
-	#endif
-
-		uint32_t pdpte = (address & 0xC0000000) >> 30;
-		uint32_t pde   = (address & 0x3FE00000) >> 21;
-		uint32_t pte   = (address & 0x001FF000) >> 12;
-
-		uint64_t* page_directory = (uint64_t*)(m_highest_paging_struct[pdpte] & PAGE_MASK);
-		if (!(page_directory[pde] & Flags::Present))
-			return;
-
-		uint64_t* page_table = (uint64_t*)(page_directory[pde] & PAGE_MASK);
-		if (!(page_table[pte] & Flags::Present))
-			return;
-
-		page_table[pte] = 0;
-
-		// TODO: Unallocate the page table if this was the only allocated page
-	}
-
-	void MMU::unmap_range(vaddr_t address, ptrdiff_t size)
-	{
-		uintptr_t s_page = address & PAGE_MASK;
-		uintptr_t e_page = (address + size - 1) & PAGE_MASK;
-		for (uintptr_t page = s_page; page <= e_page; page += PAGE_SIZE)
-			unmap_page(page);
-	}
-
-	uint8_t MMU::get_page_flags(vaddr_t address) const
-	{
-		uint32_t pdpte = (address & 0xC0000000) >> 30;
-		uint32_t pde   = (address & 0x3FE00000) >> 21;
-		uint32_t pte   = (address & 0x001FF000) >> 12;
-
-		uint64_t* page_directory = (uint64_t*)(m_highest_paging_struct[pdpte] & PAGE_MASK);
-		if (!(page_directory[pde] & Flags::Present))
-			return 0;
-
-		uint64_t* page_table = (uint64_t*)(page_directory[pde] & PAGE_MASK);
-		if (!(page_table[pte] & Flags::Present))
-			return 0;
-
-		return page_table[pte] & FLAGS_MASK;
-	}
-
-}

kernel/arch/i386/SpinLock.S

@@ -1,19 +0,0 @@
-.global spinlock_lock_asm
-spinlock_lock_asm:
-	movl 4(%esp), %eax
-	lock; btsl $0, (%eax)
-	jnc .done
-.retry:
-	pause
-	testl $1, (%eax)
-	jne .retry
-	lock; btsl $0, (%eax)
-	jc .retry
-.done:
-	ret
-
-.global spinlock_unlock_asm
-spinlock_unlock_asm:
-	movl 4(%esp), %eax
-	movl $0, (%eax)
-	ret

kernel/arch/i386/Thread.S

@@ -1,47 +0,0 @@
-# uint32_t read_rip()
-.global read_rip
-read_rip:
-	popl %eax
-	jmp *%eax
-
-exit_thread_trampoline:
-	addl $4, %esp
-	pushl (%esp)
-	ret
-
-# void start_thread(uint32_t esp, uint32_t eip)
-.global start_thread
-start_thread:
-	movl 8(%esp), %ecx
-	movl 4(%esp), %esp
-	movl $0, %ebp
-	pushl $exit_thread_trampoline
-	sti
-	jmp *%ecx
-
-# void continue_thread(uint32_t rsp, uint32_t rip)
-.global continue_thread
-continue_thread:
-	movl 8(%esp), %ecx
-	movl 4(%esp), %esp
-	movl $0, %eax
-	jmp *%ecx
-
-# void thread_jump_userspace(uint32_t rsp, uint32_t rip)
-.global thread_jump_userspace
-thread_jump_userspace:
-	movl $0x23, %eax
-	movw %ax, %ds
-	movw %ax, %es
-	movw %ax, %fs
-	movw %ax, %gs
-
-	movl 8(%esp), %ecx
-	movl 4(%esp), %esp
-
-	pushl $0x23
-	pushl %esp
-	pushfl
-	pushl $0x1B
-	pushl %ecx
-	iret

kernel/arch/i386/boot.S

@@ -1,182 +0,0 @@
-# Declare constants for the multiboot header
-.set ALIGN,			1<<0						# align loaded modules on page boundaries
-.set MEMINFO,		1<<1						# provide memory map
-.set VIDEOINFO,		1<<2						# provide video info
-.set MB_FLAGS,		ALIGN | MEMINFO | VIDEOINFO # this is the Multiboot 'flag' field
-.set MB_MAGIC,		0x1BADB002					# 'magic number' lets bootloader find the header
-.set MB_CHECKSUM,	-(MB_MAGIC + MB_FLAGS)		#checksum of above, to prove we are multiboot
-
-# Multiboot header
-.section .multiboot, "aw"
-	.align 4
-	.long MB_MAGIC
-	.long MB_FLAGS
-	.long MB_CHECKSUM
-	.skip 20
-
-	.long 0
-	.long 800
-	.long 600
-	.long 32
-
-.section .bss, "aw", @nobits
-# Create stack
-.global g_boot_stack_bottom
-g_boot_stack_bottom:
-	.skip 16384
-.global g_boot_stack_top
-g_boot_stack_top:
-
-# 0 MiB -> 1 MiB: bootloader stuff
-# 1 MiB ->      : kernel
-.align 32
-boot_page_directory_pointer_table:
-	.skip 4 * 8
-.align 4096
-boot_page_directory1:
-	.skip 512 * 8
-
-.global g_kernel_cmdline
-g_kernel_cmdline:
-	.skip 4096
-
-.global g_multiboot_info
-g_multiboot_info:
-	.skip 4
-.global g_multiboot_magic
-g_multiboot_magic:
-	.skip 4
-
-.section .text
-
-boot_gdt:
-	.quad 0x0000000000000000 # null
-	.quad 0x00CF9A000000FFFF # kernel code
-	.quad 0x00CF92000000FFFF # kernel data
-boot_gdtr:
-	.short . - boot_gdt - 1
-	.long boot_gdt
-
-has_cpuid:
-	pushfl
-	pushfl
-	xorl $0x00200000, (%esp)
-	popfl
-	pushfl
-	popl %eax
-	xorl (%esp), %eax
-	popfl
-	testl $0x00200000, %eax
-	ret
-
-has_pae:
-	movl $0, %eax
-	cpuid
-	testl $(1 << 6), %edx
-	ret
-
-has_sse:
-	movl $1, %eax
-	cpuid
-	testl $(1 << 25), %edx
-	ret
-
-check_requirements:
-	call has_cpuid
-	jz .exit
-	call has_pae
-	jz .exit
-	call has_sse
-	jz .exit
-	ret
-.exit:
-	jmp system_halt
-
-copy_kernel_commandline:
-	pushl %esi
-	pushl %edi
-	movl g_multiboot_info, %esi
-	addl $16, %esi
-	movl (%esi), %esi
-	movl $1024, %ecx
-	movl $g_kernel_cmdline, %edi
-	rep movsl
-	popl %edi
-	popl %esi
-	ret
-
-enable_sse:
-	movl %cr0, %eax
-	andw $0xFFFB, %ax
-	orw $0x0002, %ax
-	movl %eax, %cr0
-	movl %cr4, %eax
-	orw $0x0600, %ax
-	movl %eax, %cr4
-	ret
-
-initialize_paging:
-	# identity map first 6 MiB
-	movl $(0x00000000           + 0x83), boot_page_directory1 + 0
-	movl $(0x00200000           + 0x83), boot_page_directory1 + 8
-	movl $(0x00400000           + 0x83), boot_page_directory1 + 16
-	movl $(boot_page_directory1 + 0x01), boot_page_directory_pointer_table
-
-	# enable PAE
-	movl %cr4, %ecx
-	orl $0x20, %ecx
-	movl %ecx, %cr4
-
-	# set address of paging structures
-	movl $boot_page_directory_pointer_table, %ecx
-	movl %ecx, %cr3
-
-	# enable paging
-	movl %cr0, %ecx
-	orl $0x80000000, %ecx
-	movl %ecx, %cr0
-
-	ret
-
-initialize_gdt:
-	lgdt boot_gdtr
-
-	# flush gdt
-	movw $0x10, %ax
-	movw %ax, %ds
-	movw %ax, %es
-	movw %ax, %fs
-	movw %ax, %gs
-	movw %ax, %ss
-	jmp $0x08, $flush
-flush:
-	ret
-
-.global _start
-.type _start, @function
-_start:
-	# Initialize stack and multiboot info
-	movl $g_boot_stack_top, %esp
-	movl %eax, g_multiboot_magic
-	movl %ebx, g_multiboot_info
-
-	call copy_kernel_commandline
-	call check_requirements
-	call enable_sse
-
-	call initialize_paging
-	call initialize_gdt
-
-	call _init
-
-	# call to the kernel itself (clear ebp for stacktrace)
-	xorl %ebp, %ebp
-	call kernel_main
-
-	call _fini
-
-system_halt:
-	xchgw %bx, %bx
-	cli
-1:	hlt
-	jmp 1b

kernel/arch/i386/crt0.S

@@ -1,23 +0,0 @@
-.section .text
-
-.global _start
-_start:
-	# Set up end of the stack frame linked list.
-	movl $0, %ebp
-	pushl %ebp # rip=0
-	pushl %ebp # rbp=0
-	movl %esp, %ebp
-
-	# Prepare signals, memory allocation, stdio and such.
-	#call initialize_standard_library
-
-	# Run the global constructors.
-	call _init
-
-	# Run main
-	call main
-
-	# Terminate the process with the exit code.
-	movl %eax, %edi
-	call exit
-.size _start, . - _start

kernel/arch/i386/linker.ld

@@ -1,28 +0,0 @@
-ENTRY (_start)
-
-SECTIONS
-{
-	. = 0x00100000;
-
-	g_kernel_start = .;
-	.text BLOCK(4K) : ALIGN(4K)
-	{
-		*(.multiboot)
-		*(.text)
-	}
-	.rodata BLOCK(4K) : ALIGN(4K)
-	{
-		*(.rodata.*)
-	}
-	.data BLOCK(4K) : ALIGN(4K)
-	{
-		*(.data)
-	}
-	.bss BLOCK(4K) : ALIGN(4K)
-	{
-		*(COMMON)
-		*(.bss)
-	}
-
-	g_kernel_end = .;
-}

kernel/arch/i686/PageTable.cpp

@@ -0,0 +1,754 @@
+#include <kernel/BootInfo.h>
+#include <kernel/CPUID.h>
+#include <kernel/Lock/SpinLock.h>
+#include <kernel/Memory/kmalloc.h>
+#include <kernel/Memory/PageTable.h>
+
+extern uint8_t g_kernel_start[];
+extern uint8_t g_kernel_end[];
+
+extern uint8_t g_kernel_execute_start[];
+extern uint8_t g_kernel_execute_end[];
+
+extern uint8_t g_kernel_writable_start[];
+extern uint8_t g_kernel_writable_end[];
+
+extern uint8_t g_userspace_start[];
+extern uint8_t g_userspace_end[];
+
+extern uint64_t g_boot_fast_page_pt[];
+
+namespace Kernel
+{
+
+	SpinLock PageTable::s_fast_page_lock;
+
+	constexpr uint64_t s_page_flag_mask = 0x8000000000000FFF;
+	constexpr uint64_t s_page_addr_mask = ~s_page_flag_mask;
+
+	static bool s_is_initialized = false;
+
+	static PageTable* s_kernel = nullptr;
+	static bool s_has_nxe = false;
+	static bool s_has_pge = false;
+	static bool s_has_pat = false;
+
+	static paddr_t s_global_pdpte = 0;
+
+	static uint64_t* s_fast_page_pt { nullptr };
+
+	static uint64_t* allocate_zeroed_page_aligned_page()
+	{
+		void* page = kmalloc(PAGE_SIZE, PAGE_SIZE, true);
+		ASSERT(page);
+		memset(page, 0, PAGE_SIZE);
+		return (uint64_t*)page;
+	}
+
+	template<typename T>
+	static paddr_t V2P(const T vaddr)
+	{
+		return (vaddr_t)vaddr - KERNEL_OFFSET + g_boot_info.kernel_paddr;
+	}
+
+	template<typename T>
+	static uint64_t* P2V(const T paddr)
+	{
+		return reinterpret_cast<uint64_t*>(reinterpret_cast<paddr_t>(paddr) - g_boot_info.kernel_paddr + KERNEL_OFFSET);
+	}
+
+	static inline PageTable::flags_t parse_flags(uint64_t entry)
+	{
+		using Flags = PageTable::Flags;
+
+		PageTable::flags_t result = 0;
+		if (s_has_nxe && !(entry & (1ull << 63)))
+			result |= Flags::Execute;
+		if (entry & Flags::Reserved)
+			result |= Flags::Reserved;
+		if (entry & Flags::UserSupervisor)
+			result |= Flags::UserSupervisor;
+		if (entry & Flags::ReadWrite)
+			result |= Flags::ReadWrite;
+		if (entry & Flags::Present)
+			result |= Flags::Present;
+		return result;
+	}
+
+	void PageTable::initialize_fast_page()
+	{
+		s_fast_page_pt = g_boot_fast_page_pt;
+	}
+
+	static void detect_cpu_features()
+	{
+		if (CPUID::has_nxe())
+			s_has_nxe = true;
+		if (CPUID::has_pge())
+			s_has_pge = true;
+		if (CPUID::has_pat())
+			s_has_pat = true;
+	}
+
+	void PageTable::enable_cpu_features()
+	{
+		if (s_has_nxe)
+		{
+			asm volatile(
+				"movl $0xC0000080, %%ecx;"
+				"rdmsr;"
+				"orl $0x800, %%eax;"
+				"wrmsr"
+				::: "eax", "ecx", "edx", "memory"
+			);
+		}
+
+		if (s_has_pge)
+		{
+			asm volatile(
+				"movl %%cr4, %%eax;"
+				"orl $0x80, %%eax;"
+				"movl %%eax, %%cr4;"
+				::: "eax"
+			);
+		}
+
+		if (s_has_pat)
+		{
+			asm volatile(
+				"movl $0x277, %%ecx;"
+				"rdmsr;"
+				"movw $0x0401, %%dx;"
+				"wrmsr;"
+				::: "eax", "ecx", "edx", "memory"
+			);
+		}
+
+		// enable write protect
+		asm volatile(
+			"movl %%cr0, %%eax;"
+			"orl $0x10000, %%eax;"
+			"movl %%eax, %%cr0;"
+			::: "rax"
+		);
+	}
+
+	void PageTable::initialize_and_load()
+	{
+		detect_cpu_features();
+		enable_cpu_features();
+
+		ASSERT(s_kernel == nullptr);
+		s_kernel = new PageTable();
+		ASSERT(s_kernel);
+
+		auto* pdpt = allocate_zeroed_page_aligned_page();
+		ASSERT(pdpt);
+
+		s_kernel->m_highest_paging_struct = V2P(pdpt);
+		s_kernel->map_kernel_memory();
+
+		PageTable::with_fast_page(s_kernel->m_highest_paging_struct, [] {
+			s_global_pdpte = PageTable::fast_page_as_sized<paddr_t>(3);
+		});
+
+		// update fast page pt
+		{
+			constexpr vaddr_t vaddr = fast_page();
+			constexpr uint16_t pdpte = (vaddr >> 30) & 0x1FF;
+			constexpr uint16_t pde   = (vaddr >> 21) & 0x1FF;
+
+			const auto get_or_allocate_entry =
+				[](paddr_t table_paddr, uint16_t entry, uint64_t flags)
+				{
+					uint64_t* table = P2V(table_paddr);
+
+					if (!(table[entry] & Flags::Present))
+					{
+						auto* vaddr = allocate_zeroed_page_aligned_page();
+						ASSERT(vaddr);
+						table[entry] = V2P(vaddr);
+					}
+
+					table[entry] |= flags;
+
+					return table[entry] & s_page_addr_mask;
+				};
+
+			const paddr_t pdpt = s_kernel->m_highest_paging_struct;
+			const paddr_t pd = get_or_allocate_entry(pdpt, pdpte, Flags::Present);
+			s_fast_page_pt = P2V(get_or_allocate_entry(pd, pde, Flags::ReadWrite | Flags::Present));
+		}
+
+		s_kernel->load();
+	}
+
+	PageTable& PageTable::kernel()
+	{
+		ASSERT(s_kernel);
+		return *s_kernel;
+	}
+
+	bool PageTable::is_valid_pointer(uintptr_t)
+	{
+		return true;
+	}
+
+	void PageTable::map_kernel_memory()
+	{
+		// Map (phys_kernel_start -> phys_kernel_end) to (virt_kernel_start -> virt_kernel_end)
+		map_range_at(
+			V2P(g_kernel_start),
+			reinterpret_cast<vaddr_t>(g_kernel_start),
+			g_kernel_end - g_kernel_start,
+			Flags::Present
+		);
+
+		// Map executable kernel memory as executable
+		map_range_at(
+			V2P(g_kernel_execute_start),
+			reinterpret_cast<vaddr_t>(g_kernel_execute_start),
+			g_kernel_execute_end - g_kernel_execute_start,
+			Flags::Execute | Flags::Present
+		);
+
+		// Map writable kernel memory as writable
+		map_range_at(
+			V2P(g_kernel_writable_start),
+			reinterpret_cast<vaddr_t>(g_kernel_writable_start),
+			g_kernel_writable_end - g_kernel_writable_start,
+			Flags::ReadWrite | Flags::Present
+		);
+
+		// Map userspace memory
+		map_range_at(
+			V2P(g_userspace_start),
+			reinterpret_cast<vaddr_t>(g_userspace_start),
+			g_userspace_end - g_userspace_start,
+			Flags::Execute | Flags::UserSupervisor | Flags::Present
+		);
+	}
+
+	void PageTable::map_fast_page(paddr_t paddr)
+	{
+		ASSERT(paddr && paddr % PAGE_SIZE == 0);
+
+		ASSERT(s_fast_page_pt);
+		ASSERT(s_fast_page_lock.current_processor_has_lock());
+
+		ASSERT(!(*s_fast_page_pt & Flags::Present));
+		s_fast_page_pt[0] = paddr | Flags::ReadWrite | Flags::Present;
+
+		asm volatile("invlpg (%0)" :: "r"(fast_page()));
+	}
+
+	void PageTable::unmap_fast_page()
+	{
+		ASSERT(s_fast_page_pt);
+		ASSERT(s_fast_page_lock.current_processor_has_lock());
+
+		ASSERT((*s_fast_page_pt & Flags::Present));
+		s_fast_page_pt[0] = 0;
+
+		asm volatile("invlpg (%0)" :: "r"(fast_page()));
+	}
+
+	BAN::ErrorOr<PageTable*> PageTable::create_userspace()
+	{
+		SpinLockGuard _(s_kernel->m_lock);
+		PageTable* page_table = new PageTable;
+		if (page_table == nullptr)
+			return BAN::Error::from_errno(ENOMEM);
+
+		uint64_t* pdpt = allocate_zeroed_page_aligned_page();
+		if (pdpt == nullptr)
+		{
+			delete page_table;
+			return BAN::Error::from_errno(ENOMEM);
+		}
+
+		page_table->m_highest_paging_struct = V2P(pdpt);
+
+		pdpt[0] = 0;
+		pdpt[1] = 0;
+		pdpt[2] = 0;
+		pdpt[3] = s_global_pdpte | Flags::Present;
+		static_assert(KERNEL_OFFSET == 0xC0000000);
+
+		return page_table;
+	}
+
+	PageTable::~PageTable()
+	{
+		if (m_highest_paging_struct == 0)
+			return;
+
+		uint64_t* pdpt = P2V(m_highest_paging_struct);
+		for (uint32_t pdpte = 0; pdpte < 3; pdpte++)
+		{
+			if (!(pdpt[pdpte] & Flags::Present))
+				continue;
+			uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
+			for (uint32_t pde = 0; pde < 512; pde++)
+			{
+				if (!(pd[pde] & Flags::Present))
+					continue;
+				kfree(P2V(pd[pde] & s_page_addr_mask));
+			}
+			kfree(pd);
+		}
+		kfree(pdpt);
+	}
+
+	void PageTable::load()
+	{
+		SpinLockGuard _(m_lock);
+		ASSERT(m_highest_paging_struct < 0x100000000);
+		asm volatile("movl %0, %%cr3" :: "r"(static_cast<uint32_t>(m_highest_paging_struct)));
+		Processor::set_current_page_table(this);
+	}
+
+	void PageTable::invalidate_range(vaddr_t vaddr, size_t pages, bool send_smp_message)
+	{
+		ASSERT(vaddr % PAGE_SIZE == 0);
+
+		const bool is_userspace = (vaddr < KERNEL_OFFSET);
+		if (is_userspace && this != &PageTable::current())
+			;
+		else if (pages <= 32 || !s_is_initialized)
+		{
+			for (size_t i = 0; i < pages; i++, vaddr += PAGE_SIZE)
+				asm volatile("invlpg (%0)" :: "r"(vaddr));
+		}
+		else if (is_userspace || !s_has_pge)
+		{
+			asm volatile("movl %0, %%cr3" :: "r"(static_cast<uint32_t>(m_highest_paging_struct)));
+		}
+		else
+		{
+			asm volatile(
+				"movl %%cr4, %%eax;"
+
+				"andl $~0x80, %%eax;"
+				"movl %%eax, %%cr4;"
+
+				"movl %0, %%cr3;"
+
+				"orl $0x80, %%eax;"
+				"movl %%eax, %%cr4;"
+				:
+				: "r"(static_cast<uint32_t>(m_highest_paging_struct))
+				: "eax"
+			);
+		}
+
+		if (send_smp_message)
+		{
+			Processor::broadcast_smp_message({
+				.type = Processor::SMPMessage::Type::FlushTLB,
+				.flush_tlb = {
+					.vaddr      = vaddr,
+					.page_count = pages,
+					.page_table = vaddr < KERNEL_OFFSET ? this : nullptr,
+				}
+			});
+		}
+	}
+
+	void PageTable::unmap_page(vaddr_t vaddr, bool invalidate)
+	{
+		ASSERT(vaddr);
+		ASSERT(vaddr % PAGE_SIZE == 0);
+		ASSERT(vaddr != fast_page());
+		if (vaddr >= KERNEL_OFFSET)
+			ASSERT(vaddr >= (vaddr_t)g_kernel_start);
+		if ((vaddr >= KERNEL_OFFSET) != (this == s_kernel))
+			Kernel::panic("unmapping {8H}, kernel: {}", vaddr, this == s_kernel);
+
+		const uint64_t pdpte = (vaddr >> 30) & 0x1FF;
+		const uint64_t pde   = (vaddr >> 21) & 0x1FF;
+		const uint64_t pte   = (vaddr >> 12) & 0x1FF;
+
+		SpinLockGuard _(m_lock);
+
+		if (is_page_free(vaddr))
+			Kernel::panic("trying to unmap unmapped page 0x{H}", vaddr);
+
+		uint64_t* pdpt = P2V(m_highest_paging_struct);
+		uint64_t* pd   = P2V(pdpt[pdpte] & s_page_addr_mask);
+		uint64_t* pt   = P2V(pd[pde] & s_page_addr_mask);
+
+		const paddr_t old_paddr = pt[pte] & s_page_addr_mask;
+
+		pt[pte] = 0;
+
+		if (invalidate && old_paddr != 0)
+			invalidate_page(vaddr, true);
+	}
+
+	void PageTable::unmap_range(vaddr_t vaddr, size_t size)
+	{
+		ASSERT(vaddr % PAGE_SIZE == 0);
+
+		size_t page_count = range_page_count(vaddr, size);
+
+		SpinLockGuard _(m_lock);
+		for (vaddr_t page = 0; page < page_count; page++)
+			unmap_page(vaddr + page * PAGE_SIZE, false);
+		invalidate_range(vaddr, page_count, true);
+	}
+
+	void PageTable::map_page_at(paddr_t paddr, vaddr_t vaddr, flags_t flags, MemoryType memory_type, bool invalidate)
+	{
+		ASSERT(vaddr);
+		ASSERT(vaddr != fast_page());
+		if ((vaddr >= KERNEL_OFFSET) != (this == s_kernel))
+			Kernel::panic("mapping {8H} to {8H}, kernel: {}", paddr, vaddr, this == s_kernel);
+
+		ASSERT(paddr % PAGE_SIZE == 0);
+		ASSERT(vaddr % PAGE_SIZE == 0);
+		ASSERT(flags & Flags::Used);
+
+		const uint64_t pdpte = (vaddr >> 30) & 0x1FF;
+		const uint64_t pde   = (vaddr >> 21) & 0x1FF;
+		const uint64_t pte   = (vaddr >> 12) & 0x1FF;
+
+		uint64_t extra_flags = 0;
+		if (s_has_pge && vaddr >= KERNEL_OFFSET) // Map kernel memory as global
+			extra_flags |= 1ull << 8;
+		if (s_has_nxe && !(flags & Flags::Execute))
+			extra_flags |= 1ull << 63;
+		if (flags & Flags::Reserved)
+			extra_flags |= Flags::Reserved;
+
+		if (memory_type == MemoryType::Uncached)
+			extra_flags |= (1ull << 4);
+		if (s_has_pat && memory_type == MemoryType::WriteCombining)
+			extra_flags |= (1ull << 7);
+		if (s_has_pat && memory_type == MemoryType::WriteThrough)
+			extra_flags |= (1ull << 7) | (1ull << 3);
+
+		// NOTE: we add present here, since it has to be available in higher level structures
+		flags_t uwr_flags = (flags & (Flags::UserSupervisor | Flags::ReadWrite)) | Flags::Present;
+
+		SpinLockGuard _(m_lock);
+
+		uint64_t* pdpt = P2V(m_highest_paging_struct);
+		if (!(pdpt[pdpte] & Flags::Present))
+			pdpt[pdpte] = V2P(allocate_zeroed_page_aligned_page()) | Flags::Present;
+
+		uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
+		if ((pd[pde] & uwr_flags) != uwr_flags)
+		{
+			if (!(pd[pde] & Flags::Present))
+				pd[pde] = V2P(allocate_zeroed_page_aligned_page());
+			pd[pde] |= uwr_flags;
+		}
+
+		if (!(flags & Flags::Present))
+			uwr_flags &= ~Flags::Present;
+
+		uint64_t* pt = P2V(pd[pde] & s_page_addr_mask);
+
+		const paddr_t old_paddr = pt[pte] & s_page_addr_mask;
+
+		pt[pte] = paddr | uwr_flags | extra_flags;
+
+		if (invalidate && old_paddr != 0)
+			invalidate_page(vaddr, true);
+	}
+
+	void PageTable::map_range_at(paddr_t paddr, vaddr_t vaddr, size_t size, flags_t flags, MemoryType memory_type)
+	{
+		ASSERT(vaddr);
+		ASSERT(paddr % PAGE_SIZE == 0);
+		ASSERT(vaddr % PAGE_SIZE == 0);
+
+		size_t page_count = range_page_count(vaddr, size);
+
+		SpinLockGuard _(m_lock);
+		for (size_t page = 0; page < page_count; page++)
+			map_page_at(paddr + page * PAGE_SIZE, vaddr + page * PAGE_SIZE, flags, memory_type, false);
+		invalidate_range(vaddr, page_count, true);
+	}
+
+	void PageTable::remove_writable_from_range(vaddr_t vaddr, size_t size)
+	{
+		ASSERT(vaddr);
+		ASSERT(vaddr % PAGE_SIZE == 0);
+
+		uint32_t pdpte = (vaddr >> 30) & 0x1FF;
+		uint32_t pde   = (vaddr >> 21) & 0x1FF;
+		uint32_t pte   = (vaddr >> 12) & 0x1FF;
+
+		const uint32_t e_pdpte = ((vaddr + size - 1) >> 30) & 0x1FF;
+		const uint32_t e_pde   = ((vaddr + size - 1) >> 21) & 0x1FF;
+		const uint32_t e_pte   = ((vaddr + size - 1) >> 12) & 0x1FF;
+
+		SpinLockGuard _(m_lock);
+
+		const uint64_t* pdpt = P2V(m_highest_paging_struct);
+		for (; pdpte <= e_pdpte; pdpte++)
+		{
+			if (!(pdpt[pdpte] & Flags::Present))
+				continue;
+			const uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
+			for (; pde < 512; pde++)
+			{
+				if (pdpte == e_pdpte && pde > e_pde)
+					break;
+				if (!(pd[pde] & Flags::ReadWrite))
+					continue;
+				uint64_t* pt = P2V(pd[pde] & s_page_addr_mask);
+				for (; pte < 512; pte++)
+				{
+					if (pdpte == e_pdpte && pde == e_pde && pte > e_pte)
+						break;
+					pt[pte] &= ~static_cast<uint64_t>(Flags::ReadWrite);
+				}
+				pte = 0;
+			}
+			pde = 0;
+		}
+
+		invalidate_range(vaddr, size / PAGE_SIZE, true);
+	}
+
+	uint64_t PageTable::get_page_data(vaddr_t vaddr) const
+	{
+		ASSERT(vaddr % PAGE_SIZE == 0);
+
+		const uint64_t pdpte = (vaddr >> 30) & 0x1FF;
+		const uint64_t pde   = (vaddr >> 21) & 0x1FF;
+		const uint64_t pte   = (vaddr >> 12) & 0x1FF;
+
+		SpinLockGuard _(m_lock);
+
+		const uint64_t* pdpt = P2V(m_highest_paging_struct);
+		if (!(pdpt[pdpte] & Flags::Present))
+			return 0;
+
+		const uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
+		if (!(pd[pde] & Flags::Present))
+			return 0;
+
+		const uint64_t* pt = P2V(pd[pde] & s_page_addr_mask);
+		if (!(pt[pte] & Flags::Used))
+			return 0;
+
+		return pt[pte];
+	}
+
+	PageTable::flags_t PageTable::get_page_flags(vaddr_t vaddr) const
+	{
+		return parse_flags(get_page_data(vaddr));
+	}
+
+	paddr_t PageTable::physical_address_of(vaddr_t vaddr) const
+	{
+		return get_page_data(vaddr) & s_page_addr_mask;
+	}
+
+	bool PageTable::is_page_free(vaddr_t vaddr) const
+	{
+		ASSERT(vaddr % PAGE_SIZE == 0);
+		return !(get_page_flags(vaddr) & Flags::Used);
+	}
+
+	bool PageTable::is_range_free(vaddr_t vaddr, size_t size) const
+	{
+		vaddr_t s_page = vaddr / PAGE_SIZE;
+		vaddr_t e_page = BAN::Math::div_round_up<vaddr_t>(vaddr + size, PAGE_SIZE);
+
+		SpinLockGuard _(m_lock);
+		for (vaddr_t page = s_page; page < e_page; page++)
+			if (!is_page_free(page * PAGE_SIZE))
+				return false;
+		return true;
+	}
+
+	bool PageTable::reserve_page(vaddr_t vaddr, bool only_free, bool send_smp_message)
+	{
+		SpinLockGuard _(m_lock);
+		ASSERT(vaddr % PAGE_SIZE == 0);
+		if (only_free && !is_page_free(vaddr))
+			return false;
+		map_page_at(0, vaddr, Flags::Reserved, MemoryType::Normal, send_smp_message);
+		return true;
+	}
+
+	bool PageTable::reserve_range(vaddr_t vaddr, size_t bytes, bool only_free)
+	{
+		if (size_t rem = bytes % PAGE_SIZE)
+			bytes += PAGE_SIZE - rem;
+		ASSERT(vaddr % PAGE_SIZE == 0);
+
+		SpinLockGuard _(m_lock);
+		if (only_free && !is_range_free(vaddr, bytes))
+			return false;
+		for (size_t offset = 0; offset < bytes; offset += PAGE_SIZE)
+			reserve_page(vaddr + offset, true, false);
+		invalidate_range(vaddr, bytes / PAGE_SIZE, true);
+
+		return true;
+	}
+
+	vaddr_t PageTable::reserve_free_page(vaddr_t first_address, vaddr_t last_address)
+	{
+		if (first_address >= KERNEL_OFFSET && first_address < (vaddr_t)g_kernel_end)
+			first_address = (vaddr_t)g_kernel_end;
+		if (size_t rem = first_address % PAGE_SIZE)
+			first_address += PAGE_SIZE - rem;
+		if (size_t rem = last_address % PAGE_SIZE)
+			last_address -= rem;
+
+		uint32_t pdpte = (first_address >> 30) & 0x1FF;
+		uint32_t pde   = (first_address >> 21) & 0x1FF;
+		uint32_t pte   = (first_address >> 12) & 0x1FF;
+
+		const uint32_t e_pdpte = ((last_address - 1) >> 30) & 0x1FF;
+		const uint32_t e_pde   = ((last_address - 1) >> 21) & 0x1FF;
+		const uint32_t e_pte   = ((last_address - 1) >> 12) & 0x1FF;
+
+		SpinLockGuard _(m_lock);
+
+		// Try to find free page that can be mapped without
+		// allocations (page table with unused entries)
+		const uint64_t* pdpt = P2V(m_highest_paging_struct);
+		for (; pdpte <= e_pdpte; pdpte++)
+		{
+			if (!(pdpt[pdpte] & Flags::Present))
+				continue;
+			const uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
+			for (; pde < 512; pde++)
+			{
+				if (pdpte == e_pdpte && pde > e_pde)
+					break;
+				if (!(pd[pde] & Flags::Present))
+					continue;
+				const uint64_t* pt = P2V(pd[pde] & s_page_addr_mask);
+				for (; pte < 512; pte++)
+				{
+					if (pdpte == e_pdpte && pde == e_pde && pte > e_pte)
+						break;
+					if (pt[pte] & Flags::Used)
+						continue;
+					vaddr_t vaddr = 0;
+					vaddr |= (vaddr_t)pdpte << 30;
+					vaddr |= (vaddr_t)pde   << 21;
+					vaddr |= (vaddr_t)pte   << 12;
+					ASSERT(reserve_page(vaddr));
+					return vaddr;
+				}
+				pte = 0;
+			}
+			pde = 0;
+		}
+
+		// Find any free page
+		for (vaddr_t vaddr = first_address; vaddr < last_address; vaddr += PAGE_SIZE)
+		{
+			if (is_page_free(vaddr))
+			{
+				ASSERT(reserve_page(vaddr));
+				return vaddr;
+			}
+		}
+
+		return 0;
+	}
+
+	vaddr_t PageTable::reserve_free_contiguous_pages(size_t page_count, vaddr_t first_address, vaddr_t last_address)
+	{
+		if (first_address >= KERNEL_OFFSET && first_address < (vaddr_t)g_kernel_start)
+			first_address = (vaddr_t)g_kernel_start;
+		if (size_t rem = first_address % PAGE_SIZE)
+			first_address += PAGE_SIZE - rem;
+		if (size_t rem = last_address % PAGE_SIZE)
+			last_address -= rem;
+
+		SpinLockGuard _(m_lock);
+
+		for (vaddr_t vaddr = first_address; vaddr < last_address;)
+		{
+			bool valid { true };
+			for (size_t page = 0; page < page_count; page++)
+			{
+				if (!is_page_free(vaddr + page * PAGE_SIZE))
+				{
+					vaddr += (page + 1) * PAGE_SIZE;
+					valid = false;
+					break;
+				}
+			}
+			if (valid)
+			{
+				ASSERT(reserve_range(vaddr, page_count * PAGE_SIZE));
+				return vaddr;
+			}
+		}
+
+		return 0;
+	}
+
+	static void dump_range(vaddr_t start, vaddr_t end, PageTable::flags_t flags)
+	{
+		if (start == 0)
+			return;
+		dprintln("{}-{}: {}{}{}{}",
+			(void*)(start), (void*)(end - 1),
+			flags & PageTable::Flags::Execute			? 'x' : '-',
+			flags & PageTable::Flags::UserSupervisor	? 'u' : '-',
+			flags & PageTable::Flags::ReadWrite			? 'w' : '-',
+			flags & PageTable::Flags::Present			? 'r' : '-'
+		);
+	}
+
+	void PageTable::debug_dump()
+	{
+		SpinLockGuard _(m_lock);
+
+		flags_t flags = 0;
+		vaddr_t start = 0;
+
+		const uint64_t* pdpt = P2V(m_highest_paging_struct);
+		for (uint32_t pdpte = 0; pdpte < 4; pdpte++)
+		{
+			if (!(pdpt[pdpte] & Flags::Present))
+			{
+				dump_range(start, (pdpte << 30), flags);
+				start = 0;
+				continue;
+			}
+			const uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
+			for (uint64_t pde = 0; pde < 512; pde++)
+			{
+				if (!(pd[pde] & Flags::Present))
+				{
+					dump_range(start, (pdpte << 30) | (pde << 21), flags);
+					start = 0;
+					continue;
+				}
+				const uint64_t* pt = P2V(pd[pde] & s_page_addr_mask);
+				for (uint64_t pte = 0; pte < 512; pte++)
+				{
+					if (parse_flags(pt[pte]) != flags)
+					{
+						dump_range(start, (pdpte << 30) | (pde << 21) | (pte << 12), flags);
+						start = 0;
+					}
+
+					if (!(pt[pte] & Flags::Used))
+						continue;
+
+					if (start == 0)
+					{
+						flags = parse_flags(pt[pte]);
+						start = (pdpte << 30) | (pde << 21) | (pte << 12);
+					}
+				}
+			}
+		}
+	}
+
+}

kernel/arch/i686/Signal.S

@@ -0,0 +1,86 @@
+.section .userspace, "ax"
+
+// stack contains
+//    (4 bytes)  return address (on return stack)
+//    (4 bytes)  return stack
+//    (4 bytes)  return rflags
+//    (8 bytes)  restore sigmask
+//    (36 bytes) siginfo_t
+//    (4 bytes)  signal number
+//    (4 bytes)  signal handler
+
+.global signal_trampoline
+signal_trampoline:
+	pushl %esi // gregs
+	pushl %edi
+	pushl %edx
+	pushl %ecx
+	pushl %ebx
+	pushl %eax
+	pushl %ebp
+
+	movl 84(%esp), %eax
+	pushl %eax; addl $4, (%esp)
+	pushl (%eax)
+
+	// FIXME: populate these
+	xorl %eax, %eax
+	pushl %eax // stack
+	pushl %eax
+	pushl %eax
+	pushl %eax // sigset
+	pushl %eax
+	pushl %eax // link
+
+	movl    %esp,  %edx // ucontext
+	leal 68(%esp), %esi // siginfo
+	movl 64(%esp), %edi // signal number
+	movl 60(%esp), %eax // handlers
+
+	// align stack to 16 bytes
+	movl %esp, %ebp
+	andl $-16, %esp
+
+	subl $512, %esp
+	fxsave (%esp)
+
+	subl $4, %esp
+	pushl %edx
+	pushl %esi
+	pushl %edi
+	call *%eax
+	addl $16, %esp
+
+	fxrstor (%esp)
+	addl $512, %esp
+
+	// restore stack
+	movl %ebp, %esp
+	addl $24, %esp
+
+	// restore sigmask
+	movl $83, %eax      // SYS_SIGPROCMASK
+	movl $3,  %ebx      // SIG_SETMASK
+	leal 72(%esp), %ecx // set
+	xorl %edx, %edx     // oset
+	int $0xF0
+
+	// restore registers
+	addl $8, %esp
+	popl %ebp
+	popl %eax
+	popl %ebx
+	popl %ecx
+	popl %edx
+	popl %edi
+	popl %esi
+
+	// skip handler, number, siginfo_t, sigmask
+	addl $52, %esp
+
+	// restore flags
+	popf
+
+	movl (%esp), %esp
+
+	ret

kernel/arch/i686/Syscall.S

@@ -0,0 +1,81 @@
+// arguments in EAX, EBX, ECX, EDX, ESI, EDI
+.global asm_syscall_handler
+asm_syscall_handler:
+	# save general purpose registers
+	pushl %ebx
+	pushl %ecx
+	pushl %edx
+	pushl %edi
+	pushl %esi
+	pushl %ebp
+	cld
+
+	# align stack
+	movl %esp, %ebp
+	andl $-16, %esp
+
+	# push arguments
+	subl $8, %esp
+	pushl %edi
+	pushl %esi
+	pushl %edx
+	pushl %ecx
+	pushl %ebx
+	pushl %eax
+
+	# load kernel segments
+	movw $0x10, %ax
+	movw %ax, %ds
+	movw %ax, %es
+	movw %ax, %fs
+	movw $0x28, %ax
+	movw %ax, %gs
+
+	call cpp_syscall_handler
+
+	movl %ebp, %esp
+
+	# restore userspace segments
+	movw $(0x20 | 3), %bx
+	movw %bx, %ds
+	movw %bx, %es
+	movw $(0x30 | 3), %bx
+	movw %bx, %fs
+	movw $(0x38 | 3), %bx
+	movw %bx, %gs
+
+	# restore general purpose registers
+	popl %ebp
+	popl %esi
+	popl %edi
+	popl %edx
+	popl %ecx
+	popl %ebx
+
+	iret
+
+.global sys_fork_trampoline
+sys_fork_trampoline:
+	pushl %ebp
+	pushl %ebx
+	pushl %esi
+	pushl %edi
+
+	call read_ip
+	testl %eax, %eax
+	jz .done
+
+	movl %esp, %ebx
+
+	subl $8, %esp
+	pushl %eax
+	pushl %ebx
+	call sys_fork
+	addl $16, %esp
+
+ .done:
+	popl %edi
+	popl %esi
+	popl %ebx
+	popl %ebp
+	ret

kernel/arch/i686/Thread.S

@@ -0,0 +1,42 @@
+# uint32_t read_ip()
+.global read_ip
+read_ip:
+	popl %eax
+	jmp *%eax
+
+# void start_kernel_thread()
+.global start_kernel_thread
+start_kernel_thread:
+	# STACK LAYOUT
+	#   on_exit arg
+	#   on_exit func
+	#   entry arg
+	#   entry func
+
+	movl 4(%esp), %edi
+	movl 0(%esp), %esi
+
+	subl $12, %esp
+	pushl %edi
+	sti
+	call *%esi
+	addl $16, %esp
+
+	movl 12(%esp), %edi
+	movl  8(%esp), %esi
+
+	subl $12, %esp
+	pushl %edi
+	call *%esi
+
+.global start_userspace_thread
+start_userspace_thread:
+	movw $(0x20 | 3), %bx
+	movw %bx, %ds
+	movw %bx, %es
+	movw $(0x30 | 3), %bx
+	movw %bx, %fs
+	movw $(0x38 | 3), %bx
+	movw %bx, %gs
+
+	iret

kernel/arch/i686/User.S

@@ -0,0 +1,54 @@
+# bool safe_user_memcpy(void*, const void*, size_t)
+.global safe_user_memcpy
+.global safe_user_memcpy_end
+.global safe_user_memcpy_fault
+safe_user_memcpy:
+	xorl %eax, %eax
+	xchgl 4(%esp), %edi
+	xchgl 8(%esp), %esi
+	movl 12(%esp), %ecx
+	movl %edi, %edx
+	rep movsb
+	movl 4(%esp), %edi
+	movl 8(%esp), %esi
+	incl %eax
+safe_user_memcpy_fault:
+	ret
+safe_user_memcpy_end:
+
+# bool safe_user_strncpy(void*, const void*, size_t)
+.global safe_user_strncpy
+.global safe_user_strncpy_end
+.global safe_user_strncpy_fault
+safe_user_strncpy:
+	xchgl 4(%esp), %edi
+	xchgl 8(%esp), %esi
+	movl 12(%esp), %ecx
+
+	testl %ecx, %ecx
+	jz safe_user_strncpy_fault
+
+ .safe_user_strncpy_loop:
+	movb (%esi), %al
+	movb %al, (%edi)
+	testb %al, %al
+	jz .safe_user_strncpy_done
+
+	incl %edi
+	incl %esi
+	decl %ecx
+	jnz .safe_user_strncpy_loop
+
+ safe_user_strncpy_fault:
+	xorl %eax, %eax
+	jmp .safe_user_strncpy_return
+
+ .safe_user_strncpy_done:
+	movl $1, %eax
+
+ .safe_user_strncpy_return:
+	movl 4(%esp), %edi
+	movl 8(%esp), %esi
+	ret
+
+safe_user_strncpy_end:

kernel/arch/i686/Yield.S

@@ -0,0 +1,25 @@
+.global asm_yield_trampoline
+asm_yield_trampoline:
+	leal 4(%esp), %ecx
+	movl 4(%esp), %esp
+
+	pushl -4(%ecx)
+	pushl %ecx
+	pushl %eax
+	pushl %ebx
+	pushl %esi
+	pushl %edi
+	pushl %ebp
+
+	pushl %esp
+	call scheduler_on_yield
+	addl $4, %esp
+
+	popl %ebp
+	popl %edi
+	popl %esi
+	popl %ebx
+	popl %eax
+	movl 4(%esp), %ecx
+	movl 0(%esp), %esp
+	jmp *%ecx

kernel/arch/i686/boot.S

@@ -0,0 +1,360 @@
+.set PG_PRESENT,	1<<0
+.set PG_READ_WRITE,	1<<1
+.set PG_PAGE_SIZE,	1<<7
+
+.set FB_WIDTH,	800
+.set FB_HEIGHT,	600
+.set FB_BPP,	32
+
+#define KERNEL_OFFSET 0xC0000000
+#define V2P(vaddr) ((vaddr) - KERNEL_OFFSET)
+
+.code32
+
+// video mode info, page align modules
+.set multiboot_flags, (1 << 2) | (1 << 0)
+
+.section .multiboot, "aw"
+multiboot_start:
+	.long 0x1BADB002
+	.long multiboot_flags
+	.long -(0x1BADB002 + multiboot_flags)
+
+	.long 0
+	.long 0
+	.long 0
+	.long 0
+	.long 0
+
+	.long 0
+	.long FB_WIDTH
+	.long FB_HEIGHT
+	.long FB_BPP
+multiboot_end:
+
+.section .multiboot2, "aw"
+multiboot2_start:
+	.long 0xE85250D6
+	.long 0
+	.long multiboot2_end - multiboot2_start
+	.long -(0xE85250D6 + (multiboot2_end - multiboot2_start))
+
+	# framebuffer tag
+	.align 8
+	.short 5
+	.short 0
+	.long 20
+	.long FB_WIDTH
+	.long FB_HEIGHT
+	.long FB_BPP
+
+	# legacy start
+	.align 8
+	.short 3
+	.short 0
+	.long 12
+	.long V2P(_start)
+
+	# page align modules
+	.align 8
+	.short 6
+	.short 0
+	.long 8
+
+	.align 8
+	.short 0
+	.short 0
+	.long 8
+multiboot2_end:
+
+.section .bananboot, "aw"
+bananboot_start:
+	.long 0xBABAB007
+	.long -(0xBABAB007 + FB_WIDTH + FB_HEIGHT + FB_BPP)
+	.long FB_WIDTH
+	.long FB_HEIGHT
+	.long FB_BPP
+bananboot_end:
+
+.section .bss, "aw", @nobits
+    .global g_boot_stack_top
+	g_boot_stack_bottom:
+		.skip 4096 * 4
+	g_boot_stack_top:
+
+	.global g_kernel_cmdline
+	g_kernel_cmdline:
+		.skip 4096
+
+	bootloader_magic:
+		.skip 8
+	bootloader_info:
+		.skip 8
+
+.section .data
+
+# Map first GiB to 0x00000000 and 0xC0000000
+.align 32
+boot_pdpt:
+	.long V2P(boot_pd) + (PG_PRESENT)
+	.long 0
+	.skip 2 * 8
+	.long V2P(boot_pd) + (PG_PRESENT)
+	.long 0
+.align 4096
+boot_pd:
+	.set i, 0
+	.rept 512
+		.long V2P(boot_pts) + i + (PG_READ_WRITE | PG_PRESENT)
+		.long 0
+		.set i, i + 0x1000
+	.endr
+boot_pts:
+	.set i, 0
+	.rept 511
+		.rept 512
+			.long i + (PG_READ_WRITE | PG_PRESENT)
+			.long 0
+			.set i, i + 0x1000
+		.endr
+	.endr
+.global g_boot_fast_page_pt
+g_boot_fast_page_pt:
+	.skip 512 * 8
+
+boot_gdt:
+	.quad 0x0000000000000000 # null descriptor
+	.quad 0x00CF9A000000FFFF # kernel code
+	.quad 0x00CF92000000FFFF # kernel data
+boot_gdtr:
+	.short . - boot_gdt - 1
+	.long V2P(boot_gdt)
+
+.global g_ap_startup_done
+g_ap_startup_done:
+	.byte 0
+.global g_ap_running_count
+g_ap_running_count:
+	.byte 0
+.global g_ap_stack_loaded
+g_ap_stack_loaded:
+	.byte 0
+
+.section .text
+
+has_cpuid:
+	pushfl
+	pushfl
+	xorl $0x00200000, (%esp)
+	popfl
+	pushfl
+	popl %eax
+	xorl (%esp), %eax
+	popfl
+	testl $0x00200000, %eax
+	ret
+
+has_pae:
+	movl $0, %eax
+	cpuid
+	testl $(1 << 6), %edx
+	ret
+
+has_sse:
+	movl $1, %eax
+	cpuid
+	testl $(1 << 25), %edx
+	ret
+
+check_requirements:
+	call has_cpuid
+	jz .exit
+	call has_pae
+	jz .exit
+	call has_sse
+	jz .exit
+	ret
+.exit:
+	jmp system_halt
+
+enable_sse:
+	movl %cr0, %eax
+	andw $0xFFFB, %ax
+	orw $0x0002, %ax
+	movl %eax, %cr0
+	movl %cr4, %eax
+	orw $0x0600, %ax
+	movl %eax, %cr4
+	ret
+
+enable_tsc:
+	# allow userspace to use RDTSC
+	movl %cr4, %ecx
+	andl $0xFFFFFFFB, %ecx
+	movl %ecx, %cr4
+	ret
+
+initialize_paging:
+	# enable PAE
+	movl %cr4, %ecx
+	orl $(1 << 5), %ecx
+	movl %ecx, %cr4
+
+	# load page tables
+	movl $V2P(boot_pdpt), %ecx
+	movl %ecx, %cr3
+
+	# enable paging
+	movl %cr0, %ecx
+	orl $(1 << 31), %ecx
+	movl %ecx, %cr0
+
+	ret
+
+.global _start
+.type _start, @function
+_start:
+	cli; cld
+
+	# save bootloader magic and info
+	movl %eax, V2P(bootloader_magic)
+	movl %ebx, V2P(bootloader_info)
+
+	# load boot stack
+	movl $V2P(g_boot_stack_top), %esp
+
+	# load boot GDT
+	lgdt V2P(boot_gdtr)
+	ljmpl $0x08, $V2P(gdt_flush)
+gdt_flush:
+	# set correct segment registers
+	movw $0x10, %ax
+	movw %ax, %ds
+	movw %ax, %ss
+	movw %ax, %es
+
+	# do processor initialization
+	call check_requirements
+	call enable_sse
+	call enable_tsc
+	call initialize_paging
+
+	# load higher half stack pointer
+	movl $g_boot_stack_top, %esp
+
+	# jump to higher half
+	leal higher_half, %ecx
+	jmp *%ecx
+
+higher_half:
+	# call global constuctors
+	call _init
+
+	movl $g_init_array_start, %ebx
+	jmp 2f
+ 1: call *(%ebx)
+	addl $4, %ebx
+ 2: cmpl $g_init_array_end, %ebx
+	jne 1b
+
+	# call to the kernel itself (clear ebp for stacktrace)
+	xorl %ebp, %ebp
+
+	subl $8, %esp
+	pushl bootloader_info
+	pushl bootloader_magic
+	call kernel_main
+	addl $16, %esp
+
+	# call global destructors
+	call _fini
+
+system_halt:
+	xchgw %bx, %bx
+	cli
+1:	hlt
+	jmp 1b
+
+
+#define AP_REL(vaddr) ((vaddr) - ap_trampoline + 0xF000)
+
+.section .ap_init, "ax"
+
+.code16
+.global ap_trampoline
+ap_trampoline:
+	jmp 1f
+
+.align 8
+ap_stack_paddr:
+	.skip 4
+ap_stack_vaddr:
+	.skip 4
+ap_prepare_paging:
+	.skip 4
+ap_page_table:
+	.skip 4
+ap_ready:
+	.skip 4
+
+1:	cli; cld
+	ljmpl $0x00, $AP_REL(ap_cs_clear)
+
+ap_cs_clear:
+	# load ap gdt and enter protected mode
+	lgdt AP_REL(ap_gdtr)
+	movl %cr0, %eax
+	orb $1, %al
+	movl %eax, %cr0
+	ljmpl $0x08, $AP_REL(ap_protected_mode)
+
+.code32
+ap_protected_mode:
+	movw $0x10, %ax
+	movw %ax, %ds
+	movw %ax, %ss
+	movw %ax, %es
+
+	movl AP_REL(ap_stack_paddr), %esp
+
+	leal V2P(enable_sse),        %ecx; call *%ecx
+	leal V2P(enable_tsc),        %ecx; call *%ecx
+	leal V2P(initialize_paging), %ecx; call *%ecx
+
+	# load boot gdt and enter long mode
+	lgdt V2P(boot_gdtr)
+	ljmpl $0x08, $AP_REL(ap_flush_gdt)
+
+ap_flush_gdt:
+	movl $ap_higher_half, %ecx
+	jmp *%ecx
+
+ap_higher_half:
+	movl AP_REL(ap_prepare_paging), %eax
+	call *%eax
+
+	# load AP's initial values
+	movl AP_REL(ap_stack_vaddr), %esp
+	movl AP_REL(ap_page_table), %eax
+	movl $1, AP_REL(ap_ready)
+	movl %eax, %cr3
+
+	# clear rbp for stacktrace
+	xorl %ebp, %ebp
+
+1:	pause
+	cmpb $0, g_ap_startup_done
+	je 1b
+
+	lock incb g_ap_running_count
+
+	call ap_main
+	jmp system_halt
+
+ap_gdt:
+	.quad 0x0000000000000000 # null descriptor
+	.quad 0x00CF9A000000FFFF # 32 bit code
+	.quad 0x00CF92000000FFFF # 32 bit data
+ap_gdtr:
+	.short . - ap_gdt - 1
+	.long ap_gdt

kernel/arch/i686/crti.S

@@ -1,9 +1,9 @@
-/* x86 crti.s */
+/* i686 crti.s */
 .section .init
 .global _init
 .type _init, @function
 _init:
-	push %ebp
+	pushl %ebp
 	movl %esp, %ebp
 	/* gcc will nicely put the contents of crtbegin.o's .init section here. */
 
@@ -11,6 +11,6 @@ _init:
 .global _fini
 .type _fini, @function
 _fini:
-	push %ebp
+	pushl %ebp
 	movl %esp, %ebp
 	/* gcc will nicely put the contents of crtbegin.o's .fini section here. */

kernel/arch/i686/crtn.S

@@ -1,4 +1,4 @@
-/* x86 crtn.s */
+/* i686 crtn.s */
 .section .init
 	/* gcc will nicely put the contents of crtend.o's .init section here. */
 	popl %ebp

kernel/arch/i686/interrupts.S

@@ -0,0 +1,185 @@
+.macro intr_header, n
+	pushal
+	testb $3, \n+8*4(%esp)
+	jz 1f
+	movw $0x10, %ax
+	movw %ax, %ds
+	movw %ax, %es
+	movw %ax, %fs
+	movw $0x28, %ax
+	movw %ax, %gs
+1:	cld
+.endm
+
+.macro intr_footer, n
+	testb $3, \n+8*4(%esp)
+	jz 1f
+	call cpp_check_signal
+	movw $(0x20 | 3), %bx
+	movw %bx, %ds
+	movw %bx, %es
+	movw $(0x30 | 3), %bx
+	movw %bx, %fs
+	movw $(0x38 | 3), %bx
+	movw %bx, %gs
+1:	popal
+.endm
+
+isr_stub:
+	intr_header 12
+	movl %cr0, %eax; pushl %eax
+	movl %cr2, %eax; pushl %eax
+	movl %cr3, %eax; pushl %eax
+	movl %cr4, %eax; pushl %eax
+
+	movl 48(%esp), %edi // isr number
+	movl 52(%esp), %esi // error code
+	leal 56(%esp), %edx // interrupt stack ptr
+	movl %esp,     %ecx // register ptr
+
+	# stack frame for stack trace
+	leal 56(%esp), %eax
+	pushl (%eax)
+	pushl %ebp
+
+	movl %esp, %ebp
+	andl $-16, %esp
+
+	pushl %ecx
+	pushl %edx
+	pushl %esi
+	pushl %edi
+	call cpp_isr_handler
+
+	movl %ebp, %esp
+	addl $24, %esp
+
+	intr_footer 12
+	addl $8, %esp
+	iret
+
+irq_stub:
+	intr_header 12
+
+	movl 32(%esp), %edi # interrupt number
+
+	movl %esp, %ebp
+	andl $-16, %esp
+
+	subl $12, %esp
+	pushl %edi
+	call cpp_irq_handler
+
+	movl %ebp, %esp
+
+	intr_footer 12
+	addl $8, %esp
+	iret
+
+.global asm_ipi_handler
+asm_ipi_handler:
+	intr_header 4
+
+	movl %esp, %ebp
+	andl $-16, %esp
+
+	call cpp_ipi_handler
+
+	movl %ebp, %esp
+
+	intr_footer 4
+	iret
+
+.global asm_timer_handler
+asm_timer_handler:
+	intr_header 4
+
+	movl %esp, %ebp
+	andl $-16, %esp
+
+	call cpp_timer_handler
+
+	movl %ebp, %esp
+
+	intr_footer 4
+	iret
+
+.macro isr n
+	.global isr\n
+	isr\n:
+		pushl $0
+		pushl $\n
+		jmp isr_stub
+.endm
+
+.macro isr_err n
+	.global isr\n
+	isr\n:
+		pushl $\n
+		jmp isr_stub
+.endm
+
+.macro irq n
+	.global irq\n
+	irq\n:
+		pushl $0
+		pushl $\n
+		jmp irq_stub
+.endm
+
+isr 0
+isr 1
+isr 2
+isr 3
+isr 4
+isr 5
+isr 6
+isr 7
+isr_err 8
+isr 9
+isr_err 10
+isr_err 11
+isr_err 12
+isr_err 13
+isr_err 14
+isr 15
+isr 16
+isr_err 17
+isr 18
+isr 19
+isr 20
+isr 21
+isr 22
+isr 23
+isr 24
+isr 25
+isr 26
+isr 27
+isr 28
+isr 29
+isr 30
+isr 31
+
+.irp i,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, \
+        10, 11, 12, 13, 14, 15, 16, 17, 18, 19, \
+        20, 21, 22, 23, 24, 25, 26, 27, 28, 29, \
+        30, 31, 32, 33, 34, 35, 36, 37, 38, 39, \
+        40, 41, 42, 43, 44, 45, 46, 47, 48, 49, \
+        50, 51, 52, 53, 54, 55, 56, 57, 58, 59, \
+        60, 61, 62, 63, 64, 65, 66, 67, 68, 69, \
+        70, 71, 72, 73, 74, 75, 76, 77, 78, 79, \
+        80, 81, 82, 83, 84, 85, 86, 87, 88, 89, \
+        90, 91, 92, 93, 94, 95, 96, 97, 98, 99, \
+       100,101,102,103,104,105,106,107,108,109, \
+       110,111,112,113,114,115,116,117,118,119, \
+       120,121,122,123,124,125,126,127,128,129, \
+       130,131,132,133,134,135,136,137,138,139, \
+       140,141,142,143,144,145,146,147,148,149, \
+       150,151,152,153,154,155,156,157,158,159, \
+       160,161,162,163,164,165,166,167,168,169, \
+       170,171,172,173,174,175,176,177,178,179, \
+       180,181,182,183,184,185,186,187,188,189, \
+       190,191,192,193,194,195,196,197,198,199, \
+       200,201,202,203,204,205,206,207
+	irq \i
+.endr

kernel/arch/i686/linker.ld

@@ -0,0 +1,52 @@
+ENTRY (_start)
+
+KERNEL_OFFSET = 0xC0000000;
+
+SECTIONS
+{
+	. = 0x00100000 + KERNEL_OFFSET;
+
+	g_kernel_start = .;
+	.text ALIGN(4K) : AT(ADDR(.text) - KERNEL_OFFSET)
+	{
+		g_kernel_execute_start = .;
+		*(.multiboot)
+		*(.multiboot2)
+		*(.bananboot)
+		*(.text.*)
+	}
+	.ap_init ALIGN(4K) : AT(ADDR(.ap_init) - KERNEL_OFFSET)
+	{
+		g_ap_init_addr = .;
+		*(.ap_init)
+		g_kernel_execute_end = .;
+	}
+	.userspace ALIGN(4K) : AT(ADDR(.userspace) - KERNEL_OFFSET)
+	{
+		g_userspace_start = .;
+		*(.userspace)
+		g_userspace_end = .;
+	}
+	.rodata ALIGN(4K) : AT(ADDR(.rodata) - KERNEL_OFFSET)
+	{
+		*(.rodata.*)
+	}
+	.init_array ALIGN(4K) : AT(ADDR(.init_array) - KERNEL_OFFSET)
+	{
+		g_init_array_start = .;
+		*(.init_array)
+		g_init_array_end = .;
+	}
+	.data ALIGN(4K) : AT(ADDR(.data) - KERNEL_OFFSET)
+	{
+		g_kernel_writable_start = .;
+		*(.data)
+	}
+	.bss ALIGN(4K) : AT(ADDR(.bss) - KERNEL_OFFSET)
+	{
+		*(COMMON)
+		*(.bss)
+		g_kernel_writable_end = .;
+	}
+	g_kernel_end = .;
+}

kernel/arch/x86_64/GDT.cpp

@@ -1,125 +0,0 @@
-#include <BAN/Array.h>
-#include <kernel/GDT.h>
-
-#include <string.h>
-
-extern "C" uintptr_t g_boot_stack_top[0];
-
-namespace Kernel::GDT
-{
-
-	struct TaskStateSegment
-	{
-		uint32_t reserved1;
-		uint64_t rsp0;
-		uint64_t rsp1;
-		uint64_t rsp2;
-		uint64_t reserved2;
-		uint64_t ist1;
-		uint64_t ist2;
-		uint64_t ist3;
-		uint64_t ist4;
-		uint64_t ist5;
-		uint64_t ist6;
-		uint64_t ist7;
-		uint64_t reserved3;
-		uint16_t reserved4;
-		uint16_t iopb;
-	} __attribute__((packed));
-
-	union SegmentDescriptor
-	{
-		struct
-		{
-			uint16_t	limit1;
-			uint16_t	base1;
-			uint8_t		base2;
-			uint8_t		access;
-			uint8_t		limit2 : 4;
-			uint8_t		flags  : 4;
-			uint8_t		base3;
-		} __attribute__((packed));
-		
-		struct
-		{
-			uint32_t low;
-			uint32_t high;
-		} __attribute__((packed));
-
-	} __attribute__((packed));
-
-	struct GDTR
-	{
-		uint16_t size;
-		uint64_t address;
-	} __attribute__((packed));
-
-	static constexpr uint16_t s_tss_offset = 0x28;
-
-	static TaskStateSegment s_tss;
-	static BAN::Array<SegmentDescriptor, 7> s_gdt; // null, kernel code, kernel data, user code, user data, tss low, tss high
-	static GDTR s_gdtr;
-
-	static void write_entry(uint8_t offset, uint32_t base, uint32_t limit, uint8_t access, uint8_t flags)
-	{
-		ASSERT(offset % sizeof(SegmentDescriptor) == 0);
-
-		SegmentDescriptor& desc = s_gdt[offset / sizeof(SegmentDescriptor)];
-		desc.base1 = (base >>  0) & 0xFFFF;
-		desc.base2 = (base >> 16) & 0xFF;
-		desc.base3 = (base >> 24) & 0xFF;
-
-		desc.limit1 = (limit >>  0) & 0xFFFF;
-		desc.limit2 = (limit >> 16) & 0x0F;
-
-		desc.access = access & 0xFF;
-
-		desc.flags = flags & 0x0F;
-	}
-
-	static void write_tss()
-	{
-		memset(&s_tss, 0x00, sizeof(TaskStateSegment));
-		s_tss.iopb = sizeof(TaskStateSegment);
-		
-		uint64_t base = (uint64_t)&s_tss;
-
-		write_entry(s_tss_offset, (uint32_t)base, sizeof(TaskStateSegment), 0x89, 0x0);
-
-		SegmentDescriptor& desc = s_gdt[s_tss_offset / sizeof(SegmentDescriptor) + 1];
-		desc.low = base >> 32;
-		desc.high = 0;
-	}
-
-	void set_tss_stack(uintptr_t rsp)
-	{
-		s_tss.rsp0 = rsp;
-	}
-
-	static void flush_gdt()
-	{
-		asm volatile("lgdt %0" :: "m"(s_gdtr));
-	}
-
-	static void flush_tss()
-	{
-		asm volatile("ltr %0" :: "m"(s_tss_offset));
-	}
-
-	void initialize()
-	{
-		s_gdtr.address = (uint64_t)&s_gdt;
-		s_gdtr.size = s_gdt.size() * sizeof(SegmentDescriptor) - 1;
-
-		write_entry(0x00, 0x00000000, 0x00000, 0x00, 0x0); // null
-		write_entry(0x08, 0x00000000, 0xFFFFF, 0x9A, 0xA); // kernel code
-		write_entry(0x10, 0x00000000, 0xFFFFF, 0x92, 0xC); // kernel data
-		write_entry(0x18, 0x00000000, 0xFFFFF, 0xFA, 0xA); // user code
-		write_entry(0x20, 0x00000000, 0xFFFFF, 0xF2, 0xC); // user data
-		write_tss();
-
-		flush_gdt();
-		flush_tss();
-	}
-
-}