ports: Update xbanan

Scheduler will now set a timer interrupt deadline for when it should get
interrupted next. This fixes a big issue I've had for a long time where
sleeping on an idle core would have to wait for the next periodic
interrupt to wake up. This could cause 1 ms sleeps to be close to 10 ms.

This currently only supports lapic timers and will still fallback to
periodic interrupts when running with PIC. I should add deadline support
to PIT/HPET but why would you run with APIC disabled ;)

BAN/include/BAN/HashMap.h

@@ -98,7 +98,8 @@ namespace BAN
 
 		struct EntryHash
 		{
-			constexpr bool operator()(const Key& a)
+			template<detail::HashMapFindable<Key, HASH, COMP> U>
+			constexpr bool operator()(const U& a)
 			{
 				return HASH()(a);
 			}
@@ -110,7 +111,8 @@ namespace BAN
 
 		struct EntryComp
 		{
-			constexpr bool operator()(const Entry& a, const Key& b)
+			template<detail::HashMapFindable<Key, HASH, COMP> U>
+			constexpr bool operator()(const Entry& a, const U& b)
 			{
 				return COMP()(a.key, b);
 			}

BAN/include/BAN/Sort.h

@@ -67,11 +67,20 @@ namespace BAN::sort
 	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)
+		while (distance(begin, end) > 1)
-			return;
+		{
-		const auto [lt, gt] = detail::partition(begin, end, comp);
+			const auto [lt, gt] = detail::partition(begin, end, comp);
-		quick_sort(begin, lt, comp);
+			if (distance(begin, lt) < distance(gt, end))
-		quick_sort(gt, end, comp);
+			{
+				quick_sort(begin, lt);
+				begin = gt;
+			}
+			else
+			{
+				quick_sort(gt, end);
+				end = lt;
+			}
+		}
 	}
 
 	template<typename It, typename Comp = less<it_value_type_t<It>>>
@@ -102,13 +111,28 @@ namespace BAN::sort
 		template<typename It, typename Comp>
 		void intro_sort_impl(It begin, It end, size_t max_depth, Comp comp)
 		{
-			if (distance(begin, end) <= 16)
+			for (size_t i = 0; i < max_depth; i++)
-				return insertion_sort(begin, end, comp);
+			{
-			if (max_depth == 0)
+				const size_t len = distance(begin, end);
-				return heap_sort(begin, end, comp);
+				if (len <= 1)
-			const auto [lt, gt] = detail::partition(begin, end, comp);
+					return;
-			intro_sort_impl(begin, lt, max_depth - 1, comp);
+				if (len <= 16)
-			intro_sort_impl(gt, end, max_depth - 1, comp);
+					return insertion_sort(begin, end, comp);
+
+				const auto [lt, gt] = detail::partition(begin, end, comp);
+				if (distance(begin, lt) < distance(gt, end))
+				{
+					intro_sort_impl(begin, lt, max_depth - 1, comp);
+					begin = gt;
+				}
+				else
+				{
+					intro_sort_impl(gt, end, max_depth - 1, comp);
+					end = lt;
+				}
+			}
+
+			heap_sort(begin, end, comp);
 		}
 
 	}

BAN/include/BAN/Span.h

@@ -100,3 +100,22 @@ namespace BAN
 	};
 
 }
+
+#include <BAN/Formatter.h>
+
+namespace BAN::Formatter
+{
+
+	template<typename F, typename T>
+	void print_argument(F putc, const Span<T>& span, const ValueFormat& format)
+	{
+		putc('[');
+		for (typename Span<T>::size_type i = 0; i < span.size(); i++)
+		{
+			if (i != 0) putc(',');
+			print_argument(putc, span[i], format);
+		}
+		putc(']');
+	}
+
+}

README.md

@@ -118,7 +118,7 @@ To change the bootloader you can set environment variable BANAN\_BOOTLOADER; sup
 
 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.
+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 BANAN\_INITRD is set to a value larger than 1, initrd will be gzip compressed.
 
 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

kernel/CMakeLists.txt

@@ -11,6 +11,7 @@ set(KERNEL_SOURCES
 	kernel/Audio/Controller.cpp
 	kernel/Audio/HDAudio/AudioFunctionGroup.cpp
 	kernel/Audio/HDAudio/Controller.cpp
+	kernel/Banos.cpp
 	kernel/BootInfo.cpp
 	kernel/CPUID.cpp
 	kernel/Credentials.cpp
@@ -121,6 +122,7 @@ set(KERNEL_SOURCES
 	kernel/USB/USBManager.cpp
 	kernel/USB/XHCI/Controller.cpp
 	kernel/USB/XHCI/Device.cpp
+	kernel/UserCopy.cpp
 	icxxabi.cpp
 )
 

kernel/arch/i686/PageTable.cpp

@@ -26,8 +26,6 @@ namespace Kernel
 	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;
@@ -260,7 +258,11 @@ namespace Kernel
 
 		ASSERT(index < 512);
 		ASSERT(s_fast_page_pt);
-		ASSERT(s_fast_page_lock.current_processor_has_lock());
+
+		if (index < reserved_fast_pages)
+			ASSERT(s_fast_page_lock.current_processor_has_lock());
+		else
+			ASSERT(Processor::get_interrupt_state() == InterruptState::Disabled);
 
 		ASSERT(!(s_fast_page_pt[index] & Flags::Present));
 		s_fast_page_pt[index] = paddr | Flags::ReadWrite | Flags::Present;
@@ -274,7 +276,11 @@ namespace Kernel
 	{
 		ASSERT(index < 512);
 		ASSERT(s_fast_page_pt);
-		ASSERT(s_fast_page_lock.current_processor_has_lock());
+
+		if (index < reserved_fast_pages)
+			ASSERT(s_fast_page_lock.current_processor_has_lock());
+		else
+			ASSERT(Processor::get_interrupt_state() == InterruptState::Disabled);
 
 		ASSERT((s_fast_page_pt[index] & Flags::Present));
 		s_fast_page_pt[index] = 0;
@@ -341,32 +347,10 @@ namespace Kernel
 		const bool is_userspace = (vaddr < KERNEL_OFFSET);
 		if (is_userspace && this != &PageTable::current())
 			;
-		else if (pages <= 32 || !s_is_initialized)
+		else if (pages >= full_tlb_flush_threshold)
-		{
+			invalidate_full_address_space(!is_userspace);
-			for (size_t i = 0; i < pages; i++)
+		else for (size_t i = 0; i < pages; i++)
-				asm volatile("invlpg (%0)" :: "r"(vaddr + i * PAGE_SIZE));
+			asm volatile("invlpg (%0)" :: "r"(vaddr + i * PAGE_SIZE));
-		}
-		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)
 		{
@@ -381,6 +365,34 @@ namespace Kernel
 		}
 	}
 
+	void PageTable::invalidate_full_address_space(bool global)
+	{
+		if (!global || !s_has_pge)
+		{
+			asm volatile(
+				"movl %%cr3, %%eax;"
+				"movl %%eax, %%cr3;"
+				::: "eax"
+			);
+		}
+		else
+		{
+			asm volatile(
+				"movl %%cr4, %%eax;"
+
+				"andl $~0x80, %%eax;"
+				"movl %%eax, %%cr4;"
+
+				"movl %%cr3, %%ecx;"
+				"movl %%ecx, %%cr3;"
+
+				"orl $0x80, %%eax;"
+				"movl %%eax, %%cr4;"
+				::: "eax", "ecx"
+			);
+		}
+	}
+
 	void PageTable::unmap_page(vaddr_t vaddr, bool invalidate)
 	{
 		ASSERT(vaddr);
@@ -597,30 +609,24 @@ namespace Kernel
 		return true;
 	}
 
-	bool PageTable::reserve_page(vaddr_t vaddr, bool only_free, bool send_smp_message)
+	void PageTable::reserve_page(vaddr_t vaddr)
 	{
-		SpinLockGuard _(m_lock);
 		ASSERT(vaddr % PAGE_SIZE == 0);
-		if (only_free && !is_page_free(vaddr))
+		SpinLockGuard _(m_lock);
-			return false;
+		ASSERT(is_page_free(vaddr));
-		map_page_at(0, vaddr, Flags::Reserved, MemoryType::Normal, send_smp_message);
+		map_page_at(0, vaddr, Flags::Reserved, MemoryType::Normal, false);
-		return true;
 	}
 
-	bool PageTable::reserve_range(vaddr_t vaddr, size_t bytes, bool only_free)
+	void PageTable::reserve_range(vaddr_t vaddr, size_t bytes)
 	{
 		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))
+		ASSERT(is_range_free(vaddr, bytes));
-			return false;
 		for (size_t offset = 0; offset < bytes; offset += PAGE_SIZE)
-			reserve_page(vaddr + offset, true, false);
+			reserve_page(vaddr + offset);
-		invalidate_range(vaddr, bytes / PAGE_SIZE, true);
-
-		return true;
 	}
 
 	vaddr_t PageTable::reserve_free_page(vaddr_t first_address, vaddr_t last_address)
@@ -675,7 +681,7 @@ namespace Kernel
 					vaddr |= (vaddr_t)pdpte << 30;
 					vaddr |= (vaddr_t)pde   << 21;
 					vaddr |= (vaddr_t)pte   << 12;
-					ASSERT(reserve_page(vaddr));
+					reserve_page(vaddr);
 					return vaddr;
 				}
 				unmap_fast_page(2);
@@ -693,7 +699,7 @@ namespace Kernel
 		{
 			if (is_page_free(vaddr))
 			{
-				ASSERT(reserve_page(vaddr));
+				reserve_page(vaddr);
 				return vaddr;
 			}
 		}
@@ -726,7 +732,7 @@ namespace Kernel
 			}
 			if (valid)
 			{
-				ASSERT(reserve_range(vaddr, page_count * PAGE_SIZE));
+				reserve_range(vaddr, page_count * PAGE_SIZE);
 				return vaddr;
 			}
 		}

kernel/arch/i686/Signal.S

@@ -59,7 +59,7 @@ signal_trampoline:
 	addl $24, %esp
 
 	// restore sigmask
-	movl $83, %eax      // SYS_SIGPROCMASK
+	movl $78, %eax      // SYS_SIGPROCMASK
 	movl $3,  %ebx      // SIG_SETMASK
 	leal 72(%esp), %ecx // set
 	xorl %edx, %edx     // oset

kernel/arch/i686/Yield.S

@@ -12,7 +12,7 @@ asm_yield_trampoline:
 	pushl %ebp
 
 	pushl %esp
-	call scheduler_on_yield
+	call scheduler_on_yield_trampoline
 	addl $4, %esp
 
 	popl %ebp

kernel/arch/i686/interrupts.S

@@ -27,14 +27,10 @@
 
 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 32(%esp), %edi // isr number
-	movl 52(%esp), %esi // error code
+	movl 36(%esp), %esi // error code
-	leal 56(%esp), %edx // interrupt stack ptr
+	leal 40(%esp), %edx // interrupt stack ptr
 	movl %esp,     %ecx // register ptr
 
 	# stack frame for stack trace
@@ -52,7 +48,7 @@ isr_stub:
 	call cpp_isr_handler
 
 	movl %ebp, %esp
-	addl $24, %esp
+	addl $8, %esp
 
 	intr_footer 12
 	addl $8, %esp

kernel/arch/x86_64/PageTable.cpp

@@ -24,7 +24,6 @@ namespace Kernel
 	SpinLock PageTable::s_fast_page_lock;
 
 	static constexpr vaddr_t s_hhdm_offset = 0xFFFF800000000000;
-	static bool s_is_initialized = false;
 
 	constexpr uint64_t s_page_flag_mask = 0x8000000000000FFF;
 	constexpr uint64_t s_page_addr_mask = ~s_page_flag_mask;
@@ -383,7 +382,11 @@ namespace Kernel
 
 		ASSERT(index < 512);
 		ASSERT(s_fast_page_pt);
-		ASSERT(s_fast_page_lock.current_processor_has_lock());
+
+		if (index < reserved_fast_pages)
+			ASSERT(s_fast_page_lock.current_processor_has_lock());
+		else
+			ASSERT(Processor::get_interrupt_state() == InterruptState::Disabled);
 
 		ASSERT(!(s_fast_page_pt[index] & Flags::Present));
 		s_fast_page_pt[index] = paddr | Flags::ReadWrite | Flags::Present;
@@ -397,7 +400,11 @@ namespace Kernel
 	{
 		ASSERT(index < 512);
 		ASSERT(s_fast_page_pt);
-		ASSERT(s_fast_page_lock.current_processor_has_lock());
+
+		if (index < reserved_fast_pages)
+			ASSERT(s_fast_page_lock.current_processor_has_lock());
+		else
+			ASSERT(Processor::get_interrupt_state() == InterruptState::Disabled);
 
 		ASSERT((s_fast_page_pt[index] & Flags::Present));
 		s_fast_page_pt[index] = 0;
@@ -470,32 +477,10 @@ namespace Kernel
 		const bool is_userspace = (vaddr < KERNEL_OFFSET);
 		if (is_userspace && this != &PageTable::current())
 			;
-		else if (pages <= 32 || !s_is_initialized)
+		else if (pages >= full_tlb_flush_threshold)
-		{
+			invalidate_full_address_space(!is_userspace);
-			for (size_t i = 0; i < pages; i++)
+		else for (size_t i = 0; i < pages; i++)
-				asm volatile("invlpg (%0)" :: "r"(vaddr + i * PAGE_SIZE));
+			asm volatile("invlpg (%0)" :: "r"(vaddr + i * PAGE_SIZE));
-		}
-		else if (is_userspace || !s_has_pge)
-		{
-			asm volatile("movq %0, %%cr3" :: "r"(m_highest_paging_struct));
-		}
-		else
-		{
-			asm volatile(
-				"movq %%cr4, %%rax;"
-
-				"andq $~0x80, %%rax;"
-				"movq %%rax, %%cr4;"
-
-				"movq %0, %%cr3;"
-
-				"orq $0x80, %%rax;"
-				"movq %%rax, %%cr4;"
-				:
-				: "r"(m_highest_paging_struct)
-				: "rax"
-			);
-		}
 
 		if (send_smp_message)
 		{
@@ -510,6 +495,34 @@ namespace Kernel
 		}
 	}
 
+	void PageTable::invalidate_full_address_space(bool global)
+	{
+		if (!global || !s_has_pge)
+		{
+			asm volatile(
+				"movq %%cr3, %%rax;"
+				"movq %%rax, %%cr3;"
+				::: "rax"
+			);
+		}
+		else
+		{
+			asm volatile(
+				"movq %%cr4, %%rax;"
+
+				"andq $~0x80, %%rax;"
+				"movq %%rax, %%cr4;"
+
+				"movq %%cr3, %%rcx;"
+				"movq %%rcx, %%cr3;"
+
+				"orq $0x80, %%rax;"
+				"movq %%rax, %%cr4;"
+				::: "rax", "rcx"
+			);
+		}
+	}
+
 	void PageTable::unmap_page(vaddr_t vaddr, bool invalidate)
 	{
 		ASSERT(vaddr);
@@ -551,12 +564,70 @@ namespace Kernel
 	{
 		ASSERT(vaddr % PAGE_SIZE == 0);
 
-		const size_t page_count = range_page_count(vaddr, size);
+		ASSERT(is_canonical(vaddr));
+		ASSERT(is_canonical(vaddr + size - 1));
+
+		const vaddr_t uc_vaddr_start = uncanonicalize(vaddr);
+		const vaddr_t uc_vaddr_end   = uncanonicalize(vaddr + size - 1);
+
+		uint16_t pml4e = (uc_vaddr_start >> 39) & 0x1FF;
+		uint16_t pdpte = (uc_vaddr_start >> 30) & 0x1FF;
+		uint16_t pde   = (uc_vaddr_start >> 21) & 0x1FF;
+		uint16_t pte   = (uc_vaddr_start >> 12) & 0x1FF;
+
+		const uint16_t e_pml4e = (uc_vaddr_end >> 39) & 0x1FF;
+		const uint16_t e_pdpte = (uc_vaddr_end >> 30) & 0x1FF;
+		const uint16_t e_pde   = (uc_vaddr_end >> 21) & 0x1FF;
+		const uint16_t e_pte   = (uc_vaddr_end >> 12) & 0x1FF;
 
 		SpinLockGuard _(m_lock);
-		for (vaddr_t page = 0; page < page_count; page++)
+
-			unmap_page(vaddr + page * PAGE_SIZE, false);
+		uint64_t* pml4 = P2V(m_highest_paging_struct);
-		invalidate_range(vaddr, page_count, true);
+		for (; pml4e <= e_pml4e; pml4e++)
+		{
+#define UNALLOCATE_TABLE_IF_EMPTY(outer, inner) \
+			if (old_##inner##e == 0 && inner##e == 512) { \
+				unallocate_page(outer[outer##e] & s_page_addr_mask); \
+				outer[outer##e] = 0; \
+			}
+			if (!(pml4[pml4e] & Flags::Present))
+				continue;
+			const uint16_t old_pdpte = pdpte;
+			uint64_t* pdpt = P2V(pml4[pml4e] & s_page_addr_mask);
+			for (; pdpte < 512; pdpte++)
+			{
+				if (pml4e == e_pml4e && pdpte > e_pdpte)
+					break;
+				if (!(pdpt[pdpte] & Flags::Present))
+					continue;
+				const uint16_t old_pde = pde;
+				uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
+				for (; pde < 512; pde++)
+				{
+					if (pml4e == e_pml4e && pdpte == e_pdpte && pde > e_pde)
+						break;
+					if (!(pd[pde] & Flags::Present))
+						continue;
+					const uint16_t old_pte = pte;
+					uint64_t* pt = P2V(pd[pde] & s_page_addr_mask);
+					for (; pte < 512; pte++)
+					{
+						if (pml4e == e_pml4e && pdpte == e_pdpte && pde == e_pde && pte > e_pte)
+							break;
+						pt[pte] = 0;
+					}
+					UNALLOCATE_TABLE_IF_EMPTY(pd, pt);
+					pte = 0;
+				}
+				UNALLOCATE_TABLE_IF_EMPTY(pdpt, pd);
+				pde = 0;
+			}
+			UNALLOCATE_TABLE_IF_EMPTY(pml4, pdpt);
+			pdpte = 0;
+#undef UNALLOCATE_TABLE_IF_EMPTY
+		}
+
+		invalidate_range(vaddr, range_page_count(vaddr, size), true);
 	}
 
 	void PageTable::map_page_at(paddr_t paddr, vaddr_t vaddr, flags_t flags, MemoryType memory_type, bool invalidate)
@@ -746,29 +817,71 @@ namespace Kernel
 		return get_page_data(addr) & s_page_addr_mask;
 	}
 
-	bool PageTable::reserve_page(vaddr_t vaddr, bool only_free, bool invalidate)
+	void PageTable::reserve_page(vaddr_t vaddr)
 	{
-		SpinLockGuard _(m_lock);
 		ASSERT(vaddr % PAGE_SIZE == 0);
-		if (only_free && !is_page_free(vaddr))
+		SpinLockGuard _(m_lock);
-			return false;
+		ASSERT(is_page_free(vaddr));
-		map_page_at(0, vaddr, Flags::Reserved, MemoryType::Normal, invalidate);
+		map_page_at(0, vaddr, Flags::Reserved, MemoryType::Normal, false);
-		return true;
 	}
 
-	bool PageTable::reserve_range(vaddr_t vaddr, size_t bytes, bool only_free)
+	void PageTable::reserve_range(vaddr_t vaddr, size_t bytes)
 	{
 		if (size_t rem = bytes % PAGE_SIZE)
 			bytes += PAGE_SIZE - rem;
 		ASSERT(vaddr % PAGE_SIZE == 0);
 
+		ASSERT(is_canonical(vaddr));
+		ASSERT(is_canonical(vaddr + bytes - 1));
+
+		const vaddr_t uc_vaddr_start = uncanonicalize(vaddr);
+		uint16_t pml4e = (uc_vaddr_start >> 39) & 0x1FF;
+		uint16_t pdpte = (uc_vaddr_start >> 30) & 0x1FF;
+		uint16_t pde   = (uc_vaddr_start >> 21) & 0x1FF;
+		uint16_t pte   = (uc_vaddr_start >> 12) & 0x1FF;
+
+		size_t pages_to_reserve = bytes / PAGE_SIZE;
+		ASSERT(pages_to_reserve);
+
 		SpinLockGuard _(m_lock);
-		if (only_free && !is_range_free(vaddr, bytes))
+
-			return false;
+		uint64_t* pml4 = P2V(m_highest_paging_struct);
-		for (size_t offset = 0; offset < bytes; offset += PAGE_SIZE)
+		for (;; pml4e++)
-			reserve_page(vaddr + offset, true, false);
+		{
-		invalidate_range(vaddr, bytes / PAGE_SIZE, true);
+#define CHECK_IF_PRESENT(expr) \
-		return true;
+			if (!((expr) & Flags::Present)) { \
+				const paddr_t paddr = allocate_zeroed_page_aligned_page(); \
+				ASSERT(paddr); \
+				(expr) = paddr | Flags::Present; \
+			}
+			CHECK_IF_PRESENT(pml4[pml4e]);
+			uint64_t* pdpt = P2V(pml4[pml4e] & s_page_addr_mask);
+			for (; pdpte < 512; pdpte++)
+			{
+				CHECK_IF_PRESENT(pdpt[pdpte]);
+				uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
+				for (; pde < 512; pde++)
+				{
+					CHECK_IF_PRESENT(pd[pde]);
+					uint64_t* pt = P2V(pd[pde] & s_page_addr_mask);
+					for (; pte < 512; pte++)
+					{
+						ASSERT(!(pt[pte] & Flags::Used));
+						pt[pte] = Flags::Reserved;
+
+						pages_to_reserve--;
+						if (pages_to_reserve == 0)
+							return;
+					}
+					pte = 0;
+				}
+				pde = 0;
+			}
+			pdpte = 0;
+#undef CHECK_IF_PRESENT
+		}
+
+		ASSERT_NOT_REACHED();
 	}
 
 	vaddr_t PageTable::reserve_free_page(vaddr_t first_address, vaddr_t last_address)
@@ -782,6 +895,7 @@ namespace Kernel
 
 		ASSERT(is_canonical(first_address));
 		ASSERT(is_canonical(last_address - 1));
+
 		const vaddr_t uc_vaddr_start = uncanonicalize(first_address);
 		const vaddr_t uc_vaddr_end   = uncanonicalize(last_address - 1);
 
@@ -831,7 +945,7 @@ namespace Kernel
 						vaddr |= static_cast<uint64_t>(pde)   << 21;
 						vaddr |= static_cast<uint64_t>(pte)   << 12;
 						vaddr = canonicalize(vaddr);
-						ASSERT(reserve_page(vaddr));
+						reserve_page(vaddr);
 						return vaddr;
 					}
 					pte = 0;
@@ -845,7 +959,7 @@ namespace Kernel
 		{
 			if (vaddr_t vaddr = canonicalize(uc_vaddr); is_page_free(vaddr))
 			{
-				ASSERT(reserve_page(vaddr));
+				reserve_page(vaddr);
 				return vaddr;
 			}
 		}
@@ -855,44 +969,90 @@ namespace Kernel
 
 	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)
+		if (first_address >= KERNEL_OFFSET && first_address < reinterpret_cast<vaddr_t>(g_kernel_start))
-			first_address = (vaddr_t)g_kernel_start;
+			first_address = reinterpret_cast<vaddr_t>(g_kernel_start);
-		if (size_t rem = first_address % PAGE_SIZE)
+		if (const auto rem = first_address % PAGE_SIZE)
 			first_address += PAGE_SIZE - rem;
-		if (size_t rem = last_address % PAGE_SIZE)
+		if (const auto rem = last_address % PAGE_SIZE)
 			last_address -= rem;
 
 		ASSERT(is_canonical(first_address));
 		ASSERT(is_canonical(last_address - 1));
 
+		const vaddr_t uc_vaddr_start = uncanonicalize(first_address);
+		const vaddr_t uc_vaddr_end   = uncanonicalize(last_address - 1);
+
+		uint16_t pml4e = (uc_vaddr_start >> 39) & 0x1FF;
+		uint16_t pdpte = (uc_vaddr_start >> 30) & 0x1FF;
+		uint16_t pde   = (uc_vaddr_start >> 21) & 0x1FF;
+		uint16_t pte   = (uc_vaddr_start >> 12) & 0x1FF;
+
+		const uint16_t e_pml4e = (uc_vaddr_end >> 39) & 0x1FF;
+		const uint16_t e_pdpte = (uc_vaddr_end >> 30) & 0x1FF;
+		const uint16_t e_pde   = (uc_vaddr_end >> 21) & 0x1FF;
+		const uint16_t e_pte   = (uc_vaddr_end >> 12) & 0x1FF;
+
+		vaddr_t vaddr = first_address;
+		size_t free_count = 0;
+
 		SpinLockGuard _(m_lock);
 
-		for (vaddr_t vaddr = first_address; vaddr < last_address;)
+		const uint64_t* pml4 = P2V(m_highest_paging_struct);
+		for (; pml4e <= e_pml4e; pml4e++)
 		{
-			bool valid { true };
+#define CHECK_IF_PRESENT(expr, advance) \
-			for (size_t page = 0; page < page_count; page++)
+			if (!((expr) & Flags::Present)) { \
-			{
+				if ((free_count += advance) >= page_count) \
-				if (!is_canonical(vaddr + page * PAGE_SIZE))
+					goto found_free_region; \
-				{
+				continue; \
-					vaddr = canonicalize(uncanonicalize(vaddr + page * PAGE_SIZE));
-					valid = false;
-					break;
-				}
-				if (!is_page_free(vaddr + page * PAGE_SIZE))
-				{
-					vaddr += (page + 1) * PAGE_SIZE;
-					valid = false;
-					break;
-				}
 			}
-			if (valid)
+			CHECK_IF_PRESENT(pml4[pml4e], 512 * 512 * 512);
+			const uint64_t* pdpt = P2V(pml4[pml4e] & s_page_addr_mask);
+			for (; pdpte < 512; pdpte++)
 			{
-				ASSERT(reserve_range(vaddr, page_count * PAGE_SIZE));
+				if (pml4e == e_pml4e && pdpte > e_pdpte)
-				return vaddr;
+					break;
+				CHECK_IF_PRESENT(pdpt[pdpte], 512 * 512);
+				const uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
+				for (; pde < 512; pde++)
+				{
+					if (pml4e == e_pml4e && pdpte == e_pdpte && pde > e_pde)
+						break;
+					CHECK_IF_PRESENT(pd[pde], 512);
+					uint64_t* pt = P2V(pd[pde] & s_page_addr_mask);
+					for (; pte < 512; pte++)
+					{
+						if (pml4e == e_pml4e && pdpte == e_pdpte && pde == e_pde && pte > e_pte)
+							break;
+						if (!(pt[pte] & Flags::Used))
+						{
+							if (++free_count >= page_count)
+								goto found_free_region;
+						}
+						else
+						{
+							vaddr = 0;
+							vaddr |= static_cast<uint64_t>(pml4e) << 39;
+							vaddr |= static_cast<uint64_t>(pdpte) << 30;
+							vaddr |= static_cast<uint64_t>(pde)   << 21;
+							vaddr |= static_cast<uint64_t>(pte)   << 12;
+							vaddr = canonicalize(vaddr + PAGE_SIZE);
+							free_count = 0;
+						}
+					}
+					pte = 0;
+				}
+				pde = 0;
 			}
+			pdpte = 0;
+#undef CHECK_IF_PRESENT
 		}
 
 		return 0;
+
+	found_free_region:
+		reserve_range(vaddr, page_count * PAGE_SIZE);
+		return vaddr;
 	}
 
 	bool PageTable::is_page_free(vaddr_t page) const

kernel/arch/x86_64/Signal.S

@@ -61,7 +61,7 @@ signal_trampoline:
 	addq $40, %rsp
 
 	// restore sigmask
-	movq $83, %rdi       // SYS_SIGPROCMASK
+	movq $78, %rdi       // SYS_SIGPROCMASK
 	movq $3,  %rsi       // SIG_SETMASK
 	leaq 192(%rsp), %rdx // set
 	xorq %r10, %r10      // oset

kernel/arch/x86_64/Yield.S

@@ -15,7 +15,7 @@ asm_yield_trampoline:
 	pushq %r15
 
 	movq %rsp, %rdi
-	call scheduler_on_yield
+	call scheduler_on_yield_trampoline
 
 	popq %r15
 	popq %r14

kernel/arch/x86_64/interrupts.S

@@ -44,17 +44,12 @@
 
 isr_stub:
 	intr_header 24
-	movq %cr0, %rax; pushq %rax
-	movq %cr2, %rax; pushq %rax
-	movq %cr3, %rax; pushq %rax
-	movq %cr4, %rax; pushq %rax
 
-	movq 152(%rsp), %rdi	// isr number
+	movq 120(%rsp), %rdi // isr number
-	movq 160(%rsp), %rsi	// error code
+	movq 128(%rsp), %rsi // error code
-	leaq 168(%rsp), %rdx	// interrupt stack ptr
+	leaq 136(%rsp), %rdx // interrupt stack ptr
-	movq %rsp, %rcx			// register ptr
+	movq %rsp, %rcx      // register ptr
 	call cpp_isr_handler
-	addq $32, %rsp
 
 	intr_footer 24
 	addq $16, %rsp

kernel/arch/x86_64/linker.ld

@@ -41,7 +41,18 @@ SECTIONS
 	{
 		g_kernel_writable_start = .;
 		*(.data)
+
+		. = ALIGN(8);
+		g_drv_builtin_begin = .;
+		KEEP(*(.banos-driver))
+		g_drv_builtin_end = .;
+		. = ALIGN(8);
+		g_banos_export = .;
+		KEEP(*(.banos-export))
+		g_banos_export_end = .;
 	}
+
+
 	.bss ALIGN(4K) : AT(ADDR(.bss) - KERNEL_OFFSET)
 	{
 		g_kernel_bss_start = .;

kernel/include/banos/driver.h

@@ -0,0 +1,27 @@
+#pragma once
+// Copyright (c) 2026 Dcraftbg
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#include "version.h"
+#include "revision.h"
+
+#define BANOS_DRIVER_REVISION_CURRENT 0
+
+typedef struct Banos_Driver Banos_Driver;
+struct Banos_Driver {
+    unsigned long driver_size;
+    banos_version_t minimal_banos_version;
+    const char* name;
+    const char* license;
+    banos_version_t version;
+
+    // NOTE: checkout BANOS_DRIVER_INSTANCE_SIZE.
+    // You may use this instance data for anything you wish to store.
+    // If you need more than that just allocate it on the heap or
+    // globally if you add the proper verification of having your driver run only
+    // within a single instance
+    int (*init)(Banos_Driver* drv);
+    int (*uninit)(Banos_Driver* drv);
+};
+#define BANOS_DRIVER_API static __attribute__((section(".banos-driver"), used, aligned(8)))

kernel/include/banos/export.h

@@ -0,0 +1,15 @@
+#pragma once
+// Copyright (c) 2026 Dcraftbg
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+typedef struct Banos_Symbol {
+    const char* name;
+    void* arg;
+} Banos_Symbol;
+#define BANOS_EXPORT_SYMBOL(symname, str, ptr) \
+    static __attribute__((section(".banos-export"), used, aligned(8))) Banos_Symbol __symbol_##symname = {\
+        .name = str, \
+        .arg = ptr \
+    };
+#define BANOS_EXPORT(name) BANOS_EXPORT_SYMBOL(name, #name, (void*)&name)

kernel/include/banos/print.h

@@ -0,0 +1,13 @@
+#pragma once
+// Copyright (c) 2026 Dcraftbg
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void banos_dprintln(const char* str);
+#ifdef __cplusplus
+}
+#endif

kernel/include/banos/revision.h

@@ -0,0 +1,2 @@
+#pragma once
+typedef unsigned long banos_revision_t;

kernel/include/banos/version.h

@@ -0,0 +1,28 @@
+#pragma once
+// Copyright (c) 2026 Dcraftbg
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// [ 8 bit major ] [ 8 minor ] [ 16 patch]
+typedef unsigned int banos_version_t;
+#define BANOS_VERSION_MAJOR_SHIFT 24
+#define BANOS_VERSION_MINOR_SHIFT 16
+#define BANOS_VERSION_PATCH_SHIFT 0
+
+#define BANOS_VERSION_MAJOR_MASK 0xFF
+#define BANOS_VERSION_MINOR_MASK 0xFF
+#define BANOS_VERSION_PATCH_MASK 0xFFFF
+
+#define BANOS_VERSION_MAKE(major, minor, patch) \
+    (banos_version_t)( \
+        (((major) & BANOS_VERSION_MAJOR_MASK) << BANOS_VERSION_MAJOR_SHIFT) | \
+        (((minor) & BANOS_VERSION_MINOR_MASK) << BANOS_VERSION_MINOR_SHIFT) | \
+        (((patch) & BANOS_VERSION_PATCH_MASK) << BANOS_VERSION_PATCH_SHIFT) \
+    )
+
+#define BANOS_VERSION_CURRENT BANOS_VERSION_MAKE(0, 0, 1)
+
+#define BANOS_VERSION_GET_MAJOR(v) (((v) >> BANOS_VERSION_MAJOR_SHIFT) & BANOS_VERSION_MAJOR_MASK)
+#define BANOS_VERSION_GET_MINOR(v) (((v) >> BANOS_VERSION_MINOR_SHIFT) & BANOS_VERSION_MINOR_MASK)
+#define BANOS_VERSION_GET_PATCH(v) (((v) >> BANOS_VERSION_PATCH_SHIFT) & BANOS_VERSION_PATCH_MASK)

kernel/include/kernel/API/SharedPage.h

@@ -8,6 +8,7 @@ namespace Kernel::API
 	enum SharedPageFeature : uint32_t
 	{
 		SPF_GETTIME = 1 << 0,
+		SPF_RDTSCP  = 1 << 1,
 	};
 
 	struct SharedPage
@@ -18,9 +19,8 @@ namespace Kernel::API
 
 		struct
 		{
-			uint8_t shift;
+			uint64_t realtime_s;
-			uint64_t mult;
+			uint32_t realtime_ns;
-			uint64_t realtime_seconds;
 		} gettime_shared;
 
 		struct
@@ -28,6 +28,8 @@ namespace Kernel::API
 			struct
 			{
 				uint32_t seq;
+				uint32_t mult;
+				int8_t shift;
 				uint64_t last_ns;
 				uint64_t last_tsc;
 			} gettime_local;

kernel/include/kernel/APIC.h

@@ -26,6 +26,7 @@ namespace Kernel
 		BAN::ErrorOr<uint8_t> reserve_gsi(uint32_t gsi);
 
 		void initialize_timer();
+		void set_timer_dealine(uint64_t ns);
 
 	private:
 		uint32_t read_from_local_apic(ptrdiff_t);

kernel/include/kernel/Audio/Controller.h

@@ -38,7 +38,7 @@ namespace Kernel
 
 		BAN::ErrorOr<size_t> write_impl(off_t, BAN::ConstByteSpan) override;
 
-		BAN::ErrorOr<long> ioctl_impl(int cmd, void* arg) override;
+		BAN::ErrorOr<long> ioctl_impl(unsigned long request, void* arg) override;
 
 	protected:
 		ThreadBlocker m_sample_data_blocker;

kernel/include/kernel/Banos.h

@@ -0,0 +1,10 @@
+#pragma once
+#include <BAN/Vector.h>
+#include <BAN/StringView.h>
+typedef struct Banos_Symbol Banos_Symbol;
+namespace Banos {
+	void* resolve_symbol(const char* name);
+	void import_symbols(Banos_Symbol* symbols, size_t count);
+	void initialize_initial_drivers(void);
+	BAN::ErrorOr<size_t> load_driver_from_image(const char* u_image);
+}

kernel/include/kernel/CPUID.h

@@ -82,5 +82,8 @@ namespace CPUID
 	bool has_pat();
 	bool has_1gib_pages();
 	bool has_invariant_tsc();
+	bool has_rdtscp();
+	uint64_t get_tsc_frequency();
+	bool has_kvm_pvclock();
 
 }

kernel/include/kernel/Device/FramebufferDevice.h

@@ -36,7 +36,7 @@ namespace Kernel
 		virtual BAN::ErrorOr<size_t> read_impl(off_t, BAN::ByteSpan) override;
 		virtual BAN::ErrorOr<size_t> write_impl(off_t, BAN::ConstByteSpan) override;
 
-		BAN::ErrorOr<long> ioctl_impl(int cmd, void* arg) override;
+		BAN::ErrorOr<long> ioctl_impl(unsigned long request, void* arg) override;
 
 		virtual bool can_read_impl() const override { return true; }
 		virtual bool can_write_impl() const override { return true; }

kernel/include/kernel/ELF.h

@@ -14,8 +14,8 @@ namespace Kernel::ELF
 			size_t size;
 		};
 
-		bool open_execfd;
 		vaddr_t entry_point;
+		BAN::Optional<vaddr_t> interp_base;
 		BAN::Optional<TLS> master_tls;
 		BAN::Vector<BAN::UniqPtr<MemoryRegion>> regions;
 	};

kernel/include/kernel/FS/Ext2/FileSystem.h

@@ -99,7 +99,8 @@ namespace Kernel
 		BAN::ErrorOr<uint32_t> reserve_free_block(uint32_t primary_bgd);
 		BAN::ErrorOr<void> release_block(uint32_t block);
 
-		BAN::HashMap<ino_t, BAN::RefPtr<Ext2Inode>>& inode_cache() { return m_inode_cache; }
+		BAN::ErrorOr<BAN::RefPtr<Ext2Inode>> open_inode(ino_t);
+		void remove_from_cache(ino_t);
 
 		const Ext2::Superblock& superblock() const { return m_superblock; }
 
@@ -155,6 +156,7 @@ namespace Kernel
 		BAN::RefPtr<Inode> m_root_inode;
 		BAN::Vector<uint32_t> m_superblock_backups;
 
+		Mutex m_inode_cache_lock;
 		BAN::HashMap<ino_t, BAN::RefPtr<Ext2Inode>> m_inode_cache;
 
 		BlockBufferManager m_buffer_manager;

kernel/include/kernel/FS/Ext2/Inode.h

@@ -55,7 +55,7 @@ namespace Kernel
 		BAN::ErrorOr<BAN::RefPtr<Inode>> find_inode_no_lock(BAN::StringView);
 
 		/* needs write end of the lock when allocate is true*/
-		BAN::ErrorOr<BAN::Optional<uint32_t>> block_from_indirect_block_no_lock(uint32_t& block, uint32_t index, uint32_t depth, bool allocate);
+		BAN::ErrorOr<BAN::Optional<uint32_t>> block_from_indirect_block_no_lock(uint32_t block, uint32_t index, uint32_t depth, bool allocate);
 		BAN::ErrorOr<BAN::Optional<uint32_t>> fs_block_of_data_block_index_no_lock(uint32_t data_block_index, bool allocate);
 
 		/* needs write end of the lock */
@@ -71,7 +71,13 @@ namespace Kernel
 	private:
 		Ext2Inode(Ext2FS& fs, Ext2::Inode inode, uint32_t ino);
 
-		static BAN::ErrorOr<BAN::RefPtr<Ext2Inode>> create(Ext2FS&, uint32_t);
+		BAN::Optional<uint32_t> block_cache_find(uint32_t block, uint32_t index) const;
+		void block_cache_remove(uint32_t block, uint32_t index);
+		void block_cache_add(uint32_t block, uint32_t index, uint32_t target);
+
+		BAN::RefPtr<Inode> dir_cache_find(BAN::StringView) const;
+		void dir_cache_remove(BAN::StringView);
+		void dir_cache_add(BAN::StringView, BAN::RefPtr<Inode>);
 
 	private:
 		struct ScopedSync
@@ -107,6 +113,27 @@ namespace Kernel
 		const uint32_t m_og_faddr;
 		const Ext2::Osd2 m_og_osd2;
 
+		struct BlockCacheEntry
+		{
+			mutable uint32_t freq;
+			uint32_t block;
+			uint32_t index;
+			uint32_t target;
+		};
+		mutable SpinLock m_block_cache_lock;
+		BAN::Array<BlockCacheEntry, 8> m_block_cache;
+
+		struct DirCacheEntry
+		{
+			mutable size_t freq { 0 };
+			BAN::RefPtr<Inode> inode;
+			size_t name_len { 0 };
+			char   name[256];
+		};
+		static constexpr size_t dir_cache_size = 32;
+		mutable RWLock m_dir_cache_lock;
+		BAN::Vector<DirCacheEntry> m_dir_cache;
+
 		friend class Ext2FS;
 		friend class BAN::RefPtr<Ext2Inode>;
 	};

kernel/include/kernel/FS/Inode.h

@@ -150,7 +150,7 @@ namespace Kernel
 		bool has_error() const  { return has_error_impl(); }
 		bool has_hungup() const { return has_hungup_impl(); }
 
-		BAN::ErrorOr<long> ioctl(int request, void* arg);
+		BAN::ErrorOr<long> ioctl(unsigned long request, void* arg);
 
 		BAN::ErrorOr<void> add_epoll(class Epoll*);
 		void del_epoll(class Epoll*);
@@ -199,7 +199,7 @@ namespace Kernel
 		virtual bool has_error_impl() const = 0;
 		virtual bool has_hungup_impl() const = 0;
 
-		virtual BAN::ErrorOr<long> ioctl_impl(int, void*) { return BAN::Error::from_errno(ENOTSUP); }
+		virtual BAN::ErrorOr<long> ioctl_impl(unsigned long, void*) { return BAN::Error::from_errno(ENOTSUP); }
 
 	protected:
 		// TODO: this is supposed to be const I guess?

kernel/include/kernel/FS/Pipe.h

@@ -35,8 +35,6 @@ namespace Kernel
 		virtual bool has_error_impl() const override { return m_reading_count == 0; }
 		virtual bool has_hungup_impl() const override { return m_writing_count == 0; }
 
-		virtual BAN::ErrorOr<long> ioctl_impl(int, void*) override;
-
 	private:
 		Pipe(const struct stat&);
 

kernel/include/kernel/FS/ProcFS/FileSystem.h

@@ -13,6 +13,8 @@ namespace Kernel
 		static void initialize();
 		static ProcFileSystem& get();
 
+		void post_scheduler_initialize();
+
 		BAN::ErrorOr<void> on_process_create(Process&);
 		void on_process_delete(Process&);
 

kernel/include/kernel/FS/ProcFS/Inode.h

@@ -76,7 +76,7 @@ namespace Kernel
 	class ProcROInode final : public TmpInode
 	{
 	public:
-		static BAN::ErrorOr<BAN::RefPtr<ProcROInode>> create_new(size_t (*callback)(off_t, BAN::ByteSpan), TmpFileSystem&, mode_t, uid_t, gid_t);
+		static BAN::ErrorOr<BAN::RefPtr<ProcROInode>> create_new(BAN::ErrorOr<size_t> (*callback)(off_t, BAN::ByteSpan, void*), TmpFileSystem&, void*, mode_t, uid_t, gid_t);
 		~ProcROInode() = default;
 
 	protected:
@@ -92,10 +92,11 @@ namespace Kernel
 		virtual bool has_hungup_impl() const override { return false; }
 
 	private:
-		ProcROInode(size_t (*callback)(off_t, BAN::ByteSpan), TmpFileSystem&, const TmpInodeInfo&);
+		ProcROInode(BAN::ErrorOr<size_t> (*callback)(off_t, BAN::ByteSpan, void*), TmpFileSystem&, void*, const TmpInodeInfo&);
 
 	private:
-		size_t (*m_callback)(off_t, BAN::ByteSpan);
+		BAN::ErrorOr<size_t> (*m_callback)(off_t, BAN::ByteSpan, void*);
+		void* m_argument;
 	};
 
 	class ProcSymlinkInode final : public TmpInode

kernel/include/kernel/FS/VirtualFileSystem.h

@@ -92,8 +92,9 @@ namespace Kernel
 		MountPoint* mount_from_root_inode(BAN::RefPtr<Inode>);
 
 	private:
-		Mutex					m_mutex;
 		BAN::RefPtr<FileSystem>	m_root_fs;
+
+		Mutex					m_mount_point_lock;
 		BAN::Vector<MountPoint>	m_mount_points;
 
 		friend class BAN::RefPtr<VirtualFileSystem>;

kernel/include/kernel/Input/InputDevice.h

@@ -61,6 +61,7 @@ namespace Kernel
 	{
 	public:
 		static BAN::ErrorOr<BAN::RefPtr<KeyboardDevice>> create(mode_t mode, uid_t uid, gid_t gid);
+		static BAN::ErrorOr<void> initialize_tty_thread();
 
 		void notify();
 

kernel/include/kernel/Lock/RWLock.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <kernel/Lock/Mutex.h>
+#include <kernel/Lock/SpinLock.h>
-#include <kernel/Lock/LockGuard.h>
+#include <kernel/Lock/SpinLockAsMutex.h>
 
 namespace Kernel
 {
@@ -15,15 +15,18 @@ namespace Kernel
 
 		void rd_lock()
 		{
-			LockGuard _(m_mutex);
+			SpinLockGuard _(m_lock);
 			while (m_writers_waiting > 0 || m_writer != -1)
-				m_thread_blocker.block_indefinite(&m_mutex);
+			{
+				SpinLockGuardAsMutex smutex(_);
+				m_thread_blocker.block_indefinite(&smutex);
+			}
 			m_readers_active++;
 		}
 
 		void rd_unlock()
 		{
-			LockGuard _(m_mutex);
+			SpinLockGuard _(m_lock);
 			if (--m_readers_active == 0)
 				m_thread_blocker.unblock();
 		}
@@ -36,11 +39,14 @@ namespace Kernel
 				return;
 			}
 
-			LockGuard _(m_mutex);
+			SpinLockGuard _(m_lock);
 
 			m_writers_waiting++;
 			while (m_readers_active > 0 || m_writer != -1)
-				m_thread_blocker.block_indefinite(&m_mutex);
+			{
+				SpinLockGuardAsMutex smutex(_);
+				m_thread_blocker.block_indefinite(&smutex);
+			}
 			m_writers_waiting--;
 
 			m_writer = Thread::current_tid();
@@ -51,13 +57,13 @@ namespace Kernel
 		{
 			if (--m_writer_depth != 0)
 				return;
-			LockGuard _(m_mutex);
+			SpinLockGuard _(m_lock);
 			m_writer = -1;
 			m_thread_blocker.unblock();
 		}
 
 	private:
-		Mutex m_mutex;
+		SpinLock m_lock;
 		ThreadBlocker m_thread_blocker;
 		uint32_t m_readers_active  { 0 };
 		uint32_t m_writers_waiting { 0 };

kernel/include/kernel/Memory/PageTable.h

@@ -14,6 +14,12 @@ namespace Kernel
 		requires BAN::is_same_v<decltype(func()), void>;
 	};
 
+	template<typename F>
+	concept with_per_cpu_fast_page_callback = requires(F func, void* addr)
+	{
+		requires BAN::is_same_v<decltype(func(addr)), void>;
+	};
+
 	template<typename F>
 	concept with_fast_page_callback_error = requires(F func)
 	{
@@ -45,6 +51,10 @@ namespace Kernel
 			WriteThrough,
 		};
 
+		static constexpr bool full_tlb_flush_threshold = 32;
+
+		static constexpr size_t reserved_fast_pages = 0x10;
+
 	public:
 		static void initialize_fast_page();
 		static void initialize_and_load();
@@ -72,6 +82,18 @@ namespace Kernel
 			unmap_fast_page();
 		}
 
+		template<with_per_cpu_fast_page_callback F>
+		static void with_per_cpu_fast_page(paddr_t paddr, F callback)
+		{
+			const auto state = Processor::get_interrupt_state();
+			Processor::set_interrupt_state(InterruptState::Disabled);
+			const size_t index = Processor::current_index() + reserved_fast_pages;
+			void* addr = map_fast_page(index, paddr);
+			callback(addr);
+			unmap_fast_page(index);
+			Processor::set_interrupt_state(state);
+		}
+
 		template<with_fast_page_callback_error F>
 		static BAN::ErrorOr<void> with_fast_page(paddr_t paddr, F callback)
 		{
@@ -123,8 +145,8 @@ namespace Kernel
 		bool is_page_free(vaddr_t) const;
 		bool is_range_free(vaddr_t, size_t bytes) const;
 
-		bool reserve_page(vaddr_t, bool only_free = true, bool invalidate = true);
+		void reserve_page(vaddr_t);
-		bool reserve_range(vaddr_t, size_t bytes, bool only_free = true);
+		void reserve_range(vaddr_t, size_t bytes);
 
 		vaddr_t reserve_free_page(vaddr_t first_address, vaddr_t last_address = UINTPTR_MAX);
 		vaddr_t reserve_free_contiguous_pages(size_t page_count, vaddr_t first_address, vaddr_t last_address = UINTPTR_MAX);
@@ -133,6 +155,7 @@ namespace Kernel
 
 		void invalidate_page(vaddr_t addr, bool send_smp_message) { invalidate_range(addr, 1, send_smp_message); }
 		void invalidate_range(vaddr_t addr, size_t pages, bool send_smp_message);
+		void invalidate_full_address_space(bool global);
 
 		InterruptState lock() const { return m_lock.lock(); }
 		void unlock(InterruptState state) const { m_lock.unlock(state); }

kernel/include/kernel/Networking/E1000/Definitions.h

@@ -29,6 +29,7 @@ namespace Kernel
 		REG_TDLEN	= 0x3808,
 		REG_TDH		= 0x3810,
 		REG_TDT		= 0x3818,
+		REG_RXCSUM	= 0x5000,
 		REG_MTA		= 0x5200,
 	};
 
@@ -167,6 +168,15 @@ namespace Kernel
 		RCTL_BSIZE_16384	= (0b01 << 16) | RCTL_BSEX,
 	};
 
+	enum E1000_RXCSUM : uint32_t
+	{
+		RXSUM_IPOFLD  = 1 << 8,
+		RXSUM_TUOFLD  = 1 << 9,
+		RXSUM_CRCOFLD = 1 << 11,
+		RXSUM_IPPCE   = 1 << 12,
+		RXSUM_PCSD    = 1 << 13,
+	};
+
 	enum E1000_CMD : uint8_t
 	{
 		CMD_EOP		= 1 << 0,
@@ -178,6 +188,26 @@ namespace Kernel
 		CMD_IDE		= 1 << 7,
 	};
 
+	enum E1000_RX_STS : uint8_t
+	{
+		RX_STS_IPCS  = 1 << 6,
+		RX_STS_TCPCS = 1 << 5,
+		RX_STS_UDPCS = 1 << 5,
+		RX_STS_EOP   = 1 << 1,
+		RX_STS_DD    = 1 << 0,
+	};
+
+	enum E1000_RX_ERR : uint8_t
+	{
+		RX_ERR_RXE  = 1 << 7,
+		RX_ERR_IPE  = 1 << 6,
+		RX_ERR_TCPE = 1 << 5,
+		RX_ERR_CXE  = 1 << 4,
+		RX_ERR_SEQ  = 1 << 2,
+		RX_ERR_SE   = 1 << 1,
+		RX_ERR_CE   = 1 << 0,
+	};
+
 	struct e1000_rx_desc
 	{
 		uint64_t addr;

kernel/include/kernel/Networking/E1000/E1000.h

@@ -45,7 +45,7 @@ namespace Kernel
 		uint32_t read32(uint16_t reg);
 		void write32(uint16_t reg, uint32_t value);
 
-		BAN::ErrorOr<void> send_bytes(BAN::MACAddress destination, EtherType protocol, BAN::Span<const BAN::ConstByteSpan> payload) override;
+		BAN::ErrorOr<void> send_raw_bytes(BAN::Span<const BAN::ConstByteSpan> buffers) override;
 
 		bool can_read_impl() const override { return false; }
 		bool can_write_impl() const override { return false; }
@@ -74,8 +74,8 @@ namespace Kernel
 		BAN::UniqPtr<DMARegion>	m_rx_descriptor_region;
 		BAN::UniqPtr<DMARegion>	m_tx_descriptor_region;
 
-		BAN::Atomic<uint32_t> m_tx_head1 { 0 };
+		BAN::Atomic<uint32_t> m_tx_head   { 0 };
-		BAN::Atomic<uint32_t> m_tx_head2 { 0 };
+		BAN::Atomic<uint32_t> m_tx_commit { 0 };
 
 		SpinLock m_rx_lock;
 		ThreadBlocker m_rx_blocker;

kernel/include/kernel/Networking/IPv4Layer.h

@@ -41,14 +41,14 @@ namespace Kernel
 
 		ARPTable& arp_table() { return *m_arp_table; }
 
-		BAN::ErrorOr<void> handle_ipv4_packet(NetworkInterface&, BAN::ConstByteSpan);
+		BAN::ErrorOr<void> handle_ipv4_packet(NetworkInterface&, BAN::ConstByteSpan, uint32_t validated_cksums);
 
 		virtual void unbind_socket(uint16_t port) override;
 		virtual BAN::ErrorOr<void> bind_socket_with_target(BAN::RefPtr<NetworkSocket>, const sockaddr* target_address, socklen_t target_address_len) override;
 		virtual BAN::ErrorOr<void> bind_socket_to_address(BAN::RefPtr<NetworkSocket>, const sockaddr* address, socklen_t address_len) override;
 		virtual BAN::ErrorOr<void> get_socket_address(BAN::RefPtr<NetworkSocket>, sockaddr* address, socklen_t* address_len) override;
 
-		virtual BAN::ErrorOr<size_t> sendto(NetworkSocket&, BAN::ConstByteSpan, const sockaddr*, socklen_t) override;
+		virtual BAN::ErrorOr<void> sendto(NetworkSocket&, BAN::ConstByteSpan, const sockaddr*, socklen_t) override;
 
 		virtual Socket::Domain domain() const override { return Socket::Domain::INET ;}
 		virtual size_t header_size() const override { return sizeof(IPv4Header); }

kernel/include/kernel/Networking/Loopback.h

@@ -27,7 +27,7 @@ namespace Kernel
 		{}
 		~LoopbackInterface();
 
-		BAN::ErrorOr<void> send_bytes(BAN::MACAddress destination, EtherType protocol, BAN::Span<const BAN::ConstByteSpan> payload) override;
+		BAN::ErrorOr<void> send_raw_bytes(BAN::Span<const BAN::ConstByteSpan> buffers) override;
 
 		bool can_read_impl() const override { return false; }
 		bool can_write_impl() const override { return false; }
@@ -46,7 +46,7 @@ namespace Kernel
 		};
 
 	private:
-		Mutex m_buffer_lock;
+		SpinLock m_buffer_lock;
 		BAN::UniqPtr<VirtualRange> m_buffer;
 
 		uint32_t m_buffer_tail { 0 };

kernel/include/kernel/Networking/NetworkInterface.h

@@ -23,6 +23,13 @@ namespace Kernel
 		ARP = 0x0806,
 	};
 
+	enum NetworkChecksum : uint32_t
+	{
+		CKSUM_IPV4 = 1 << 0,
+		CKSUM_TCP  = 1 << 1,
+		CKSUM_UDP  = 1 << 2,
+	};
+
 	class NetworkInterface : public CharacterDevice
 	{
 		BAN_NON_COPYABLE(NetworkInterface);
@@ -59,11 +66,33 @@ namespace Kernel
 
 		virtual BAN::StringView name() const override { return m_name; }
 
-		BAN::ErrorOr<void> send_bytes(BAN::MACAddress destination, EtherType protocol, BAN::ConstByteSpan payload)
+		BAN::ErrorOr<void> send_with_ethernet_header(BAN::MACAddress dst_mac, EtherType ether_type, BAN::ConstByteSpan buffer)
 		{
-			return send_bytes(destination, protocol, { &payload, 1 });
+			BAN::ConstByteSpan buffer_array[1] { buffer };
+			return send_with_ethernet_header(dst_mac, ether_type, buffer_array);
 		}
-		virtual BAN::ErrorOr<void> send_bytes(BAN::MACAddress destination, EtherType protocol, BAN::Span<const BAN::ConstByteSpan> payload) = 0;
+
+		template<size_t SIZE>
+		BAN::ErrorOr<void> send_with_ethernet_header(BAN::MACAddress dst_mac, EtherType ether_type, const BAN::ConstByteSpan (&buffer_array)[SIZE])
+		{
+			const auto ethernet_header = EthernetHeader {
+				.dst_mac = dst_mac,
+				.src_mac = get_mac_address(),
+				.ether_type = ether_type,
+			};
+
+			BAN::ConstByteSpan new_buffer_array[SIZE + 1];
+			new_buffer_array[0] = BAN::ConstByteSpan::from(ethernet_header);
+			for (size_t i = 0; i < SIZE; i++)
+				new_buffer_array[i + 1] = buffer_array[i];
+
+			return send_raw_bytes({ new_buffer_array, SIZE + 1 });
+		}
+
+		virtual BAN::ErrorOr<void> send_raw_bytes(BAN::Span<const BAN::ConstByteSpan> buffers) = 0;
+
+	private:
+		BAN::ErrorOr<long> ioctl_impl(unsigned long, void*) override;
 
 	private:
 		const Type m_type;

kernel/include/kernel/Networking/NetworkLayer.h

@@ -27,7 +27,7 @@ namespace Kernel
 		virtual BAN::ErrorOr<void> bind_socket_to_address(BAN::RefPtr<NetworkSocket>, const sockaddr* address, socklen_t address_len) = 0;
 		virtual BAN::ErrorOr<void> get_socket_address(BAN::RefPtr<NetworkSocket>, sockaddr* address, socklen_t* address_len) = 0;
 
-		virtual BAN::ErrorOr<size_t> sendto(NetworkSocket&, BAN::ConstByteSpan, const sockaddr*, socklen_t) = 0;
+		virtual BAN::ErrorOr<void> sendto(NetworkSocket&, BAN::ConstByteSpan, const sockaddr*, socklen_t) = 0;
 
 		virtual Socket::Domain domain() const = 0;
 		virtual size_t header_size() const = 0;

kernel/include/kernel/Networking/NetworkManager.h

@@ -27,7 +27,7 @@ namespace Kernel
 		BAN::ErrorOr<BAN::RefPtr<Socket>> create_socket(Socket::Domain, Socket::Type, mode_t, uid_t, gid_t);
 		BAN::ErrorOr<void> connect_sockets(Socket::Domain, BAN::RefPtr<Socket>, BAN::RefPtr<Socket>);
 
-		void on_receive(NetworkInterface&, BAN::ConstByteSpan);
+		void on_receive(NetworkInterface&, BAN::ConstByteSpan, uint32_t validated_cksums);
 
 	private:
 		NetworkManager() {}

kernel/include/kernel/Networking/NetworkSocket.h

@@ -35,7 +35,7 @@ namespace Kernel
 		virtual void get_protocol_header(BAN::ByteSpan header, BAN::ConstByteSpan payload, uint16_t dst_port, PseudoHeader) = 0;
 		virtual NetworkProtocol protocol() const = 0;
 
-		virtual void receive_packet(BAN::ConstByteSpan, const sockaddr* sender, socklen_t sender_len) = 0;
+		virtual void receive_packet(BAN::ConstByteSpan, const sockaddr* sender, socklen_t sender_len, uint32_t validated_cksums) = 0;
 
 		bool is_bound() const { return m_address_len >= static_cast<socklen_t>(sizeof(sa_family_t)) && m_address.ss_family != AF_UNSPEC; }
 		in_port_t bound_port() const
@@ -54,7 +54,7 @@ namespace Kernel
 	protected:
 		NetworkSocket(NetworkLayer&, const Socket::Info&);
 
-		virtual BAN::ErrorOr<long> ioctl_impl(int request, void* arg) override;
+		virtual BAN::ErrorOr<long> ioctl_impl(unsigned long request, void* arg) override;
 		virtual BAN::ErrorOr<void> getsockname_impl(sockaddr*, socklen_t*) override;
 		virtual BAN::ErrorOr<void> getpeername_impl(sockaddr*, socklen_t*) override = 0;
 

kernel/include/kernel/Networking/RTL8169/Definitions.h

@@ -7,25 +7,25 @@ namespace Kernel
 
 	enum RTL8169_IO_REGS : uint16_t
 	{
-		RTL8169_IO_IDR0   = 0x00,
+		RTL8169_IO_IDR0    = 0x00,
-		RTL8169_IO_IDR1   = 0x01,
+		RTL8169_IO_IDR1    = 0x01,
-		RTL8169_IO_IDR2   = 0x02,
+		RTL8169_IO_IDR2    = 0x02,
-		RTL8169_IO_IDR3   = 0x03,
+		RTL8169_IO_IDR3    = 0x03,
-		RTL8169_IO_IDR4   = 0x04,
+		RTL8169_IO_IDR4    = 0x04,
-		RTL8169_IO_IDR5   = 0x05,
+		RTL8169_IO_IDR5    = 0x05,
 
-		RTL8169_IO_TNPDS  = 0x20,
+		RTL8169_IO_TNPDS   = 0x20,
-		RTL8169_IO_CR     = 0x37,
+		RTL8169_IO_CR      = 0x37,
-		RTL8169_IO_TPPoll = 0x38,
+		RTL8169_IO_TPPoll  = 0x38,
-		RTL8169_IO_IMR    = 0x3C,
+		RTL8169_IO_IMR     = 0x3C,
-		RTL8169_IO_ISR    = 0x3E,
+		RTL8169_IO_ISR     = 0x3E,
-		RTL8169_IO_TCR    = 0x40,
+		RTL8169_IO_TCR     = 0x40,
-		RTL8169_IO_RCR    = 0x44,
+		RTL8169_IO_RCR     = 0x44,
-		RTL8169_IO_9346CR = 0x50,
+		RTL8169_IO_PHYSts  = 0x6C,
-		RTL8169_IO_PHYSts = 0x6C,
+		RTL8169_IO_RMS     = 0xDA,
-		RTL8169_IO_RMS    = 0xDA,
+		RTL8169_IO_CPlusCR = 0xE0,
-		RTL8169_IO_RDSAR  = 0xE4,
+		RTL8169_IO_RDSAR   = 0xE4,
-		RTL8169_IO_MTPS   = 0xEC,
+		RTL8169_IO_MTPS    = 0xEC,
 	};
 
 	enum RTL8169_CR : uint8_t

kernel/include/kernel/Networking/RTL8169/RTL8169.h

@@ -20,7 +20,7 @@ namespace Kernel
 		virtual bool link_up() override { return m_link_up; }
 		virtual int link_speed() override;
 
-		virtual size_t payload_mtu() const override { return 7436 - sizeof(EthernetHeader); }
+		virtual size_t payload_mtu() const override { return 0x1FF8 - sizeof(EthernetHeader); }
 
 		virtual void handle_irq() override;
 
@@ -33,7 +33,7 @@ namespace Kernel
 
 		BAN::ErrorOr<void> initialize();
 
-		virtual BAN::ErrorOr<void> send_bytes(BAN::MACAddress destination, EtherType protocol, BAN::Span<const BAN::ConstByteSpan>) override;
+		virtual BAN::ErrorOr<void> send_raw_bytes(BAN::Span<const BAN::ConstByteSpan> buffers) override;
 
 		virtual bool can_read_impl() const override { return false; }
 		virtual bool can_write_impl() const override { return false; }
@@ -64,14 +64,17 @@ namespace Kernel
 		BAN::UniqPtr<DMARegion>	m_rx_descriptor_region;
 		BAN::UniqPtr<DMARegion>	m_tx_descriptor_region;
 
-		SpinLock m_lock;
+		BAN::Atomic<bool> m_rx_thread_should_die { false };
+		BAN::Atomic<bool> m_rx_thread_is_dead { true };
 
-		bool m_thread_should_die { false };
+		uint32_t m_rx_head { 0 };
-		BAN::Atomic<bool> m_thread_is_dead { true };
+		SpinLock m_rx_lock;
-		ThreadBlocker m_thread_blocker;
+		ThreadBlocker m_rx_blocker;
 
-		uint32_t m_rx_current { 0 };
+		BAN::Atomic<uint32_t> m_tx_head { 0 };
-		size_t m_tx_current { 0 };
+		BAN::Atomic<uint32_t> m_tx_commit { 0 };
+		SpinLock m_tx_lock;
+		ThreadBlocker m_tx_blocker;
 
 		BAN::MACAddress	m_mac_address {};
 		BAN::Atomic<bool> m_link_up { false };

kernel/include/kernel/Networking/TCPSocket.h

@@ -66,9 +66,9 @@ namespace Kernel
 		BAN::ErrorOr<void> getsockopt_impl(int, int, void*, socklen_t*) override;
 		BAN::ErrorOr<void> setsockopt_impl(int, int, const void*, socklen_t) override;
 
-		BAN::ErrorOr<long> ioctl_impl(int, void*) override;
+		BAN::ErrorOr<long> ioctl_impl(unsigned long, void*) override;
 
-		void receive_packet(BAN::ConstByteSpan, const sockaddr* sender, socklen_t sender_len) override;
+		void receive_packet(BAN::ConstByteSpan, const sockaddr* sender, socklen_t sender_len, uint32_t validated_cksums) override;
 
 		bool can_read_impl() const override;
 		bool can_write_impl() const override;

kernel/include/kernel/Networking/UDPSocket.h

@@ -31,7 +31,7 @@ namespace Kernel
 		void get_protocol_header(BAN::ByteSpan header, BAN::ConstByteSpan payload, uint16_t dst_port, PseudoHeader) override;
 
 	protected:
-		void receive_packet(BAN::ConstByteSpan, const sockaddr* sender, socklen_t sender_len) override;
+		void receive_packet(BAN::ConstByteSpan, const sockaddr* sender, socklen_t sender_len, uint32_t validated_cksums) override;
 
 		BAN::ErrorOr<void> connect_impl(const sockaddr*, socklen_t) override;
 		BAN::ErrorOr<void> bind_impl(const sockaddr* address, socklen_t address_len) override;
@@ -41,7 +41,7 @@ namespace Kernel
 		BAN::ErrorOr<void> getsockopt_impl(int, int, void*, socklen_t*) override;
 		BAN::ErrorOr<void> setsockopt_impl(int, int, const void*, socklen_t) override;
 
-		BAN::ErrorOr<long> ioctl_impl(int, void*) override;
+		BAN::ErrorOr<long> ioctl_impl(unsigned long, void*) override;
 
 		bool can_read_impl() const override { return !m_packets.empty(); }
 		bool can_write_impl() const override { return true; }

kernel/include/kernel/Networking/UNIX/Socket.h

@@ -30,6 +30,7 @@ namespace Kernel
 		virtual BAN::ErrorOr<void> bind_impl(const sockaddr*, socklen_t) override;
 		virtual BAN::ErrorOr<size_t> recvmsg_impl(msghdr& message, int flags) override;
 		virtual BAN::ErrorOr<size_t> sendmsg_impl(const msghdr& message, int flags) override;
+		virtual BAN::ErrorOr<void> getsockname_impl(sockaddr*, socklen_t*) override;
 		virtual BAN::ErrorOr<void> getpeername_impl(sockaddr*, socklen_t*) override;
 		virtual BAN::ErrorOr<void> getsockopt_impl(int, int, void*, socklen_t*) override;
 		virtual BAN::ErrorOr<void> setsockopt_impl(int, int, const void*, socklen_t) override;

kernel/include/kernel/OpenFileDescriptorSet.h

@@ -58,6 +58,8 @@ namespace Kernel
 		BAN::ErrorOr<size_t> recvmsg(int socket, msghdr& message, int flags);
 		BAN::ErrorOr<size_t> sendmsg(int socket, const msghdr& message, int flags);
 
+		int get_max_open_fd() const;
+
 		BAN::ErrorOr<VirtualFileSystem::File> file_of(int) const;
 		BAN::ErrorOr<BAN::String> path_of(int) const;
 		BAN::ErrorOr<BAN::RefPtr<Inode>> inode_of(int);

kernel/include/kernel/PCI.h

@@ -4,7 +4,6 @@
 #include <BAN/Vector.h>
 #include <kernel/ACPI/AML/Node.h>
 #include <kernel/Memory/Types.h>
-#include <kernel/Storage/StorageController.h>
 
 #include <sys/types.h>
 
@@ -179,7 +178,7 @@ namespace Kernel::PCI
 	private:
 		struct PCIeInfo
 		{
-			paddr_t bus_paddr[256];
+			paddr_t bus_paddr[256] {};
 		};
 
 		PCIManager() = default;

kernel/include/kernel/Process.h

@@ -44,10 +44,10 @@ namespace Kernel
 		~Process();
 		void cleanup_function(Thread*);
 
-		void register_to_scheduler();
+		BAN::ErrorOr<vaddr_t> setup_initial_process_stack(MemoryBackedRegion&, BAN::Span<BAN::String> argv, BAN::Span<BAN::String> envp, BAN::Span<LibELF::AuxiliaryVector> auxv);
+
 		void exit(int status, int signal);
 
-		void add_thread(Thread*);
 		// returns true if thread was the last one
 		bool on_thread_exit(Thread&);
 
@@ -68,7 +68,6 @@ namespace Kernel
 		BAN::ErrorOr<long> sys_exec(const char* path, const char* const* argv, const char* const* envp);
 
 		BAN::ErrorOr<long> sys_wait(pid_t pid, int* stat_loc, int options);
-		BAN::ErrorOr<long> sys_sleep(int seconds);
 		BAN::ErrorOr<long> sys_nanosleep(const timespec* rqtp, timespec* rmtp);
 		BAN::ErrorOr<long> sys_setitimer(int which, const itimerval* value, itimerval* ovalue);
 
@@ -137,7 +136,7 @@ namespace Kernel
 		BAN::ErrorOr<long> sys_recvmsg(int socket, msghdr* message, int flags);
 		BAN::ErrorOr<long> sys_sendmsg(int socket, const msghdr* message, int flags);
 
-		BAN::ErrorOr<long> sys_ioctl(int fildes, int request, void* arg);
+		BAN::ErrorOr<long> sys_ioctl(int fildes, unsigned long request, void* arg);
 
 		BAN::ErrorOr<long> sys_pselect(sys_pselect_t* arguments);
 		BAN::ErrorOr<long> sys_ppoll(pollfd* fds, nfds_t nfds, const timespec* tmp_p, const sigset_t* sigmask);
@@ -210,28 +209,31 @@ namespace Kernel
 		BAN::ErrorOr<long> sys_set_gsbase(void*);
 		BAN::ErrorOr<long> sys_get_gsbase();
 
-		BAN::ErrorOr<long> sys_pthread_create(const pthread_attr_t* attr, void (*entry)(void*), void* arg);
+		BAN::ErrorOr<long> sys_thread_create(void (*entry)(void*), void* arg, void* stack_base, size_t stack_size);
-		BAN::ErrorOr<long> sys_pthread_exit(void* value);
+		BAN::ErrorOr<long> sys_thread_exit(void* value);
-		BAN::ErrorOr<long> sys_pthread_join(pthread_t thread, void** value);
+		BAN::ErrorOr<long> sys_thread_join(pid_t tid, void** value);
-		BAN::ErrorOr<long> sys_pthread_self();
+		BAN::ErrorOr<long> sys_thread_getid();
-		BAN::ErrorOr<long> sys_pthread_kill(pthread_t thread, int signal);
+		BAN::ErrorOr<long> sys_thread_kill(pid_t tid, int signal);
-		BAN::ErrorOr<long> sys_pthread_detach(pthread_t thread);
+		BAN::ErrorOr<long> sys_thread_detach(pid_t tid);
 
 		BAN::ErrorOr<long> sys_clock_gettime(clockid_t, timespec*);
 
 		BAN::ErrorOr<long> sys_load_keymap(const char* path);
 
+		BAN::ErrorOr<long> sys_banos_install(const char* object);
+
 		BAN::RefPtr<TTY> controlling_terminal() { return m_controlling_terminal; }
 
 		static Process& current() { return Thread::current().process(); }
 
 		vaddr_t shared_page_vaddr() const { return m_shared_page_vaddr; }
 
-		PageTable& page_table() { return m_page_table ? *m_page_table : PageTable::kernel(); }
+		PageTable& page_table() { return *m_page_table; }
 
 		size_t proc_meminfo(off_t offset, BAN::ByteSpan) const;
 		size_t proc_cmdline(off_t offset, BAN::ByteSpan) const;
 		size_t proc_environ(off_t offset, BAN::ByteSpan) const;
+		size_t proc_cputime(off_t offset, BAN::ByteSpan) const;
 		BAN::ErrorOr<BAN::String> proc_cwd() const;
 		BAN::ErrorOr<BAN::String> proc_exe() const;
 
@@ -278,13 +280,12 @@ namespace Kernel
 		// You must hold reader end of m_mapped_region_lock when calling this.
 		size_t find_mapped_region(vaddr_t) const;
 
+		BAN::ErrorOr<AddressRange> find_free_address_range(size_t size);
+
 		BAN::ErrorOr<VirtualFileSystem::File> find_file(int fd, const char* path, int flags) const;
 		BAN::ErrorOr<FileParent> find_parent_file(int fd, const char* path, int flags) const;
 		BAN::ErrorOr<VirtualFileSystem::File> find_relative_parent(int fd, const char* path) const;
 
-		BAN::ErrorOr<void> read_from_user(const void* user_addr, void* out, size_t size);
-		BAN::ErrorOr<void> read_string_from_user(const char* user_addr, char* out, size_t max_size);
-		BAN::ErrorOr<void> write_to_user(void* user_addr, const void* in, size_t size);
 		BAN::ErrorOr<MemoryRegion*> validate_and_pin_pointer_access(const void*, size_t, bool needs_write);
 
 		uint64_t signal_pending_mask() const
@@ -363,13 +364,13 @@ namespace Kernel
 
 		BAN::Vector<Thread*> m_threads;
 
-		struct pthread_info_t
+		struct exited_thread_info_t
 		{
-			pthread_t thread;
+			pid_t tid;
 			void* value;
 		};
-		BAN::Vector<pthread_info_t> m_exited_pthreads;
+		BAN::Vector<exited_thread_info_t> m_exited_threads;
-		ThreadBlocker m_pthread_exit_blocker;
+		ThreadBlocker m_thread_exit_blocker;
 
 		uint64_t m_alarm_interval_ns { 0 };
 		uint64_t m_alarm_wake_time_ns { 0 };

kernel/include/kernel/Processor.h

@@ -29,6 +29,13 @@ namespace Kernel
 		BAN_NON_MOVABLE(Processor);
 
 	public:
+		struct TLBEntry
+		{
+			vaddr_t vaddr;
+			size_t page_count;
+			class PageTable* page_table;
+		};
+
 		struct SMPMessage
 		{
 			enum class Type
@@ -43,18 +50,19 @@ namespace Kernel
 			Type type;
 			union
 			{
-				struct
+				TLBEntry flush_tlb;
-				{
-					uintptr_t vaddr;
-					size_t page_count;
-					void* page_table;
-				} flush_tlb;
 				SchedulerQueue::Node* new_thread;
 				SchedulerQueue::Node* unblock_thread;
 				bool dummy;
 			};
 		};
 
+		struct LoadStats
+		{
+			uint64_t ns_idle;
+			uint64_t ns_total;
+		};
+
 	public:
 		static Processor& create(ProcessorID id);
 		static Processor& initialize();
@@ -70,9 +78,6 @@ namespace Kernel
 		static void set_smp_enabled() { s_is_smp_enabled = true; }
 		static void wait_until_processors_ready();
 
-		static void toggle_should_print_cpu_load() { s_should_print_cpu_load = !s_should_print_cpu_load; }
-		static bool get_should_print_cpu_load() { return s_should_print_cpu_load; }
-
 		static ProcessorID bsp_id() { return s_bsp_id; }
 		static bool current_is_bsp() { return current_id() == bsp_id(); }
 
@@ -114,10 +119,12 @@ namespace Kernel
 		static void* get_current_page_table()					{ return read_gs_sized<void*>(offsetof(Processor, m_current_page_table)); }
 		static void set_current_page_table(void* page_table)	{ write_gs_sized<void*>(offsetof(Processor, m_current_page_table), page_table); }
 
+		static LoadStats get_load_stats(size_t index);
+
 		static void yield();
 		static Scheduler& scheduler() { return *read_gs_sized<Scheduler*>(offsetof(Processor, m_scheduler)); }
 
-		static void initialize_tsc(uint8_t shift, uint64_t mult, uint64_t realtime_seconds);
+		static void initialize_tsc(uint64_t realtime_seconds);
 		static void update_tsc();
 		static uint64_t ns_since_boot_tsc();
 
@@ -130,7 +137,7 @@ namespace Kernel
 		static void handle_ipi();
 
 		static void handle_smp_messages();
-		static void send_smp_message(ProcessorID, const SMPMessage&, bool send_ipi = true);
+		static bool send_smp_message(ProcessorID, const SMPMessage&, bool send_ipi = true);
 		static void broadcast_smp_message(const SMPMessage&);
 
 		static void load_segments();
@@ -178,11 +185,13 @@ namespace Kernel
 			asm volatile("mov %[value], %%gs:%a[offset]" :: [value]"r"(value), [offset]"ir"(offset) : "memory");
 		}
 
+		void lock_tlb_lock();
+		void unlock_tlb_lock();
+
 	private:
 		static ProcessorID s_bsp_id;
 		static BAN::Atomic<uint8_t> s_processor_count;
 		static BAN::Atomic<bool>    s_is_smp_enabled;
-		static BAN::Atomic<bool>    s_should_print_cpu_load;
 		static paddr_t              s_shared_page_paddr;
 		static vaddr_t              s_shared_page_vaddr;
 
@@ -202,15 +211,19 @@ namespace Kernel
 
 		Scheduler* m_scheduler { nullptr };
 
-		uint64_t m_start_ns { 0 };
+		BAN::Atomic<bool> m_load_stat_lock;
-		uint64_t m_idle_ns { 0 };
+		uint64_t m_load_start_ns { 0 };
-		uint64_t m_last_update_ns { 0 };
+		LoadStats m_load_stats {};
-		uint64_t m_next_update_ns { 0 };
 
 		BAN::Atomic<SMPMessage*> m_smp_pending { nullptr };
 		BAN::Atomic<SMPMessage*> m_smp_free    { nullptr };
 		SMPMessage* m_smp_message_storage { nullptr };
 
+		BAN::Atomic<bool> m_tlb_lock { false };
+		size_t m_tlb_entry_count { 0 };
+		BAN::Array<TLBEntry, 32> m_tlb_entries;
+		bool m_tlb_global { false };
+
 		void* m_current_page_table { nullptr };
 
 		friend class BAN::Array<Processor, 0xFF>;

kernel/include/kernel/Scheduler.h

@@ -23,7 +23,7 @@ namespace Kernel
 
 	public:
 		void add_thread_to_back(Node*);
-		void add_thread_with_wake_time(Node*);
+		bool add_thread_with_wake_time(Node*); // return true if node was inserted as the first element
 		template<typename F>
 		Node* remove_with_condition(F callback);
 		void remove_node(Node*);
@@ -60,7 +60,8 @@ namespace Kernel
 		void reschedule(YieldRegisters*);
 		void reschedule_if_idle();
 
-		void timer_interrupt();
+		void on_timer_interrupt();
+		void on_yield(YieldRegisters*);
 
 		static BAN::ErrorOr<void> bind_thread_to_processor(Thread*, ProcessorID);
 		// if thread is already bound, this will never fail
@@ -82,6 +83,7 @@ namespace Kernel
 		void update_most_loaded_node_queue(SchedulerQueue::Node*, SchedulerQueue* target_queue);
 		void remove_node_from_most_loaded(SchedulerQueue::Node*);
 
+		void update_wake_up_deadline();
 		void wake_up_sleeping_threads();
 
 		void do_load_balancing();

kernel/include/kernel/Storage/ATA/AHCI/Controller.h

@@ -10,12 +10,14 @@
 namespace Kernel
 {
 
-	class AHCIController final : public StorageController, public Interruptable
+	class AHCIController final : public BAN::RefCounted<AHCIController>, public Interruptable
 	{
 		BAN_NON_COPYABLE(AHCIController);
 		BAN_NON_MOVABLE(AHCIController);
 
 	public:
+		static BAN::ErrorOr<BAN::RefPtr<AHCIController>> create(PCI::Device&);
+
 		~AHCIController();
 
 		virtual void handle_irq() override;
@@ -27,6 +29,7 @@ namespace Kernel
 			: m_pci_device(pci_device)
 		{ }
 		BAN::ErrorOr<void> initialize();
+
 		BAN::Optional<AHCIPortType> check_port_type(volatile HBAPortMemorySpace&);
 
 	private:

kernel/include/kernel/Storage/ATA/ATABus.h

@@ -56,8 +56,6 @@ namespace Kernel
 
 		// Non-owning pointers
 		BAN::Vector<ATADevice*> m_devices;
-
-		friend class ATAController;
 	};
 
 }

kernel/include/kernel/Storage/ATA/ATAController.h

@@ -2,23 +2,22 @@
 
 #include <BAN/UniqPtr.h>
 #include <kernel/PCI.h>
-#include <kernel/Storage/StorageController.h>
 #include <kernel/Storage/ATA/ATABus.h>
 #include <kernel/Storage/ATA/ATADevice.h>
 
 namespace Kernel
 {
 
-	class ATAController : public StorageController
+	class ATAController : public BAN::RefCounted<ATAController>
 	{
 	public:
-		static BAN::ErrorOr<BAN::RefPtr<StorageController>> create(PCI::Device&);
+		static BAN::ErrorOr<BAN::RefPtr<ATAController>> create(PCI::Device&);
-		virtual BAN::ErrorOr<void> initialize() override;
 
 	private:
 		ATAController(PCI::Device& pci_device)
 			: m_pci_device(pci_device)
 		{ }
+		BAN::ErrorOr<void> initialize();
 
 	private:
 		PCI::Device& m_pci_device;

kernel/include/kernel/Storage/NVMe/Controller.h

@@ -10,13 +10,13 @@
 namespace Kernel
 {
 
-	class NVMeController final : public StorageController, public CharacterDevice
+	class NVMeController final : public CharacterDevice
 	{
 		BAN_NON_COPYABLE(NVMeController);
 		BAN_NON_MOVABLE(NVMeController);
 
 	public:
-		static BAN::ErrorOr<BAN::RefPtr<StorageController>> create(PCI::Device&);
+		static BAN::ErrorOr<BAN::RefPtr<NVMeController>> create(PCI::Device&);
 
 		NVMeQueue& io_queue() { return *m_io_queue; }
 
@@ -30,7 +30,7 @@ namespace Kernel
 
 	private:
 		NVMeController(PCI::Device& pci_device);
-		virtual BAN::ErrorOr<void> initialize() override;
+		BAN::ErrorOr<void> initialize();
 
 		BAN::ErrorOr<void> identify_controller();
 		BAN::ErrorOr<void> identify_namespaces();

kernel/include/kernel/Storage/StorageController.h

@@ -1,15 +0,0 @@
-#pragma once
-
-#include <BAN/RefPtr.h>
-
-namespace Kernel
-{
-
-	class StorageController : public BAN::RefCounted<StorageController>
-	{
-	public:
-		virtual ~StorageController() {}
-		virtual BAN::ErrorOr<void> initialize() = 0;
-	};
-
-}

kernel/include/kernel/Terminal/PseudoTerminal.h

@@ -32,7 +32,7 @@ namespace Kernel
 
 		void on_close(int) override;
 
-		BAN::ErrorOr<long> ioctl_impl(int, void*) override;
+		BAN::ErrorOr<long> ioctl_impl(unsigned long, void*) override;
 
 	private:
 		PseudoTerminalMaster(BAN::UniqPtr<VirtualRange>, mode_t, uid_t, gid_t);

kernel/include/kernel/Terminal/TTY.h

@@ -68,7 +68,7 @@ namespace Kernel
 		virtual bool has_error_impl() const override { return false; }
 		virtual bool has_hungup_impl() const override { return false; }
 
-		virtual BAN::ErrorOr<long> ioctl_impl(int, void*) override;
+		virtual BAN::ErrorOr<long> ioctl_impl(unsigned long, void*) override;
 
 	private:
 		bool putchar(uint8_t ch);

kernel/include/kernel/Thread.h

@@ -41,22 +41,20 @@ namespace Kernel
 		// TODO: userspace stack size is hard limited, maybe make this dynamic?
 #if ARCH(x86_64)
 		static constexpr size_t userspace_stack_size { 32 << 20 };
+		static constexpr vaddr_t userspace_stack_base { 0x0000700000000000 };
 #elif ARCH(i686)
 		static constexpr size_t userspace_stack_size { 4 << 20 };
+		static constexpr vaddr_t userspace_stack_base { 0xB0000000 };
 #endif
 
 	public:
 		static BAN::ErrorOr<Thread*> create_kernel(entry_t, void*);
-		static BAN::ErrorOr<Thread*> create_userspace(Process*, PageTable&);
+		static BAN::ErrorOr<Thread*> create_userspace(Process*, PageTable&, vaddr_t userspace_stack_vaddr, size_t userspace_stack_size, vaddr_t entry_point, vaddr_t stack_pointer);
 		~Thread();
 
-		BAN::ErrorOr<Thread*> pthread_create(entry_t, void*);
-
 		BAN::ErrorOr<Thread*> clone(Process*, uintptr_t sp, uintptr_t ip);
 		void setup_process_cleanup();
 
-		BAN::ErrorOr<void> initialize_userspace(vaddr_t entry, BAN::Span<BAN::String> argv, BAN::Span<BAN::String> envp, BAN::Span<LibELF::AuxiliaryVector> auxv);
-
 		// Returns true, if thread is going to trigger signal
 		bool is_interrupted_by_signal(bool skip_stop_and_cont = false) const;
 
@@ -77,15 +75,21 @@ namespace Kernel
 
 		// blocks current thread and returns either on unblock, eintr, spuriously or after timeout
 		// if mutex is not nullptr, it will be atomically freed before blocking and automatically locked on wake
-		BAN::ErrorOr<void> sleep_or_eintr_ns(uint64_t ns);
+		BAN::ErrorOr<void> sleep_or_eintr_for_ns(uint64_t timeout_ns);
+		BAN::ErrorOr<void> sleep_or_eintr_until_ns(uint64_t waketime_ns);
 		BAN::ErrorOr<void> block_or_eintr_indefinite(ThreadBlocker& thread_blocker, BaseMutex* mutex);
 		BAN::ErrorOr<void> block_or_eintr_or_timeout_ns(ThreadBlocker& thread_blocker, uint64_t timeout_ns, bool etimedout, BaseMutex* mutex);
 		BAN::ErrorOr<void> block_or_eintr_or_waketime_ns(ThreadBlocker& thread_blocker, uint64_t wake_time_ns, bool etimedout, BaseMutex* mutex);
 
-		BAN::ErrorOr<void> sleep_or_eintr_ms(uint64_t ms)
+		BAN::ErrorOr<void> sleep_or_eintr_for_ms(uint64_t timeout_ms)
 		{
-			ASSERT(!BAN::Math::will_multiplication_overflow<uint64_t>(ms, 1'000'000));
+			ASSERT(!BAN::Math::will_multiplication_overflow<uint64_t>(timeout_ms, 1'000'000));
-			return sleep_or_eintr_ns(ms * 1'000'000);
+			return sleep_or_eintr_for_ns(timeout_ms * 1'000'000);
+		}
+		BAN::ErrorOr<void> sleep_or_eintr_until_ms(uint64_t waketime_ms)
+		{
+			ASSERT(!BAN::Math::will_multiplication_overflow<uint64_t>(waketime_ms, 1'000'000));
+			return sleep_or_eintr_until_ns(waketime_ms * 1'000'000);
 		}
 		BAN::ErrorOr<void> block_or_eintr_or_timeout_ms(ThreadBlocker& thread_blocker, uint64_t timeout_ms, bool etimedout, BaseMutex* mutex)
 		{
@@ -106,8 +110,6 @@ namespace Kernel
 		vaddr_t kernel_stack_top() const	{ return m_kernel_stack->vaddr() + m_kernel_stack->size(); }
 		VirtualRange& kernel_stack() { return *m_kernel_stack; }
 
-		MemoryBackedRegion& userspace_stack() { ASSERT(is_userspace() && m_userspace_stack); return *m_userspace_stack; }
-
 		static Thread& current();
 		static pid_t current_tid();
 
@@ -151,8 +153,6 @@ namespace Kernel
 	private:
 		Thread(pid_t tid, Process*);
 
-		void setup_exec(vaddr_t ip, vaddr_t sp);
-
 		static void on_exit_trampoline(Thread*);
 		void on_exit();
 
@@ -174,7 +174,6 @@ namespace Kernel
 		BAN::UniqPtr<PageTable>    m_keep_alive_page_table;
 
 		BAN::UniqPtr<VirtualRange> m_kernel_stack;
-		MemoryBackedRegion*        m_userspace_stack      { nullptr };
 		const pid_t                m_tid                  { 0 };
 		State                      m_state                { State::NotStarted };
 		Process*                   m_process              { nullptr };
@@ -182,6 +181,9 @@ namespace Kernel
 		BAN::Atomic<bool>          m_is_detached          { false };
 		bool                       m_delete_process       { false };
 
+		vaddr_t                    m_userspace_stack_vaddr { 0 };
+		size_t                     m_userspace_stack_size  { 0 };
+
 		vaddr_t                    m_fsbase               { 0 };
 		vaddr_t                    m_gsbase               { 0 };
 

kernel/include/kernel/Timer/HPET.h

@@ -12,7 +12,7 @@ namespace Kernel
 	class HPET final : public Timer, public Interruptable
 	{
 	public:
-		static BAN::ErrorOr<BAN::UniqPtr<HPET>> create(bool force_pic);
+		static BAN::ErrorOr<BAN::UniqPtr<HPET>> create();
 		~HPET();
 
 		virtual uint64_t ms_since_boot() const override;
@@ -26,7 +26,7 @@ namespace Kernel
 
 	private:
 		HPET() = default;
-		BAN::ErrorOr<void> initialize(bool force_pic);
+		BAN::ErrorOr<void> initialize();
 
 		volatile HPETRegisters& registers();
 		const volatile HPETRegisters& registers() const;

kernel/include/kernel/Timer/Timer.h

@@ -2,6 +2,7 @@
 
 #include <BAN/UniqPtr.h>
 #include <BAN/Vector.h>
+#include <kernel/Memory/DMARegion.h>
 #include <kernel/Timer/RTC.h>
 
 #include <time.h>
@@ -31,7 +32,14 @@ namespace Kernel
 	class SystemTimer : public Timer
 	{
 	public:
-		static void initialize(bool force_pic);
+		struct TSCInfo
+		{
+			int8_t shift;
+			uint32_t mult;
+		};
+
+	public:
+		static void initialize();
 		static SystemTimer& get();
 		static bool is_initialized();
 
@@ -44,29 +52,60 @@ namespace Kernel
 		virtual bool pre_scheduler_sleep_needs_lock() const override;
 		virtual void pre_scheduler_sleep_ns(uint64_t) override;
 
-		void sleep_ms(uint64_t ms) const { ASSERT(!BAN::Math::will_multiplication_overflow<uint64_t>(ms, 1'000'000)); return sleep_ns(ms * 1'000'000); }
+		void sleep_for_ns(uint64_t timeout_ns) const;
-		void sleep_ns(uint64_t ns) const;
+		void sleep_until_ns(uint64_t waketime_ns) const;
+
+		void sleep_for_ms(uint64_t timeout_ms) const
+		{
+			ASSERT(!BAN::Math::will_multiplication_overflow<uint64_t>(timeout_ms, 1'000'000));
+			return sleep_for_ns(timeout_ms * 1'000'000);
+		}
+		void sleep_until_ms(uint64_t waketime_ms) const
+		{
+			ASSERT(!BAN::Math::will_multiplication_overflow<uint64_t>(waketime_ms, 1'000'000));
+			return sleep_until_ns(waketime_ms * 1'000'000);
+		}
 
 		void dont_invoke_scheduler() { m_timer->m_should_invoke_scheduler = false; }
 
-		void update_tsc() const;
+		void update_tsc();
-		uint64_t ns_since_boot_no_tsc() const;
+		TSCInfo tsc_info() const;
+
+		uint64_t ns_since_boot_no_tsc() const { return m_timer->ns_since_boot(); }
 
 		timespec real_time() const;
 
 	private:
 		SystemTimer() = default;
 
-		void initialize_timers(bool force_pic);
+		void initialize_timers();
 
-		uint64_t get_tsc_frequency() const;
+		void initialize_invariant_tsc();
+		void initialize_pvclock();
 
 	private:
+		enum class TSCType
+		{
+			None,
+			Invariant,
+			PVClock,
+		};
+
 		uint64_t m_boot_time { 0 };
 		BAN::UniqPtr<RTC> m_rtc;
 		BAN::UniqPtr<Timer> m_timer;
-		bool m_has_invariant_tsc { false };
+
-		mutable uint32_t m_timer_ticks { 0 };
+		TSCType m_tsc_type = TSCType::None;
+
+		union {
+			struct {
+				int8_t shift;
+				uint32_t mult;
+			} invariant;
+		} m_tsc_info;
+
+		BAN::UniqPtr<DMARegion> m_tsc_page;
+		uint64_t m_tsc_update_ns { 0 };
 	};
 
 }

kernel/include/kernel/USB/HID/Joystick.h

@@ -34,7 +34,7 @@ namespace Kernel
 		BAN::ErrorOr<size_t> read_impl(off_t, BAN::ByteSpan) override;
 		bool can_read_impl() const override { return true; }
 
-		BAN::ErrorOr<long> ioctl_impl(int request, void* arg) override;
+		BAN::ErrorOr<long> ioctl_impl(unsigned long request, void* arg) override;
 
 	private:
 		USBJoystick(USBHIDDriver&);

kernel/include/kernel/USB/MassStorage/SCSIDevice.h

@@ -33,7 +33,7 @@ namespace Kernel
 		const uint64_t m_block_count;
 		const uint32_t m_block_size;
 
-		const char m_name[4];
+		char m_name[4];
 
 		friend class BAN::RefPtr<USBSCSIDevice>;
 	};

kernel/include/kernel/UserCopy.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <BAN/Errors.h>
+
+namespace Kernel
+{
+
+	BAN::ErrorOr<void> read_from_user(const void* user_addr, void* out, size_t size);
+	BAN::ErrorOr<void> read_string_from_user(const char* user_addr, char* out, size_t max_size);
+	BAN::ErrorOr<void> write_to_user(void* user_addr, const void* in, size_t size);
+
+};

kernel/kernel/ACPI/ACPI.cpp

@@ -952,7 +952,7 @@ acpi_release_global_lock:
 			{
 				if (IO::inw(fadt().pm1a_cnt_blk) & PM1_CNT_SCI_EN)
 					break;
-				SystemTimer::get().sleep_ms(10);
+				SystemTimer::get().sleep_for_ms(10);
 			}
 
 			if (!(IO::inw(fadt().pm1a_cnt_blk) & PM1_CNT_SCI_EN))

kernel/kernel/ACPI/AML/Node.cpp

@@ -2146,9 +2146,9 @@ namespace Kernel::ACPI::AML
 
 		auto milliseconds = TRY(convert_node(TRY(parse_node(context)), ConvInteger, sizeof(uint64_t)));
 
-		const uint64_t wakeup_ms = SystemTimer::get().ms_since_boot() + milliseconds.as.integer.value;
+		const uint64_t waketime_ms = SystemTimer::get().ms_since_boot() + milliseconds.as.integer.value;
-		for (uint64_t curr_ms = SystemTimer::get().ms_since_boot(); curr_ms < wakeup_ms; curr_ms = SystemTimer::get().ms_since_boot())
+		while (SystemTimer::get().ms_since_boot() < waketime_ms)
-			SystemTimer::get().sleep_ms(wakeup_ms - curr_ms);
+			SystemTimer::get().sleep_until_ms(waketime_ms);
 
 		return {};
 	}
@@ -2392,7 +2392,7 @@ namespace Kernel::ACPI::AML
 		result.type = Node::Type::Integer;
 		result.as.integer.value = BAN::numeric_limits<uint64_t>::max();
 
-		const uint64_t wake_time_ms = (timeout_ms >= 0xFFFF)
+		const uint64_t waketime_ms = (timeout_ms >= 0xFFFF)
 			? BAN::numeric_limits<uint64_t>::max()
 			: SystemTimer::get().ms_since_boot() + timeout_ms;
 
@@ -2401,9 +2401,9 @@ namespace Kernel::ACPI::AML
 		{
 			if (sync_object->node.as.mutex->mutex.try_lock())
 				break;
-			if (SystemTimer::get().ms_since_boot() >= wake_time_ms)
+			if (SystemTimer::get().ms_since_boot() >= waketime_ms)
 				return result;
-			SystemTimer::get().sleep_ms(1);
+			Processor::yield();
 		}
 
 		if (sync_object->node.as.mutex->global_lock)

kernel/kernel/APIC.cpp

@@ -437,8 +437,27 @@ namespace Kernel
 
 		dprintln("CPU {}: lapic timer frequency: {} Hz", Kernel::Processor::current_id(), m_lapic_timer_frequency_hz);
 
-		write_to_local_apic(LAPIC_TIMER_LVT,         TimerModePeriodic | IRQ_TIMER);
+		write_to_local_apic(LAPIC_TIMER_LVT,         TimerModeOneShot | IRQ_TIMER);
-		write_to_local_apic(LAPIC_TIMER_INITIAL_REG, m_lapic_timer_frequency_hz / 2 / 100);
+		write_to_local_apic(LAPIC_TIMER_INITIAL_REG, 0);
+	}
+
+	void APIC::set_timer_dealine(uint64_t target_ns)
+	{
+		// TODO: don't hardcode divide by 2
+		const uint64_t effective_freq = m_lapic_timer_frequency_hz / 2;
+
+		const uint64_t delta_ns = [&]() -> uint64_t {
+			const uint64_t current_ns = SystemTimer::get().ns_since_boot();
+			if (current_ns >= target_ns)
+				return 1;
+			const uint64_t delta_ns = target_ns - current_ns;
+			if (BAN::Math::will_multiplication_overflow(delta_ns, effective_freq))
+				return BAN::numeric_limits<uint64_t>::max() / effective_freq;
+			return delta_ns;
+		}();
+
+		const uint64_t ticks = BAN::Math::div_round_up<uint64_t>(delta_ns * effective_freq, 1'000'000'000);
+		write_to_local_apic(LAPIC_TIMER_INITIAL_REG, BAN::Math::min<uint64_t>(ticks, BAN::numeric_limits<uint32_t>::max()));
 	}
 
 	uint32_t APIC::read_from_local_apic(ptrdiff_t offset)

kernel/kernel/Audio/Controller.cpp

@@ -77,9 +77,9 @@ namespace Kernel
 		return to_copy;
 	}
 
-	BAN::ErrorOr<long> AudioController::ioctl_impl(int cmd, void* arg)
+	BAN::ErrorOr<long> AudioController::ioctl_impl(unsigned long request, void* arg)
 	{
-		switch (cmd)
+		switch (request)
 		{
 			case SND_GET_CHANNELS:
 				*static_cast<uint32_t*>(arg) = get_channels();
@@ -92,7 +92,7 @@ namespace Kernel
 			{
 				SpinLockGuard _(m_spinlock);
 				*static_cast<uint32_t*>(arg) = m_sample_data->size();
-				if (cmd == SND_RESET_BUFFER)
+				if (request == SND_RESET_BUFFER)
 					m_sample_data->pop(m_sample_data->size());
 				return 0;
 			}
@@ -113,7 +113,7 @@ namespace Kernel
 				return 0;
 		}
 
-		return CharacterDevice::ioctl_impl(cmd, arg);
+		return CharacterDevice::ioctl_impl(request, arg);
 	}
 
 }

kernel/kernel/Audio/HDAudio/AudioFunctionGroup.cpp

@@ -448,7 +448,7 @@ namespace Kernel
 				continue;
 			const auto& amp = path[i]->output_amplifier.value();
 
-			const int32_t step_mdB = amp.step_size * 250;
+			const int32_t step_mdB = (amp.step_size + 1) * 250;
 			m_volume_info.step_mdB = step_mdB;
 			m_volume_info.min_mdB = -amp.offset * step_mdB;
 			m_volume_info.max_mdB = (amp.num_steps - amp.offset) * step_mdB;

kernel/kernel/Audio/HDAudio/Controller.cpp

@@ -113,7 +113,7 @@ namespace Kernel
 		// 4.3 The software must wait at least 521 us (25 frames) after reading CRST as a 1
 		// before assuming that codecs have all made status change requests and have been
 		// registered by the controller
-		SystemTimer::get().sleep_ms(1);
+		SystemTimer::get().sleep_for_ns(521'000);
 
 		return {};
 	}

kernel/kernel/Banos.cpp

@@ -0,0 +1,215 @@
+#include <kernel/Debug.h>
+#include <kernel/Banos.h>
+#include <BAN/Assert.h>
+#include <banos/driver.h>
+#include <banos/print.h>
+#include <banos/export.h>
+#include <kernel/FS/VirtualFileSystem.h>
+#include <kernel/Memory/PageTable.h>
+#include <kernel/ELF.h>
+#include <LibELF/Types.h>
+#include <LibELF/Values.h>
+#include <kernel/Process.h>
+#include <BAN/HashMap.h>
+#include <kernel/Lock/SpinLock.h>
+#include <kernel/UserCopy.h>
+
+using namespace LibELF;
+using namespace Kernel;
+
+extern "C" {
+	void banos_dprintln(const char* str) {
+		dprintln("{}", str);
+	}
+	void* banos_lookup_symbol(const char* str) {
+		return Banos::resolve_symbol(str);
+	}
+}
+BANOS_EXPORT(banos_dprintln);
+BANOS_EXPORT(banos_lookup_symbol);
+
+BAN::HashMap<BAN::StringView, void*> g_banos_symbols;
+void* Banos::resolve_symbol(const char* name) {
+	auto it = g_banos_symbols.find(name);
+	return it == g_banos_symbols.end() ? NULL : it->value;
+}
+void Banos::import_symbols(Banos_Symbol* symbols, size_t count) {
+	for(size_t i = 0; i < count; ++i) {
+		auto sym = symbols + i;
+		MUST(g_banos_symbols.insert(sym->name, sym->arg));
+	}
+}
+// TODO: driver unloading with a reference counter
+struct Driver_Instance {
+	Banos_Driver* drv;
+};
+static BAN::Vector<Driver_Instance> s_driver_instaces;
+static SpinLock s_driver_instaces_lock;
+
+extern Banos_Symbol g_banos_export[],
+					g_banos_export_end[];
+static void load_drv(Banos_Driver* drv) {
+	ASSERT(drv->driver_size >= sizeof(Banos_Driver));
+	dprintln("Loading driver:");
+	dprintln("  name: {}", drv->name);
+	if(drv->license) dprintln("  license: {}", drv->license);
+	dprintln("  version: {}.{}.{}", BANOS_VERSION_GET_MAJOR(drv->version), BANOS_VERSION_GET_MINOR(drv->version), BANOS_VERSION_GET_PATCH(drv->version));
+	int e = drv->init(drv);
+	if(e < 0) dprintln(" Failed to init {} => {}", drv->name, -e);
+}
+BAN::ErrorOr<size_t> Banos::load_driver_from_image(const char* u_image) {
+	if(!Process::current().credentials().is_superuser()) return BAN::Error::from_errno(EPERM);
+	// TODO: permission verification. Only root should be allowed to do this
+	LibELF::ElfNativeFileHeader header;
+
+	const unsigned char elf_class =
+		#if ARCH(i686)
+			ELFCLASS32;
+		#elif ARCH(x86_64)
+			ELFCLASS64;
+		#else
+		#   error update elf class
+		#endif
+
+	// TODO: is banan-os really ever gonna be running on MSB machines?
+	const unsigned char elf_data = ELFDATA2LSB;
+	// TODO: do we need to verify e_machine? I mean we do not really care.
+	// But I'm leaving this todo:
+	//   Look up EM_X86_64 and EM_360|EM_860|EM_960
+	TRY(read_from_user(u_image, &header, sizeof header));
+	if( header.e_ident[EI_MAG0]	   != ELFMAG0        ||
+		header.e_ident[EI_MAG1]	   != ELFMAG1        ||
+		header.e_ident[EI_MAG2]	   != ELFMAG2        ||
+		header.e_ident[EI_MAG3]	   != ELFMAG3        ||
+		header.e_ident[EI_CLASS]   != elf_class	     ||
+		header.e_ident[EI_DATA]	   != elf_data       ||
+		header.e_ident[EI_VERSION] != EV_CURRENT     ||
+		header.e_type			   != ET_REL         ||
+		header.e_version		   != EV_CURRENT     ||
+		header.e_ehsize			   != sizeof(header) ||
+		header.e_shentsize		   != sizeof(ElfNativeSectionHeader))
+		return BAN::Error::from_errno(EINVAL);
+
+
+	BAN::Vector<LibELF::ElfNativeSectionHeader> secs(header.e_shnum);
+	TRY(read_from_user(u_image + header.e_shoff, secs.data(), secs.size() * sizeof(*secs.data())));
+	auto shstr = secs[header.e_shstrndx];
+
+	size_t total_size = 0;
+
+	LibELF::ElfNativeSectionHeader  *strtab = nullptr,
+									*symtab = nullptr,
+									*driver_section = nullptr;
+
+	for(auto& sec : secs) {
+		if(sec.sh_flags & LibELF::SHF_ALLOC) {
+			sec.sh_addr = total_size;
+			total_size += sec.sh_size;
+		}
+		if(sec.sh_name == 0) continue;
+		char name[256];
+		TRY(read_string_from_user(u_image + shstr.sh_offset + sec.sh_name, name, sizeof name));
+		BAN::StringView name_sv(name);
+
+		if(sec.sh_type == LibELF::SHT_SYMTAB) {
+			symtab = &sec;
+		}
+		// TODO: verify sh_type for both of these?
+		if(name_sv == ".strtab") {
+			strtab = &sec;
+		} else if(name_sv == ".banos-driver") {
+			driver_section = &sec;
+		}
+	}
+	if(!symtab || !strtab || !driver_section)
+		return BAN::Error::from_errno(EINVAL);
+	total_size += PAGE_SIZE;
+	total_size &= ~(PAGE_SIZE-1);
+	auto driver = TRY(VirtualRange::create_to_vaddr_range(PageTable::kernel(), { KERNEL_OFFSET, UINTPTR_MAX }, total_size, PageTable::Execute | PageTable::ReadWrite | PageTable::Present, true));
+
+	for(auto& sec : secs) {
+		if(sec.sh_flags & LibELF::SHF_ALLOC) {
+			sec.sh_addr += driver->vaddr();
+		}
+	}
+	Banos_Driver* banos_driver = reinterpret_cast<Banos_Driver*>(driver_section->sh_addr);
+	for(auto& sec : secs) {
+		if(sec.sh_name == 0) continue;
+		if(sec.sh_flags & LibELF::SHF_ALLOC) {
+			TRY(read_from_user(u_image + sec.sh_offset, reinterpret_cast<char*>(sec.sh_addr), sec.sh_size));
+		}
+		if(sec.sh_type == LibELF::SHT_RELA) {
+			auto& link_sec = secs[sec.sh_info];
+			size_t rela_count = sec.sh_size/sizeof(LibELF::ElfNativeRelocationA);
+			BAN::Vector<LibELF::ElfNativeRelocationA> rela_data(rela_count);
+			TRY(read_from_user(u_image + sec.sh_offset, rela_data.data(), rela_count * sizeof *rela_data.data()));
+
+			for(auto rela : rela_data) {
+				auto type   = ELF64_R_TYPE(rela.r_info);
+				auto symbol = ELF64_R_SYM(rela.r_info);
+
+				vaddr_t value = 0;
+
+				LibELF::ElfNativeSymbol sym;
+				TRY(read_from_user(u_image + symtab->sh_offset + sizeof(sym) * symbol, &sym, sizeof sym));
+
+				if(sym.st_shndx) {
+					value = secs[sym.st_shndx].sh_addr;
+				} else {
+					char name[256];
+					TRY(read_string_from_user(u_image + strtab->sh_offset + sym.st_name, name, sizeof name));
+
+					value = reinterpret_cast<vaddr_t>(Banos::resolve_symbol(name));
+					if(!value) {
+						derrorln("Failed to find symbol {}", name);
+						return BAN::Error::from_errno(ENOENT);
+					}
+				}
+				vaddr_t at = link_sec.sh_addr + rela.r_offset;
+				size_t size = 0;
+				switch(type) {
+				case LibELF::R_X86_64_PLT32:
+				case LibELF::R_X86_64_PC32:
+					value -= at;
+					// fallthrough
+				case LibELF::R_X86_64_32:
+				case LibELF::R_X86_64_32S:
+					value += rela.r_addend;
+					size = sizeof(uint32_t);
+					break;
+				case LibELF::R_X86_64_64:
+					value += rela.r_addend;
+					size = sizeof(uint64_t);
+					break;
+				default:
+					derrorln("TODO: Unsupported relocation type {}", type);
+					return BAN::Error::from_errno(ENOSYS);
+				}
+
+				switch(size) {
+				case 4: *reinterpret_cast<uint32_t*>(at) = value; break;
+				case 8: *reinterpret_cast<uint64_t*>(at) = value; break;
+				}
+			}
+		}
+	}
+	Driver_Instance instance;
+	instance.drv = banos_driver;
+	load_drv(instance.drv);
+	SpinLockGuard _(s_driver_instaces_lock);
+	TRY(s_driver_instaces.push_back(instance));
+	// TODO: import symbols and resolve redefintions :)
+	return s_driver_instaces.size() - 1;
+}
+// NOTE: should be more than plenty ;)
+extern char g_drv_builtin_begin[];
+extern char g_drv_builtin_end[];
+void Banos::initialize_initial_drivers(void) {
+	import_symbols(g_banos_export, g_banos_export_end - g_banos_export);
+	char* head = g_drv_builtin_begin;
+	while(head < g_drv_builtin_end) {
+		Banos_Driver* drv = (Banos_Driver*)head;
+		load_drv(drv);
+		head += drv->driver_size;
+	}
+}

kernel/kernel/CPUID.cpp

@@ -85,6 +85,38 @@ namespace CPUID
 		return buffer[3] & (1 << 8);
 	}
 
+	bool has_rdtscp()
+	{
+		uint32_t buffer[4] {};
+		get_cpuid(0x80000000, buffer);
+		if (buffer[0] < 0x80000001)
+			return false;
+		get_cpuid(0x80000001, buffer);
+		return buffer[3] & (1 << 27);
+	}
+
+	uint64_t get_tsc_frequency()
+	{
+		uint32_t buffer[4];
+		get_cpuid(0x00, buffer);
+		if (buffer[0] < 0x15)
+			return 0;
+		get_cpuid(0x15, buffer);
+		if (buffer[0] == 0 || buffer[1] == 0 || buffer[2] == 0)
+			return 0;
+		return static_cast<uint64_t>(buffer[2]) * buffer[1] / buffer[0];
+	}
+
+	bool has_kvm_pvclock()
+	{
+		uint32_t buffer[4] {};
+		get_cpuid(0x40000000, buffer);
+		if (buffer[1] != 0x4B4D564B || buffer[2] != 0x564B4D56 || buffer[3] != 0x4D)
+			return false;
+		get_cpuid(0x40000001, buffer);
+		return buffer[0] & (1 << 3);
+	}
+
 	const char* feature_string_ecx(uint32_t feat)
 	{
 		switch (feat)

kernel/kernel/Device/FramebufferDevice.cpp

@@ -135,9 +135,9 @@ namespace Kernel
 		return bytes_to_copy;
 	}
 
-	BAN::ErrorOr<long> FramebufferDevice::ioctl_impl(int cmd, void* arg)
+	BAN::ErrorOr<long> FramebufferDevice::ioctl_impl(unsigned long request, void* arg)
 	{
-		switch (cmd)
+		switch (request)
 		{
 			case FB_MSYNC_RECTANGLE:
 			{
@@ -152,7 +152,7 @@ namespace Kernel
 			}
 		}
 
-		return CharacterDevice::ioctl(cmd, arg);
+		return CharacterDevice::ioctl_impl(request, arg);
 	}
 
 	uint32_t FramebufferDevice::get_pixel(uint32_t x, uint32_t y) const
@@ -356,51 +356,7 @@ namespace Kernel
 
 		void do_msync(uint32_t first_pixel, uint32_t pixel_count)
 		{
-			if (!Processor::get_should_print_cpu_load())
+			m_framebuffer->sync_pixels_linear(first_pixel, pixel_count);
-				return m_framebuffer->sync_pixels_linear(first_pixel, pixel_count);
-
-			const uint32_t fb_width = m_framebuffer->width();
-
-			// If we are here (in FramebufferMemoryRegion), our terminal driver is FramebufferTerminalDriver
-			ASSERT(g_terminal_driver->has_font());
-			const auto& font = g_terminal_driver->font();
-
-			const uint32_t x = first_pixel % fb_width;
-			const uint32_t y = first_pixel / fb_width;
-
-			const uint32_t load_w = 16                 * font.width();
-			const uint32_t load_h = Processor::count() * font.height();
-
-			if (y >= load_h || x + pixel_count <= fb_width - load_w)
-				return m_framebuffer->sync_pixels_linear(first_pixel, pixel_count);
-
-			if (x >= fb_width - load_w && x + pixel_count <= fb_width)
-				return;
-
-			if (x < fb_width - load_w)
-				m_framebuffer->sync_pixels_linear(first_pixel, fb_width - load_w - x);
-
-			if (x + pixel_count > fb_width)
-			{
-				const uint32_t past_last_pixel = first_pixel + pixel_count;
-
-				first_pixel = (y + 1) * fb_width;
-				pixel_count = past_last_pixel - first_pixel;
-
-				const uint32_t cpu_load_end = load_h * fb_width;
-
-				while (pixel_count && first_pixel < cpu_load_end)
-				{
-					m_framebuffer->sync_pixels_linear(first_pixel, BAN::Math::min(pixel_count, fb_width - load_w));
-
-					const uint32_t advance = BAN::Math::min(pixel_count, fb_width);
-					pixel_count -= advance;
-					first_pixel += advance;
-				}
-
-				if (pixel_count)
-					m_framebuffer->sync_pixels_linear(first_pixel, pixel_count);
-			}
 		}
 
 	private:

kernel/kernel/ELF.cpp

@@ -8,7 +8,6 @@
 
 #include <ctype.h>
 #include <fcntl.h>
-#include <pthread.h>
 
 namespace Kernel::ELF
 {
@@ -291,7 +290,9 @@ namespace Kernel::ELF
 			TRY(memory_regions.emplace_back(BAN::move(region)));
 		}
 
-		result.open_execfd = !interpreter.empty();
+		if (!interpreter.empty())
+			result.interp_base = load_base_vaddr;
+
 		result.entry_point = load_base_vaddr + file_header.e_entry;
 		result.regions = BAN::move(memory_regions);
 		return BAN::move(result);

kernel/kernel/FS/DevFS/FileSystem.cpp

@@ -50,6 +50,7 @@ namespace Kernel
 			[](void* _devfs)
 			{
 				auto* devfs = static_cast<DevFileSystem*>(_devfs);
+				uint64_t next_update_ms = SystemTimer::get().ms_since_boot();
 				while (true)
 				{
 					{
@@ -57,7 +58,8 @@ namespace Kernel
 						for (auto& device : devfs->m_devices)
 							device->update();
 					}
-					SystemTimer::get().sleep_ms(10);
+					SystemTimer::get().sleep_until_ms(next_update_ms);
+					next_update_ms += 10;
 				}
 			}, s_instance
 		));

kernel/kernel/FS/Ext2/FileSystem.cpp

@@ -167,10 +167,36 @@ namespace Kernel
 
 	BAN::ErrorOr<void> Ext2FS::initialize_root_inode()
 	{
-		m_root_inode = TRY(Ext2Inode::create(*this, Ext2::Enum::ROOT_INO));
+		m_root_inode = TRY(open_inode(Ext2::Enum::ROOT_INO));
 		return {};
 	}
 
+	BAN::ErrorOr<BAN::RefPtr<Ext2Inode>> Ext2FS::open_inode(ino_t ino)
+	{
+		LockGuard _(m_inode_cache_lock);
+
+		auto it = m_inode_cache.find(ino);
+		if (it != m_inode_cache.end())
+			return it->value;
+
+		auto inode_location = TRY(locate_inode(ino));
+
+		auto block_buffer = TRY(get_block_buffer());
+		TRY(read_block(inode_location.block, block_buffer));
+
+		auto& inode = block_buffer.span().slice(inode_location.offset).as<Ext2::Inode>();
+
+		auto result = TRY(BAN::RefPtr<Ext2Inode>::create(*this, inode, ino));
+		TRY(m_inode_cache.insert(ino, result));
+		return result;
+	}
+
+	void Ext2FS::remove_from_cache(ino_t ino)
+	{
+		LockGuard _(m_inode_cache_lock);
+		m_inode_cache.remove(ino);
+	}
+
 	BAN::ErrorOr<uint32_t> Ext2FS::create_inode(const Ext2::Inode& ext2_inode)
 	{
 		auto bgd_buffer = TRY(m_buffer_manager.get_buffer());

kernel/kernel/FS/Ext2/Inode.cpp

@@ -42,24 +42,6 @@ namespace Kernel
 		return (m_ino - 1) / m_fs.superblock().blocks_per_group;
 	}
 
-	BAN::ErrorOr<BAN::RefPtr<Ext2Inode>> Ext2Inode::create(Ext2FS& fs, uint32_t inode_ino)
-	{
-		auto it = fs.inode_cache().find(inode_ino);
-		if (it != fs.inode_cache().end())
-			return it->value;
-
-		auto inode_location = TRY(fs.locate_inode(inode_ino));
-
-		auto block_buffer = TRY(fs.get_block_buffer());
-		TRY(fs.read_block(inode_location.block, block_buffer));
-
-		auto& inode = block_buffer.span().slice(inode_location.offset).as<Ext2::Inode>();
-
-		auto result = TRY(BAN::RefPtr<Ext2Inode>::create(fs, inode, inode_ino));
-		TRY(fs.inode_cache().insert(inode_ino, result));
-		return result;
-	}
-
 	Ext2Inode::~Ext2Inode()
 	{
 		if (m_nlink > 0)
@@ -89,57 +71,53 @@ namespace Kernel
 		return {};
 	}
 
-	BAN::ErrorOr<BAN::Optional<uint32_t>> Ext2Inode::block_from_indirect_block_no_lock(uint32_t& block, uint32_t index, uint32_t depth, bool allocate)
+	BAN::ErrorOr<BAN::Optional<uint32_t>> Ext2Inode::block_from_indirect_block_no_lock(uint32_t block, uint32_t index, uint32_t depth, bool allocate)
 	{
 		const uint32_t indices_per_fs_block = blksize() / sizeof(uint32_t);
 
-		if (block == 0 && !allocate)
+		ASSERT(block != 0);
-			return BAN::Optional<uint32_t>();
 
 		if (depth == 0)
+			return BAN::Optional<uint32_t>(block);
+
+		uint32_t local_index = index;
+		for (uint32_t i = 1; i < depth; i++)
+			local_index /= indices_per_fs_block;
+		local_index %= indices_per_fs_block;
+
+		uint32_t next_block = 0;
+
+		if (auto cached = block_cache_find(block, local_index); cached.has_value())
+			next_block = cached.value();
+
+		if (next_block == 0)
 		{
-			if (block == 0)
+			auto block_buffer = TRY(m_fs.get_block_buffer());
+			TRY(m_fs.read_block(block, block_buffer));
+			auto block_span = block_buffer.span().as_span<uint32_t>();
+
+			next_block = block_span[local_index];
+
+			if (next_block == 0)
 			{
-				block = TRY(m_fs.reserve_free_block(block_group()));
+				if (!allocate)
+					return BAN::Optional<uint32_t>();
+
+				auto zero_buffer = TRY(m_fs.get_block_buffer());
+				memset(zero_buffer.data(), 0, zero_buffer.size());
+
+				next_block = TRY(m_fs.reserve_free_block(block_group()));
+				TRY(m_fs.write_block(next_block, zero_buffer));
 				m_blocks++;
 
-				auto block_buffer = TRY(m_fs.get_block_buffer());
+				block_span[local_index] = next_block;
-				memset(block_buffer.data(), 0x00, block_buffer.size());
 				TRY(m_fs.write_block(block, block_buffer));
 			}
 
-			return BAN::Optional<uint32_t>(block);
+			block_cache_add(block, local_index, next_block);
 		}
 
-		auto block_buffer = TRY(m_fs.get_block_buffer());
+		return block_from_indirect_block_no_lock(next_block, index, depth - 1, allocate);
-
-		bool needs_write = false;
-
-		if (block != 0)
-			TRY(m_fs.read_block(block, block_buffer));
-		else
-		{
-			block = TRY(m_fs.reserve_free_block(block_group()));
-			m_blocks++;
-
-			memset(block_buffer.data(), 0, block_buffer.size());
-
-			needs_write = true;
-		}
-
-		uint32_t divisor = 1;
-		for (uint32_t i = 1; i < depth; i++)
-			divisor *= indices_per_fs_block;
-
-		uint32_t& new_block = block_buffer.span().as_span<uint32_t>()[(index / divisor) % indices_per_fs_block];
-		const auto old_block = new_block;
-
-		const auto result = TRY(block_from_indirect_block_no_lock(new_block, index, depth - 1, allocate));
-
-		if (needs_write || old_block != new_block)
-			TRY(m_fs.write_block(block, block_buffer));
-
-		return result;
 	}
 
 	BAN::ErrorOr<BAN::Optional<uint32_t>> Ext2Inode::fs_block_of_data_block_index_no_lock(uint32_t data_block_index, bool allocate)
@@ -166,16 +144,29 @@ namespace Kernel
 		}
 		data_block_index -= 12;
 
-		if (data_block_index < indices_per_block)
+		uint32_t depth_block_count = indices_per_block;
-			return block_from_indirect_block_no_lock(m_ext2_blocks.block[12], data_block_index, 1, allocate);
+		for (size_t i = 0; i < 3; i++)
-		data_block_index -= indices_per_block;
+		{
+			if (data_block_index < depth_block_count)
+			{
+				auto& block = m_ext2_blocks.block[12 + i];
+				if (block == 0)
+				{
+					if (!allocate)
+						return BAN::Optional<uint32_t>();
 
-		if (data_block_index < indices_per_block * indices_per_block)
+					auto zero_buffer = TRY(m_fs.get_block_buffer());
-			return block_from_indirect_block_no_lock(m_ext2_blocks.block[13], data_block_index, 2, allocate);
+					memset(zero_buffer.data(), 0, zero_buffer.size());
-		data_block_index -= indices_per_block * indices_per_block;
 
-		if (data_block_index < indices_per_block * indices_per_block * indices_per_block)
+					block = TRY(m_fs.reserve_free_block(block_group()));
-			return block_from_indirect_block_no_lock(m_ext2_blocks.block[14], data_block_index, 3, allocate);
+					TRY(m_fs.write_block(block, zero_buffer));
+					m_blocks++;
+				}
+				return block_from_indirect_block_no_lock(block, data_block_index, i + 1, allocate);
+			}
+			data_block_index -= depth_block_count;
+			depth_block_count *= indices_per_block;
+		}
 
 		ASSERT_NOT_REACHED();
 	}
@@ -230,13 +221,11 @@ namespace Kernel
 		if (static_cast<BAN::make_unsigned_t<decltype(offset)>>(offset) >= UINT32_MAX || buffer.size() >= UINT32_MAX || buffer.size() >= (size_t)(UINT32_MAX - offset))
 			return BAN::Error::from_errno(EOVERFLOW);
 
-		RWLockRDGuard _0(m_lock);
+		RWLockRDGuard _(m_lock);
 
 		if (static_cast<BAN::make_unsigned_t<decltype(offset)>>(offset) >= static_cast<size_t>(m_size))
 			return 0;
 
-		ScopedSync _1(*this);
-
 		uint32_t count = buffer.size();
 		if (offset + buffer.size() > static_cast<size_t>(m_size))
 			count = m_size - offset;
@@ -283,7 +272,7 @@ namespace Kernel
 		if (static_cast<size_t>(m_size) < offset + buffer.size())
 			TRY(truncate_impl(offset + buffer.size()));
 
-		ScopedSync _(*this);
+		ScopedSync _1(*this);
 
 		const uint32_t block_size = blksize();
 
@@ -544,7 +533,7 @@ done:
 
 		const uint32_t new_ino = TRY(m_fs.create_inode(initialize_new_inode_info(mode, uid, gid)));
 
-		auto inode_or_error = Ext2Inode::create(m_fs, new_ino);
+		auto inode_or_error = m_fs.open_inode(new_ino);
 		if (inode_or_error.is_error())
 		{
 			TRY(m_fs.delete_inode(new_ino));
@@ -570,7 +559,7 @@ done:
 
 		const uint32_t new_ino = TRY(m_fs.create_inode(initialize_new_inode_info(mode, uid, gid)));
 
-		auto inode_or_error = Ext2Inode::create(m_fs, new_ino);
+		auto inode_or_error = m_fs.open_inode(new_ino);
 		if (inode_or_error.is_error())
 		{
 			TRY(m_fs.delete_inode(new_ino));
@@ -816,7 +805,7 @@ needs_new_block:
 					}
 					else if (entry_name == ".."_sv)
 					{
-						auto parent = TRY(Ext2Inode::create(m_fs, entry.inode));
+						auto parent = TRY(m_fs.open_inode(entry.inode));
 						parent->m_nlink--;
 						TRY(parent->sync_inode_no_lock());
 					}
@@ -862,7 +851,7 @@ needs_new_block:
 				auto& entry = block_buffer.span().slice(offset).as<Ext2::LinkedDirectoryEntry>();
 				if (entry.inode && name == BAN::StringView(entry.name, entry.name_len))
 				{
-					auto inode = TRY(Ext2Inode::create(m_fs, entry.inode));
+					auto inode = TRY(m_fs.open_inode(entry.inode));
 					if (cleanup_directory && inode->mode().ifdir())
 					{
 						if (!TRY(inode->is_directory_empty_no_lock()))
@@ -880,11 +869,7 @@ needs_new_block:
 					// NOTE: If this was the last link to inode we must
 					//       remove it from inode cache to trigger cleanup
 					if (inode->nlink() == 0)
-					{
+						m_fs.remove_from_cache(inode->ino());
-						auto& cache = m_fs.inode_cache();
-						if (cache.contains(inode->ino()))
-							cache.remove(inode->ino());
-					}
 
 					// FIXME: This should expand the last inode if exists
 					entry.inode = 0;
@@ -894,6 +879,8 @@ needs_new_block:
 			}
 		}
 
+		dir_cache_remove(name);
+
 		return {};
 	}
 
@@ -930,6 +917,8 @@ needs_new_block:
 		auto inode_location = TRY(m_fs.locate_inode(ino()));
 		auto block_buffer = TRY(m_fs.get_block_buffer());
 
+		// FIXME: race condition when syncing multiple inodes :)
+
 		TRY(m_fs.read_block(inode_location.block, block_buffer));
 		if (memcmp(block_buffer.data() + inode_location.offset, &inode, sizeof(Ext2::Inode)))
 		{
@@ -950,6 +939,9 @@ needs_new_block:
 	{
 		ASSERT(mode().ifdir());
 
+		if (auto cached = dir_cache_find(file_name))
+			return cached;
+
 		auto block_buffer = TRY(m_fs.get_block_buffer());
 
 		for (uint32_t i = 0; i < max_used_data_block_count(); i++)
@@ -965,11 +957,129 @@ needs_new_block:
 				auto& entry = entry_span.as<const Ext2::LinkedDirectoryEntry>();
 				BAN::StringView entry_name(entry.name, entry.name_len);
 				if (entry.inode && entry_name == file_name)
-					return BAN::RefPtr<Inode>(TRY(Ext2Inode::create(m_fs, entry.inode)));
+				{
+					auto inode = BAN::RefPtr<Inode>(TRY(m_fs.open_inode(entry.inode)));
+					dir_cache_add(file_name, inode);
+					return inode;
+				}
 				entry_span = entry_span.slice(entry.rec_len);
 			}
 		}
 
 		return BAN::Error::from_errno(ENOENT);
 	}
+
+	BAN::Optional<uint32_t> Ext2Inode::block_cache_find(uint32_t block, uint32_t index) const
+	{
+		SpinLockGuard _(m_block_cache_lock);
+		for (const auto& cache : m_block_cache)
+		{
+			if (cache.block != block || cache.index != index)
+				continue;
+			cache.freq++;
+			return cache.target;
+		}
+		return {};
+	}
+
+	void Ext2Inode::block_cache_remove(uint32_t block, uint32_t index)
+	{
+		SpinLockGuard _(m_block_cache_lock);
+		for (auto& cache : m_block_cache)
+		{
+			if (cache.block != block || cache.index != index)
+				continue;
+			cache = {};
+			return;
+		}
+	}
+
+	void Ext2Inode::block_cache_add(uint32_t block, uint32_t index, uint32_t target)
+	{
+		SpinLockGuard _(m_block_cache_lock);
+
+		size_t min_freq = BAN::numeric_limits<size_t>::max();
+		size_t min_index = 0;
+		for (size_t i = 0; i < m_block_cache.size(); i++)
+		{
+			const auto& cache = m_block_cache[i];
+			if (cache.block == block && cache.index == index)
+			{
+				ASSERT(cache.target == target);
+				cache.freq++;
+				return;
+			}
+			if (cache.freq < min_freq)
+			{
+				min_freq = cache.freq;
+				min_index = i;
+			}
+		}
+
+		m_block_cache[min_index] = {
+			.freq = 1,
+			.block = block,
+			.index = index,
+			.target = target,
+		};
+	}
+
+	BAN::RefPtr<Inode> Ext2Inode::dir_cache_find(BAN::StringView name) const
+	{
+		RWLockRDGuard _(m_dir_cache_lock);
+		for (const auto& cache : m_dir_cache)
+		{
+			if (!cache.inode || name != BAN::StringView(cache.name, cache.name_len))
+				continue;
+			BAN::atomic_add_fetch(cache.freq, 1);
+			return cache.inode;
+		}
+		return {};
+	}
+
+	void Ext2Inode::dir_cache_remove(BAN::StringView name)
+	{
+		RWLockWRGuard _(m_dir_cache_lock);
+		for (auto& cache : m_dir_cache)
+		{
+			if (!cache.inode || name != BAN::StringView(cache.name, cache.name_len))
+				continue;
+			cache.freq = 0;
+			cache.inode = {};
+			return;
+		}
+	}
+
+	void Ext2Inode::dir_cache_add(BAN::StringView name, BAN::RefPtr<Inode> inode)
+	{
+		RWLockWRGuard _(m_dir_cache_lock);
+
+		if (m_dir_cache.empty() && m_dir_cache.resize(dir_cache_size).is_error())
+			return;
+
+		size_t min_freq = BAN::numeric_limits<size_t>::max();
+		size_t min_index = 0;
+		for (size_t i = 0; i < m_dir_cache.size(); i++)
+		{
+			const auto& cache = m_dir_cache[i];
+			if (cache.inode && name == BAN::StringView(cache.name, cache.name_len))
+			{
+				ASSERT(cache.inode == inode);
+				cache.freq++;
+				return;
+			}
+			if (cache.freq < min_freq)
+			{
+				min_freq  = cache.freq;
+				min_index = i;
+			}
+		}
+
+		auto& cache = m_dir_cache[min_index];
+		cache.freq     = 1;
+		cache.inode    = inode;
+		cache.name_len = name.size();
+		memcpy(cache.name, name.data(), name.size());
+	}
+
 }

kernel/kernel/FS/Inode.cpp

@@ -5,6 +5,7 @@
 #include <kernel/Memory/FileBackedRegion.h>
 
 #include <fcntl.h>
+#include <sys/ioctl.h>
 #include <sys/statvfs.h>
 
 namespace Kernel
@@ -315,9 +316,24 @@ namespace Kernel
 		return {};
 	}
 
-	BAN::ErrorOr<long> Inode::ioctl(int request, void* arg)
+	BAN::ErrorOr<long> Inode::ioctl(unsigned long request, void* arg)
 	{
-		return ioctl_impl(request, arg);
+		auto ret = ioctl_impl(request, arg);
+		if (!ret.is_error() || ret.error().get_error_code() != ENOTSUP)
+			return BAN::move(ret);
+
+		switch (request)
+		{
+			case TIOCGWINSZ:
+			case TIOCSWINSZ:
+			case TCGETS:
+			case TCSETS:
+			case TCSETSW:
+			case TCSETSF:
+				return BAN::Error::from_errno(EINVAL);
+			default:
+				return BAN::Error::from_errno(ENOTSUP);
+		}
 	}
 
 	BAN::ErrorOr<void> Inode::add_epoll(class Epoll* epoll)

kernel/kernel/FS/Pipe.cpp

@@ -268,19 +268,4 @@ namespace Kernel
 		return BAN::Error::from_errno(ENODEV);
 	}
 
-	BAN::ErrorOr<long> Pipe::ioctl_impl(int cmd, void* arg)
-	{
-		switch (cmd)
-		{
-			case TIOCGWINSZ:
-			case TIOCSWINSZ:
-			case TCGETS:
-			case TCSETS:
-			case TCSETSW:
-			case TCSETSF:
-				return BAN::Error::from_errno(EINVAL);
-		}
-		return Inode::ioctl_impl(cmd, arg);
-	}
-
 }

kernel/kernel/FS/ProcFS/FileSystem.cpp

@@ -16,22 +16,23 @@ namespace Kernel
 		MUST(s_instance->TmpFileSystem::initialize(0555, 0, 0));
 
 		auto meminfo_inode = MUST(ProcROInode::create_new(
-			[](off_t offset, BAN::ByteSpan buffer) -> size_t
+			[](off_t offset, BAN::ByteSpan buffer, void*) -> BAN::ErrorOr<size_t>
 			{
 				ASSERT(offset >= 0);
 				if ((size_t)offset >= sizeof(full_meminfo_t))
 					return 0;
 
-				full_meminfo_t meminfo;
+				const full_meminfo_t meminfo {
-				meminfo.page_size = PAGE_SIZE;
+					.page_size = PAGE_SIZE,
-				meminfo.free_pages = Heap::get().free_pages();
+					.free_pages = Heap::get().free_pages(),
-				meminfo.used_pages = Heap::get().used_pages();
+					.used_pages = Heap::get().used_pages(),
+				};
 
 				size_t bytes = BAN::Math::min<size_t>(sizeof(full_meminfo_t) - offset, buffer.size());
 				memcpy(buffer.data(), (uint8_t*)&meminfo + offset, bytes);
 				return bytes;
 			},
-			*s_instance, 0444, 0, 0
+			*s_instance, nullptr, 0444, 0, 0
 		));
 		MUST(static_cast<TmpDirectoryInode*>(s_instance->root_inode().ptr())->link_inode(*meminfo_inode, "meminfo"_sv));
 
@@ -48,6 +49,35 @@ namespace Kernel
 		MUST(static_cast<TmpDirectoryInode*>(s_instance->root_inode().ptr())->link_inode(*self_inode, "self"_sv));
 	}
 
+	void ProcFileSystem::post_scheduler_initialize()
+	{
+		MUST(s_instance->root_inode()->create_directory("cpu"_sv, Inode::Mode::IFDIR | 0555, 0, 0));
+		auto cpu_directory = MUST(s_instance->root_inode()->find_inode("cpu"_sv));
+
+		for (size_t i = 0; i < Processor::count(); i++)
+		{
+			auto cpu_inode = MUST(ProcROInode::create_new(
+				[](off_t offset, BAN::ByteSpan buffer, void* index_ptr) -> BAN::ErrorOr<size_t>
+				{
+					ASSERT(offset >= 0);
+
+					const size_t index = reinterpret_cast<uintptr_t>(index_ptr);
+					const auto load_stats = Processor::get_load_stats(index);
+
+					auto string = TRY(BAN::String::formatted("{} {}", load_stats.ns_idle, load_stats.ns_total));
+					if (static_cast<size_t>(offset) >= string.size())
+						return 0;
+
+					const size_t bytes = BAN::Math::min<size_t>(string.size() - offset, buffer.size());
+					memcpy(buffer.data(), string.data() + offset, bytes);
+					return bytes;
+				},
+				*s_instance, reinterpret_cast<void*>(i), 0444, 0, 0
+			));
+			MUST(cpu_directory->link_inode(MUST(BAN::String::formatted("{}", i)), cpu_inode));
+		}
+	}
+
 	ProcFileSystem& ProcFileSystem::get()
 	{
 		ASSERT(s_instance);

kernel/kernel/FS/ProcFS/Inode.cpp

@@ -16,12 +16,13 @@ namespace Kernel
 
 		TRY(inode->link_inode(*inode, "."_sv));
 		TRY(inode->link_inode(static_cast<TmpInode&>(*fs.root_inode()), ".."_sv));
-		TRY(inode->link_inode(*MUST(ProcROProcessInode::create_new(process, &Process::proc_meminfo, fs, 0400)), "meminfo"_sv));
+		TRY(inode->link_inode(*MUST(ProcROProcessInode::create_new(process, &Process::proc_meminfo, fs, 0444)), "meminfo"_sv));
 		TRY(inode->link_inode(*MUST(ProcROProcessInode::create_new(process, &Process::proc_cmdline, fs, 0444)), "cmdline"_sv));
 		TRY(inode->link_inode(*MUST(ProcROProcessInode::create_new(process, &Process::proc_environ, fs, 0400)), "environ"_sv));
+		TRY(inode->link_inode(*MUST(ProcROProcessInode::create_new(process, &Process::proc_cputime, fs, 0444)), "cputime"_sv));
 		TRY(inode->link_inode(*MUST(ProcSymlinkProcessInode::create_new(process, &Process::proc_cwd, fs, 0777)), "cwd"_sv));
 		TRY(inode->link_inode(*MUST(ProcSymlinkProcessInode::create_new(process, &Process::proc_exe, fs, 0777)), "exe"_sv));
-		TRY(inode->link_inode(*MUST(ProcFDDirectoryInode::create_new(process, fs, 0777)), "fd"_sv));
+		TRY(inode->link_inode(*MUST(ProcFDDirectoryInode::create_new(process, fs, 0500)), "fd"_sv));
 
 		return inode;
 	}
@@ -38,6 +39,7 @@ namespace Kernel
 		(void)TmpDirectoryInode::unlink_impl("meminfo"_sv);
 		(void)TmpDirectoryInode::unlink_impl("cmdline"_sv);
 		(void)TmpDirectoryInode::unlink_impl("environ"_sv);
+		(void)TmpDirectoryInode::unlink_impl("cputime"_sv);
 		(void)TmpDirectoryInode::unlink_impl("cwd"_sv);
 		(void)TmpDirectoryInode::unlink_impl("exe"_sv);
 		(void)TmpDirectoryInode::unlink_impl("fd"_sv);
@@ -95,19 +97,20 @@ namespace Kernel
 		return (m_process.*m_callback)();
 	}
 
-	BAN::ErrorOr<BAN::RefPtr<ProcROInode>> ProcROInode::create_new(size_t (*callback)(off_t, BAN::ByteSpan), TmpFileSystem& fs, mode_t mode, uid_t uid, gid_t gid)
+	BAN::ErrorOr<BAN::RefPtr<ProcROInode>> ProcROInode::create_new(BAN::ErrorOr<size_t> (*callback)(off_t, BAN::ByteSpan, void*), TmpFileSystem& fs, void* argument, mode_t mode, uid_t uid, gid_t gid)
 	{
 		auto inode_info = create_inode_info(Mode::IFREG | mode, uid, gid);
 
-		auto* inode_ptr = new ProcROInode(callback, fs, inode_info);
+		auto* inode_ptr = new ProcROInode(callback, fs, argument, inode_info);
 		if (inode_ptr == nullptr)
 			return BAN::Error::from_errno(ENOMEM);
 		return BAN::RefPtr<ProcROInode>::adopt(inode_ptr);
 	}
 
-	ProcROInode::ProcROInode(size_t (*callback)(off_t, BAN::ByteSpan), TmpFileSystem& fs, const TmpInodeInfo& inode_info)
+	ProcROInode::ProcROInode(BAN::ErrorOr<size_t> (*callback)(off_t, BAN::ByteSpan, void*), TmpFileSystem& fs, void* argument, const TmpInodeInfo& inode_info)
 		: TmpInode(fs, MUST(fs.allocate_inode(inode_info)), inode_info)
 		, m_callback(callback)
+		, m_argument(argument)
 	{
 		m_mode |= Inode::Mode::IFREG;
 	}
@@ -116,7 +119,7 @@ namespace Kernel
 	{
 		if (offset < 0)
 			return BAN::Error::from_errno(EINVAL);
-		return m_callback(offset, buffer);
+		return TRY(m_callback(offset, buffer, m_argument));
 	}
 
 	BAN::ErrorOr<BAN::RefPtr<ProcSymlinkInode>> ProcSymlinkInode::create_new(BAN::ErrorOr<BAN::String> (*callback)(void*), void (*destructor)(void*), void* data, TmpFileSystem& fs, mode_t mode, uid_t uid, gid_t gid)

kernel/kernel/FS/VirtualFileSystem.cpp

@@ -157,7 +157,7 @@ namespace Kernel
 			if (i == 4)
 				dwarnln("Could not find specified root device, waiting for it to get loaded...");
 
-			SystemTimer::get().sleep_ms(sleep_ms);
+			SystemTimer::get().sleep_for_ms(sleep_ms);
 		}
 
 		derrorln("Could not find root device '{}' after {} ms", root_path, timeout_ms);
@@ -210,14 +210,14 @@ namespace Kernel
 		if (!file.inode->mode().ifdir())
 			return BAN::Error::from_errno(ENOTDIR);
 
-		LockGuard _(m_mutex);
+		LockGuard _(m_mount_point_lock);
 		TRY(m_mount_points.emplace_back(file_system, BAN::move(file)));
 		return {};
 	}
 
 	VirtualFileSystem::MountPoint* VirtualFileSystem::mount_from_host_inode(BAN::RefPtr<Inode> inode)
 	{
-		LockGuard _(m_mutex);
+		LockGuard _(m_mount_point_lock);
 		for (MountPoint& mount : m_mount_points)
 			if (*mount.host.inode == *inode)
 				return &mount;
@@ -226,53 +226,52 @@ namespace Kernel
 
 	VirtualFileSystem::MountPoint* VirtualFileSystem::mount_from_root_inode(BAN::RefPtr<Inode> inode)
 	{
-		LockGuard _(m_mutex);
+		LockGuard _(m_mount_point_lock);
 		for (MountPoint& mount : m_mount_points)
 			if (*mount.target->root_inode() == *inode)
 				return &mount;
 		return nullptr;
 	}
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstack-usage="
 	BAN::ErrorOr<VirtualFileSystem::File> VirtualFileSystem::file_from_relative_path(BAN::RefPtr<Inode> root_inode, const File& parent, const Credentials& credentials, BAN::StringView path, int flags)
 	{
-		LockGuard _(m_mutex);
-
 		auto inode = parent.inode;
 		ASSERT(inode);
 
-		BAN::String canonical_path;
+		char canonical_buf[PATH_MAX];
-		TRY(canonical_path.append(parent.canonical_path));
+		size_t canonical_len = parent.canonical_path.size();
-		if (!canonical_path.empty() && canonical_path.back() == '/')
+		if (!parent.canonical_path.empty() && parent.canonical_path.back() == '/')
-			canonical_path.pop_back();
+			canonical_len--;
-		ASSERT(canonical_path.empty() || canonical_path.back() != '/');
+		memcpy(canonical_buf, parent.canonical_path.data(), canonical_len);
+		ASSERT(canonical_len == 0 || canonical_buf[canonical_len - 1] != '/');
 
-		BAN::Vector<BAN::String> path_parts;
+		char path_storage[PATH_MAX];
-
-		const auto append_string_view_in_reverse =
-			[&path_parts](BAN::StringView path) -> BAN::ErrorOr<void>
-			{
-				auto split_path = TRY(path.split('/'));
-				TRY(path_parts.reserve(path_parts.size() + split_path.size()));
-				for (size_t i = split_path.size(); i > 0; i--)
-				{
-					TRY(path_parts.emplace_back());
-					TRY(path_parts.back().append(split_path[i - 1]));
-				}
-				return {};
-			};
-		TRY(append_string_view_in_reverse(path));
 
 		size_t link_depth = 0;
-
+		for (;;)
-		while (!path_parts.empty())
 		{
-			BAN::String path_part = BAN::move(path_parts.back());
+			const auto path_part = [&path] {
-			path_parts.pop_back();
+				size_t off = 0;
+				while (off < path.size() && path[off] == '/')
+					off++;
 
-			if (path_part.empty() || path_part == "."_sv)
+				size_t len = 0;
+				while (off + len < path.size() && path[off + len] != '/')
+					len++;
+
+				const auto result = path.substring(off, len);
+				path = path.substring(off + len);
+				return result;
+			}();
+
+			if (path_part.empty())
+				break;
+			if (path_part == "."_sv)
 				continue;
 
-			auto orig = inode;
+			auto orig_inode = inode;
 
 			// resolve file name
 			{
@@ -289,26 +288,26 @@ namespace Kernel
 
 				if (path_part == ".."_sv)
 				{
-					if (!canonical_path.empty())
+					while (canonical_len && canonical_buf[canonical_len - 1] != '/')
-					{
+						canonical_len--;
-						ASSERT(canonical_path.front() == '/');
+					if (canonical_len)
-						while (canonical_path.back() != '/')
+						canonical_len--;
-							canonical_path.pop_back();
-						canonical_path.pop_back();
-					}
 				}
 				else
 				{
 					if (auto* mount_point = mount_from_host_inode(inode))
 						inode = mount_point->target->root_inode();
-					TRY(canonical_path.push_back('/'));
+					if (canonical_len + 1 + path_part.size() > sizeof(canonical_buf))
-					TRY(canonical_path.append(path_part));
+						return BAN::Error::from_errno(ENAMETOOLONG);
+					canonical_buf[canonical_len++] = '/';
+					memcpy(canonical_buf + canonical_len, path_part.data(), path_part.size());
+					canonical_len += path_part.size();
 				}
 			}
 
 			if (!inode->mode().iflnk())
 				continue;
-			if ((flags & O_NOFOLLOW) && path_parts.empty())
+			if ((flags & O_NOFOLLOW) && !path.find([](char ch) { return ch != '/'; }).has_value())
 				continue;
 
 			// resolve symbolic links
@@ -320,21 +319,26 @@ namespace Kernel
 				if (link_target.front() == '/')
 				{
 					inode = root_inode;
-					canonical_path.clear();
+					canonical_len = 0;
 				}
 				else
 				{
-					inode = orig;
+					inode = orig_inode;
 
-					while (canonical_path.back() != '/')
+					while (canonical_len && canonical_buf[canonical_len - 1] != '/')
-						canonical_path.pop_back();
+						canonical_len--;
-					canonical_path.pop_back();
+					if (canonical_len)
+						canonical_len--;
 				}
 
-				TRY(append_string_view_in_reverse(link_target.sv()));
+				if (link_target.size() + path.size() > sizeof(path_storage))
+					return BAN::Error::from_errno(ENAMETOOLONG);
+				memcpy(path_storage, link_target.data(), link_target.size());
+				memcpy(path_storage + link_target.size(), path.data(), path.size());
+				path = BAN::StringView(path_storage, link_target.size() + path.size());
 
 				link_depth++;
-				if (link_depth > 100)
+				if (link_depth > SYMLOOP_MAX)
 					return BAN::Error::from_errno(ELOOP);
 			}
 		}
@@ -342,17 +346,14 @@ namespace Kernel
 		if (!inode->can_access(credentials, flags))
 			return BAN::Error::from_errno(EACCES);
 
-		if (canonical_path.empty())
+		if (canonical_len == 0)
-			TRY(canonical_path.push_back('/'));
+			canonical_buf[canonical_len++] = '/';
 
-		File file;
+		BAN::String canonical_path;
-		file.inode = inode;
+		TRY(canonical_path.append(BAN::StringView(canonical_buf, canonical_len)));
-		file.canonical_path = BAN::move(canonical_path);
 
-		if (file.canonical_path.empty())
+		return File(BAN::move(inode), BAN::move(canonical_path));
-			TRY(file.canonical_path.push_back('/'));
-
-		return file;
 	}
+#pragma GCC diagnostic pop
 
 }

kernel/kernel/IDT.cpp

@@ -24,11 +24,6 @@ namespace Kernel
 #if ARCH(x86_64)
 	struct Registers
 	{
-		uint64_t cr4;
-		uint64_t cr3;
-		uint64_t cr2;
-		uint64_t cr0;
-
 		uint64_t r15;
 		uint64_t r14;
 		uint64_t r13;
@@ -49,11 +44,6 @@ namespace Kernel
 #elif ARCH(i686)
 	struct Registers
 	{
-		uint32_t cr4;
-		uint32_t cr3;
-		uint32_t cr2;
-		uint32_t cr0;
-
 		uint32_t edi;
 		uint32_t esi;
 		uint32_t ebp;
@@ -226,8 +216,11 @@ namespace Kernel
 					return;
 				}
 
+				uintptr_t cr2;
+				asm volatile("mov %%cr2, %0" : "=r"(cr2));
+
 				Processor::set_interrupt_state(InterruptState::Enabled);
-				auto result = Process::current().allocate_page_for_demand_paging(regs->cr2, page_fault_error.write, page_fault_error.instruction);
+				auto result = Process::current().allocate_page_for_demand_paging(cr2, page_fault_error.write, page_fault_error.instruction);
 				Processor::set_interrupt_state(InterruptState::Disabled);
 
 				if (result.is_error())
@@ -256,6 +249,18 @@ namespace Kernel
 
 				break;
 			}
+			case ISR::GeneralProtectionFault:
+			{
+				const uint8_t* ip = reinterpret_cast<const uint8_t*>(interrupt_stack->ip);
+				for (const auto& safe_user : s_safe_user_page_faults)
+				{
+					if (ip < safe_user.ip_start || ip >= safe_user.ip_end)
+						continue;
+					interrupt_stack->ip = reinterpret_cast<vaddr_t>(safe_user.ip_fault);
+					return;
+				}
+				break;
+			}
 			case ISR::DeviceNotAvailable:
 			{
 				if (pid == 0 || !Thread::current().is_userspace())
@@ -274,6 +279,15 @@ namespace Kernel
 			}
 		}
 
+		uintptr_t cr0, cr2, cr3, cr4;
+		asm volatile(
+			"mov %%cr0, %0;"
+			"mov %%cr2, %1;"
+			"mov %%cr3, %2;"
+			"mov %%cr4, %3;"
+			: "=r"(cr0), "=r"(cr2), "=r"(cr3), "=r"(cr4)
+		);
+
 		Debug::s_debug_lock.lock();
 
 		if (PageTable::current().get_page_flags(interrupt_stack->ip & PAGE_ADDR_MASK) & PageTable::Flags::Present)
@@ -311,7 +325,7 @@ namespace Kernel
 			regs->r8, regs->r9, regs->r10, regs->r11,
 			regs->r12, regs->r13, regs->r14, regs->r15,
 			interrupt_stack->ip, interrupt_stack->flags,
-			regs->cr0, regs->cr2, regs->cr3, regs->cr4
+			cr0, cr2, cr3, cr4
 		);
 #elif ARCH(i686)
 		dwarnln(
@@ -325,7 +339,7 @@ namespace Kernel
 			regs->eax, regs->ebx, regs->ecx, regs->edx,
 			interrupt_stack->sp, regs->ebp, regs->edi, regs->esi,
 			interrupt_stack->ip, interrupt_stack->flags,
-			regs->cr0, regs->cr2, regs->cr3, regs->cr4
+			cr0, cr2, cr3, cr4
 		);
 #endif
 		if (isr == ISR::PageFault)
@@ -373,11 +387,11 @@ namespace Kernel
 				break;
 			case ISR::PageFault:
 				signal_info.si_signo = SIGSEGV;
-				if (PageTable::current().get_page_flags(regs->cr2 & PAGE_ADDR_MASK) & PageTable::Flags::Present)
+				if (PageTable::current().get_page_flags(cr2 & PAGE_ADDR_MASK) & PageTable::Flags::Present)
 					signal_info.si_code = SEGV_ACCERR;
 				else
 					signal_info.si_code = SEGV_MAPERR;
-				signal_info.si_addr = reinterpret_cast<void*>(regs->cr2);
+				signal_info.si_addr = reinterpret_cast<void*>(cr2);
 				break;
 			default:
 				dwarnln("Unhandled exception");
@@ -421,7 +435,7 @@ namespace Kernel
 		if (Processor::current_is_bsp())
 			Process::update_alarm_queue();
 
-		Processor::scheduler().timer_interrupt();
+		Processor::scheduler().on_timer_interrupt();
 	}
 
 	extern "C" void cpp_irq_handler(uint32_t irq)

kernel/kernel/Input/InputDevice.cpp

@@ -1,7 +1,10 @@
+#include <BAN/CircularQueue.h>
+
 #include <kernel/Device/DeviceNumbers.h>
 #include <kernel/FS/DevFS/FileSystem.h>
 #include <kernel/Input/InputDevice.h>
 #include <kernel/Lock/SpinLockAsMutex.h>
+#include <kernel/Terminal/TTY.h>
 
 #include <LibInput/Joystick.h>
 #include <LibInput/KeyEvent.h>
@@ -24,6 +27,10 @@ namespace Kernel
 	static SpinLock s_joystick_lock;
 	static BAN::Vector<BAN::WeakPtr<InputDevice>> s_joysticks;
 
+	static SpinLock s_tty_keyboard_event_lock;
+	static ThreadBlocker s_tty_keyboard_event_blocker;
+	static BAN::CircularQueue<LibInput::RawKeyEvent, 128> s_tty_keyboard_events;
+
 	static const char* get_name_format(InputDevice::Type type)
 	{
 		switch (type)
@@ -190,9 +197,6 @@ namespace Kernel
 					}
 					else switch (key_event.keycode)
 					{
-						case LibInput::keycode_function(1):
-							Processor::toggle_should_print_cpu_load();
-							break;
 						case LibInput::keycode_function(11):
 							DevFileSystem::get().initiate_disk_cache_drop();
 							break;
@@ -201,6 +205,15 @@ namespace Kernel
 							break;
 					}
 				}
+
+				if (TTY::current()->should_receive_input())
+				{
+					SpinLockGuard _(s_tty_keyboard_event_lock);
+					if (!s_tty_keyboard_events.full())
+						s_tty_keyboard_events.push(key_event);
+					s_tty_keyboard_event_blocker.unblock();
+					return;
+				}
 			}
 
 			if (m_event_count == m_max_event_count)
@@ -261,6 +274,41 @@ namespace Kernel
 	}
 
 
+	static void tty_keyboard_thread(void*)
+	{
+		static BAN::Atomic<bool> initialized = false;
+		[[maybe_unused]] bool old_initialized = initialized.exchange(true);
+		ASSERT(old_initialized == false);
+
+		for (;;)
+		{
+			LibInput::RawKeyEvent event;
+
+			{
+				SpinLockGuard guard(s_tty_keyboard_event_lock);
+
+				if (s_tty_keyboard_events.empty())
+				{
+					SpinLockGuardAsMutex smutex(guard);
+					s_tty_keyboard_event_blocker.block_indefinite(&smutex);
+					continue;
+				}
+
+				event = s_tty_keyboard_events.front();
+				s_tty_keyboard_events.pop();
+			}
+
+			TTY::current()->on_key_event(event);
+		}
+	}
+
+	BAN::ErrorOr<void> KeyboardDevice::initialize_tty_thread()
+	{
+		auto* thread = TRY(Thread::create_kernel(tty_keyboard_thread, nullptr));
+		ASSERT(thread);
+		TRY(Processor::scheduler().add_thread(thread));
+		return {};
+	}
 
 	BAN::ErrorOr<BAN::RefPtr<KeyboardDevice>> KeyboardDevice::create(mode_t mode, uid_t uid, gid_t gid)
 	{

kernel/kernel/Input/PS2/Keyboard.cpp

@@ -151,16 +151,18 @@ namespace Kernel::Input
 		uint16_t toggle_mask = 0;
 		switch (dummy_event.key)
 		{
-			case Key::LeftShift:	modifier_mask = KeyModifier::LShift;	break;
+			case Key::LeftShift:  modifier_mask = KeyModifier::LShift; break;
-			case Key::RightShift:	modifier_mask = KeyModifier::RShift;	break;
+			case Key::RightShift: modifier_mask = KeyModifier::RShift; break;
-			case Key::LeftCtrl:		modifier_mask = KeyModifier::LCtrl;		break;
+			case Key::LeftCtrl:   modifier_mask = KeyModifier::LCtrl;  break;
-			case Key::RightCtrl:	modifier_mask = KeyModifier::RCtrl;		break;
+			case Key::RightCtrl:  modifier_mask = KeyModifier::RCtrl;  break;
-			case Key::LeftAlt:		modifier_mask = KeyModifier::LAlt;		break;
+			case Key::LeftAlt:    modifier_mask = KeyModifier::LAlt;   break;
-			case Key::RightAlt:		modifier_mask = KeyModifier::RAlt;		break;
+			case Key::RightAlt:   modifier_mask = KeyModifier::RAlt;   break;
+			case Key::LeftSuper:  modifier_mask = KeyModifier::LSuper; break;
+			case Key::RightSuper: modifier_mask = KeyModifier::RSuper; break;
 
-			case Key::ScrollLock:	toggle_mask = KeyModifier::ScrollLock;	break;
+			case Key::ScrollLock: toggle_mask = KeyModifier::ScrollLock; break;
-			case Key::NumLock:		toggle_mask = KeyModifier::NumLock;		break;
+			case Key::NumLock:    toggle_mask = KeyModifier::NumLock;    break;
-			case Key::CapsLock:		toggle_mask = KeyModifier::CapsLock;	break;
+			case Key::CapsLock:   toggle_mask = KeyModifier::CapsLock;   break;
 
 			default: break;
 		}

kernel/kernel/Input/PS2/Keymap.cpp

@@ -95,7 +95,9 @@ namespace Kernel::Input
 		m_scancode_to_keycode_normal[0x38]   = keycode_normal(4,  2);
 		m_scancode_to_keycode_normal[0x39]   = keycode_normal(4,  3);
 		m_scancode_to_keycode_extended[0x38] = keycode_normal(4,  4);
-		m_scancode_to_keycode_extended[0x1D] = keycode_normal(4,  5);
+		m_scancode_to_keycode_extended[0x5C] = keycode_normal(4,  5);
+		m_scancode_to_keycode_extended[0x5D] = keycode_normal(4,  6);
+		m_scancode_to_keycode_extended[0x1D] = keycode_normal(4,  7);
 
 		m_scancode_to_keycode_normal[0x45]   = keycode_numpad(0, 0);
 		m_scancode_to_keycode_extended[0x35] = keycode_numpad(0, 1);
@@ -208,7 +210,9 @@ namespace Kernel::Input
 		m_scancode_to_keycode_normal[0x11]   = keycode_normal(4,  2);
 		m_scancode_to_keycode_normal[0x29]   = keycode_normal(4,  3);
 		m_scancode_to_keycode_extended[0x11] = keycode_normal(4,  4);
-		m_scancode_to_keycode_extended[0x14] = keycode_normal(4,  5);
+		m_scancode_to_keycode_extended[0x27] = keycode_normal(4,  5);
+		m_scancode_to_keycode_extended[0x2F] = keycode_normal(4,  6);
+		m_scancode_to_keycode_extended[0x14] = keycode_normal(4,  7);
 
 		m_scancode_to_keycode_normal[0x77]   = keycode_numpad(0, 0);
 		m_scancode_to_keycode_extended[0x4A] = keycode_numpad(0, 1);
@@ -321,7 +325,9 @@ namespace Kernel::Input
 		m_scancode_to_keycode_normal[0x19] = keycode_normal(4,  2);
 		m_scancode_to_keycode_normal[0x29] = keycode_normal(4,  3);
 		m_scancode_to_keycode_normal[0x39] = keycode_normal(4,  4);
-		m_scancode_to_keycode_normal[0x58] = keycode_normal(4,  5);
+		m_scancode_to_keycode_normal[0x8C] = keycode_normal(4,  5);
+		m_scancode_to_keycode_normal[0x8D] = keycode_normal(4,  6);
+		m_scancode_to_keycode_normal[0x58] = keycode_normal(4,  7);
 
 		m_scancode_to_keycode_normal[0x76] = keycode_numpad(0, 0);
 		m_scancode_to_keycode_normal[0x4A] = keycode_numpad(0, 1);

kernel/kernel/Memory/FileBackedRegion.cpp

@@ -93,12 +93,12 @@ namespace Kernel
 
 	void SharedFileData::sync_no_lock(size_t page_index)
 	{
-		if (pages[page_index] == 0 || BAN::atomic_load(writers[page_index]) == 0)
+		if (pages[page_index] == 0 || BAN::atomic_load(writers[page_index]) > 0)
 			return;
 
 		uint8_t page_buffer[PAGE_SIZE];
-		PageTable::with_fast_page(pages[page_index], [&] {
+		PageTable::with_per_cpu_fast_page(pages[page_index], [&](void* addr) {
-			memcpy(page_buffer, PageTable::fast_page_as_ptr(), PAGE_SIZE);
+			memcpy(page_buffer, addr, PAGE_SIZE);
 		});
 
 		const size_t write_size = BAN::Math::min<size_t>(PAGE_SIZE, inode->size() - page_index * PAGE_SIZE);
@@ -108,8 +108,9 @@ namespace Kernel
 
 	BAN::ErrorOr<void> FileBackedRegion::msync(vaddr_t address, size_t size, int flags)
 	{
-		if (flags != MS_SYNC)
+		// TODO: maybe do something with the flags :)
-			dprintln("async file backed mmap msync");
+		(void)flags;
+
 		if (m_type != Type::SHARED)
 			return {};
 
@@ -162,8 +163,8 @@ namespace Kernel
 						m_shared_data->pages[shared_page_index] = Heap::get().take_free_page();
 						if (m_shared_data->pages[shared_page_index] == 0)
 							return BAN::Error::from_errno(ENOMEM);
-						PageTable::with_fast_page(m_shared_data->pages[shared_page_index], [&] {
+						PageTable::with_per_cpu_fast_page(m_shared_data->pages[shared_page_index], [&](void* addr) {
-							memcpy(PageTable::fast_page_as_ptr(), page_buffer, PAGE_SIZE);
+							memcpy(addr, page_buffer, PAGE_SIZE);
 						});
 						shared_data_has_correct_page = true;
 					}
@@ -181,12 +182,12 @@ namespace Kernel
 					return BAN::Error::from_errno(ENOMEM);
 				if (!shared_data_has_correct_page)
 				{
-					PageTable::with_fast_page(m_shared_data->pages[shared_page_index], [&] {
+					PageTable::with_per_cpu_fast_page(m_shared_data->pages[shared_page_index], [&](void* addr) {
-						memcpy(page_buffer, PageTable::fast_page_as_ptr(), PAGE_SIZE);
+						memcpy(page_buffer, addr, PAGE_SIZE);
 					});
 				}
-				PageTable::with_fast_page(paddr, [&] {
+				PageTable::with_per_cpu_fast_page(paddr, [&](void* addr) {
-					memcpy(PageTable::fast_page_as_ptr(), page_buffer, PAGE_SIZE);
+					memcpy(addr, page_buffer, PAGE_SIZE);
 				});
 				m_dirty_pages[local_page_index] = paddr;
 				m_page_table.map_page_at(paddr, vaddr, m_flags);
@@ -210,8 +211,8 @@ namespace Kernel
 				return BAN::Error::from_errno(ENOMEM);
 
 			ASSERT(&m_page_table == &PageTable::current());
-			PageTable::with_fast_page(paddr, [vaddr] {
+			PageTable::with_per_cpu_fast_page(paddr, [vaddr](void* addr) {
-				memcpy(PageTable::fast_page_as_ptr(), reinterpret_cast<void*>(vaddr), PAGE_SIZE);
+				memcpy(addr, reinterpret_cast<void*>(vaddr), PAGE_SIZE);
 			});
 
 			m_dirty_pages[local_page_index] = paddr;
@@ -240,8 +241,8 @@ namespace Kernel
 				return BAN::Error::from_errno(ENOMEM);
 
 			ASSERT(&m_page_table == &PageTable::current() || &m_page_table == &PageTable::kernel());
-			PageTable::with_fast_page(paddr, [&] {
+			PageTable::with_per_cpu_fast_page(paddr, [&](void* addr) {
-				memcpy(PageTable::fast_page_as_ptr(), reinterpret_cast<void*>(vaddr), PAGE_SIZE);
+				memcpy(addr, reinterpret_cast<void*>(vaddr), PAGE_SIZE);
 			});
 
 			result->m_page_table.map_page_at(paddr, vaddr, m_flags);

kernel/kernel/Memory/MemoryBackedRegion.cpp

@@ -64,8 +64,8 @@ namespace Kernel
 				return BAN::Error::from_errno(ENOMEM);
 
 			m_page_table.map_page_at(paddr, vaddr, m_flags);
-			PageTable::with_fast_page(paddr, [] {
+			PageTable::with_per_cpu_fast_page(paddr, [](void* addr) {
-				memset(PageTable::fast_page_as_ptr(), 0x00, PAGE_SIZE);
+				memset(addr, 0x00, PAGE_SIZE);
 			});
 
 			return true;
@@ -93,8 +93,8 @@ namespace Kernel
 		m_page_table.map_page_at(paddr, vaddr, m_flags);
 
 		ASSERT(&m_page_table == &PageTable::current());
-		PageTable::with_fast_page(physical_page->paddr, [vaddr] {
+		PageTable::with_per_cpu_fast_page(physical_page->paddr, [vaddr](void* addr) {
-			memcpy(reinterpret_cast<void*>(vaddr), PageTable::fast_page_as_ptr(), PAGE_SIZE);
+			memcpy(reinterpret_cast<void*>(vaddr), addr, PAGE_SIZE);
 		});
 
 		if (--physical_page->ref_count == 0)
@@ -164,9 +164,9 @@ namespace Kernel
 		size_t written = 0;
 		while (written < buffer_size)
 		{
-			vaddr_t write_vaddr = m_vaddr + offset_into_region + written;
+			const vaddr_t write_vaddr = m_vaddr + offset_into_region + written;
-			vaddr_t page_offset = write_vaddr % PAGE_SIZE;
+			const vaddr_t page_offset = write_vaddr % PAGE_SIZE;
-			size_t bytes = BAN::Math::min<size_t>(buffer_size - written, PAGE_SIZE - page_offset);
+			const size_t bytes = BAN::Math::min<size_t>(buffer_size - written, PAGE_SIZE - page_offset);
 
 			if (!(m_page_table.get_page_flags(write_vaddr & PAGE_ADDR_MASK) & PageTable::ReadWrite))
 			{
@@ -180,8 +180,8 @@ namespace Kernel
 			const paddr_t paddr = m_page_table.physical_address_of(write_vaddr & PAGE_ADDR_MASK);
 			ASSERT(paddr);
 
-			PageTable::with_fast_page(paddr, [&] {
+			PageTable::with_per_cpu_fast_page(paddr, [&](void* addr) {
-				memcpy(PageTable::fast_page_as_ptr(page_offset), (void*)(buffer + written), bytes);
+				memcpy(static_cast<uint8_t*>(addr) + page_offset, (void*)(buffer + written), bytes);
 			});
 
 			written += bytes;

kernel/kernel/Memory/PhysicalRange.cpp

@@ -21,8 +21,8 @@ namespace Kernel
 		const size_t bitmap_page_count = BAN::Math::div_round_up<size_t>(m_page_count, bits_per_page);
 		for (size_t i = 0; i < bitmap_page_count; i++)
 		{
-			PageTable::with_fast_page(paddr + i * PAGE_SIZE, [] {
+			PageTable::with_per_cpu_fast_page(paddr + i * PAGE_SIZE, [](void* addr) {
-				memset(PageTable::fast_page_as_ptr(), 0, PAGE_SIZE);
+				memset(addr, 0, PAGE_SIZE);
 			});
 		}
 
@@ -40,15 +40,15 @@ namespace Kernel
 			BAN::Optional<size_t> page_matched_bit;
 
 			const paddr_t current_paddr = m_paddr + i * PAGE_SIZE;
-			PageTable::with_fast_page(current_paddr, [&page_matched_bit] {
+			PageTable::with_per_cpu_fast_page(current_paddr, [&page_matched_bit](void* addr) {
 				for (size_t j = 0; j < PAGE_SIZE / sizeof(size_t); j++)
 				{
 					static_assert(sizeof(size_t) == sizeof(long));
-					const size_t current = PageTable::fast_page_as_sized<volatile size_t>(j);
+					auto& current = static_cast<size_t*>(addr)[j];
 					if (current == BAN::numeric_limits<size_t>::max())
 						continue;
 					const int ctz = __builtin_ctzl(~current);
-					PageTable::fast_page_as_sized<volatile size_t>(j) = current | (static_cast<size_t>(1) << ctz);
+					current |= static_cast<size_t>(1) << ctz;
 					page_matched_bit = j * sizeof(size_t) * 8 + ctz;
 					return;
 				}
@@ -75,15 +75,14 @@ namespace Kernel
 
 		const size_t paddr_index = (paddr - m_paddr) / PAGE_SIZE;
 
-		PageTable::with_fast_page(m_paddr + paddr_index / bits_per_page * PAGE_SIZE, [paddr_index] {
+		PageTable::with_per_cpu_fast_page(m_paddr + paddr_index / bits_per_page * PAGE_SIZE, [paddr_index] (void* addr) {
 			const size_t bitmap_bit = paddr_index % bits_per_page;
 			const size_t byte       = bitmap_bit / 8;
 			const size_t bit        = bitmap_bit % 8;
 
-			volatile uint8_t& bitmap_byte = PageTable::fast_page_as_sized<volatile uint8_t>(byte);
+			uint8_t& bitmap_byte = static_cast<uint8_t*>(addr)[byte];
 			ASSERT(bitmap_byte & (1u << bit));
-
+			bitmap_byte &= ~(1u << bit);
-			bitmap_byte = bitmap_byte & ~(1u << bit);
 		});
 
 		m_free_pages++;
@@ -103,8 +102,8 @@ namespace Kernel
 				const size_t bit  = bit_index % 8;
 
 				uint8_t current;
-				PageTable::with_fast_page(m_paddr + page_index * PAGE_SIZE, [&current, byte] {
+				PageTable::with_per_cpu_fast_page(m_paddr + page_index * PAGE_SIZE, [&current, byte](void* addr) {
-					current = PageTable::fast_page_as_sized<volatile uint8_t>(byte);
+					current = static_cast<uint8_t*>(addr)[byte];
 				});
 
 				return current & (1u << bit);
@@ -117,9 +116,9 @@ namespace Kernel
 				const size_t bit_index  = buffer_bit % bits_per_page;
 				const size_t byte = bit_index / 8;
 				const size_t bit  = bit_index % 8;
-				PageTable::with_fast_page(m_paddr + page_index * PAGE_SIZE, [byte, bit] {
+				PageTable::with_per_cpu_fast_page(m_paddr + page_index * PAGE_SIZE, [byte, bit](void* addr) {
-					volatile uint8_t& current = PageTable::fast_page_as_sized<volatile uint8_t>(byte);
+					uint8_t& current = static_cast<uint8_t*>(addr)[byte];
-					current = current | (1u << bit);
+					current |= 1u << bit;
 				});
 			};
 

kernel/kernel/Memory/SharedMemoryObject.cpp

@@ -112,8 +112,8 @@ namespace Kernel
 			paddr = Heap::get().take_free_page();
 			if (paddr == 0)
 				return BAN::Error::from_errno(ENOMEM);
-			PageTable::with_fast_page(paddr, [&] {
+			PageTable::with_per_cpu_fast_page(paddr, [&](void* addr) {
-				memset(PageTable::fast_page_as_ptr(), 0x00, PAGE_SIZE);
+				memset(addr, 0x00, PAGE_SIZE);
 			});
 			m_object->paddrs[(vaddr - m_vaddr) / PAGE_SIZE] = paddr;
 		}

kernel/kernel/Networking/ARPTable.cpp

@@ -12,8 +12,8 @@ namespace Kernel
 		Reply = 2,
 	};
 
-	static constexpr BAN::IPv4Address	s_broadcast_ipv4 { 0xFFFFFFFF };
+	static constexpr BAN::IPv4Address s_broadcast_ipv4 { 0xFFFFFFFF };
-	static constexpr BAN::MACAddress	s_broadcast_mac {{ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }};
+	static constexpr BAN::MACAddress  s_broadcast_mac  {{ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }};
 
 	BAN::ErrorOr<BAN::UniqPtr<ARPTable>> ARPTable::create()
 	{
@@ -50,18 +50,19 @@ namespace Kernel
 				return it->value;
 		}
 
-		ARPPacket arp_request;
+		const auto arp_request = ARPPacket {
-		arp_request.htype = 0x0001;
+			.htype = 0x0001,
-		arp_request.ptype = EtherType::IPv4;
+			.ptype = EtherType::IPv4,
-		arp_request.hlen = 0x06;
+			.hlen = 0x06,
-		arp_request.plen = 0x04;
+			.plen = 0x04,
-		arp_request.oper = ARPOperation::Request;
+			.oper = ARPOperation::Request,
-		arp_request.sha = interface.get_mac_address();
+			.sha = interface.get_mac_address(),
-		arp_request.spa = interface.get_ipv4_address();
+			.spa = interface.get_ipv4_address(),
-		arp_request.tha = {{ 0, 0, 0, 0, 0, 0 }};
+			.tha = {{ 0, 0, 0, 0, 0, 0 }},
-		arp_request.tpa = ipv4_address;
+			.tpa = ipv4_address,
+		};
 
-		TRY(interface.send_bytes(s_broadcast_mac, EtherType::ARP, BAN::ConstByteSpan::from(arp_request)));
+		TRY(interface.send_with_ethernet_header(s_broadcast_mac, EtherType::ARP, BAN::ConstByteSpan::from(arp_request)));
 
 		uint64_t timeout = SystemTimer::get().ms_since_boot() + 1'000;
 		while (SystemTimer::get().ms_since_boot() < timeout)
@@ -100,7 +101,7 @@ namespace Kernel
 			{
 				if (packet.tpa == interface.get_ipv4_address())
 				{
-					const ARPPacket arp_reply {
+					const auto arp_reply = ARPPacket {
 						.htype = 0x0001,
 						.ptype = EtherType::IPv4,
 						.hlen = 0x06,
@@ -111,7 +112,7 @@ namespace Kernel
 						.tha = packet.sha,
 						.tpa = packet.spa,
 					};
-					TRY(interface.send_bytes(packet.sha, EtherType::ARP, BAN::ConstByteSpan::from(arp_reply)));
+					TRY(interface.send_with_ethernet_header(packet.sha, EtherType::ARP, BAN::ConstByteSpan::from(arp_reply)));
 				}
 				break;
 			}

kernel/kernel/Networking/E1000/E1000.cpp

@@ -202,6 +202,8 @@ namespace Kernel
 		rctrl |= RCTL_BSIZE_8192;
 		write32(REG_RCTL, rctrl);
 
+		write32(REG_RXCSUM, RXSUM_IPOFLD | RXSUM_TUOFLD);
+
 		return {};
 	}
 
@@ -279,9 +281,13 @@ namespace Kernel
 		return {};
 	}
 
-	BAN::ErrorOr<void> E1000::send_bytes(BAN::MACAddress destination, EtherType protocol, BAN::Span<const BAN::ConstByteSpan> payload)
+	BAN::ErrorOr<void> E1000::send_raw_bytes(BAN::Span<const BAN::ConstByteSpan> buffers)
 	{
-		const uint32_t tx_current = m_tx_head1.fetch_add(1) % E1000_TX_DESCRIPTOR_COUNT;
+		const auto interrupt_state = Processor::get_interrupt_state();
+		Processor::set_interrupt_state(InterruptState::Disabled);
+
+		const uint32_t tx_current_nowrap = m_tx_head.fetch_add(1);
+		const uint32_t tx_current = tx_current_nowrap % E1000_TX_DESCRIPTOR_COUNT;
 
 		auto& descriptor = reinterpret_cast<volatile e1000_tx_desc*>(m_tx_descriptor_region->vaddr())[tx_current];
 		while (descriptor.status == 0)
@@ -289,15 +295,10 @@ namespace Kernel
 
 		auto* tx_buffer = reinterpret_cast<uint8_t*>(m_tx_buffer_region->vaddr() + E1000_TX_BUFFER_SIZE * tx_current);
 
-		auto& ethernet_header = *reinterpret_cast<EthernetHeader*>(tx_buffer);
+		size_t packet_size = 0;
-		ethernet_header.dst_mac = destination;
+		for (const auto& buffer : buffers)
-		ethernet_header.src_mac = get_mac_address();
-		ethernet_header.ether_type = protocol;
-
-		size_t packet_size = sizeof(EthernetHeader);
-		for (const auto& buffer : payload)
 		{
-			ASSERT(packet_size + buffer.size() < E1000_TX_BUFFER_SIZE);
+			ASSERT(packet_size + buffer.size() <= E1000_TX_BUFFER_SIZE);
 			memcpy(tx_buffer + packet_size, buffer.data(), buffer.size());
 			packet_size += buffer.size();
 		}
@@ -306,8 +307,12 @@ namespace Kernel
 		descriptor.status = 0;
 		descriptor.cmd = CMD_EOP | CMD_IFCS | CMD_RS;
 
-		if (tx_current == m_tx_head2.fetch_add(1) % E1000_TX_DESCRIPTOR_COUNT)
+		while (tx_current_nowrap != m_tx_commit.load())
-			write32(REG_TDT, (tx_current + 1) % E1000_TX_DESCRIPTOR_COUNT);
+			Processor::pause();
+		write32(REG_TDT, (tx_current + 1) % E1000_TX_DESCRIPTOR_COUNT);
+		m_tx_commit.add_fetch(1);
+
+		Processor::set_interrupt_state(interrupt_state);
 
 		dprintln_if(DEBUG_E1000, "sent {} bytes", packet_size);
 
@@ -316,35 +321,66 @@ namespace Kernel
 
 	void E1000::receive_thread()
 	{
-		SpinLockGuard _(m_rx_lock);
+		SpinLockGuard guard(m_rx_lock);
+
+		uint32_t rx_current = 0;
 
 		while (!m_thread_should_die)
 		{
+			uint32_t rx_tail = rx_current;
+
 			for (;;)
 			{
-				const uint32_t rx_current = (read32(REG_RDT0) + 1) % E1000_RX_DESCRIPTOR_COUNT;
-
 				auto& descriptor = reinterpret_cast<volatile e1000_rx_desc*>(m_rx_descriptor_region->vaddr())[rx_current];
-				if (!(descriptor.status & 1))
+
+				const auto status = descriptor.status;
+				if (!(status & RX_STS_DD))
 					break;
-				ASSERT(descriptor.length <= E1000_RX_BUFFER_SIZE);
 
-				dprintln_if(DEBUG_E1000, "got {} bytes", (uint16_t)descriptor.length);
+				const auto errors = descriptor.errors;
+				if (!(status & RX_STS_EOP))
+					dwarnln("multi descriptor packet??");
+				else if (errors & (RX_ERR_CE | RX_ERR_SE | RX_ERR_RXE))
+					dwarnln("descriptor error {2h}", errors);
+				else if ((status & RX_STS_IPCS) && (errors & RX_ERR_IPE))
+					dwarnln("IPv4 checksum error");
+				else if ((status & RX_STS_TCPCS) && (errors & RX_ERR_TCPE))
+					dwarnln("TCP checkum error");
+				else if ((status & RX_STS_UDPCS) && (errors & RX_ERR_TCPE))
+					dwarnln("UDP checksum error");
+				else
+				{
+					m_rx_lock.unlock(InterruptState::Enabled);
 
-				m_rx_lock.unlock(InterruptState::Enabled);
+					const uint32_t packet_length = descriptor.length;
+					ASSERT(packet_length <= E1000_RX_BUFFER_SIZE);
 
-				NetworkManager::get().on_receive(*this, BAN::ConstByteSpan {
+					dprintln_if(DEBUG_E1000, "got {} bytes", packet_length);
-					reinterpret_cast<const uint8_t*>(m_rx_buffer_region->vaddr() + rx_current * E1000_RX_BUFFER_SIZE),
-					descriptor.length
-				});
 
-				m_rx_lock.lock();
+					uint32_t validated_cksums = 0;
+					if ((status & RX_STS_IPCS) && !(errors & RX_ERR_IPE))
+						validated_cksums |= CKSUM_IPV4;
+					if ((status & RX_STS_TCPCS) && !(errors & RX_ERR_TCPE))
+						validated_cksums |= CKSUM_TCP;
+					if ((status & RX_STS_UDPCS) && !(errors & RX_ERR_TCPE))
+						validated_cksums |= CKSUM_UDP;
+
+					const uint8_t* packet_data = reinterpret_cast<const uint8_t*>(m_rx_buffer_region->vaddr() + rx_current * E1000_RX_BUFFER_SIZE);
+					NetworkManager::get().on_receive(*this, BAN::ConstByteSpan { packet_data, packet_length }, validated_cksums);
+
+					m_rx_lock.lock();
+				}
 
 				descriptor.status = 0;
-				write32(REG_RDT0, rx_current);
+
+				rx_tail = rx_current;
+				rx_current = (rx_current + 1) % E1000_RX_DESCRIPTOR_COUNT;
 			}
 
-			SpinLockAsMutex smutex(m_rx_lock, InterruptState::Enabled);
+			if (rx_current != rx_tail)
+				write32(REG_RDT0, rx_tail);
+
+			SpinLockGuardAsMutex smutex(guard);
 			m_rx_blocker.block_indefinite(&smutex);
 		}
 

kernel/kernel/Networking/IPv4Layer.cpp

@@ -180,7 +180,7 @@ namespace Kernel
 		return {};
 	}
 
-	BAN::ErrorOr<size_t> IPv4Layer::sendto(NetworkSocket& socket, BAN::ConstByteSpan payload, const sockaddr* address, socklen_t address_len)
+	BAN::ErrorOr<void> IPv4Layer::sendto(NetworkSocket& socket, BAN::ConstByteSpan payload, const sockaddr* address, socklen_t address_len)
 	{
 		if (address->sa_family != AF_INET)
 			return BAN::Error::from_errno(EINVAL);
@@ -224,23 +224,21 @@ namespace Kernel
 		};
 
 		uint8_t protocol_header_buffer[32];
-		ASSERT(socket.protocol_header_size() < sizeof(protocol_header_buffer));
-
 		auto protocol_header = BAN::ByteSpan::from(protocol_header_buffer).slice(0, socket.protocol_header_size());
 		socket.get_protocol_header(protocol_header, payload, dst_port, pseudo_header);
 
-		BAN::ConstByteSpan buffers[] {
+		const BAN::ConstByteSpan buffers[] {
 			BAN::ConstByteSpan::from(ipv4_header),
 			protocol_header,
 			payload,
 		};
 
-		TRY(interface->send_bytes(dst_mac, EtherType::IPv4, { buffers, sizeof(buffers) / sizeof(*buffers) }));
+		TRY(interface->send_with_ethernet_header(dst_mac, EtherType::IPv4, buffers));
 
-		return payload.size();
+		return {};
 	}
 
-	BAN::ErrorOr<void> IPv4Layer::handle_ipv4_packet(NetworkInterface& interface, BAN::ConstByteSpan packet)
+	BAN::ErrorOr<void> IPv4Layer::handle_ipv4_packet(NetworkInterface& interface, BAN::ConstByteSpan packet, uint32_t validated_cksums)
 	{
 		if (packet.size() < sizeof(IPv4Header))
 		{
@@ -249,7 +247,7 @@ namespace Kernel
 		}
 
 		auto& ipv4_header = packet.as<const IPv4Header>();
-		if (calculate_internet_checksum(BAN::ConstByteSpan::from(ipv4_header)) != 0)
+		if (!(validated_cksums & CKSUM_IPV4) && calculate_internet_checksum(BAN::ConstByteSpan::from(ipv4_header)) != 0)
 		{
 			dwarnln_if(DEBUG_IPV4, "IPv4 packet checksum failed");
 			return {};
@@ -284,34 +282,33 @@ namespace Kernel
 				{
 					case ICMPType::EchoRequest:
 					{
-						auto dst_mac = TRY(m_arp_table->get_mac_from_ipv4(interface, src_ipv4));
+						const auto dst_mac = TRY(m_arp_table->get_mac_from_ipv4(interface, src_ipv4));
 
-						auto send_ipv4_header = get_ipv4_header(
+						const auto send_ipv4_header = get_ipv4_header(
 							ipv4_data.size(),
 							interface.get_ipv4_address(),
 							src_ipv4,
 							NetworkProtocol::ICMP
 						);
 
-						ICMPHeader send_icmp_header {
+						auto send_icmp_header = ICMPHeader {
 							.type = ICMPType::EchoReply,
 							.code = icmp_header.code,
 							.checksum = 0,
 							.rest = icmp_header.rest,
 						};
 
-						auto send_payload = ipv4_data.slice(sizeof(ICMPHeader));
-
 						const BAN::ConstByteSpan send_buffers[] {
 							BAN::ConstByteSpan::from(send_ipv4_header),
 							BAN::ConstByteSpan::from(send_icmp_header),
-							send_payload
+							ipv4_data.slice(sizeof(ICMPHeader))
 						};
-						auto send_buffers_span = BAN::Span { send_buffers, sizeof(send_buffers) / sizeof(*send_buffers) };
 
-						send_icmp_header.checksum = calculate_internet_checksum(send_buffers_span.slice(1));
+						send_icmp_header.checksum = calculate_internet_checksum({
+							send_buffers + 1, sizeof(send_buffers) / sizeof(*send_buffers) - 1
+						});
 
-						TRY(interface.send_bytes(dst_mac, EtherType::IPv4, send_buffers_span));
+						TRY(interface.send_with_ethernet_header(dst_mac, EtherType::IPv4, send_buffers));
 
 						break;
 					}
@@ -389,7 +386,7 @@ namespace Kernel
 		sender.sin_family = AF_INET;
 		sender.sin_port = BAN::host_to_network_endian(src_port);
 		sender.sin_addr.s_addr = src_ipv4.raw;
-		bound_socket->receive_packet(ipv4_data, reinterpret_cast<const sockaddr*>(&sender), sizeof(sender));
+		bound_socket->receive_packet(ipv4_data, reinterpret_cast<const sockaddr*>(&sender), sizeof(sender), validated_cksums);
 
 		return {};
 	}

kernel/kernel/Networking/Loopback.cpp

@@ -1,4 +1,4 @@
-#include <kernel/Lock/LockGuard.h>
+#include <kernel/Lock/SpinLockAsMutex.h>
 #include <kernel/Networking/Loopback.h>
 #include <kernel/Networking/NetworkManager.h>
 
@@ -54,12 +54,15 @@ namespace Kernel
 			Processor::yield();
 	}
 
-	BAN::ErrorOr<void> LoopbackInterface::send_bytes(BAN::MACAddress destination, EtherType protocol, BAN::Span<const BAN::ConstByteSpan> payload)
+	BAN::ErrorOr<void> LoopbackInterface::send_raw_bytes(BAN::Span<const BAN::ConstByteSpan> buffers)
 	{
+		const auto interrupt_state = Processor::get_interrupt_state();
+		Processor::set_interrupt_state(InterruptState::Disabled);
+
 		auto& descriptor =
 			[&]() -> Descriptor&
 			{
-				LockGuard _(m_buffer_lock);
+				SpinLockGuard guard(m_buffer_lock);
 				for (;;)
 				{
 					auto& descriptor = m_descriptors[m_buffer_head];
@@ -69,34 +72,31 @@ namespace Kernel
 						descriptor.state = 1;
 						return descriptor;
 					}
-					m_thread_blocker.block_indefinite(&m_buffer_lock);
+					SpinLockGuardAsMutex smutex(guard);
+					m_thread_blocker.block_indefinite(&smutex);
 				}
 			}();
 
-		auto& ethernet_header = *reinterpret_cast<EthernetHeader*>(descriptor.addr);
+		size_t packet_size = 0;
-		ethernet_header.dst_mac = destination;
+		for (const auto& buffer : buffers)
-		ethernet_header.src_mac = get_mac_address();
-		ethernet_header.ether_type = protocol;
-
-		size_t packet_size = sizeof(EthernetHeader);
-		for (const auto& buffer : payload)
 		{
 			ASSERT(packet_size + buffer.size() <= buffer_size);
 			memcpy(descriptor.addr + packet_size, buffer.data(), buffer.size());
 			packet_size += buffer.size();
 		}
 
-		LockGuard _(m_buffer_lock);
+		m_buffer_lock.lock();
 		descriptor.size = packet_size;
 		descriptor.state = 2;
 		m_thread_blocker.unblock();
+		m_buffer_lock.unlock(interrupt_state);
 
 		return {};
 	}
 
 	void LoopbackInterface::receive_thread()
 	{
-		LockGuard _(m_buffer_lock);
+		SpinLockGuard guard(m_buffer_lock);
 
 		while (!m_thread_should_die)
 		{
@@ -107,12 +107,9 @@ namespace Kernel
 					break;
 				m_buffer_tail = (m_buffer_tail + 1) % buffer_count;
 
-				m_buffer_lock.unlock();
+				m_buffer_lock.unlock(InterruptState::Enabled);
 
-				NetworkManager::get().on_receive(*this, {
+				NetworkManager::get().on_receive(*this, BAN::ConstByteSpan { descriptor.addr, descriptor.size }, 0);
-					descriptor.addr,
-					descriptor.size,
-				});
 
 				m_buffer_lock.lock();
 
@@ -121,7 +118,8 @@ namespace Kernel
 				m_thread_blocker.unblock();
 			}
 
-			m_thread_blocker.block_indefinite(&m_buffer_lock);
+			SpinLockGuardAsMutex smutex(guard);
+			m_thread_blocker.block_indefinite(&smutex);
 		}
 
 		m_thread_is_dead = true;

kernel/kernel/Networking/NetworkInterface.cpp

@@ -3,6 +3,8 @@
 #include <kernel/FS/DevFS/FileSystem.h>
 #include <kernel/Networking/NetworkInterface.h>
 
+#include <netinet/in.h>
+#include <net/if.h>
 #include <sys/sysmacros.h>
 #include <string.h>
 
@@ -25,7 +27,7 @@ namespace Kernel
 	}
 
 	NetworkInterface::NetworkInterface(Type type)
-		: CharacterDevice(0400, 0, 0)
+		: CharacterDevice(0664, 0, 0)
 		, m_type(type)
 	{
 		m_rdev = get_rdev(type);
@@ -43,4 +45,95 @@ namespace Kernel
 		}
 	}
 
+	BAN::ErrorOr<long> NetworkInterface::ioctl_impl(unsigned long request, void* arg)
+	{
+		if (arg == nullptr)
+		{
+			dprintln("No argument provided");
+			return BAN::Error::from_errno(EINVAL);
+		}
+
+		auto* ifreq = reinterpret_cast<struct ifreq*>(arg);
+
+		switch (request)
+		{
+			case SIOCGIFADDR:
+			{
+				auto& ifru_addr = *reinterpret_cast<sockaddr_in*>(&ifreq->ifr_ifru.ifru_addr);
+				ifru_addr.sin_family = AF_INET;
+				ifru_addr.sin_addr.s_addr = get_ipv4_address().raw;
+				return 0;
+			}
+			case SIOCSIFADDR:
+			{
+				auto& ifru_addr = *reinterpret_cast<const sockaddr_in*>(&ifreq->ifr_ifru.ifru_addr);
+				if (ifru_addr.sin_family != AF_INET)
+					return BAN::Error::from_errno(EADDRNOTAVAIL);
+				set_ipv4_address(BAN::IPv4Address { ifru_addr.sin_addr.s_addr });
+				dprintln("IPv4 address set to {}", get_ipv4_address());
+				return 0;
+			}
+			case SIOCGIFNETMASK:
+			{
+				auto& ifru_netmask = *reinterpret_cast<sockaddr_in*>(&ifreq->ifr_ifru.ifru_netmask);
+				ifru_netmask.sin_family = AF_INET;
+				ifru_netmask.sin_addr.s_addr = get_netmask().raw;
+				return 0;
+			}
+			case SIOCSIFNETMASK:
+			{
+				auto& ifru_netmask = *reinterpret_cast<const sockaddr_in*>(&ifreq->ifr_ifru.ifru_netmask);
+				if (ifru_netmask.sin_family != AF_INET)
+					return BAN::Error::from_errno(EADDRNOTAVAIL);
+				set_netmask(BAN::IPv4Address { ifru_netmask.sin_addr.s_addr });
+				dprintln("Netmask set to {}", get_netmask());
+				return 0;
+			}
+			case SIOCGIFGWADDR:
+			{
+				auto& ifru_gwaddr = *reinterpret_cast<sockaddr_in*>(&ifreq->ifr_ifru.ifru_gwaddr);
+				ifru_gwaddr.sin_family = AF_INET;
+				ifru_gwaddr.sin_addr.s_addr = get_gateway().raw;
+				return 0;
+			}
+			case SIOCSIFGWADDR:
+			{
+				auto& ifru_gwaddr = *reinterpret_cast<const sockaddr_in*>(&ifreq->ifr_ifru.ifru_gwaddr);
+				if (ifru_gwaddr.sin_family != AF_INET)
+					return BAN::Error::from_errno(EADDRNOTAVAIL);
+				set_gateway(BAN::IPv4Address { ifru_gwaddr.sin_addr.s_addr });
+				dprintln("Gateway set to {}", get_gateway());
+				return 0;
+			}
+			case SIOCGIFHWADDR:
+			{
+				auto mac_address = get_mac_address();
+				ifreq->ifr_ifru.ifru_hwaddr.sa_family = AF_INET;
+				memcpy(ifreq->ifr_ifru.ifru_hwaddr.sa_data, &mac_address, sizeof(mac_address));
+				return 0;
+			}
+			case SIOCGIFNAME:
+			{
+				auto& ifrn_name = ifreq->ifr_ifrn.ifrn_name;
+				ASSERT(name().size() < sizeof(ifrn_name));
+				memcpy(ifrn_name, name().data(), name().size());
+				ifrn_name[name().size()] = '\0';
+				return 0;
+			}
+			case SIOCGIFFLAGS:
+			{
+				int flags = 0;
+				if (link_up())
+					flags |= IFF_UP | IFF_RUNNING;
+				if (m_type == Type::Loopback)
+					flags |= IFF_LOOPBACK;
+				ifreq->ifr_ifru.ifru_flags = flags;
+				return 0;
+			}
+		}
+
+		return CharacterDevice::ioctl_impl(request, arg);
+	}
+
+
 }

kernel/kernel/Networking/NetworkManager.cpp

@@ -148,7 +148,7 @@ namespace Kernel
 		return {};
 	}
 
-	void NetworkManager::on_receive(NetworkInterface& interface, BAN::ConstByteSpan packet)
+	void NetworkManager::on_receive(NetworkInterface& interface, BAN::ConstByteSpan packet, uint32_t validated_cksums)
 	{
 		if (packet.size() < sizeof(EthernetHeader))
 			return;
@@ -163,7 +163,7 @@ namespace Kernel
 					dwarnln("ARP: {}", ret.error());
 				break;
 			case EtherType::IPv4:
-				if (auto ret = m_ipv4_layer->handle_ipv4_packet(interface, packet_data); ret.is_error())
+				if (auto ret = m_ipv4_layer->handle_ipv4_packet(interface, packet_data, validated_cksums); ret.is_error())
 					dwarnln("IPv4; {}", ret.error());
 				break;
 			default: