LibC: add strcasestr to string.h

Also don't depend on mesa or Xlib. We only need the protocol headers to
compile the project

BAN/include/BAN/MacroUtils.h

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

BAN/include/BAN/Math.h

@@ -6,19 +6,6 @@
 
 #include <float.h>
 
-// This is ugly but my clangd does not like including
-// intrinsic headers at all
-#if !defined(__SSE__) || !defined(__SSE2__)
-#pragma GCC push_options
-#ifndef __SSE__
-#pragma GCC target("sse")
-#endif
-#ifndef __SSE2__
-#pragma GCC target("sse2")
-#endif
-#define BAN_MATH_POP_OPTIONS
-#endif
-
 namespace BAN::Math
 {
 
@@ -49,12 +36,11 @@ namespace BAN::Math
 	template<integral T>
 	inline constexpr T gcd(T a, T b)
 	{
-		T t;
 		while (b)
 		{
-			t = b;
+			T temp = b;
 			b = a % b;
-			a = t;
+			a = temp;
 		}
 		return a;
 	}
@@ -79,25 +65,20 @@ namespace BAN::Math
 		return (x & (x - 1)) == 0;
 	}
 
-	template<BAN::integral T>
-	static constexpr bool will_multiplication_overflow(T a, T b)
+	template<integral T>
+	__attribute__((always_inline))
+	inline constexpr bool will_multiplication_overflow(T a, T b)
 	{
-		if (a == 0 || b == 0)
-			return false;
-		if ((a > 0) == (b > 0))
-			return a > BAN::numeric_limits<T>::max() / b;
-		else
-			return a < BAN::numeric_limits<T>::min() / b;
+		T dummy;
+		return __builtin_mul_overflow(a, b, &dummy);
 	}
 
-	template<BAN::integral T>
-	static constexpr bool will_addition_overflow(T a, T b)
+	template<integral T>
+	__attribute__((always_inline))
+	inline constexpr bool will_addition_overflow(T a, T b)
 	{
-		if (a > 0 && b > 0)
-			return a > BAN::numeric_limits<T>::max() - b;
-		if (a < 0 && b < 0)
-			return a < BAN::numeric_limits<T>::min() - b;
-		return false;
+		T dummy;
+		return __builtin_add_overflow(a, b, &dummy);
 	}
 
 	template<typename T>
@@ -111,6 +92,19 @@ namespace BAN::Math
 		return sizeof(T) * 8 - __builtin_clzll(x) - 1;
 	}
 
+// This is ugly but my clangd does not like including
+// intrinsic headers at all
+#if !defined(__SSE__) || !defined(__SSE2__)
+#pragma GCC push_options
+#ifndef __SSE__
+#pragma GCC target("sse")
+#endif
+#ifndef __SSE2__
+#pragma GCC target("sse2")
+#endif
+#define BAN_MATH_POP_OPTIONS
+#endif
+
 	template<floating_point T>
 	inline constexpr T floor(T x)
 	{
@@ -172,7 +166,23 @@ namespace BAN::Math
 			"jne 1b;"
 			: "+t"(a)
 			: "u"(b)
-			: "ax"
+			: "ax", "cc"
+		);
+		return a;
+	}
+
+	template<floating_point T>
+	inline constexpr T remainder(T a, T b)
+	{
+		asm(
+			"1:"
+			"fprem1;"
+			"fnstsw %%ax;"
+			"testb $4, %%ah;"
+			"jne 1b;"
+			: "+t"(a)
+			: "u"(b)
+			: "ax", "cc"
 		);
 		return a;
 	}
@@ -447,9 +457,9 @@ namespace BAN::Math
 		return sqrt<T>(x * x + y * y);
 	}
 
-}
-
 #ifdef BAN_MATH_POP_OPTIONS
 #undef BAN_MATH_POP_OPTIONS
 #pragma GCC pop_options
 #endif
+
+}

kernel/CMakeLists.txt

@@ -139,6 +139,7 @@ if("${BANAN_ARCH}" STREQUAL "x86_64")
 		arch/x86_64/Signal.S
 		arch/x86_64/Syscall.S
 		arch/x86_64/Thread.S
+		arch/x86_64/User.S
 		arch/x86_64/Yield.S
 	)
 elseif("${BANAN_ARCH}" STREQUAL "i686")
@@ -150,6 +151,7 @@ elseif("${BANAN_ARCH}" STREQUAL "i686")
 		arch/i686/Signal.S
 		arch/i686/Syscall.S
 		arch/i686/Thread.S
+		arch/i686/User.S
 		arch/i686/Yield.S
 	)
 else()
@@ -166,10 +168,7 @@ set(BAN_SOURCES
 set(KLIBC_SOURCES
 	klibc/ctype.cpp
 	klibc/string.cpp
-
-	# Ehhh don't do this but for now libc uses the same stuff kernel can use
-	# This won't work after libc starts using sse implemetations tho
-	../userspace/libraries/LibC/arch/${BANAN_ARCH}/string.S
+	klibc/arch/${BANAN_ARCH}/string.S
 )
 
 set(LIBDEFLATE_SOURCE

kernel/arch/i686/PageTable.cpp

@@ -21,6 +21,11 @@ namespace Kernel
 
 	SpinLock PageTable::s_fast_page_lock;
 
+	constexpr uint64_t s_page_flag_mask = 0x8000000000000FFF;
+	constexpr uint64_t s_page_addr_mask = ~s_page_flag_mask;
+
+	static bool s_is_post_heap_done = false;
+
 	static PageTable* s_kernel = nullptr;
 	static bool s_has_nxe = false;
 	static bool s_has_pge = false;
@@ -67,7 +72,7 @@ namespace Kernel
 
 	void PageTable::initialize_post_heap()
 	{
-		// NOTE: this is no-op as our 32 bit target does not use hhdm
+		s_is_post_heap_done = true;
 	}
 
 	void PageTable::initial_load()
@@ -141,9 +146,9 @@ namespace Kernel
 	}
 
 	template<typename T>
-	static vaddr_t P2V(const T paddr)
+	static uint64_t* P2V(const T paddr)
 	{
-		return (paddr_t)paddr - g_boot_info.kernel_paddr + KERNEL_OFFSET;
+		return reinterpret_cast<uint64_t*>(reinterpret_cast<paddr_t>(paddr) - g_boot_info.kernel_paddr + KERNEL_OFFSET);
 	}
 
 	void PageTable::initialize_kernel()
@@ -193,13 +198,18 @@ namespace Kernel
 	{
 		constexpr uint64_t pdpte = (fast_page() >> 30) & 0x1FF;
 		constexpr uint64_t pde   = (fast_page() >> 21) & 0x1FF;
+		constexpr uint64_t pte   = (fast_page() >> 12) & 0x1FF;
 
-		uint64_t* pdpt = reinterpret_cast<uint64_t*>(P2V(m_highest_paging_struct));
+		const uint64_t* pdpt = P2V(m_highest_paging_struct);
 		ASSERT(pdpt[pdpte] & Flags::Present);
 
-		uint64_t* pd = reinterpret_cast<uint64_t*>(P2V(pdpt[pdpte]) & PAGE_ADDR_MASK);
+		uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
 		ASSERT(!(pd[pde] & Flags::Present));
 		pd[pde] = V2P(allocate_zeroed_page_aligned_page()) | Flags::ReadWrite | Flags::Present;
+
+		uint64_t* pt = P2V(pd[pde] & s_page_addr_mask);
+		ASSERT(pt[pte] == 0);
+		pt[pte] = Flags::Reserved;
 	}
 
 	void PageTable::map_fast_page(paddr_t paddr)
@@ -214,9 +224,9 @@ namespace Kernel
 		constexpr uint64_t pde   = (fast_page() >> 21) & 0x1FF;
 		constexpr uint64_t pte   = (fast_page() >> 12) & 0x1FF;
 
-		uint64_t* pdpt = reinterpret_cast<uint64_t*>(P2V(s_kernel->m_highest_paging_struct));
-		uint64_t* pd   = reinterpret_cast<uint64_t*>(P2V(pdpt[pdpte] & PAGE_ADDR_MASK));
-		uint64_t* pt   = reinterpret_cast<uint64_t*>(P2V(pd[pde] & PAGE_ADDR_MASK));
+		uint64_t* pdpt = P2V(s_kernel->m_highest_paging_struct);
+		uint64_t* pd   = P2V(pdpt[pdpte] & s_page_addr_mask);
+		uint64_t* pt   = P2V(pd[pde] & s_page_addr_mask);
 
 		ASSERT(!(pt[pte] & Flags::Present));
 		pt[pte] = paddr | Flags::ReadWrite | Flags::Present;
@@ -234,12 +244,12 @@ namespace Kernel
 		constexpr uint64_t pde   = (fast_page() >> 21) & 0x1FF;
 		constexpr uint64_t pte   = (fast_page() >> 12) & 0x1FF;
 
-		uint64_t* pdpt = reinterpret_cast<uint64_t*>(P2V(s_kernel->m_highest_paging_struct));
-		uint64_t* pd   = reinterpret_cast<uint64_t*>(P2V(pdpt[pdpte] & PAGE_ADDR_MASK));
-		uint64_t* pt   = reinterpret_cast<uint64_t*>(P2V(pd[pde] & PAGE_ADDR_MASK));
+		uint64_t* pdpt = P2V(s_kernel->m_highest_paging_struct);
+		uint64_t* pd   = P2V(pdpt[pdpte] & s_page_addr_mask);
+		uint64_t* pt   = P2V(pd[pde] & s_page_addr_mask);
 
 		ASSERT(pt[pte] & Flags::Present);
-		pt[pte] = 0;
+		pt[pte] = Flags::Reserved;
 
 		asm volatile("invlpg (%0)" :: "r"(fast_page()) : "memory");
 	}
@@ -263,7 +273,7 @@ namespace Kernel
 		m_highest_paging_struct = V2P(kmalloc(32, 32, true));
 		ASSERT(m_highest_paging_struct);
 
-		uint64_t* pdpt = reinterpret_cast<uint64_t*>(P2V(m_highest_paging_struct));
+		uint64_t* pdpt = P2V(m_highest_paging_struct);
 		pdpt[0] = 0;
 		pdpt[1] = 0;
 		pdpt[2] = 0;
@@ -276,18 +286,17 @@ namespace Kernel
 		if (m_highest_paging_struct == 0)
 			return;
 
-		uint64_t* pdpt = reinterpret_cast<uint64_t*>(P2V(m_highest_paging_struct));
-
+		uint64_t* pdpt = P2V(m_highest_paging_struct);
 		for (uint32_t pdpte = 0; pdpte < 3; pdpte++)
 		{
 			if (!(pdpt[pdpte] & Flags::Present))
 				continue;
-			uint64_t* pd = reinterpret_cast<uint64_t*>(P2V(pdpt[pdpte] & PAGE_ADDR_MASK));
+			uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
 			for (uint32_t pde = 0; pde < 512; pde++)
 			{
 				if (!(pd[pde] & Flags::Present))
 					continue;
-				kfree(reinterpret_cast<uint64_t*>(P2V(pd[pde] & PAGE_ADDR_MASK)));
+				kfree(P2V(pd[pde] & s_page_addr_mask));
 			}
 			kfree(pd);
 		}
@@ -298,15 +307,43 @@ namespace Kernel
 	{
 		SpinLockGuard _(m_lock);
 		ASSERT(m_highest_paging_struct < 0x100000000);
-		const uint32_t pdpt_lo = m_highest_paging_struct;
-		asm volatile("movl %0, %%cr3" :: "r"(pdpt_lo));
+		asm volatile("movl %0, %%cr3" :: "r"(static_cast<uint32_t>(m_highest_paging_struct)));
 		Processor::set_current_page_table(this);
 	}
 
-	void PageTable::invalidate(vaddr_t vaddr, bool send_smp_message)
+	void PageTable::invalidate_range(vaddr_t vaddr, size_t pages, bool send_smp_message)
 	{
 		ASSERT(vaddr % PAGE_SIZE == 0);
-		asm volatile("invlpg (%0)" :: "r"(vaddr) : "memory");
+
+		const bool is_userspace = (vaddr < KERNEL_OFFSET);
+		if (is_userspace && this != &PageTable::current())
+			;
+		else if (pages <= 32 || !s_is_post_heap_done)
+		{
+			for (size_t i = 0; i < pages; i++, vaddr += PAGE_SIZE)
+				asm volatile("invlpg (%0)" :: "r"(vaddr));
+		}
+		else if (is_userspace || !s_has_pge)
+		{
+			asm volatile("movl %0, %%cr3" :: "r"(static_cast<uint32_t>(m_highest_paging_struct)));
+		}
+		else
+		{
+			asm volatile(
+				"movl %%cr4, %%eax;"
+
+				"andl $~0x80, %%eax;"
+				"movl %%eax, %%cr4;"
+
+				"movl %0, %%cr3;"
+
+				"orl $0x80, %%eax;"
+				"movl %%eax, %%cr4;"
+				:
+				: "r"(static_cast<uint32_t>(m_highest_paging_struct))
+				: "eax"
+			);
+		}
 
 		if (send_smp_message)
 		{
@@ -314,14 +351,14 @@ namespace Kernel
 				.type = Processor::SMPMessage::Type::FlushTLB,
 				.flush_tlb = {
 					.vaddr      = vaddr,
-					.page_count = 1,
+					.page_count = pages,
 					.page_table = vaddr < KERNEL_OFFSET ? this : nullptr,
 				}
 			});
 		}
 	}
 
-	void PageTable::unmap_page(vaddr_t vaddr, bool send_smp_message)
+	void PageTable::unmap_page(vaddr_t vaddr, bool invalidate)
 	{
 		ASSERT(vaddr);
 		ASSERT(vaddr % PAGE_SIZE == 0);
@@ -340,16 +377,16 @@ namespace Kernel
 		if (is_page_free(vaddr))
 			Kernel::panic("trying to unmap unmapped page 0x{H}", vaddr);
 
-		uint64_t* pdpt = reinterpret_cast<uint64_t*>(P2V(m_highest_paging_struct));
-		uint64_t* pd   = reinterpret_cast<uint64_t*>(P2V(pdpt[pdpte] & PAGE_ADDR_MASK));
-		uint64_t* pt   = reinterpret_cast<uint64_t*>(P2V(pd[pde] & PAGE_ADDR_MASK));
+		uint64_t* pdpt = P2V(m_highest_paging_struct);
+		uint64_t* pd   = P2V(pdpt[pdpte] & s_page_addr_mask);
+		uint64_t* pt   = P2V(pd[pde] & s_page_addr_mask);
 
-		const paddr_t old_paddr = pt[pte] & PAGE_ADDR_MASK;
+		const paddr_t old_paddr = pt[pte] & s_page_addr_mask;
 
 		pt[pte] = 0;
 
-		if (old_paddr != 0)
-			invalidate(vaddr, send_smp_message);
+		if (invalidate && old_paddr != 0)
+			invalidate_page(vaddr, true);
 	}
 
 	void PageTable::unmap_range(vaddr_t vaddr, size_t size)
@@ -361,18 +398,10 @@ namespace Kernel
 		SpinLockGuard _(m_lock);
 		for (vaddr_t page = 0; page < page_count; page++)
 			unmap_page(vaddr + page * PAGE_SIZE, false);
-
-		Processor::broadcast_smp_message({
-			.type = Processor::SMPMessage::Type::FlushTLB,
-			.flush_tlb = {
-				.vaddr      = vaddr,
-				.page_count = page_count,
-				.page_table = vaddr < KERNEL_OFFSET ? this : nullptr,
-			}
-		});
+		invalidate_range(vaddr, page_count, true);
 	}
 
-	void PageTable::map_page_at(paddr_t paddr, vaddr_t vaddr, flags_t flags, MemoryType memory_type, bool send_smp_message)
+	void PageTable::map_page_at(paddr_t paddr, vaddr_t vaddr, flags_t flags, MemoryType memory_type, bool invalidate)
 	{
 		ASSERT(vaddr);
 		ASSERT(vaddr != fast_page());
@@ -407,11 +436,11 @@ namespace Kernel
 
 		SpinLockGuard _(m_lock);
 
-		uint64_t* pdpt = reinterpret_cast<uint64_t*>(P2V(m_highest_paging_struct));
+		uint64_t* pdpt = P2V(m_highest_paging_struct);
 		if (!(pdpt[pdpte] & Flags::Present))
 			pdpt[pdpte] = V2P(allocate_zeroed_page_aligned_page()) | Flags::Present;
 
-		uint64_t* pd = reinterpret_cast<uint64_t*>(P2V(pdpt[pdpte] & PAGE_ADDR_MASK));
+		uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
 		if ((pd[pde] & uwr_flags) != uwr_flags)
 		{
 			if (!(pd[pde] & Flags::Present))
@@ -422,14 +451,14 @@ namespace Kernel
 		if (!(flags & Flags::Present))
 			uwr_flags &= ~Flags::Present;
 
-		uint64_t* pt = reinterpret_cast<uint64_t*>(P2V(pd[pde] & PAGE_ADDR_MASK));
+		uint64_t* pt = P2V(pd[pde] & s_page_addr_mask);
 
-		const paddr_t old_paddr = pt[pte] & PAGE_ADDR_MASK;
+		const paddr_t old_paddr = pt[pte] & s_page_addr_mask;
 
 		pt[pte] = paddr | uwr_flags | extra_flags;
 
-		if (old_paddr != 0)
-			invalidate(vaddr, send_smp_message);
+		if (invalidate && old_paddr != 0)
+			invalidate_page(vaddr, true);
 	}
 
 	void PageTable::map_range_at(paddr_t paddr, vaddr_t vaddr, size_t size, flags_t flags, MemoryType memory_type)
@@ -443,15 +472,49 @@ namespace Kernel
 		SpinLockGuard _(m_lock);
 		for (size_t page = 0; page < page_count; page++)
 			map_page_at(paddr + page * PAGE_SIZE, vaddr + page * PAGE_SIZE, flags, memory_type, false);
-
-		Processor::broadcast_smp_message({
-			.type = Processor::SMPMessage::Type::FlushTLB,
-			.flush_tlb = {
-				.vaddr      = vaddr,
-				.page_count = page_count,
-				.page_table = vaddr < KERNEL_OFFSET ? this : nullptr,
+		invalidate_range(vaddr, page_count, true);
 	}
-		});
+
+	void PageTable::remove_writable_from_range(vaddr_t vaddr, size_t size)
+	{
+		ASSERT(vaddr);
+		ASSERT(vaddr % PAGE_SIZE == 0);
+
+		uint32_t pdpte = (vaddr >> 30) & 0x1FF;
+		uint32_t pde   = (vaddr >> 21) & 0x1FF;
+		uint32_t pte   = (vaddr >> 12) & 0x1FF;
+
+		const uint32_t e_pdpte = ((vaddr + size - 1) >> 30) & 0x1FF;
+		const uint32_t e_pde   = ((vaddr + size - 1) >> 21) & 0x1FF;
+		const uint32_t e_pte   = ((vaddr + size - 1) >> 12) & 0x1FF;
+
+		SpinLockGuard _(m_lock);
+
+		const uint64_t* pdpt = P2V(m_highest_paging_struct);
+		for (; pdpte <= e_pdpte; pdpte++)
+		{
+			if (!(pdpt[pdpte] & Flags::Present))
+				continue;
+			const uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
+			for (; pde < 512; pde++)
+			{
+				if (pdpte == e_pdpte && pde > e_pde)
+					break;
+				if (!(pd[pde] & Flags::ReadWrite))
+					continue;
+				uint64_t* pt = P2V(pd[pde] & s_page_addr_mask);
+				for (; pte < 512; pte++)
+				{
+					if (pdpte == e_pdpte && pde == e_pde && pte > e_pte)
+						break;
+					pt[pte] &= ~static_cast<uint64_t>(Flags::ReadWrite);
+				}
+				pte = 0;
+			}
+			pde = 0;
+		}
+
+		invalidate_range(vaddr, size / PAGE_SIZE, true);
 	}
 
 	uint64_t PageTable::get_page_data(vaddr_t vaddr) const
@@ -464,15 +527,15 @@ namespace Kernel
 
 		SpinLockGuard _(m_lock);
 
-		uint64_t* pdpt = (uint64_t*)P2V(m_highest_paging_struct);
+		const uint64_t* pdpt = P2V(m_highest_paging_struct);
 		if (!(pdpt[pdpte] & Flags::Present))
 			return 0;
 
-		uint64_t* pd = (uint64_t*)P2V(pdpt[pdpte] & PAGE_ADDR_MASK);
+		const uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
 		if (!(pd[pde] & Flags::Present))
 			return 0;
 
-		uint64_t* pt = (uint64_t*)P2V(pd[pde] & PAGE_ADDR_MASK);
+		const uint64_t* pt = P2V(pd[pde] & s_page_addr_mask);
 		if (!(pt[pte] & Flags::Used))
 			return 0;
 
@@ -486,8 +549,7 @@ namespace Kernel
 
 	paddr_t PageTable::physical_address_of(vaddr_t vaddr) const
 	{
-		uint64_t page_data = get_page_data(vaddr);
-		return (page_data & PAGE_ADDR_MASK) & ~(1ull << 63);
+		return get_page_data(vaddr) & s_page_addr_mask;
 	}
 
 	bool PageTable::is_page_free(vaddr_t vaddr) const
@@ -529,14 +591,8 @@ namespace Kernel
 			return false;
 		for (size_t offset = 0; offset < bytes; offset += PAGE_SIZE)
 			reserve_page(vaddr + offset, true, false);
-		Processor::broadcast_smp_message({
-			.type = Processor::SMPMessage::Type::FlushTLB,
-			.flush_tlb = {
-				.vaddr      = vaddr,
-				.page_count = bytes / PAGE_SIZE,
-				.page_table = vaddr < KERNEL_OFFSET ? this : nullptr,
-			}
-		});
+		invalidate_range(vaddr, bytes / PAGE_SIZE, true);
+
 		return true;
 	}
 
@@ -549,39 +605,37 @@ namespace Kernel
 		if (size_t rem = last_address % PAGE_SIZE)
 			last_address -= rem;
 
-		const uint32_t s_pdpte = (first_address >> 30) & 0x1FF;
-		const uint32_t s_pde   = (first_address >> 21) & 0x1FF;
-		const uint32_t s_pte   = (first_address >> 12) & 0x1FF;
+		uint32_t pdpte = (first_address >> 30) & 0x1FF;
+		uint32_t pde   = (first_address >> 21) & 0x1FF;
+		uint32_t pte   = (first_address >> 12) & 0x1FF;
 
-		const uint32_t e_pdpte = (last_address >> 30) & 0x1FF;
-		const uint32_t e_pde   = (last_address >> 21) & 0x1FF;
-		const uint32_t e_pte   = (last_address >> 12) & 0x1FF;
+		const uint32_t e_pdpte = ((last_address - 1) >> 30) & 0x1FF;
+		const uint32_t e_pde   = ((last_address - 1) >> 21) & 0x1FF;
+		const uint32_t e_pte   = ((last_address - 1) >> 12) & 0x1FF;
 
 		SpinLockGuard _(m_lock);
 
 		// Try to find free page that can be mapped without
 		// allocations (page table with unused entries)
-		uint64_t* pdpt = reinterpret_cast<uint64_t*>(P2V(m_highest_paging_struct));
-		for (uint32_t pdpte = s_pdpte; pdpte < 4; pdpte++)
+		const uint64_t* pdpt = P2V(m_highest_paging_struct);
+		for (; pdpte <= e_pdpte; pdpte++)
 		{
-			if (pdpte > e_pdpte)
-				break;
 			if (!(pdpt[pdpte] & Flags::Present))
 				continue;
-			uint64_t* pd = reinterpret_cast<uint64_t*>(P2V(pdpt[pdpte] & PAGE_ADDR_MASK));
-			for (uint32_t pde = s_pde; pde < 512; pde++)
+			const uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
+			for (; pde < 512; pde++)
 			{
 				if (pdpte == e_pdpte && pde > e_pde)
 					break;
 				if (!(pd[pde] & Flags::Present))
 					continue;
-				uint64_t* pt = (uint64_t*)P2V(pd[pde] & PAGE_ADDR_MASK);
-				for (uint32_t pte = s_pte; pte < 512; pte++)
+				const uint64_t* pt = P2V(pd[pde] & s_page_addr_mask);
+				for (; pte < 512; pte++)
 				{
-					if (pdpte == e_pdpte && pde == e_pde && pte >= e_pte)
+					if (pdpte == e_pdpte && pde == e_pde && pte > e_pte)
 						break;
-					if (!(pt[pte] & Flags::Used))
-					{
+					if (pt[pte] & Flags::Used)
+						continue;
 					vaddr_t vaddr = 0;
 					vaddr |= (vaddr_t)pdpte << 30;
 					vaddr |= (vaddr_t)pde   << 21;
@@ -589,8 +643,9 @@ namespace Kernel
 					ASSERT(reserve_page(vaddr));
 					return vaddr;
 				}
+				pte = 0;
 			}
-			}
+			pde = 0;
 		}
 
 		// Find any free page
@@ -603,7 +658,7 @@ namespace Kernel
 			}
 		}
 
-		ASSERT_NOT_REACHED();
+		return 0;
 	}
 
 	vaddr_t PageTable::reserve_free_contiguous_pages(size_t page_count, vaddr_t first_address, vaddr_t last_address)
@@ -636,7 +691,7 @@ namespace Kernel
 			}
 		}
 
-		ASSERT_NOT_REACHED();
+		return 0;
 	}
 
 	static void dump_range(vaddr_t start, vaddr_t end, PageTable::flags_t flags)
@@ -659,7 +714,7 @@ namespace Kernel
 		flags_t flags = 0;
 		vaddr_t start = 0;
 
-		uint64_t* pdpt = reinterpret_cast<uint64_t*>(P2V(m_highest_paging_struct));
+		const uint64_t* pdpt = P2V(m_highest_paging_struct);
 		for (uint32_t pdpte = 0; pdpte < 4; pdpte++)
 		{
 			if (!(pdpt[pdpte] & Flags::Present))
@@ -668,7 +723,7 @@ namespace Kernel
 				start = 0;
 				continue;
 			}
-			uint64_t* pd = (uint64_t*)P2V(pdpt[pdpte] & PAGE_ADDR_MASK);
+			const uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
 			for (uint64_t pde = 0; pde < 512; pde++)
 			{
 				if (!(pd[pde] & Flags::Present))
@@ -677,7 +732,7 @@ namespace Kernel
 					start = 0;
 					continue;
 				}
-				uint64_t* pt = (uint64_t*)P2V(pd[pde] & PAGE_ADDR_MASK);
+				const uint64_t* pt = P2V(pd[pde] & s_page_addr_mask);
 				for (uint64_t pte = 0; pte < 512; pte++)
 				{
 					if (parse_flags(pt[pte]) != flags)

kernel/arch/i686/Signal.S

@@ -1,12 +1,13 @@
 .section .userspace, "ax"
 
 // stack contains
-//    return address
-//    return stack
-//    return rflags
-//    siginfo_t
-//    signal number
-//    signal handler
+//    (4 bytes)  return address (on return stack)
+//    (4 bytes)  return stack
+//    (4 bytes)  return rflags
+//    (8 bytes)  restore sigmask
+//    (36 bytes) siginfo_t
+//    (4 bytes)  signal number
+//    (4 bytes)  signal handler
 
 .global signal_trampoline
 signal_trampoline:
@@ -18,6 +19,10 @@ signal_trampoline:
 	pushl %eax
 	pushl %ebp
 
+	movl 80(%esp), %eax
+	pushl %eax; addl $4, (%esp)
+	pushl (%eax)
+
 	// FIXME: populate these
 	xorl %eax, %eax
 	pushl %eax // stack
@@ -28,9 +33,9 @@ signal_trampoline:
 	pushl %eax // link
 
 	movl    %esp,  %edx // ucontext
-	leal 60(%esp), %esi // siginfo
-	movl 56(%esp), %edi // signal number
-	movl 52(%esp), %eax // handlers
+	leal 68(%esp), %esi // siginfo
+	movl 64(%esp), %edi // signal number
+	movl 60(%esp), %eax // handlers
 
 	// align stack to 16 bytes
 	movl %esp, %ebp
@@ -53,7 +58,15 @@ signal_trampoline:
 	movl %ebp, %esp
 	addl $24, %esp
 
+	// restore sigmask
+	movl $83, %eax      // SYS_SIGPROCMASK
+	movl $3,  %ebx      // SIG_SETMASK
+	leal 72(%esp), %ecx // set
+	xorl %edx, %edx     // oset
+	int $0xF0
+
 	// restore registers
+	addl $8, %esp
 	popl %ebp
 	popl %eax
 	popl %ebx
@@ -62,8 +75,8 @@ signal_trampoline:
 	popl %edi
 	popl %esi
 
-	// skip handler, number, siginfo_t
-	addl $44, %esp
+	// skip handler, number, siginfo_t, sigmask
+	addl $52, %esp
 
 	// restore flags
 	popf

kernel/arch/i686/Syscall.S

@@ -63,7 +63,7 @@ sys_fork_trampoline:
 
 	call read_ip
 	testl %eax, %eax
-	jz .reload_stack
+	jz .done
 
 	movl %esp, %ebx
 
@@ -79,9 +79,3 @@ sys_fork_trampoline:
 	popl %ebx
 	popl %ebp
 	ret
-
- .reload_stack:
-	call get_thread_start_sp
-	movl %eax, %esp
-	xorl %eax, %eax
-	jmp .done

kernel/arch/i686/Thread.S

@@ -7,9 +7,6 @@ read_ip:
 # void start_kernel_thread()
 .global start_kernel_thread
 start_kernel_thread:
-	call get_thread_start_sp
-	movl %eax, %esp
-
 	# STACK LAYOUT
 	#   on_exit arg
 	#   on_exit func
@@ -34,9 +31,6 @@ start_kernel_thread:
 
 .global start_userspace_thread
 start_userspace_thread:
-	call get_thread_start_sp
-	movl %eax, %esp
-
 	movw $(0x20 | 3), %bx
 	movw %bx, %ds
 	movw %bx, %es

kernel/arch/i686/User.S

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

kernel/arch/i686/boot.S

@@ -11,13 +11,14 @@
 
 .code32
 
-# multiboot2 header
+// video mode info, page align modules
+.set multiboot_flags, (1 << 2) | (1 << 0)
+
 .section .multiboot, "aw"
-	.align 8
 multiboot_start:
 	.long 0x1BADB002
-	.long (1 << 2) # page align modules
-	.long -(0x1BADB002 + (1 << 2))
+	.long multiboot_flags
+	.long -(0x1BADB002 + multiboot_flags)
 
 	.long 0
 	.long 0
@@ -30,7 +31,8 @@ multiboot_start:
 	.long FB_HEIGHT
 	.long FB_BPP
 multiboot_end:
-	.align 8
+
+.section .multiboot2, "aw"
 multiboot2_start:
 	.long 0xE85250D6
 	.long 0
@@ -66,7 +68,6 @@ multiboot2_start:
 multiboot2_end:
 
 .section .bananboot, "aw"
-	.align 8
 bananboot_start:
 	.long 0xBABAB007
 	.long -(0xBABAB007 + FB_WIDTH + FB_HEIGHT + FB_BPP)

kernel/arch/i686/interrupts.S

@@ -1,20 +1,20 @@
-.macro maybe_load_kernel_segments, n
-	testb $3, \n(%esp)
-	jz 1f; jnp 1f
-
+.macro intr_header, n
+	pushal
+	testb $3, \n+8*4(%esp)
+	jz 1f
 	movw $0x10, %ax
 	movw %ax, %ds
 	movw %ax, %es
 	movw %ax, %fs
 	movw $0x28, %ax
 	movw %ax, %gs
-1:
+1:	cld
 .endm
 
-.macro maybe_load_userspace_segments, n
-	testb $3, \n(%esp)
-	jz 1f; jnp 1f
-
+.macro intr_footer, n
+	testb $3, \n+8*4(%esp)
+	jz 1f
+	call cpp_check_signal
 	movw $(0x20 | 3), %bx
 	movw %bx, %ds
 	movw %bx, %es
@@ -22,14 +22,11 @@
 	movw %bx, %fs
 	movw $(0x38 | 3), %bx
 	movw %bx, %gs
-1:
+1:	popal
 .endm
 
 isr_stub:
-	pushal
-	maybe_load_kernel_segments 44
-	cld
-
+	intr_header 12
 	movl %cr0, %eax; pushl %eax
 	movl %cr2, %eax; pushl %eax
 	movl %cr3, %eax; pushl %eax
@@ -57,15 +54,12 @@ isr_stub:
 	movl %ebp, %esp
 	addl $24, %esp
 
-	maybe_load_userspace_segments 44
-	popal
+	intr_footer 12
 	addl $8, %esp
 	iret
 
 irq_stub:
-	pushal
-	maybe_load_kernel_segments 44
-	cld
+	intr_header 12
 
 	movl 32(%esp), %edi # interrupt number
 
@@ -78,16 +72,13 @@ irq_stub:
 
 	movl %ebp, %esp
 
-	maybe_load_userspace_segments 44
-	popal
+	intr_footer 12
 	addl $8, %esp
 	iret
 
 .global asm_ipi_handler
 asm_ipi_handler:
-	pushal
-	maybe_load_kernel_segments 36
-	cld
+	intr_header 4
 
 	movl %esp, %ebp
 	andl $-16, %esp
@@ -96,15 +87,12 @@ asm_ipi_handler:
 
 	movl %ebp, %esp
 
-	maybe_load_userspace_segments 36
-	popal
+	intr_footer 4
 	iret
 
 .global asm_timer_handler
 asm_timer_handler:
-	pushal
-	maybe_load_kernel_segments 36
-	cld
+	intr_header 4
 
 	movl %esp, %ebp
 	andl $-16, %esp
@@ -113,8 +101,7 @@ asm_timer_handler:
 
 	movl %ebp, %esp
 
-	maybe_load_userspace_segments 36
-	popal
+	intr_footer 4
 	iret
 
 .macro isr n

kernel/arch/i686/linker.ld

@@ -11,6 +11,7 @@ SECTIONS
 	{
 		g_kernel_execute_start = .;
 		*(.multiboot)
+		*(.multiboot2)
 		*(.bananboot)
 		*(.text.*)
 	}

kernel/arch/x86_64/PageTable.cpp

@@ -23,7 +23,7 @@ namespace Kernel
 	SpinLock PageTable::s_fast_page_lock;
 
 	static constexpr vaddr_t s_hhdm_offset = 0xFFFF800000000000;
-	static bool s_is_hddm_initialized = false;
+	static bool s_is_post_heap_done = false;
 
 	constexpr uint64_t s_page_flag_mask = 0x8000000000000FFF;
 	constexpr uint64_t s_page_addr_mask = ~s_page_flag_mask;
@@ -376,7 +376,7 @@ namespace Kernel
 		V2P                               = &FuncsHHDM::V2P;
 		P2V                               = &FuncsHHDM::P2V;
 
-		s_is_hddm_initialized = true;
+		s_is_post_heap_done = true;
 
 		// This is a hack to unmap fast page. fast page pt is copied
 		// while it is mapped, so we need to manually unmap it
@@ -485,6 +485,7 @@ namespace Kernel
 		constexpr uint64_t pml4e = (uc_vaddr >> 39) & 0x1FF;
 		constexpr uint64_t pdpte = (uc_vaddr >> 30) & 0x1FF;
 		constexpr uint64_t pde   = (uc_vaddr >> 21) & 0x1FF;
+		constexpr uint64_t pte   = (uc_vaddr >> 12) & 0x1FF;
 
 		uint64_t* pml4 = P2V(m_highest_paging_struct);
 		ASSERT(!(pml4[pml4e] & Flags::Present));
@@ -497,6 +498,10 @@ namespace Kernel
 		uint64_t* pd = P2V(pdpt[pdpte] & s_page_addr_mask);
 		ASSERT(!(pd[pde] & Flags::Present));
 		pd[pde] = allocate_zeroed_page_aligned_page() | Flags::ReadWrite | Flags::Present;
+
+		uint64_t* pt = P2V(pd[pde] & s_page_addr_mask);
+		ASSERT(pt[pte] == 0);
+		pt[pte] = Flags::Reserved;
 	}
 
 	void PageTable::map_fast_page(paddr_t paddr)
@@ -542,7 +547,7 @@ namespace Kernel
 		      uint64_t* pt   = P2V(pd[pde] & s_page_addr_mask);
 
 		ASSERT(pt[pte] & Flags::Present);
-		pt[pte] = 0;
+		pt[pte] = Flags::Reserved;
 
 		asm volatile("invlpg (%0)" :: "r"(fast_page()) : "memory");
 	}
@@ -612,10 +617,39 @@ namespace Kernel
 		Processor::set_current_page_table(this);
 	}
 
-	void PageTable::invalidate(vaddr_t vaddr, bool send_smp_message)
+	void PageTable::invalidate_range(vaddr_t vaddr, size_t pages, bool send_smp_message)
 	{
 		ASSERT(vaddr % PAGE_SIZE == 0);
-		asm volatile("invlpg (%0)" :: "r"(vaddr) : "memory");
+
+		const bool is_userspace = (vaddr < KERNEL_OFFSET);
+		if (is_userspace && this != &PageTable::current())
+			;
+		else if (pages <= 32 || !s_is_post_heap_done)
+		{
+			for (size_t i = 0; i < pages; i++, vaddr += PAGE_SIZE)
+				asm volatile("invlpg (%0)" :: "r"(vaddr));
+		}
+		else if (is_userspace || !s_has_pge)
+		{
+			asm volatile("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)
 		{
@@ -623,14 +657,14 @@ namespace Kernel
 				.type = Processor::SMPMessage::Type::FlushTLB,
 				.flush_tlb = {
 					.vaddr      = vaddr,
-					.page_count = 1,
+					.page_count = pages,
 					.page_table = vaddr < KERNEL_OFFSET ? this : nullptr,
 				}
 			});
 		}
 	}
 
-	void PageTable::unmap_page(vaddr_t vaddr, bool send_smp_message)
+	void PageTable::unmap_page(vaddr_t vaddr, bool invalidate)
 	{
 		ASSERT(vaddr);
 		ASSERT(vaddr != fast_page());
@@ -663,31 +697,23 @@ namespace Kernel
 
 		pt[pte] = 0;
 
-		if (old_paddr != 0)
-			invalidate(vaddr, send_smp_message);
+		if (invalidate && old_paddr != 0)
+			invalidate_page(vaddr, true);
 	}
 
 	void PageTable::unmap_range(vaddr_t vaddr, size_t size)
 	{
 		ASSERT(vaddr % PAGE_SIZE == 0);
 
-		size_t page_count = range_page_count(vaddr, size);
+		const size_t page_count = range_page_count(vaddr, size);
 
 		SpinLockGuard _(m_lock);
 		for (vaddr_t page = 0; page < page_count; page++)
 			unmap_page(vaddr + page * PAGE_SIZE, false);
-
-		Processor::broadcast_smp_message({
-			.type = Processor::SMPMessage::Type::FlushTLB,
-			.flush_tlb = {
-				.vaddr      = vaddr,
-				.page_count = page_count,
-				.page_table = vaddr < KERNEL_OFFSET ? this : nullptr,
-			}
-		});
+		invalidate_range(vaddr, page_count, true);
 	}
 
-	void PageTable::map_page_at(paddr_t paddr, vaddr_t vaddr, flags_t flags, MemoryType memory_type, bool send_smp_message)
+	void PageTable::map_page_at(paddr_t paddr, vaddr_t vaddr, flags_t flags, MemoryType memory_type, bool invalidate)
 	{
 		ASSERT(vaddr);
 		ASSERT(vaddr != fast_page());
@@ -752,8 +778,8 @@ namespace Kernel
 
 		pt[pte] = paddr | uwr_flags | extra_flags;
 
-		if (old_paddr != 0)
-			invalidate(vaddr, send_smp_message);
+		if (invalidate && old_paddr != 0)
+			invalidate_page(vaddr, true);
 	}
 
 	void PageTable::map_range_at(paddr_t paddr, vaddr_t vaddr, size_t size, flags_t flags, MemoryType memory_type)
@@ -769,15 +795,66 @@ namespace Kernel
 		SpinLockGuard _(m_lock);
 		for (size_t page = 0; page < page_count; page++)
 			map_page_at(paddr + page * PAGE_SIZE, vaddr + page * PAGE_SIZE, flags, memory_type, false);
-
-		Processor::broadcast_smp_message({
-			.type = Processor::SMPMessage::Type::FlushTLB,
-			.flush_tlb = {
-				.vaddr      = vaddr,
-				.page_count = page_count,
-				.page_table = vaddr < KERNEL_OFFSET ? this : nullptr,
+		invalidate_range(vaddr, page_count, true);
 	}
-		});
+
+	void PageTable::remove_writable_from_range(vaddr_t vaddr, size_t size)
+	{
+		ASSERT(vaddr);
+		ASSERT(vaddr % PAGE_SIZE == 0);
+
+		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);
+
+		const uint64_t* pml4 = P2V(m_highest_paging_struct);
+		for (; pml4e <= e_pml4e; pml4e++)
+		{
+			if (!(pml4[pml4e] & Flags::ReadWrite))
+				continue;
+			const 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::ReadWrite))
+					continue;
+				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;
+					if (!(pd[pde] & Flags::ReadWrite))
+						continue;
+					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] &= ~static_cast<uint64_t>(Flags::ReadWrite);
+					}
+					pte = 0;
+				}
+				pde = 0;
+			}
+			pdpte = 0;
+		}
+
+		invalidate_range(vaddr, size / PAGE_SIZE, true);
 	}
 
 	uint64_t PageTable::get_page_data(vaddr_t vaddr) const
@@ -824,13 +901,13 @@ namespace Kernel
 		return page_data & s_page_addr_mask;
 	}
 
-	bool PageTable::reserve_page(vaddr_t vaddr, bool only_free, bool send_smp_message)
+	bool PageTable::reserve_page(vaddr_t vaddr, bool only_free, bool invalidate)
 	{
 		SpinLockGuard _(m_lock);
 		ASSERT(vaddr % PAGE_SIZE == 0);
 		if (only_free && !is_page_free(vaddr))
 			return false;
-		map_page_at(0, vaddr, Flags::Reserved, MemoryType::Normal, send_smp_message);
+		map_page_at(0, vaddr, Flags::Reserved, MemoryType::Normal, invalidate);
 		return true;
 	}
 
@@ -845,14 +922,7 @@ namespace Kernel
 			return false;
 		for (size_t offset = 0; offset < bytes; offset += PAGE_SIZE)
 			reserve_page(vaddr + offset, true, false);
-		Processor::broadcast_smp_message({
-			.type = Processor::SMPMessage::Type::FlushTLB,
-			.flush_tlb = {
-				.vaddr      = vaddr,
-				.page_count = bytes / PAGE_SIZE,
-				.page_table = vaddr < KERNEL_OFFSET ? this : nullptr,
-			}
-		});
+		invalidate_range(vaddr, bytes / PAGE_SIZE, true);
 		return true;
 	}
 
@@ -866,9 +936,9 @@ namespace Kernel
 			last_address -= rem;
 
 		ASSERT(is_canonical(first_address));
-		ASSERT(is_canonical(last_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);
+		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;
@@ -885,10 +955,8 @@ namespace Kernel
 		// Try to find free page that can be mapped without
 		// allocations (page table with unused entries)
 		const uint64_t* pml4 = P2V(m_highest_paging_struct);
-		for (; pml4e < 512; pml4e++)
+		for (; pml4e <= e_pml4e; pml4e++)
 		{
-			if (pml4e > e_pml4e)
-				break;
 			if (!(pml4[pml4e] & Flags::Present))
 				continue;
 			const uint64_t* pdpt = P2V(pml4[pml4e] & s_page_addr_mask);
@@ -908,10 +976,10 @@ namespace Kernel
 					const 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)
+						if (pml4e == e_pml4e && pdpte == e_pdpte && pde == e_pde && pte > e_pte)
 							break;
-						if (!(pt[pte] & Flags::Used))
-						{
+						if (pt[pte] & Flags::Used)
+							continue;
 						vaddr_t vaddr = 0;
 						vaddr |= static_cast<uint64_t>(pml4e) << 39;
 						vaddr |= static_cast<uint64_t>(pdpte) << 30;
@@ -921,9 +989,11 @@ namespace Kernel
 						ASSERT(reserve_page(vaddr));
 						return vaddr;
 					}
+					pte = 0;
 				}
+				pde = 0;
 			}
-			}
+			pdpte = 0;
 		}
 
 		for (vaddr_t uc_vaddr = uc_vaddr_start; uc_vaddr < uc_vaddr_end; uc_vaddr += PAGE_SIZE)
@@ -935,7 +1005,7 @@ namespace Kernel
 			}
 		}
 
-		ASSERT_NOT_REACHED();
+		return 0;
 	}
 
 	vaddr_t PageTable::reserve_free_contiguous_pages(size_t page_count, vaddr_t first_address, vaddr_t last_address)
@@ -948,7 +1018,7 @@ namespace Kernel
 			last_address -= rem;
 
 		ASSERT(is_canonical(first_address));
-		ASSERT(is_canonical(last_address));
+		ASSERT(is_canonical(last_address - 1));
 
 		SpinLockGuard _(m_lock);
 
@@ -977,7 +1047,7 @@ namespace Kernel
 			}
 		}
 
-		ASSERT_NOT_REACHED();
+		return 0;
 	}
 
 	bool PageTable::is_page_free(vaddr_t page) const

kernel/arch/x86_64/Signal.S

@@ -1,12 +1,13 @@
 .section .userspace, "ax"
 
 // stack contains
-//    return address
-//    return stack
-//    return rflags
-//    siginfo_t
-//    signal number
-//    signal handler
+//    (8 bytes)  return address (on return stack)
+//    (8 bytes)  return stack
+//    (8 bytes)  return rflags
+//    (8 bytes)  restore sigmask
+//    (56 bytes) siginfo_t
+//    (8 bytes)  signal number
+//    (8 bytes)  signal handler
 
 .global signal_trampoline
 signal_trampoline:
@@ -26,6 +27,10 @@ signal_trampoline:
 	pushq %rax
 	pushq %rbp
 
+	movq 208(%rsp), %rax
+	pushq %rax; addq $(128 + 8), (%rsp)
+	pushq (%rax)
+
 	// FIXME: populate these
 	xorq %rax, %rax
 	pushq %rax // stack
@@ -35,9 +40,9 @@ signal_trampoline:
 	pushq %rax // link
 
 	movq  %rsp,     %rdx // ucontext
-	leaq 176(%rsp), %rsi // siginfo
-	movq 168(%rsp), %rdi // signal number
-	movq 160(%rsp), %rax // handler
+	leaq 192(%rsp), %rsi // siginfo
+	movq 184(%rsp), %rdi // signal number
+	movq 176(%rsp), %rax // handler
 
 	// align stack to 16 bytes
 	movq %rsp, %rbp
@@ -55,7 +60,15 @@ signal_trampoline:
 	movq %rbp, %rsp
 	addq $40, %rsp
 
+	// restore sigmask
+	movq $83, %rdi       // SYS_SIGPROCMASK
+	movq $3,  %rsi       // SIG_SETMASK
+	leaq 192(%rsp), %rdx // set
+	xorq %r10, %r10      // oset
+	syscall
+
 	// restore registers
+	addq $16, %rsp
 	popq %rbp
 	popq %rax
 	popq %rbx
@@ -72,13 +85,13 @@ signal_trampoline:
 	popq %r14
 	popq %r15
 
-	// skip handler, number, siginfo_t
-	addq $72, %rsp
+	// skip handler, number, siginfo_t, sigmask
+	addq $80, %rsp
 
 	// restore flags
 	popfq
 
 	movq (%rsp), %rsp
 
-	// return over red-zone and siginfo_t
+	// return over red-zone
 	ret $128

kernel/arch/x86_64/Syscall.S

@@ -33,7 +33,7 @@ sys_fork_trampoline:
 
 	call read_ip
 	testq %rax, %rax
-	je .done
+	jz .done
 
 	movq %rax, %rsi
 	movq %rsp, %rdi

kernel/arch/x86_64/Thread.S

@@ -7,9 +7,6 @@ read_ip:
 # void start_kernel_thread()
 .global start_kernel_thread
 start_kernel_thread:
-	call get_thread_start_sp
-	movq %rax, %rsp
-
 	# STACK LAYOUT
 	#   on_exit arg
 	#   on_exit func
@@ -27,9 +24,5 @@ start_kernel_thread:
 
 .global start_userspace_thread
 start_userspace_thread:
-	call get_thread_start_sp
-	movq %rax, %rsp
-
 	swapgs
-
 	iretq

kernel/arch/x86_64/User.S

@@ -0,0 +1,87 @@
+# bool safe_user_memcpy(void*, const void*, size_t)
+.global safe_user_memcpy
+.global safe_user_memcpy_end
+.global safe_user_memcpy_fault
+safe_user_memcpy:
+	xorq %rax, %rax
+	movq %rdx, %rcx
+	rep movsb
+	incq %rax
+safe_user_memcpy_fault:
+	ret
+safe_user_memcpy_end:
+
+# bool safe_user_strncpy(void*, const void*, size_t)
+.global safe_user_strncpy
+.global safe_user_strncpy_end
+.global safe_user_strncpy_fault
+safe_user_strncpy:
+	movq %rdx, %rcx
+	testq %rcx, %rcx
+	jz safe_user_strncpy_fault
+
+ .safe_user_strncpy_align_loop:
+	testb $0x7, %sil
+	jz .safe_user_strncpy_align_done
+
+	movb (%rsi), %al
+	movb %al, (%rdi)
+	testb %al, %al
+	jz .safe_user_strncpy_done
+
+	incq %rdi
+	incq %rsi
+	decq %rcx
+	jnz .safe_user_strncpy_align_loop
+	jmp safe_user_strncpy_fault
+
+ .safe_user_strncpy_align_done:
+	movq $0x0101010101010101, %r8
+	movq $0x8080808080808080, %r9
+
+ .safe_user_strncpy_qword_loop:
+	cmpq $8, %rcx
+	jb .safe_user_strncpy_qword_done
+
+	movq (%rsi), %rax
+	movq %rax, %r10
+	movq %rax, %r11
+
+	# https://graphics.stanford.edu/~seander/bithacks.html#ZeroInWord
+	subq %r8, %r10
+	notq %r11
+	andq %r11, %r10
+	andq %r9, %r10
+	jnz .safe_user_strncpy_byte_loop
+
+	movq %rax, (%rdi)
+
+	addq $8, %rdi
+	addq $8, %rsi
+	subq $8, %rcx
+	jnz .safe_user_strncpy_qword_loop
+	jmp safe_user_strncpy_fault
+
+ .safe_user_strncpy_qword_done:
+	testq %rcx, %rcx
+	jz safe_user_strncpy_fault
+
+ .safe_user_strncpy_byte_loop:
+	movb (%rsi), %al
+	movb %al, (%rdi)
+	testb %al, %al
+	jz .safe_user_strncpy_done
+
+	incq %rdi
+	incq %rsi
+	decq %rcx
+	jnz .safe_user_strncpy_byte_loop
+
+ safe_user_strncpy_fault:
+	xorq %rax, %rax
+	ret
+
+ .safe_user_strncpy_done:
+	movb $1, %al
+	ret
+safe_user_strncpy_end:

kernel/arch/x86_64/boot.S

@@ -11,26 +11,28 @@
 
 .code32
 
-# multiboot2 header
+// custom addresses, video mode info, page align modules
+.set multiboot_flags, (1 << 16) | (1 << 2) | (1 << 0)
+
 .section .multiboot, "aw"
-	.align 8
 multiboot_start:
 	.long 0x1BADB002
-	.long (1 << 2) # page align modules
-	.long -(0x1BADB002 + (1 << 2))
+	.long multiboot_flags
+	.long -(0x1BADB002 + multiboot_flags)
 
-	.long 0
-	.long 0
-	.long 0
-	.long 0
-	.long 0
+	.long V2P(multiboot_start)
+	.long V2P(g_kernel_start)
+	.long V2P(g_kernel_bss_start)
+	.long V2P(g_kernel_end)
+	.long V2P(_start)
 
 	.long 0
 	.long FB_WIDTH
 	.long FB_HEIGHT
 	.long FB_BPP
 multiboot_end:
-	.align 8
+
+.section .multiboot2, "aw"
 multiboot2_start:
 	.long 0xE85250D6
 	.long 0
@@ -66,7 +68,6 @@ multiboot2_start:
 multiboot2_end:
 
 .section .bananboot, "aw"
-	.align 8
 bananboot_start:
 	.long 0xBABAB007
 	.long -(0xBABAB007 + FB_WIDTH + FB_HEIGHT + FB_BPP)

kernel/arch/x86_64/interrupts.S

@@ -1,12 +1,4 @@
-.macro swapgs_if_necessary, n
-	testb $3, \n(%rsp)
-	jz 1f; jnp 1f
-	swapgs
-1:
-.endm
-
-.macro pushaq, n
-	swapgs_if_necessary \n
+.macro intr_header, n
 	pushq %rax
 	pushq %rcx
 	pushq %rdx
@@ -22,10 +14,18 @@
 	pushq %r13
 	pushq %r14
 	pushq %r15
+	testb $3, \n+15*8(%rsp)
+	jz 1f
+	swapgs
+1:	cld
 .endm
 
-.macro popaq, n
-	popq %r15
+.macro intr_footer, n
+	testb $3, \n+15*8(%rsp)
+	jz 1f
+	call cpp_check_signal
+	swapgs
+1:	popq %r15
 	popq %r14
 	popq %r13
 	popq %r12
@@ -40,12 +40,10 @@
 	popq %rdx
 	popq %rcx
 	popq %rax
-	swapgs_if_necessary \n
 .endm
 
 isr_stub:
-	pushaq 24
-	cld
+	intr_header 24
 	movq %cr0, %rax; pushq %rax
 	movq %cr2, %rax; pushq %rax
 	movq %cr3, %rax; pushq %rax
@@ -58,33 +56,33 @@ isr_stub:
 	call cpp_isr_handler
 	addq $32, %rsp
 
-	popaq 24
+	intr_footer 24
 	addq $16, %rsp
 	iretq
 
 irq_stub:
-	pushaq 24
-	cld
+	intr_header 24
+	xorq %rbp, %rbp
 	movq 120(%rsp), %rdi	# irq number
 	call cpp_irq_handler
-	popaq 24
+	intr_footer 24
 	addq $16, %rsp
 	iretq
 
 .global asm_ipi_handler
 asm_ipi_handler:
-	pushaq 8
-	cld
+	intr_header 8
+	xorq %rbp, %rbp
 	call cpp_ipi_handler
-	popaq 8
+	intr_footer 8
 	iretq
 
 .global asm_timer_handler
 asm_timer_handler:
-	pushaq 8
-	cld
+	intr_header 8
+	xorq %rbp, %rbp
 	call cpp_timer_handler
-	popaq 8
+	intr_footer 8
 	iretq
 
 .macro isr n

kernel/arch/x86_64/linker.ld

@@ -11,6 +11,7 @@ SECTIONS
 	{
 		g_kernel_execute_start = .;
 		*(.multiboot)
+		*(.multiboot2)
 		*(.bananboot)
 		*(.text.*)
 	}
@@ -43,6 +44,7 @@ SECTIONS
 	}
 	.bss ALIGN(4K) : AT(ADDR(.bss) - KERNEL_OFFSET)
 	{
+		g_kernel_bss_start = .;
 		*(COMMON)
 		*(.bss)
 		g_kernel_writable_end = .;

kernel/include/kernel/API/Syscall.h

@@ -1,44 +1,34 @@
 #pragma once
 
-#include <kernel/Attributes.h>
-#include <kernel/IDT.h>
-#include <stdint.h>
-#include <sys/syscall.h>
+#include <BAN/MacroUtils.h>
 
-namespace Kernel
-{
-
-	ALWAYS_INLINE long syscall(int syscall, uintptr_t arg1 = 0, uintptr_t arg2 = 0, uintptr_t arg3 = 0, uintptr_t arg4 = 0, uintptr_t arg5 = 0)
-	{
-		long ret;
-#if ARCH(x86_64)
-		register uintptr_t r10 asm("r10") = arg3;
-		register uintptr_t r8  asm( "r8") = arg4;
-		register uintptr_t r9  asm( "r9") = arg5;
-		asm volatile(
-			"syscall"
-			: "=a"(ret)
-			, "+D"(syscall)
-			, "+S"(arg1)
-			, "+d"(arg2)
-			, "+r"(r10)
-			, "+r"(r8)
-			, "+r"(r9)
-			:: "rcx", "r11", "memory");
-#elif ARCH(i686)
-		asm volatile(
-			"int %[irq]"
-			: "=a"(ret)
-			: [irq]"i"(static_cast<int>(IRQ_SYSCALL)) // WTF GCC 15
-			, "a"(syscall)
-			, "b"(arg1)
-			, "c"(arg2)
-			, "d"(arg3)
-			, "S"(arg4)
-			, "D"(arg5)
-			: "memory");
+#if defined(__x86_64__)
+	#define _kas_instruction "syscall"
+	#define _kas_result rax
+	#define _kas_arguments rdi, rsi, rdx, r10, r8, r9
+	#define _kas_globbers rcx, rdx, rdi, rsi, r8, r9, r10, r11
+#elif defined(__i686__)
+	#define _kas_instruction "int $0xF0"
+	#define _kas_result eax
+	#define _kas_arguments eax, ebx, ecx, edx, esi, edi
+	#define _kas_globbers
 #endif
-		return ret;
-	}
 
-}
+#define _kas_argument_var(index, value) register long _kas_a##index asm(_ban_stringify(_ban_get(index, _kas_arguments))) = (long)value;
+#define _kas_dummy_var(index, value) register long _kas_d##index asm(#value);
+#define _kas_input(index, _) "r"(_kas_a##index)
+#define _kas_output(index, _) , "=r"(_kas_d##index)
+#define _kas_globber(_, value) #value
+
+#define _kas_syscall(...) ({ \
+		register long _kas_ret asm(_ban_stringify(_kas_result)); \
+		_ban_for_each(_kas_argument_var, __VA_ARGS__) \
+		_ban_for_each(_kas_dummy_var, _kas_globbers) \
+		asm volatile( \
+			_kas_instruction \
+			: "=r"(_kas_ret) _ban_for_each(_kas_output, _kas_globbers) \
+			: _ban_for_each_comma(_kas_input, __VA_ARGS__) \
+			: "cc", "memory"); \
+		(void)_kas_a0; /* require 1 argument */ \
+		_kas_ret; \
+	})

kernel/include/kernel/Audio/AC97/Controller.h

@@ -6,7 +6,7 @@
 namespace Kernel
 {
 
-	class AC97AudioController : public AudioController, public Interruptable
+	class AC97AudioController final : public AudioController, public Interruptable
 	{
 	public:
 		static BAN::ErrorOr<void> create(PCI::Device& pci_device);
@@ -23,11 +23,15 @@ namespace Kernel
 		uint32_t get_current_pin() const override { return 0; }
 		BAN::ErrorOr<void> set_current_pin(uint32_t pin) override { if (pin != 0) return BAN::Error::from_errno(EINVAL); return {}; }
 
+		BAN::ErrorOr<void> set_volume_mdB(int32_t) override;
+
 	private:
 		AC97AudioController(PCI::Device& pci_device)
 			: m_pci_device(pci_device)
 		{ }
 
+		uint32_t get_volume_data() const;
+
 		BAN::ErrorOr<void> initialize();
 		BAN::ErrorOr<void> initialize_bld();
 		BAN::ErrorOr<void> initialize_interrupts();

kernel/include/kernel/Audio/Controller.h

@@ -4,6 +4,8 @@
 #include <kernel/Memory/ByteRingBuffer.h>
 #include <kernel/PCI.h>
 
+#include <sys/ioctl.h>
+
 namespace Kernel
 {
 
@@ -28,6 +30,8 @@ namespace Kernel
 		virtual uint32_t get_current_pin() const = 0;
 		virtual BAN::ErrorOr<void> set_current_pin(uint32_t) = 0;
 
+		virtual BAN::ErrorOr<void> set_volume_mdB(int32_t) = 0;
+
 		bool can_read_impl() const override { return false; }
 		bool can_write_impl() const override { SpinLockGuard _(m_spinlock); return !m_sample_data->full(); }
 		bool has_error_impl() const override { return false; }
@@ -44,6 +48,8 @@ namespace Kernel
 		static constexpr size_t m_sample_data_capacity = 1 << 20;
 		BAN::UniqPtr<ByteRingBuffer> m_sample_data;
 
+		snd_volume_info m_volume_info {};
+
 	private:
 		const dev_t m_rdev;
 		char m_name[10] {};

kernel/include/kernel/Audio/HDAudio/AudioFunctionGroup.h

@@ -8,7 +8,7 @@ namespace Kernel
 
 	class HDAudioController;
 
-	class HDAudioFunctionGroup : public AudioController
+	class HDAudioFunctionGroup final : public AudioController
 	{
 	public:
 		static BAN::ErrorOr<BAN::RefPtr<HDAudioFunctionGroup>> create(BAN::RefPtr<HDAudioController>, uint8_t cid, HDAudio::AFGNode&&);
@@ -24,6 +24,8 @@ namespace Kernel
 		uint32_t get_current_pin() const override;
 		BAN::ErrorOr<void> set_current_pin(uint32_t) override;
 
+		BAN::ErrorOr<void> set_volume_mdB(int32_t) override;
+
 		void handle_new_data() override;
 
 	private:
@@ -46,7 +48,6 @@ namespace Kernel
 		BAN::ErrorOr<void> recurse_output_paths(const HDAudio::AFGWidget& widget, BAN::Vector<const HDAudio::AFGWidget*>& path);
 
 		uint16_t get_format_data() const;
-		uint16_t get_volume_data() const;
 
 		size_t bdl_offset() const;
 

kernel/include/kernel/Audio/HDAudio/Definitions.h

@@ -55,6 +55,16 @@ namespace Kernel::HDAudio
 			} pin_complex;
 		};
 
+		struct Amplifier
+		{
+			uint8_t offset;
+			uint8_t num_steps;
+			uint8_t step_size;
+			bool mute;
+		};
+
+		BAN::Optional<Amplifier> output_amplifier;
+
 		BAN::Vector<uint16_t> connections;
 	};
 

kernel/include/kernel/BootInfo.h

@@ -44,7 +44,7 @@ namespace Kernel
 	struct BootModule
 	{
 		paddr_t start;
-		size_t size;
+		uint64_t size;
 	};
 
 	struct BootInfo

kernel/include/kernel/Device/FramebufferDevice.h

@@ -37,6 +37,8 @@ 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;
+
 		virtual bool can_read_impl() const override { return true; }
 		virtual bool can_write_impl() const override { return true; }
 		virtual bool has_error_impl() const override { return false; }

kernel/include/kernel/FS/USTARModule.h

@@ -1,12 +1,11 @@
 #pragma once
 
 #include <kernel/BootInfo.h>
-#include <kernel/FS/FileSystem.h>
+#include <kernel/FS/Inode.h>
 
 namespace Kernel
 {
 
-	bool is_ustar_boot_module(const BootModule&);
-	BAN::ErrorOr<void> unpack_boot_module_into_filesystem(BAN::RefPtr<FileSystem>, const BootModule&);
+	BAN::ErrorOr<bool> unpack_boot_module_into_directory(BAN::RefPtr<Inode>, const BootModule&);
 
 }

kernel/include/kernel/IDT.h

@@ -20,7 +20,7 @@ namespace Kernel
 	constexpr uint8_t IRQ_MSI_BASE      = 0x80;
 	constexpr uint8_t IRQ_MSI_END       = 0xF0;
 #if ARCH(i686)
-	constexpr uint8_t IRQ_SYSCALL       = 0xF0;
+	constexpr uint8_t IRQ_SYSCALL       = 0xF0; // hard coded in kernel/API/Syscall.h
 #endif
 	constexpr uint8_t IRQ_IPI           = 0xF1;
 	constexpr uint8_t IRQ_TIMER         = 0xF2;

kernel/include/kernel/Memory/Heap.h

@@ -18,6 +18,8 @@ namespace Kernel
 		static void initialize();
 		static Heap& get();
 
+		void release_boot_modules();
+
 		paddr_t take_free_page();
 		void release_page(paddr_t);
 

kernel/include/kernel/Memory/MemoryBackedRegion.h

@@ -28,6 +28,20 @@ namespace Kernel
 
 	private:
 		MemoryBackedRegion(PageTable&, size_t size, Type, PageTable::flags_t, int status_flags);
+
+	private:
+		struct PhysicalPage
+		{
+			PhysicalPage(paddr_t paddr)
+				: paddr(paddr)
+			{ }
+			~PhysicalPage();
+
+			BAN::Atomic<uint32_t> ref_count { 1 };
+			const paddr_t paddr;
+		};
+		BAN::Vector<PhysicalPage*> m_physical_pages;
+		Mutex m_mutex;
 	};
 
 }

kernel/include/kernel/Memory/PageTable.h

@@ -100,19 +100,21 @@ namespace Kernel
 		static BAN::ErrorOr<PageTable*> create_userspace();
 		~PageTable();
 
-		void unmap_page(vaddr_t, bool send_smp_message = true);
+		void unmap_page(vaddr_t, bool invalidate = true);
 		void unmap_range(vaddr_t, size_t bytes);
 
-		void map_page_at(paddr_t, vaddr_t, flags_t, MemoryType = MemoryType::Normal, bool send_smp_message = true);
+		void map_page_at(paddr_t, vaddr_t, flags_t, MemoryType = MemoryType::Normal, bool invalidate = true);
 		void map_range_at(paddr_t, vaddr_t, size_t bytes, flags_t, MemoryType = MemoryType::Normal);
 
+		void remove_writable_from_range(vaddr_t, size_t);
+
 		paddr_t physical_address_of(vaddr_t) const;
 		flags_t get_page_flags(vaddr_t) const;
 
 		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 send_smp_message = true);
+		bool reserve_page(vaddr_t, bool only_free = true, bool invalidate = true);
 		bool reserve_range(vaddr_t, size_t bytes, bool only_free = true);
 
 		vaddr_t reserve_free_page(vaddr_t first_address, vaddr_t last_address = UINTPTR_MAX);
@@ -121,6 +123,9 @@ namespace Kernel
 		void load();
 		void initial_load();
 
+		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);
+
 		InterruptState lock() const { return m_lock.lock(); }
 		void unlock(InterruptState state) const { m_lock.unlock(state); }
 
@@ -133,8 +138,6 @@ namespace Kernel
 		void map_kernel_memory();
 		void prepare_fast_page();
 
-		void invalidate(vaddr_t, bool send_smp_message);
-
 		static void map_fast_page(paddr_t);
 		static void unmap_fast_page();
 

kernel/include/kernel/Memory/PhysicalRange.h

@@ -10,7 +10,7 @@ namespace Kernel
 	class PhysicalRange
 	{
 	public:
-		PhysicalRange(paddr_t, size_t);
+		PhysicalRange(paddr_t, uint64_t);
 
 		paddr_t reserve_page();
 		void release_page(paddr_t);

kernel/include/kernel/Memory/Types.h

@@ -4,7 +4,7 @@
 
 #if ARCH(x86_64)
 	#define KERNEL_OFFSET 0xFFFFFFFF80000000
-	#define USERSPACE_END 0xFFFF800000000000
+	#define USERSPACE_END 0x800000000000
 #elif ARCH(i686)
 	#define KERNEL_OFFSET 0xC0000000
 	#define USERSPACE_END 0xC0000000

kernel/include/kernel/Memory/VirtualRange.h

@@ -20,8 +20,6 @@ namespace Kernel
 		static BAN::ErrorOr<BAN::UniqPtr<VirtualRange>> create_to_vaddr_range(PageTable&, vaddr_t vaddr_start, vaddr_t vaddr_end, size_t, PageTable::flags_t flags, bool preallocate_pages, bool add_guard_pages);
 		~VirtualRange();
 
-		BAN::ErrorOr<BAN::UniqPtr<VirtualRange>> clone(PageTable&);
-
 		vaddr_t vaddr() const { return m_vaddr + (m_has_guard_pages ? PAGE_SIZE : 0); }
 		size_t size() const { return m_size - (m_has_guard_pages ? 2 * PAGE_SIZE : 0); }
 		PageTable::flags_t flags() const { return m_flags; }

kernel/include/kernel/OpenFileDescriptorSet.h

@@ -44,6 +44,10 @@ namespace Kernel
 		void close_all();
 		void close_cloexec();
 
+		bool is_cloexec(int fd);
+		void add_cloexec(int fd);
+		void remove_cloexec(int fd);
+
 		BAN::ErrorOr<void> flock(int fd, int op);
 
 		BAN::ErrorOr<size_t> read(int fd, BAN::ByteSpan);
@@ -84,27 +88,6 @@ namespace Kernel
 			friend class BAN::RefPtr<OpenFileDescription>;
 		};
 
-		struct OpenFile
-		{
-			OpenFile() = default;
-			OpenFile(BAN::RefPtr<OpenFileDescription> description, int descriptor_flags)
-				: description(BAN::move(description))
-				, descriptor_flags(descriptor_flags)
-			{ }
-
-			BAN::RefPtr<Inode> inode() const { ASSERT(description); return description->file.inode; }
-			BAN::StringView    path()  const { ASSERT(description); return description->file.canonical_path.sv(); }
-
-			int& status_flags() { ASSERT(description); return description->status_flags; }
-			const int& status_flags() const { ASSERT(description); return description->status_flags; }
-
-			off_t& offset() { ASSERT(description); return description->offset; }
-			const off_t& offset() const { ASSERT(description); return description->offset; }
-
-			BAN::RefPtr<OpenFileDescription> description;
-			int descriptor_flags { 0 };
-		};
-
 		BAN::ErrorOr<void> validate_fd(int) const;
 		BAN::ErrorOr<int> get_free_fd() const;
 		BAN::ErrorOr<void> get_free_fd_pair(int fds[2]) const;
@@ -139,7 +122,8 @@ namespace Kernel
 		const Credentials& m_credentials;
 		mutable Mutex m_mutex;
 
-		BAN::Array<OpenFile, OPEN_MAX> m_open_files;
+		BAN::Array<BAN::RefPtr<OpenFileDescription>, OPEN_MAX> m_open_files;
+		BAN::Array<uint32_t, (OPEN_MAX + 31) / 32> m_cloexec_files {};
 	};
 
 }

kernel/include/kernel/Scheduler.h

@@ -101,7 +101,7 @@ namespace Kernel
 		InterruptStack* m_interrupt_stack { nullptr };
 		InterruptRegisters* m_interrupt_registers { nullptr };
 
-		uint64_t m_last_reschedule_ns { 0 };
+		uint64_t m_next_reschedule_ns { 0 };
 		uint64_t m_last_load_balance_ns { 0 };
 
 		struct ThreadInfo

kernel/include/kernel/Thread.h

@@ -38,8 +38,12 @@ namespace Kernel
 		//        stack overflows on some machines with 8 page stack
 		static constexpr size_t kernel_stack_size    { PAGE_SIZE * 16 };
 
-		// TODO: userspace stack is hard limited to 32 MiB, maybe make this dynamic?
+		// TODO: userspace stack size is hard limited, maybe make this dynamic?
+#if ARCH(x86_64)
 		static constexpr size_t userspace_stack_size { 32 << 20 };
+#elif ARCH(i686)
+		static constexpr size_t userspace_stack_size { 4 << 20 };
+#endif
 
 	public:
 		static BAN::ErrorOr<Thread*> create_kernel(entry_t, void*);
@@ -56,12 +60,10 @@ namespace Kernel
 		// Returns true, if thread is going to trigger signal
 		bool is_interrupted_by_signal(bool skip_stop_and_cont = false) const;
 
-		// Returns true if pending signal can be added to thread
-		bool can_add_signal_to_execute() const;
-		bool will_execute_signal() const;
 		// Returns true if handled signal had SA_RESTART
-		bool handle_signal(int signal = 0, const siginfo_t& signal_info = {});
-		void add_signal(int signal, const siginfo_t& info);
+		bool handle_signal_if_interrupted();
+		bool handle_signal(int signal, const siginfo_t&);
+		void add_signal(int signal, const siginfo_t&);
 		void set_suspend_signal_mask(uint64_t sigmask);
 
 		static bool is_stopping_signal(int signal);
@@ -153,6 +155,16 @@ namespace Kernel
 
 		bool currently_on_alternate_stack() const;
 
+		struct signal_handle_info_t
+		{
+			vaddr_t handler;
+			vaddr_t stack_top;
+			uint64_t restore_sigmask;
+			bool has_sa_restart;
+		};
+		signal_handle_info_t remove_signal_and_get_info(int signal);
+		void handle_signal_impl(int signal, const siginfo_t&, const signal_handle_info_t&);
+
 	private:
 		// NOTE: this is the first member to force it being last destructed
 		//       {kernel,userspace}_stack has to be destroyed before page table
@@ -166,7 +178,9 @@ namespace Kernel
 		bool                       m_is_userspace         { false };
 		bool                       m_delete_process       { false };
 
+		bool                       m_has_custom_fsbase    { false };
 		vaddr_t                    m_fsbase               { 0 };
+		bool                       m_has_custom_gsbase    { false };
 		vaddr_t                    m_gsbase               { 0 };
 
 		SchedulerQueue::Node*      m_scheduler_node       { nullptr };

kernel/kernel/ACPI/ACPI.cpp

@@ -531,11 +531,8 @@ acpi_release_global_lock:
 			return BAN::Error::from_errno(EFAULT);
 		}
 
-		if (!s5_node.as.package->elements[0].resolved || !s5_node.as.package->elements[1].resolved)
-		{
-			dwarnln("TODO: lazy evaluate package \\_S5 elements");
-			return BAN::Error::from_errno(ENOTSUP);
-		}
+		TRY(AML::resolve_package_element(s5_node.as.package->elements[0], true));
+		TRY(AML::resolve_package_element(s5_node.as.package->elements[1], true));
 
 		auto slp_typa_node = TRY(AML::convert_node(TRY(s5_node.as.package->elements[0].value.node->copy()), AML::ConvInteger, sizeof(uint64_t)));
 		auto slp_typb_node = TRY(AML::convert_node(TRY(s5_node.as.package->elements[1].value.node->copy()), AML::ConvInteger, sizeof(uint64_t)));

kernel/kernel/Audio/AC97/Controller.cpp

@@ -137,8 +137,27 @@ namespace Kernel
 		// Reset mixer to default values
 		m_mixer->write16(AudioMixerRegister::Reset, 0);
 
-		// Master volume 100%, no mute
-		m_mixer->write16(AudioMixerRegister::MasterVolume, 0x0000);
+		// Master volumes
+		m_mixer->write16(AudioMixerRegister::MasterVolume, 0x2020);
+		if (m_mixer->read16(AudioMixerRegister::MasterVolume) == 0x2020)
+		{
+			m_volume_info = {
+				.min_mdB = -94500,
+				.max_mdB = 0,
+				.step_mdB = 1500,
+				.mdB = 0,
+			};
+		}
+		else
+		{
+			m_volume_info = {
+				.min_mdB = -46500,
+				.max_mdB = 0,
+				.step_mdB = 1500,
+				.mdB = 0,
+			};
+		}
+		m_mixer->write16(AudioMixerRegister::MasterVolume, get_volume_data());
 
 		// PCM output volume left/right +0 db, no mute
 		m_mixer->write16(AudioMixerRegister::PCMOutVolume, 0x0808);
@@ -187,6 +206,19 @@ namespace Kernel
 		return {};
 	}
 
+	uint32_t AC97AudioController::get_volume_data() const
+	{
+		const uint32_t steps = (-m_volume_info.mdB + m_volume_info.step_mdB / 2) / m_volume_info.step_mdB;
+		return (steps << 8) | steps;
+	}
+
+	BAN::ErrorOr<void> AC97AudioController::set_volume_mdB(int32_t mdB)
+	{
+		m_volume_info.mdB = BAN::Math::clamp(mdB, m_volume_info.min_mdB, m_volume_info.max_mdB);
+		m_mixer->write16(AudioMixerRegister::MasterVolume, get_volume_data());
+		return {};
+	}
+
 	void AC97AudioController::handle_new_data()
 	{
 		ASSERT(m_spinlock.current_processor_has_lock());

kernel/kernel/Audio/Controller.cpp

@@ -105,6 +105,12 @@ namespace Kernel
 			case SND_SET_PIN:
 				TRY(set_current_pin(*static_cast<uint32_t*>(arg)));
 				return 0;
+			case SND_GET_VOLUME_INFO:
+				*static_cast<snd_volume_info*>(arg) = m_volume_info;
+				return 0;
+			case SND_SET_VOLUME_MDB:
+				TRY(set_volume_mdB(*static_cast<int32_t*>(arg)));
+				return 0;
 		}
 
 		return CharacterDevice::ioctl_impl(cmd, arg);

kernel/kernel/Audio/HDAudio/AudioFunctionGroup.cpp

@@ -136,6 +136,37 @@ namespace Kernel
 		return BAN::Error::from_errno(ENOTSUP);
 	}
 
+	BAN::ErrorOr<void> HDAudioFunctionGroup::set_volume_mdB(int32_t mdB)
+	{
+		mdB = BAN::Math::clamp(mdB, m_volume_info.min_mdB, m_volume_info.max_mdB);
+
+		const auto& path = m_output_paths[m_output_path_index];
+		for (size_t i = 0; i < path.size(); i++)
+		{
+			if (!path[i]->output_amplifier.has_value())
+				continue;
+
+			const int32_t step_round = (mdB >= 0)
+				? +m_volume_info.step_mdB / 2
+				: -m_volume_info.step_mdB / 2;
+			const uint32_t step = (mdB + step_round) / m_volume_info.step_mdB + path[i]->output_amplifier->offset;
+			const uint32_t volume = 0b1'0'1'1'0000'0'0000000 | step;
+
+			TRY(m_controller->send_command({
+				.data = static_cast<uint8_t>(volume & 0xFF),
+				.command = static_cast<uint16_t>(0x300 | (volume >> 8)),
+				.node_index = path[i]->id,
+				.codec_address = m_cid,
+			}));
+
+			break;
+		}
+
+		m_volume_info.mdB = mdB;
+
+		return {};
+	}
+
 	size_t HDAudioFunctionGroup::bdl_offset() const
 	{
 		const size_t bdl_entry_bytes = m_bdl_entry_sample_frames * get_channels() * sizeof(uint16_t);
@@ -291,13 +322,6 @@ namespace Kernel
 		return 0b0'0'000'000'0'001'0001;
 	}
 
-	uint16_t HDAudioFunctionGroup::get_volume_data() const
-	{
-		// TODO: don't hardcode this
-		// left and right output, no mute, max gain
-		return 0b1'0'1'1'0000'0'1111111;
-	}
-
 	BAN::ErrorOr<void> HDAudioFunctionGroup::enable_output_path(uint8_t index)
 	{
 		ASSERT(index < m_output_paths.size());
@@ -318,7 +342,6 @@ namespace Kernel
 		}
 
 		const auto format = get_format_data();
-		const auto volume = get_volume_data();
 
 		for (size_t i = 0; i < path.size(); i++)
 		{
@@ -347,13 +370,17 @@ namespace Kernel
 				}));
 			}
 
-			// set volume
+			// set volume to 0 dB, no mute
+			if (path[i]->output_amplifier.has_value())
+			{
+				const uint32_t volume = 0b1'0'1'1'0000'0'0000000 | path[i]->output_amplifier->offset;
 				TRY(m_controller->send_command({
 					.data = static_cast<uint8_t>(volume & 0xFF),
 					.command = static_cast<uint16_t>(0x300 | (volume >> 8)),
 					.node_index = path[i]->id,
 					.codec_address = m_cid,
 				}));
+			}
 
 			switch (path[i]->type)
 			{
@@ -398,6 +425,41 @@ namespace Kernel
 			}
 		}
 
+		// update volume info to this path
+		m_volume_info.min_mdB = 0;
+		m_volume_info.max_mdB = 0;
+		m_volume_info.step_mdB = 0;
+		for (size_t i = 0; i < path.size(); i++)
+		{
+			if (!path[i]->output_amplifier.has_value())
+				continue;
+			const auto& amp = path[i]->output_amplifier.value();
+
+			const int32_t step_mdB = amp.step_size * 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;
+			m_volume_info.mdB = BAN::Math::clamp(m_volume_info.mdB, m_volume_info.min_mdB, m_volume_info.max_mdB);
+
+			const int32_t step_round = (m_volume_info.mdB >= 0)
+				? +step_mdB / 2
+				: -step_mdB / 2;
+			const uint32_t step = (m_volume_info.mdB + step_round) / step_mdB + amp.offset;
+			const uint32_t volume = 0b1'0'1'1'0000'0'0000000 | step;
+
+			TRY(m_controller->send_command({
+				.data = static_cast<uint8_t>(volume & 0xFF),
+				.command = static_cast<uint16_t>(0x300 | (volume >> 8)),
+				.node_index = path[i]->id,
+				.codec_address = m_cid,
+			}));
+
+			break;
+		}
+
+		if (m_volume_info.min_mdB == 0 && m_volume_info.max_mdB == 0)
+			m_volume_info.mdB = 0;
+
 		return {};
 	}
 

kernel/kernel/Audio/HDAudio/Controller.cpp

@@ -319,6 +319,20 @@ namespace Kernel
 			};
 		}
 
+		if (const uint32_t out_amp_cap = send_command_or_zero(0xF00, 0x12))
+		{
+			const uint8_t offset    = (out_amp_cap >>  0) & 0x7F;
+			const uint8_t num_steps = (out_amp_cap >>  8) & 0x7F;
+			const uint8_t step_size = (out_amp_cap >> 16) & 0x7F;
+			const bool    mute      = (out_amp_cap >> 31);
+			result.output_amplifier = HDAudio::AFGWidget::Amplifier {
+				.offset = offset,
+				.num_steps = num_steps,
+				.step_size = step_size,
+				.mute = mute,
+			};
+		}
+
 		const uint8_t connection_info = send_command_or_zero(0xF00, 0x0E);
 		const uint8_t conn_width = (connection_info & 0x80) ? 2 : 1;
 		const uint8_t conn_count = connection_info & 0x3F;

kernel/kernel/Device/FramebufferDevice.cpp

@@ -6,6 +6,7 @@
 #include <kernel/Terminal/FramebufferTerminal.h>
 
 #include <sys/framebuffer.h>
+#include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <sys/sysmacros.h>
 
@@ -133,6 +134,26 @@ namespace Kernel
 		return bytes_to_copy;
 	}
 
+	BAN::ErrorOr<long> FramebufferDevice::ioctl_impl(int cmd, void* arg)
+	{
+		switch (cmd)
+		{
+			case FB_MSYNC_RECTANGLE:
+			{
+				auto& rectangle = *static_cast<fb_msync_region*>(arg);
+				sync_pixels_rectangle(
+					rectangle.min_x,
+					rectangle.min_y,
+					rectangle.max_x - rectangle.min_x,
+					rectangle.max_y - rectangle.min_y
+				);
+				return 0;
+			}
+		}
+
+		return CharacterDevice::ioctl(cmd, arg);
+	}
+
 	uint32_t FramebufferDevice::get_pixel(uint32_t x, uint32_t y) const
 	{
 		ASSERT(x < m_width && y < m_height);

kernel/kernel/FS/USTARModule.cpp

@@ -1,64 +1,239 @@
 #include <BAN/ScopeGuard.h>
 #include <kernel/FS/USTARModule.h>
+#include <kernel/Timer/Timer.h>
+#include <LibDEFLATE/Decompressor.h>
 
 #include <tar.h>
 
 namespace Kernel
 {
 
-	bool is_ustar_boot_module(const BootModule& module)
+	class DataSource
 	{
-		if (module.start % PAGE_SIZE)
+	public:
+		DataSource() = default;
+		virtual ~DataSource() = default;
+
+		size_t data_size() const
 		{
-			dprintln("ignoring non-page-aligned module");
-			return false;
+			return m_data_size;
 		}
 
-		if (module.size < 512)
+		BAN::ConstByteSpan data()
+		{
+			return { m_data_buffer, m_data_size };
+		}
+
+		void pop_data(size_t size)
+		{
+			ASSERT(size <= m_data_size);
+			if (size > 0 && size < m_data_size)
+				memmove(m_data_buffer, m_data_buffer + size, m_data_size - size);
+			m_data_size -= size;
+			m_bytes_produced += size;
+		}
+
+		virtual BAN::ErrorOr<bool> produce_data() = 0;
+
+		uint64_t bytes_produced() const
+		{
+			return m_bytes_produced;
+		}
+
+		virtual uint64_t bytes_consumed() const = 0;
+
+	protected:
+		uint8_t m_data_buffer[4096];
+		size_t m_data_size { 0 };
+
+	private:
+		uint64_t m_bytes_produced { 0 };
+	};
+
+	class DataSourceRaw final : public DataSource
+	{
+	public:
+		DataSourceRaw(const BootModule& module)
+			: m_module(module)
+		{ }
+
+		BAN::ErrorOr<bool> produce_data() override
+		{
+			if (m_offset >= m_module.size || m_data_size >= sizeof(m_data_buffer))
 				return false;
 
-		bool has_ustar_signature;
-		PageTable::with_fast_page(module.start, [&] {
-			has_ustar_signature = memcmp(PageTable::fast_page_as_ptr(257), "ustar", 5) == 0;
+			while (m_offset < m_module.size && m_data_size < sizeof(m_data_buffer))
+			{
+				const size_t to_copy = BAN::Math::min(
+					sizeof(m_data_buffer) - m_data_size,
+					PAGE_SIZE - (m_offset % PAGE_SIZE)
+				);
+				PageTable::with_fast_page((m_module.start + m_offset) & PAGE_ADDR_MASK, [&] {
+					memcpy(m_data_buffer + m_data_size, PageTable::fast_page_as_ptr(m_offset % PAGE_SIZE), to_copy);
 				});
-
-		return has_ustar_signature;
+				m_data_size += to_copy;
+				m_offset += to_copy;
 			}
 
-	BAN::ErrorOr<void> unpack_boot_module_into_filesystem(BAN::RefPtr<FileSystem> filesystem, const BootModule& module)
+			return true;
+		}
+
+		uint64_t bytes_consumed() const override
 		{
-		ASSERT(is_ustar_boot_module(module));
+			return bytes_produced();
+		}
 
-		auto root_inode = filesystem->root_inode();
+	private:
+		const BootModule& m_module;
+		size_t m_offset { 0 };
+	};
 
-		uint8_t* temp_page = static_cast<uint8_t*>(kmalloc(PAGE_SIZE));
-		if (temp_page == nullptr)
-			return BAN::Error::from_errno(ENOMEM);
-		BAN::ScopeGuard _([temp_page] { kfree(temp_page); });
+	class DataSourceGZip final : public DataSource
+	{
+	public:
+		DataSourceGZip(BAN::UniqPtr<DataSource>&& data_source)
+			: m_data_source(BAN::move(data_source))
+			, m_decompressor(LibDEFLATE::StreamType::GZip)
+		{ }
 
+		BAN::ErrorOr<bool> produce_data() override
+		{
+			if (m_is_done)
+				return false;
+
+			bool did_produce_data { false };
+			for (;;)
+			{
+				TRY(m_data_source->produce_data());
+
+				size_t input_consumed, output_produced;
+				const auto status = TRY(m_decompressor.decompress(
+					m_data_source->data(),
+					input_consumed,
+					{ m_data_buffer + m_data_size, sizeof(m_data_buffer) - m_data_size },
+					output_produced
+				));
+
+				m_data_source->pop_data(input_consumed);
+				m_data_size += output_produced;
+
+				if (output_produced)
+					did_produce_data = true;
+
+				switch (status)
+				{
+					using DecompStatus = LibDEFLATE::Decompressor::Status;
+					case DecompStatus::Done:
+						m_is_done = true;
+						return did_produce_data;
+					case DecompStatus::NeedMoreInput:
+						break;
+					case DecompStatus::NeedMoreOutput:
+						return did_produce_data;
+				}
+			}
+		}
+
+		uint64_t bytes_consumed() const override
+		{
+			return m_data_source->bytes_consumed();
+		}
+
+	private:
+		BAN::UniqPtr<DataSource> m_data_source;
+		LibDEFLATE::Decompressor m_decompressor;
+		bool m_is_done { false };
+	};
+
+	static BAN::ErrorOr<void> unpack_boot_module_into_directory(BAN::RefPtr<Inode> root_inode, DataSource& data_source);
+
+	BAN::ErrorOr<bool> unpack_boot_module_into_directory(BAN::RefPtr<Inode> root_inode, const BootModule& module)
+	{
+		ASSERT(root_inode->mode().ifdir());
+
+		BAN::UniqPtr<DataSource> data_source = TRY(BAN::UniqPtr<DataSourceRaw>::create(module));
+
+		bool is_compressed = false;
+
+		TRY(data_source->produce_data());
+		if (data_source->data_size() >= 2 && memcmp(&data_source->data()[0], "\x1F\x8B", 2) == 0)
+		{
+			data_source = TRY(BAN::UniqPtr<DataSourceGZip>::create(BAN::move(data_source)));
+			is_compressed = true;
+		}
+
+		TRY(data_source->produce_data());
+		if (data_source->data_size() < 512 || memcmp(&data_source->data()[257], "ustar", 5) != 0)
+		{
+			dwarnln("Unrecognized initrd format");
+			return false;
+		}
+
+		const auto module_size_kib = module.size / 1024;
+		dprintln("unpacking {}.{3} MiB{} initrd",
+			module_size_kib / 1024, (module_size_kib % 1024) * 1000 / 1024,
+			is_compressed ? " compressed" : ""
+		);
+
+		const auto unpack_ms1 = SystemTimer::get().ms_since_boot();
+		TRY(unpack_boot_module_into_directory(root_inode, *data_source));
+		const auto unpack_ms2 = SystemTimer::get().ms_since_boot();
+
+		const auto duration_ms = unpack_ms2 - unpack_ms1;
+		dprintln("unpacking {}.{3} MiB{} initrd took {}.{3} s",
+			module_size_kib / 1024, (module_size_kib % 1024) * 1000 / 1024,
+			is_compressed ? " compressed" : "",
+			duration_ms / 1000, duration_ms % 1000
+		);
+
+		if (is_compressed)
+		{
+			const auto uncompressed_kib = data_source->bytes_produced() / 1024;
+			dprintln("uncompressed size {}.{3} MiB",
+				uncompressed_kib / 1024, (uncompressed_kib % 1024) * 1000 / 1024
+			);
+		}
+
+		return true;
+	}
+
+	BAN::ErrorOr<void> unpack_boot_module_into_directory(BAN::RefPtr<Inode> root_inode, DataSource& data_source)
+	{
 		BAN::String next_file_name;
 		BAN::String next_link_name;
 
-		size_t offset = 0;
-		while (offset + 512 <= module.size)
-		{
-			size_t file_size = 0;
-			mode_t file_mode = 0;
-			uid_t file_uid = 0;
-			gid_t file_gid = 0;
-			uint8_t file_type = 0;
-			char file_path[100 + 1 + 155 + 1] {};
+		constexpr uint32_t print_interval_ms = 1000;
+		auto next_print_ms = SystemTimer::get().ms_since_boot() + print_interval_ms;
 
-			PageTable::with_fast_page((module.start + offset) & PAGE_ADDR_MASK, [&] {
-				const size_t page_off = offset % PAGE_SIZE;
+		while (TRY(data_source.produce_data()), data_source.data_size() >= 512)
+		{
+			if (SystemTimer::get().ms_since_boot() >= next_print_ms)
+			{
+				const auto kib_consumed = data_source.bytes_consumed() / 1024;
+				const auto kib_produced = data_source.bytes_produced() / 1024;
+				if (kib_consumed == kib_produced)
+				{
+					dprintln(" ... {}.{3} MiB",
+						kib_consumed / 1024, (kib_consumed % 1024) * 1000 / 1024
+					);
+				}
+				else
+				{
+					dprintln(" ... {}.{3} MiB ({}.{3} MiB)",
+						kib_consumed / 1024, (kib_consumed % 1024) * 1000 / 1024,
+						kib_produced / 1024, (kib_produced % 1024) * 1000 / 1024
+					);
+				}
+				next_print_ms = SystemTimer::get().ms_since_boot() + print_interval_ms;
+			}
 
 			const auto parse_octal =
-					[page_off](size_t offset, size_t length) -> size_t
+				[&data_source](size_t offset, size_t length) -> size_t
 				{
 					size_t result = 0;
 					for (size_t i = 0; i < length; i++)
 					{
-							const char ch = PageTable::fast_page_as<char>(page_off + offset + i);
+						const char ch = data_source.data()[offset + i];
 						if (ch == '\0')
 							break;
 						result = (result * 8) + (ch - '0');
@@ -66,29 +241,22 @@ namespace Kernel
 					return result;
 				};
 
-				if (memcmp(PageTable::fast_page_as_ptr(page_off + 257), "ustar", 5)) {
-					file_size = SIZE_MAX;
-					return;
-				}
+			if (memcmp(&data_source.data()[257], "ustar", 5) != 0)
+				break;
 
-				memcpy(file_path, PageTable::fast_page_as_ptr(page_off + 345), 155);
+			char file_path[100 + 1 + 155 + 1];
+			memcpy(file_path, &data_source.data()[345], 155);
 			const size_t prefix_len = strlen(file_path);
 			file_path[prefix_len] = '/';
-				memcpy(file_path + prefix_len + 1, PageTable::fast_page_as_ptr(page_off), 100);
+			memcpy(file_path + prefix_len + 1, &data_source.data()[0], 100);
 
-				file_mode = parse_octal(100, 8);
-				file_uid  = parse_octal(108, 8);
-				file_gid  = parse_octal(116, 8);
-				file_size = parse_octal(124, 12);
-				file_type = PageTable::fast_page_as<char>(page_off + 156);
-			});
+			mode_t        file_mode = parse_octal(100, 8);
+			const uid_t   file_uid  = parse_octal(108, 8);
+			const gid_t   file_gid  = parse_octal(116, 8);
+			const size_t  file_size = parse_octal(124, 12);
+			const uint8_t file_type = data_source.data()[156];
 
-			if (file_size == SIZE_MAX)
-				break;
-			if (offset + 512 + file_size > module.size)
-				break;
-
-			auto parent_inode = filesystem->root_inode();
+			auto parent_inode = root_inode;
 
 			auto file_path_parts = TRY(BAN::StringView(next_file_name.empty() ? file_path : next_file_name.sv()).split('/'));
 			for (size_t i = 0; i < file_path_parts.size() - 1; i++)
@@ -111,27 +279,33 @@ namespace Kernel
 
 			auto file_name_sv = file_path_parts.back();
 
+			bool did_consume_data = false;
+
 			if (file_type == 'L' || file_type == 'K')
 			{
-				auto& target = (file_type == 'L') ? next_file_name : next_link_name;
-				TRY(target.resize(file_size));
+				auto& target_str = (file_type == 'L') ? next_file_name : next_link_name;
+				TRY(target_str.resize(file_size));
+
+				data_source.pop_data(512);
 
 				size_t nwritten = 0;
 				while (nwritten < file_size)
 				{
-					const paddr_t paddr = module.start + offset + 512 + nwritten;
-					PageTable::with_fast_page(paddr & PAGE_ADDR_MASK, [&] {
-						memcpy(temp_page, PageTable::fast_page_as_ptr(), PAGE_SIZE);
-					});
+					TRY(data_source.produce_data());
+					if (data_source.data_size() == 0)
+						return {};
 
-					const size_t page_off = paddr % PAGE_SIZE;
-					const size_t to_write = BAN::Math::min(file_size - nwritten, PAGE_SIZE - page_off);
-					memcpy(target.data() + nwritten, temp_page + page_off, to_write);
-					nwritten += to_write;
+					const size_t to_copy = BAN::Math::min(data_source.data_size(), file_size - nwritten);
+					memcpy(target_str.data() + nwritten, data_source.data().data(), to_copy);
+					nwritten += to_copy;
+
+					data_source.pop_data(to_copy);
 				}
 
-				while (!target.empty() && target.back() == '\0')
-					target.pop_back();
+				did_consume_data = true;
+
+				while (!target_str.empty() && target_str.back() == '\0')
+					target_str.pop_back();
 			}
 			else if (file_type == DIRTYPE)
 			{
@@ -149,14 +323,11 @@ namespace Kernel
 					link_name = next_link_name.sv();
 				else
 				{
-					const paddr_t paddr = module.start + offset;
-					PageTable::with_fast_page(paddr & PAGE_ADDR_MASK, [&] {
-						memcpy(link_buffer, PageTable::fast_page_as_ptr((paddr % PAGE_SIZE) + 157), 100);
-					});
+					memcpy(link_buffer, &data_source.data()[157], 100);
 					link_name = link_buffer;
 				}
 
-				auto target_inode = filesystem->root_inode();
+				auto target_inode = root_inode;
 
 				auto link_path_parts = TRY(link_name.split('/'));
 				for (const auto part : link_path_parts)
@@ -188,10 +359,7 @@ namespace Kernel
 						link_name = next_link_name.sv();
 					else
 					{
-						const paddr_t paddr = module.start + offset;
-						PageTable::with_fast_page(paddr & PAGE_ADDR_MASK, [&] {
-							memcpy(link_buffer, PageTable::fast_page_as_ptr((paddr % PAGE_SIZE) + 157), 100);
-						});
+						memcpy(link_buffer, &data_source.data()[157], 100);
 						link_name = link_buffer;
 					}
 
@@ -203,26 +371,26 @@ namespace Kernel
 			{
 				if (auto ret = parent_inode->create_file(file_name_sv, file_mode, file_uid, file_gid); ret.is_error())
 					dwarnln("failed to create file '{}': {}", file_name_sv, ret.error());
-				else
-				{
-					if (file_size)
+				else if (file_size)
 				{
 					auto inode = TRY(parent_inode->find_inode(file_name_sv));
 
+					data_source.pop_data(512);
+
 					size_t nwritten = 0;
 					while (nwritten < file_size)
 					{
-							const paddr_t paddr = module.start + offset + 512 + nwritten;
-							PageTable::with_fast_page(paddr & PAGE_ADDR_MASK, [&] {
-								memcpy(temp_page, PageTable::fast_page_as_ptr(), PAGE_SIZE);
-							});
+						TRY(data_source.produce_data());
+						ASSERT(data_source.data_size() > 0); // what to do?
 
-							const size_t page_off = paddr % PAGE_SIZE;
-							const size_t to_write = BAN::Math::min(file_size - nwritten, PAGE_SIZE - page_off);
-							TRY(inode->write(nwritten, { temp_page + page_off, to_write }));
+						const size_t to_write = BAN::Math::min(file_size - nwritten, data_source.data_size());
+						TRY(inode->write(nwritten, data_source.data().slice(0, to_write)));
 						nwritten += to_write;
+
+						data_source.pop_data(to_write);
 					}
-					}
+
+					did_consume_data = true;
 				}
 			}
 
@@ -232,9 +400,27 @@ namespace Kernel
 				next_link_name.clear();
 			}
 
-			offset += 512 + file_size;
-			if (auto rem = offset % 512)
-				offset += 512 - rem;
+			if (!did_consume_data)
+			{
+				data_source.pop_data(512);
+
+				size_t consumed = 0;
+				while (consumed < file_size)
+				{
+					TRY(data_source.produce_data());
+					if (data_source.data_size() == 0)
+						return {};
+					data_source.pop_data(BAN::Math::min(file_size - consumed, data_source.data_size()));
+				}
+			}
+
+			if (const auto rem = file_size % 512)
+			{
+				TRY(data_source.produce_data());
+				if (data_source.data_size() < rem)
+					return {};
+				data_source.pop_data(512 - rem);
+			}
 		}
 
 		return {};

kernel/kernel/FS/VirtualFileSystem.cpp

@@ -61,18 +61,22 @@ namespace Kernel
 		if (filesystem_or_error.is_error())
 			panic("Failed to create fallback filesystem: {}", filesystem_or_error.error());
 
-		dprintln("Loading fallback filesystem from {} modules", g_boot_info.modules.size());
+		dprintln("Trying to load fallback filesystem from {} modules", g_boot_info.modules.size());
 
 		auto filesystem = BAN::RefPtr<FileSystem>::adopt(filesystem_or_error.release_value());
 
+		bool loaded_initrd = false;
 		for (const auto& module : g_boot_info.modules)
 		{
-			if (!is_ustar_boot_module(module))
-				continue;
-			if (auto ret = unpack_boot_module_into_filesystem(filesystem, module); ret.is_error())
+			if (auto ret = unpack_boot_module_into_directory(filesystem->root_inode(), module); ret.is_error())
 				dwarnln("Failed to unpack boot module: {}", ret.error());
+			else
+				loaded_initrd |= ret.value();
 		}
 
+		if (!loaded_initrd)
+			panic("Could not load initrd from any boot module :(");
+
 		return filesystem;
 	}
 

kernel/kernel/IDT.cpp

@@ -164,6 +164,33 @@ namespace Kernel
 		"Unkown Exception 0x1F",
 	};
 
+	extern "C" uint8_t safe_user_memcpy[];
+	extern "C" uint8_t safe_user_memcpy_end[];
+	extern "C" uint8_t safe_user_memcpy_fault[];
+
+	extern "C" uint8_t safe_user_strncpy[];
+	extern "C" uint8_t safe_user_strncpy_end[];
+	extern "C" uint8_t safe_user_strncpy_fault[];
+
+	struct safe_user_page_fault
+	{
+		const uint8_t* ip_start;
+		const uint8_t* ip_end;
+		const uint8_t* ip_fault;
+	};
+	static constexpr safe_user_page_fault s_safe_user_page_faults[] {
+		{
+			.ip_start = safe_user_memcpy,
+			.ip_end   = safe_user_memcpy_end,
+			.ip_fault = safe_user_memcpy_fault,
+		},
+		{
+			.ip_start = safe_user_strncpy,
+			.ip_end   = safe_user_strncpy_end,
+			.ip_fault = safe_user_strncpy_fault,
+		},
+	};
+
 	extern "C" void cpp_isr_handler(uint32_t isr, uint32_t error, InterruptStack* interrupt_stack, const Registers* regs)
 	{
 		if (g_paniced)
@@ -194,13 +221,28 @@ namespace Kernel
 				if (result.is_error())
 				{
 					dwarnln("Demand paging: {}", result.error());
+
+					// TODO: this is too strict, we should maybe do SIGBUS and
+					//       SIGKILL only on recursive exceptions
+					Processor::set_interrupt_state(InterruptState::Enabled);
 					Thread::current().handle_signal(SIGKILL, {});
+					Processor::set_interrupt_state(InterruptState::Disabled);
+
 					return;
 				}
 
 				if (result.value())
 					return;
 
+				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:
@@ -285,7 +327,7 @@ namespace Kernel
 
 		Debug::s_debug_lock.unlock(InterruptState::Disabled);
 
-		if (tid && Thread::current().is_userspace())
+		if (tid && GDT::is_user_segment(interrupt_stack->cs))
 		{
 			// TODO: Confirm and fix the exception to signal mappings
 
@@ -316,6 +358,7 @@ namespace Kernel
 			case ISR::InvalidOpcode:
 				signal_info.si_signo = SIGILL;
 				signal_info.si_code = ILL_ILLOPC;
+				signal_info.si_addr = reinterpret_cast<void*>(interrupt_stack->ip);
 				break;
 			case ISR::PageFault:
 				signal_info.si_signo = SIGSEGV;
@@ -323,6 +366,7 @@ namespace Kernel
 					signal_info.si_code = SEGV_ACCERR;
 				else
 					signal_info.si_code = SEGV_MAPERR;
+				signal_info.si_addr = reinterpret_cast<void*>(regs->cr2);
 				break;
 			default:
 				dwarnln("Unhandled exception");
@@ -330,7 +374,9 @@ namespace Kernel
 				break;
 			}
 
+			Processor::set_interrupt_state(InterruptState::Enabled);
 			Thread::current().handle_signal(signal_info.si_signo, signal_info);
+			Processor::set_interrupt_state(InterruptState::Disabled);
 		}
 		else
 		{
@@ -365,10 +411,6 @@ namespace Kernel
 			Process::update_alarm_queue();
 
 		Processor::scheduler().timer_interrupt();
-
-		auto& current_thread = Thread::current();
-		if (current_thread.can_add_signal_to_execute())
-			current_thread.handle_signal();
 	}
 
 	extern "C" void cpp_irq_handler(uint32_t irq)
@@ -392,15 +434,18 @@ namespace Kernel
 		else
 			dprintln("no handler for irq 0x{2H}", irq);
 
-		auto& current_thread = Thread::current();
-		if (current_thread.can_add_signal_to_execute())
-			current_thread.handle_signal();
-
 		Processor::scheduler().reschedule_if_idle();
 
 		ASSERT(Thread::current().state() != Thread::State::Terminated);
 	}
 
+	extern "C" void cpp_check_signal()
+	{
+		Processor::set_interrupt_state(InterruptState::Enabled);
+		Thread::current().handle_signal_if_interrupted();
+		Processor::set_interrupt_state(InterruptState::Disabled);
+	}
+
 	void IDT::register_interrupt_handler(uint8_t index, void (*handler)(), uint8_t ist)
 	{
 		auto& desc = m_idt[index];
@@ -440,7 +485,6 @@ namespace Kernel
 	IRQ_LIST_X
 #undef X
 
-	extern "C" void asm_yield_handler();
 	extern "C" void asm_ipi_handler();
 	extern "C" void asm_timer_handler();
 #if ARCH(i686)

kernel/kernel/Input/PS2/Keymap.cpp

@@ -136,6 +136,9 @@ namespace Kernel::Input
 		m_scancode_to_keycode_extended[0x49] = keycode_function(18);
 		m_scancode_to_keycode_extended[0x51] = keycode_function(19);
 		m_scancode_to_keycode_normal[0x46]   = keycode_function(20);
+		m_scancode_to_keycode_extended[0x20] = keycode_function(21);
+		m_scancode_to_keycode_extended[0x2E] = keycode_function(22);
+		m_scancode_to_keycode_extended[0x30] = keycode_function(23);
 
 		// Arrow keys
 		m_scancode_to_keycode_extended[0x48] = keycode_normal(5, 0);
@@ -246,6 +249,9 @@ namespace Kernel::Input
 		m_scancode_to_keycode_extended[0x7D] = keycode_function(18);
 		m_scancode_to_keycode_extended[0x7A] = keycode_function(19);
 		m_scancode_to_keycode_normal[0x7E]   = keycode_function(20);
+		m_scancode_to_keycode_extended[0x23] = keycode_function(21);
+		m_scancode_to_keycode_extended[0x21] = keycode_function(22);
+		m_scancode_to_keycode_extended[0x32] = keycode_function(23);
 
 		// Arrow keys
 		m_scancode_to_keycode_extended[0x75] = keycode_normal(5, 0);
@@ -356,6 +362,9 @@ namespace Kernel::Input
 		m_scancode_to_keycode_normal[0x6F] = keycode_function(18);
 		m_scancode_to_keycode_normal[0x6D] = keycode_function(19);
 		m_scancode_to_keycode_normal[0x5F] = keycode_function(20);
+		m_scancode_to_keycode_normal[0x9C] = keycode_function(21);
+		m_scancode_to_keycode_normal[0x9D] = keycode_function(22);
+		m_scancode_to_keycode_normal[0x95] = keycode_function(23);
 
 		// Arrow keys
 		m_scancode_to_keycode_normal[0x63] = keycode_normal(5, 0);

kernel/kernel/Memory/Heap.cpp

@@ -2,11 +2,62 @@
 #include <kernel/Memory/Heap.h>
 #include <kernel/Memory/PageTable.h>
 
+#include <BAN/Sort.h>
+
 extern uint8_t g_kernel_end[];
 
 namespace Kernel
 {
 
+	struct ReservedRegion
+	{
+		paddr_t paddr;
+		uint64_t size;
+	};
+
+	static BAN::Vector<ReservedRegion> get_reserved_regions()
+	{
+		BAN::Vector<ReservedRegion> reserved_regions;
+		MUST(reserved_regions.reserve(2 + g_boot_info.modules.size()));
+		MUST(reserved_regions.emplace_back(0, 0x100000));
+		MUST(reserved_regions.emplace_back(g_boot_info.kernel_paddr, reinterpret_cast<size_t>(g_kernel_end - KERNEL_OFFSET)));
+		for (const auto& module : g_boot_info.modules)
+			MUST(reserved_regions.emplace_back(module.start, module.size));
+
+		// page align regions
+		for (auto& region : reserved_regions)
+		{
+			const auto rem = region.paddr % PAGE_SIZE;
+			region.paddr -= rem;
+			region.size += rem;
+
+			if (const auto rem = region.size % PAGE_SIZE)
+				region.size += PAGE_SIZE - rem;
+		}
+
+		// sort regions
+		BAN::sort::sort(reserved_regions.begin(), reserved_regions.end(),
+			[](const auto& lhs, const auto& rhs) -> bool {
+				if (lhs.paddr == rhs.paddr)
+					return lhs.size < rhs.size;
+				return lhs.paddr < rhs.paddr;
+			}
+		);
+
+		// combine overlapping regions
+		for (size_t i = 1; i < reserved_regions.size(); i++)
+		{
+			auto& prev = reserved_regions[i - 1];
+			auto& curr = reserved_regions[i - 0];
+			if (prev.paddr > curr.paddr + curr.size || curr.paddr > prev.paddr + prev.size)
+				continue;
+			prev.size = BAN::Math::max(prev.size, curr.paddr + curr.size - prev.paddr);
+			reserved_regions.remove(i--);
+		}
+
+		return reserved_regions;
+	}
+
 	static Heap* s_instance = nullptr;
 
 	void Heap::initialize()
@@ -28,6 +79,7 @@ namespace Kernel
 		if (g_boot_info.memory_map_entries.empty())
 			panic("Bootloader did not provide a memory map");
 
+		auto reserved_regions = get_reserved_regions();
 		for (const auto& entry : g_boot_info.memory_map_entries)
 		{
 			const char* entry_type_string = nullptr;
@@ -58,33 +110,71 @@ namespace Kernel
 			if (entry.type != MemoryMapEntry::Type::Available)
 				continue;
 
-			// FIXME: only reserve kernel area and modules, not everything from 0 -> kernel end
-			paddr_t start = entry.address;
-			if (start < (vaddr_t)g_kernel_end - KERNEL_OFFSET + g_boot_info.kernel_paddr)
-				start = (vaddr_t)g_kernel_end - KERNEL_OFFSET + g_boot_info.kernel_paddr;
-			for (const auto& module : g_boot_info.modules)
-				if (start < module.start + module.size)
-					start = module.start + module.size;
+			paddr_t e_start = entry.address;
+			if (auto rem = e_start % PAGE_SIZE)
+				e_start = PAGE_SIZE - rem;
+
+			paddr_t e_end = entry.address + entry.length;
+			if (auto rem = e_end % PAGE_SIZE)
+				e_end -= rem;
+
+			for (const auto& reserved_region : reserved_regions)
+			{
+				const paddr_t r_start = reserved_region.paddr;
+				const paddr_t r_end   = reserved_region.paddr + reserved_region.size;
+				if (r_end < e_start)
+					continue;
+				if (r_start > e_end)
+					break;
+
+				const paddr_t end = BAN::Math::max(e_start, r_start);
+				if (e_start + 2 * PAGE_SIZE <= end)
+					MUST(m_physical_ranges.emplace_back(e_start, end - e_start));
+
+				e_start = BAN::Math::max(e_start, BAN::Math::min(e_end, r_end));
+			}
+
+			if (e_start + 2 * PAGE_SIZE <= e_end)
+				MUST(m_physical_ranges.emplace_back(e_start, e_end - e_start));
+		}
+
+		uint64_t total_kibi_bytes = 0;
+		for (auto& range : m_physical_ranges)
+		{
+			const uint64_t kibi_bytes = range.usable_memory() / 1024;
+			dprintln("RAM {8H}->{8H} ({}.{3} MiB)", range.start(), range.end(), kibi_bytes / 1024, kibi_bytes % 1024);
+			total_kibi_bytes += kibi_bytes;
+		}
+		dprintln("Total RAM {}.{3} MiB", total_kibi_bytes / 1024, total_kibi_bytes % 1024);
+	}
+
+	void Heap::release_boot_modules()
+	{
+		const auto modules = BAN::move(g_boot_info.modules);
+
+		uint64_t kibi_bytes = 0;
+		for (const auto& module : modules)
+		{
+			vaddr_t start = module.start;
 			if (auto rem = start % PAGE_SIZE)
 				start += PAGE_SIZE - rem;
 
-			paddr_t end = entry.address + entry.length;
+			vaddr_t end = module.start + module.size;
 			if (auto rem = end % PAGE_SIZE)
 				end -= rem;
 
-			// Physical pages needs atleast 2 pages
-			if (end > start + PAGE_SIZE)
-				MUST(m_physical_ranges.emplace_back(start, end - start));
+			const size_t size = end - start;
+			if (size < 2 * PAGE_SIZE)
+				continue;
+
+			SpinLockGuard _(m_lock);
+			MUST(m_physical_ranges.emplace_back(start, size));
+
+			kibi_bytes += m_physical_ranges.back().usable_memory() / 1024;
 		}
 
-		size_t total = 0;
-		for (auto& range : m_physical_ranges)
-		{
-			size_t bytes = range.usable_memory();
-			dprintln("RAM {8H}->{8H} ({}.{} MB)", range.start(), range.end(), bytes / (1 << 20), bytes % (1 << 20) * 1000 / (1 << 20));
-			total += bytes;
-		}
-		dprintln("Total RAM {}.{} MB", total / (1 << 20), total % (1 << 20) * 1000 / (1 << 20));
+		if (kibi_bytes)
+			dprintln("Released {}.{3} MiB of RAM from boot modules", kibi_bytes / 1024, kibi_bytes % 1024);
 	}
 
 	paddr_t Heap::take_free_page()

kernel/kernel/Memory/MemoryBackedRegion.cpp

@@ -1,5 +1,6 @@
 #include <kernel/Memory/Heap.h>
 #include <kernel/Memory/MemoryBackedRegion.h>
+#include <kernel/Lock/LockGuard.h>
 
 namespace Kernel
 {
@@ -14,6 +15,9 @@ namespace Kernel
 			return BAN::Error::from_errno(ENOMEM);
 		auto region = BAN::UniqPtr<MemoryBackedRegion>::adopt(region_ptr);
 
+		const size_t page_count = (size + PAGE_SIZE - 1) / PAGE_SIZE;
+		TRY(region->m_physical_pages.resize(page_count, nullptr));
+
 		TRY(region->initialize(address_range));
 
 		return region;
@@ -28,55 +32,96 @@ namespace Kernel
 	{
 		ASSERT(m_type == Type::PRIVATE);
 
-		size_t needed_pages = BAN::Math::div_round_up<size_t>(m_size, PAGE_SIZE);
-		for (size_t i = 0; i < needed_pages; i++)
-		{
-			paddr_t paddr = m_page_table.physical_address_of(m_vaddr + i * PAGE_SIZE);
-			if (paddr != 0)
-				Heap::get().release_page(paddr);
+		for (auto* page : m_physical_pages)
+			if (page && --page->ref_count == 0)
+				delete page;
 	}
+
+	MemoryBackedRegion::PhysicalPage::~PhysicalPage()
+	{
+		Heap::get().release_page(paddr);
 	}
 
 	BAN::ErrorOr<bool> MemoryBackedRegion::allocate_page_containing_impl(vaddr_t address, bool wants_write)
 	{
 		ASSERT(m_type == Type::PRIVATE);
-
 		ASSERT(contains(address));
-		(void)wants_write;
 
-		// Check if address is already mapped
-		vaddr_t vaddr = address & PAGE_ADDR_MASK;
-		if (m_page_table.physical_address_of(vaddr) != 0)
-			return false;
+		const vaddr_t vaddr = address & PAGE_ADDR_MASK;
 
-		// Map new physcial page to address
-		paddr_t paddr = Heap::get().take_free_page();
+		LockGuard _(m_mutex);
+
+		auto& physical_page = m_physical_pages[(vaddr - m_vaddr) / PAGE_SIZE];
+
+		if (physical_page == nullptr)
+		{
+			const paddr_t paddr = Heap::get().take_free_page();
 			if (paddr == 0)
 				return BAN::Error::from_errno(ENOMEM);
-		m_page_table.map_page_at(paddr, vaddr, m_flags);
 
-		// Zero out the new page
-		PageTable::with_fast_page(paddr, [&] {
+			physical_page = new PhysicalPage(paddr);
+			if (physical_page == nullptr)
+				return BAN::Error::from_errno(ENOMEM);
+
+			m_page_table.map_page_at(paddr, vaddr, m_flags);
+			PageTable::with_fast_page(paddr, [] {
 				memset(PageTable::fast_page_as_ptr(), 0x00, PAGE_SIZE);
 			});
 
 			return true;
 		}
 
+		if (auto is_only_ref = (physical_page->ref_count == 1); is_only_ref || !wants_write)
+		{
+			auto flags = m_flags;
+			if (!is_only_ref)
+				flags &= ~PageTable::ReadWrite;
+
+			m_page_table.map_page_at(physical_page->paddr, vaddr, flags);
+
+			return true;
+		}
+
+		const paddr_t paddr = Heap::get().take_free_page();
+		if (paddr == 0)
+			return BAN::Error::from_errno(ENOMEM);
+
+		auto* new_physical_page = new PhysicalPage(paddr);
+		if (new_physical_page == nullptr)
+			return BAN::Error::from_errno(ENOMEM);
+
+		m_page_table.map_page_at(paddr, vaddr, m_flags);
+
+		ASSERT(&m_page_table == &PageTable::current());
+		PageTable::with_fast_page(physical_page->paddr, [vaddr] {
+			memcpy(reinterpret_cast<void*>(vaddr), PageTable::fast_page_as_ptr(), PAGE_SIZE);
+		});
+
+		if (--physical_page->ref_count == 0)
+			delete physical_page;
+		physical_page = new_physical_page;
+
+		return true;
+	}
+
 	BAN::ErrorOr<BAN::UniqPtr<MemoryRegion>> MemoryBackedRegion::clone(PageTable& new_page_table)
 	{
 		ASSERT(&PageTable::current() == &m_page_table);
 
+		LockGuard _(m_mutex);
+
 		const size_t aligned_size = (m_size + PAGE_SIZE - 1) & PAGE_ADDR_MASK;
 		auto result = TRY(MemoryBackedRegion::create(new_page_table, m_size, { .start = m_vaddr, .end = m_vaddr + aligned_size }, m_type, m_flags, m_status_flags));
 
-		for (size_t offset = 0; offset < m_size; offset += PAGE_SIZE)
+		if (writable())
+			m_page_table.remove_writable_from_range(m_vaddr, m_size);
+
+		for (size_t i = 0; i < m_physical_pages.size(); i++)
 		{
-			paddr_t paddr = m_page_table.physical_address_of(m_vaddr + offset);
-			if (paddr == 0)
+			if (m_physical_pages[i] == nullptr)
 				continue;
-			const size_t to_copy = BAN::Math::min<size_t>(PAGE_SIZE, m_size - offset);
-			TRY(result->copy_data_to_region(offset, (const uint8_t*)(m_vaddr + offset), to_copy));
+			result->m_physical_pages[i] = m_physical_pages[i];
+			result->m_physical_pages[i]->ref_count++;
 		}
 
 		return BAN::UniqPtr<MemoryRegion>(BAN::move(result));
@@ -87,20 +132,35 @@ namespace Kernel
 		ASSERT(offset && offset < m_size);
 		ASSERT(offset % PAGE_SIZE == 0);
 
-		auto* new_region = new MemoryBackedRegion(m_page_table, m_size - offset, m_type, m_flags, m_status_flags);
-		if (new_region == nullptr)
+		LockGuard _(m_mutex);
+
+		auto* new_region_ptr = new MemoryBackedRegion(m_page_table, m_size - offset, m_type, m_flags, m_status_flags);
+		if (new_region_ptr == nullptr)
 			return BAN::Error::from_errno(ENOMEM);
+		auto new_region = BAN::UniqPtr<MemoryBackedRegion>::adopt(new_region_ptr);
+
 		new_region->m_vaddr = m_vaddr + offset;
 
+		const size_t moved_pages = (m_size - offset + PAGE_SIZE - 1) / PAGE_SIZE;
+		TRY(new_region->m_physical_pages.resize(moved_pages));
+
+		const size_t remaining_pages = m_physical_pages.size() - moved_pages;
+
+		for (size_t i = 0; i < moved_pages; i++)
+			new_region->m_physical_pages[i] = m_physical_pages[remaining_pages + i];
+		MUST(m_physical_pages.resize(remaining_pages));
+
 		m_size = offset;
 
-		return BAN::UniqPtr<MemoryRegion>::adopt(new_region);
+		return BAN::UniqPtr<MemoryRegion>(BAN::move(new_region));
 	}
 
 	BAN::ErrorOr<void> MemoryBackedRegion::copy_data_to_region(size_t offset_into_region, const uint8_t* buffer, size_t buffer_size)
 	{
 		ASSERT(offset_into_region + buffer_size <= m_size);
 
+		LockGuard _(m_mutex);
+
 		size_t written = 0;
 		while (written < buffer_size)
 		{
@@ -108,18 +168,18 @@ namespace Kernel
 			vaddr_t page_offset = write_vaddr % PAGE_SIZE;
 			size_t bytes = BAN::Math::min<size_t>(buffer_size - written, PAGE_SIZE - page_offset);
 
-			paddr_t paddr = m_page_table.physical_address_of(write_vaddr & PAGE_ADDR_MASK);
-			if (paddr == 0)
+			if (!(m_page_table.get_page_flags(write_vaddr & PAGE_ADDR_MASK) & PageTable::ReadWrite))
 			{
-				if (!TRY(allocate_page_containing(write_vaddr, false)))
+				if (!TRY(allocate_page_containing(write_vaddr, true)))
 				{
 					dwarnln("Could not allocate page for data copying");
 					return BAN::Error::from_errno(EFAULT);
 				}
-				paddr = m_page_table.physical_address_of(write_vaddr & PAGE_ADDR_MASK);
-				ASSERT(paddr);
 			}
 
+			const paddr_t paddr = m_page_table.physical_address_of(write_vaddr & PAGE_ADDR_MASK);
+			ASSERT(paddr);
+
 			PageTable::with_fast_page(paddr, [&] {
 				memcpy(PageTable::fast_page_as_ptr(page_offset), (void*)(buffer + written), bytes);
 			});

kernel/kernel/Memory/MemoryRegion.cpp

@@ -22,8 +22,10 @@ namespace Kernel
 
 	BAN::ErrorOr<void> MemoryRegion::initialize(AddressRange address_range)
 	{
-		size_t needed_pages = BAN::Math::div_round_up<size_t>(m_size, PAGE_SIZE);
-		m_vaddr = m_page_table.reserve_free_contiguous_pages(needed_pages, address_range.start);
+		if (auto rem = address_range.end % PAGE_SIZE)
+			address_range.end += PAGE_SIZE - rem;
+		const size_t needed_pages = BAN::Math::div_round_up<size_t>(m_size, PAGE_SIZE);
+		m_vaddr = m_page_table.reserve_free_contiguous_pages(needed_pages, address_range.start, address_range.end);
 		if (m_vaddr == 0)
 			return BAN::Error::from_errno(ENOMEM);
 		if (m_vaddr + m_size > address_range.end)

kernel/kernel/Memory/PhysicalRange.cpp

@@ -10,7 +10,7 @@ namespace Kernel
 
 	static constexpr size_t bits_per_page = PAGE_SIZE * 8;
 
-	PhysicalRange::PhysicalRange(paddr_t paddr, size_t size)
+	PhysicalRange::PhysicalRange(paddr_t paddr, uint64_t size)
 		: m_paddr(paddr)
 		, m_page_count(size / PAGE_SIZE)
 		, m_free_pages(m_page_count)

kernel/kernel/Memory/VirtualRange.cpp

@@ -110,36 +110,6 @@ namespace Kernel
 		return {};
 	}
 
-	BAN::ErrorOr<BAN::UniqPtr<VirtualRange>> VirtualRange::clone(PageTable& page_table)
-	{
-		ASSERT(&PageTable::current() == &m_page_table);
-		ASSERT(&m_page_table != &page_table);
-
-		SpinLockGuard _(m_lock);
-
-		auto result = TRY(create_to_vaddr(page_table, vaddr(), size(), m_flags, m_preallocated, m_has_guard_pages));
-
-		const size_t page_count = size() / PAGE_SIZE;
-		for (size_t i = 0; i < page_count; i++)
-		{
-			if (m_paddrs[i] == 0)
-				continue;
-			if (!result->m_preallocated)
-			{
-				result->m_paddrs[i] = Heap::get().take_free_page();
-				if (result->m_paddrs[i] == 0)
-					return BAN::Error::from_errno(ENOMEM);
-				result->m_page_table.map_page_at(result->m_paddrs[i], vaddr() + i * PAGE_SIZE, m_flags);
-			}
-
-			PageTable::with_fast_page(result->m_paddrs[i], [&] {
-				memcpy(PageTable::fast_page_as_ptr(), reinterpret_cast<void*>(vaddr() + i * PAGE_SIZE), PAGE_SIZE);
-			});
-		}
-
-		return result;
-	}
-
 	BAN::ErrorOr<bool> VirtualRange::allocate_page_for_demand_paging(vaddr_t vaddr)
 	{
 		ASSERT(contains(vaddr));

kernel/kernel/OpenFileDescriptorSet.cpp

@@ -51,17 +51,19 @@ namespace Kernel
 
 		close_all();
 
-		for (int fd = 0; fd < (int)other.m_open_files.size(); fd++)
+		for (int fd = 0; fd < static_cast<int>(other.m_open_files.size()); fd++)
 		{
 			if (other.validate_fd(fd).is_error())
 				continue;
 
 			auto& open_file = m_open_files[fd];
-			open_file.description      = other.m_open_files[fd].description;
-			open_file.descriptor_flags = other.m_open_files[fd].descriptor_flags;
-			open_file.inode()->on_clone(open_file.status_flags());
+			open_file = other.m_open_files[fd];
+			open_file->file.inode->on_clone(open_file->status_flags);
 		}
 
+		for (size_t i = 0; i < m_cloexec_files.size(); i++)
+			m_cloexec_files[i] = other.m_cloexec_files[i];
+
 		return {};
 	}
 
@@ -81,11 +83,15 @@ namespace Kernel
 		if ((flags & O_TRUNC) && (flags & O_WRONLY) && file.inode->mode().ifreg())
 			TRY(file.inode->truncate(0));
 
-		LockGuard _(m_mutex);
 		constexpr int status_mask = O_APPEND | O_DSYNC | O_NONBLOCK | O_RSYNC | O_SYNC | O_ACCMODE;
-		int fd = TRY(get_free_fd());
-		m_open_files[fd].description = TRY(BAN::RefPtr<OpenFileDescription>::create(BAN::move(file), 0, flags & status_mask));
-		m_open_files[fd].descriptor_flags = flags & O_CLOEXEC;
+
+		LockGuard _(m_mutex);
+
+		const int fd = TRY(get_free_fd());
+		m_open_files[fd] = TRY(BAN::RefPtr<OpenFileDescription>::create(BAN::move(file), 0, flags & status_mask));
+		if (flags & O_CLOEXEC)
+			add_cloexec(fd);
+
 		return fd;
 	}
 
@@ -99,7 +105,7 @@ namespace Kernel
 		Socket::Domain domain;
 		Socket::Type type;
 		int status_flags;
-		int descriptor_flags;
+		bool cloexec;
 	};
 
 	static BAN::ErrorOr<SocketInfo> parse_socket_info(int domain, int type, int protocol)
@@ -124,11 +130,11 @@ namespace Kernel
 		}
 
 		info.status_flags = 0;
-		info.descriptor_flags = 0;
+		info.cloexec = false;
 		if (type & SOCK_NONBLOCK)
 			info.status_flags |= O_NONBLOCK;
 		if (type & SOCK_CLOEXEC)
-			info.descriptor_flags |= O_CLOEXEC;
+			info.cloexec = true;
 		type &= ~(SOCK_NONBLOCK | SOCK_CLOEXEC);
 
 		switch (type)
@@ -171,9 +177,12 @@ namespace Kernel
 			socket_sv = "<udp socket>";
 
 		LockGuard _(m_mutex);
-		int fd = TRY(get_free_fd());
-		m_open_files[fd].description = TRY(BAN::RefPtr<OpenFileDescription>::create(VirtualFileSystem::File(socket, socket_sv), 0, O_RDWR | sock_info.status_flags));
-		m_open_files[fd].descriptor_flags = sock_info.descriptor_flags;
+
+		const int fd = TRY(get_free_fd());
+		m_open_files[fd] = TRY(BAN::RefPtr<OpenFileDescription>::create(VirtualFileSystem::File(socket, socket_sv), 0, O_RDWR | sock_info.status_flags));
+		if (sock_info.cloexec)
+			add_cloexec(fd);
+
 		return fd;
 	}
 
@@ -188,10 +197,14 @@ namespace Kernel
 		LockGuard _(m_mutex);
 
 		TRY(get_free_fd_pair(socket_vector));
-		m_open_files[socket_vector[0]].description = TRY(BAN::RefPtr<OpenFileDescription>::create(VirtualFileSystem::File(socket1, "<socketpair>"_sv), 0, O_RDWR | sock_info.status_flags));
-		m_open_files[socket_vector[0]].descriptor_flags = sock_info.descriptor_flags;
-		m_open_files[socket_vector[1]].description = TRY(BAN::RefPtr<OpenFileDescription>::create(VirtualFileSystem::File(socket2, "<socketpair>"_sv), 0, O_RDWR | sock_info.status_flags));
-		m_open_files[socket_vector[1]].descriptor_flags = sock_info.descriptor_flags;
+		m_open_files[socket_vector[0]] = TRY(BAN::RefPtr<OpenFileDescription>::create(VirtualFileSystem::File(socket1, "<socketpair>"_sv), 0, O_RDWR | sock_info.status_flags));
+		m_open_files[socket_vector[1]] = TRY(BAN::RefPtr<OpenFileDescription>::create(VirtualFileSystem::File(socket2, "<socketpair>"_sv), 0, O_RDWR | sock_info.status_flags));
+		if (sock_info.cloexec)
+		{
+			add_cloexec(socket_vector[0]);
+			add_cloexec(socket_vector[1]);
+		}
+
 		return {};
 	}
 
@@ -202,10 +215,11 @@ namespace Kernel
 		TRY(get_free_fd_pair(fds));
 
 		auto pipe = TRY(Pipe::create(m_credentials));
-		m_open_files[fds[0]].description = TRY(BAN::RefPtr<OpenFileDescription>::create(VirtualFileSystem::File(pipe, "<pipe rd>"_sv), 0, O_RDONLY));
-		m_open_files[fds[0]].descriptor_flags = 0;
-		m_open_files[fds[1]].description = TRY(BAN::RefPtr<OpenFileDescription>::create(VirtualFileSystem::File(pipe, "<pipe wr>"_sv), 0, O_WRONLY));
-		m_open_files[fds[1]].descriptor_flags = 0;
+		m_open_files[fds[0]] = TRY(BAN::RefPtr<OpenFileDescription>::create(VirtualFileSystem::File(pipe, "<pipe rd>"_sv), 0, O_RDONLY));
+		m_open_files[fds[1]] = TRY(BAN::RefPtr<OpenFileDescription>::create(VirtualFileSystem::File(pipe, "<pipe wr>"_sv), 0, O_WRONLY));
+
+		ASSERT(!is_cloexec(fds[0]));
+		ASSERT(!is_cloexec(fds[1]));
 
 		return {};
 	}
@@ -224,9 +238,10 @@ namespace Kernel
 		(void)close(fildes2);
 
 		auto& open_file = m_open_files[fildes2];
-		open_file.description = m_open_files[fildes].description;
-		open_file.descriptor_flags = 0;
-		open_file.inode()->on_clone(open_file.status_flags());
+		open_file = m_open_files[fildes];
+		open_file->file.inode->on_clone(open_file->status_flags);
+
+		ASSERT(!is_cloexec(fildes2));
 
 		return fildes2;
 	}
@@ -246,18 +261,16 @@ namespace Kernel
 
 				TRY(validate_fd(fd));
 
-				const auto& open_file = m_open_files[fd];
-
-				inode = open_file.inode();
+				inode = m_open_files[fd]->file.inode;
 
 				switch (flock.l_whence)
 				{
 					case SEEK_SET:
 						break;
 					case SEEK_CUR:
-						if (BAN::Math::will_addition_overflow(flock.l_start, open_file.offset()))
+						if (BAN::Math::will_addition_overflow(flock.l_start, m_open_files[fd]->offset))
 							return BAN::Error::from_errno(EOVERFLOW);
-						flock.l_start += m_open_files[fd].offset();
+						flock.l_start += m_open_files[fd]->offset;
 						break;
 					case SEEK_END:
 						if (BAN::Math::will_addition_overflow(flock.l_start, inode->size()))
@@ -307,26 +320,27 @@ namespace Kernel
 				const int new_fd = TRY(get_free_fd());
 
 				auto& open_file = m_open_files[new_fd];
-				open_file.description = m_open_files[fd].description;
-				open_file.descriptor_flags = (cmd == F_DUPFD_CLOEXEC) ? O_CLOEXEC : 0;
-				open_file.inode()->on_clone(open_file.status_flags());
+				open_file = m_open_files[fd];
+				open_file->file.inode->on_clone(open_file->status_flags);
+				if (cmd == F_DUPFD_CLOEXEC)
+					add_cloexec(new_fd);
 
 				return new_fd;
 			}
 			case F_GETFD:
-				return m_open_files[fd].descriptor_flags;
+				return is_cloexec(fd) ? O_CLOEXEC : 0;
 			case F_SETFD:
 				if (extra & FD_CLOEXEC)
-					m_open_files[fd].descriptor_flags |= O_CLOEXEC;
+					add_cloexec(fd);
 				else
-					m_open_files[fd].descriptor_flags &= ~O_CLOEXEC;
+					remove_cloexec(fd);
 				return 0;
 			case F_GETFL:
-				return m_open_files[fd].status_flags();
+				return m_open_files[fd]->status_flags;
 			case F_SETFL:
 				extra &= O_APPEND | O_DSYNC | O_NONBLOCK | O_RSYNC | O_SYNC;
-				m_open_files[fd].status_flags() &= O_ACCMODE;
-				m_open_files[fd].status_flags() |= extra;
+				m_open_files[fd]->status_flags &= O_ACCMODE;
+				m_open_files[fd]->status_flags |= extra;
 				return 0;
 			default:
 				break;
@@ -349,10 +363,10 @@ namespace Kernel
 				base_offset = 0;
 				break;
 			case SEEK_CUR:
-				base_offset = m_open_files[fd].offset();
+				base_offset = m_open_files[fd]->offset;
 				break;
 			case SEEK_END:
-				base_offset = m_open_files[fd].inode()->size();
+				base_offset = m_open_files[fd]->file.inode->size();
 				break;
 			default:
 				return BAN::Error::from_errno(EINVAL);
@@ -362,7 +376,7 @@ namespace Kernel
 		if (new_offset < 0)
 			return BAN::Error::from_errno(EINVAL);
 
-		m_open_files[fd].offset() = new_offset;
+		m_open_files[fd]->offset = new_offset;
 
 		return new_offset;
 	}
@@ -371,14 +385,14 @@ namespace Kernel
 	{
 		LockGuard _(m_mutex);
 		TRY(validate_fd(fd));
-		return m_open_files[fd].offset();
+		return m_open_files[fd]->offset;
 	}
 
 	BAN::ErrorOr<void> OpenFileDescriptorSet::truncate(int fd, off_t length)
 	{
 		LockGuard _(m_mutex);
 		TRY(validate_fd(fd));
-		return m_open_files[fd].inode()->truncate(length);
+		return m_open_files[fd]->file.inode->truncate(length);
 	}
 
 	BAN::ErrorOr<void> OpenFileDescriptorSet::close(int fd)
@@ -389,7 +403,7 @@ namespace Kernel
 
 		auto& open_file = m_open_files[fd];
 
-		if (auto& flock = open_file.description->flock; Thread::current().has_process() && flock.lockers.contains(Process::current().pid()))
+		if (auto& flock = open_file->flock; Thread::current().has_process() && flock.lockers.contains(Process::current().pid()))
 		{
 			flock.lockers.remove(Process::current().pid());
 			if (flock.lockers.empty())
@@ -401,7 +415,7 @@ namespace Kernel
 
 		{
 			LockGuard _(s_fcntl_lock_mutex);
-			if (auto it = s_fcntl_locks.find(open_file.inode()); it != s_fcntl_locks.end())
+			if (auto it = s_fcntl_locks.find(open_file->file.inode); it != s_fcntl_locks.end())
 			{
 				auto& flocks = it->value;
 				for (size_t i = 0; i < flocks.size(); i++)
@@ -411,9 +425,9 @@ namespace Kernel
 			}
 		}
 
-		open_file.inode()->on_close(open_file.status_flags());
-		open_file.description.clear();
-		open_file.descriptor_flags = 0;
+		open_file->file.inode->on_close(open_file->status_flags);
+		open_file = {};
+		remove_cloexec(fd);
 
 		return {};
 	}
@@ -421,20 +435,31 @@ namespace Kernel
 	void OpenFileDescriptorSet::close_all()
 	{
 		LockGuard _(m_mutex);
-		for (int fd = 0; fd < (int)m_open_files.size(); fd++)
+		for (int fd = 0; fd < static_cast<int>(m_open_files.size()); fd++)
 			(void)close(fd);
 	}
 
 	void OpenFileDescriptorSet::close_cloexec()
 	{
 		LockGuard _(m_mutex);
-		for (int fd = 0; fd < (int)m_open_files.size(); fd++)
-		{
-			if (validate_fd(fd).is_error())
-				continue;
-			if (m_open_files[fd].descriptor_flags & O_CLOEXEC)
+		for (int fd = 0; fd < static_cast<int>(m_open_files.size()); fd++)
+			if (is_cloexec(fd))
 				(void)close(fd);
 	}
+
+	bool OpenFileDescriptorSet::is_cloexec(int fd)
+	{
+		return m_cloexec_files[fd / 32] & (1u << (fd % 32));
+	}
+
+	void OpenFileDescriptorSet::add_cloexec(int fd)
+	{
+		m_cloexec_files[fd / 32] |= 1u << (fd % 32);
+	}
+
+	void OpenFileDescriptorSet::remove_cloexec(int fd)
+	{
+		m_cloexec_files[fd / 32] &= ~(1u << (fd % 32));
 	}
 
 	static BAN::ErrorOr<void> fcntl_lock(BAN::RefPtr<Inode> inode, int cmd, struct flock& flock)
@@ -588,7 +613,7 @@ namespace Kernel
 		{
 			TRY(validate_fd(fd));
 
-			auto& flock = m_open_files[fd].description->flock;
+			auto& flock = m_open_files[fd]->flock;
 			switch (op & ~LOCK_NB)
 			{
 				case LOCK_UN:
@@ -645,11 +670,11 @@ namespace Kernel
 			LockGuard _(m_mutex);
 			TRY(validate_fd(fd));
 			auto& open_file = m_open_files[fd];
-			if (!(open_file.status_flags() & O_RDONLY))
+			if (!(open_file->status_flags & O_RDONLY))
 				return BAN::Error::from_errno(EBADF);
-			inode = open_file.inode();
-			is_nonblock = !!(open_file.status_flags() & O_NONBLOCK);
-			offset = open_file.offset();
+			inode = open_file->file.inode;
+			is_nonblock = !!(open_file->status_flags & O_NONBLOCK);
+			offset = open_file->offset;
 		}
 
 		if (inode->mode().ifsock())
@@ -685,7 +710,7 @@ namespace Kernel
 		LockGuard _(m_mutex);
 		// NOTE: race condition with offset, its UB per POSIX
 		if (!validate_fd(fd).is_error())
-			m_open_files[fd].offset() = offset + nread;
+			m_open_files[fd]->offset = offset + nread;
 		return nread;
 	}
 
@@ -699,11 +724,11 @@ namespace Kernel
 			LockGuard _(m_mutex);
 			TRY(validate_fd(fd));
 			auto& open_file = m_open_files[fd];
-			if (!(open_file.status_flags() & O_WRONLY))
+			if (!(open_file->status_flags & O_WRONLY))
 				return BAN::Error::from_errno(EBADF);
-			inode = open_file.inode();
-			is_nonblock = !!(open_file.status_flags() & O_NONBLOCK);
-			offset = (open_file.status_flags() & O_APPEND) ? inode->size() : open_file.offset();
+			inode = open_file->file.inode;
+			is_nonblock = !!(open_file->status_flags & O_NONBLOCK);
+			offset = (open_file->status_flags & O_APPEND) ? inode->size() : open_file->offset;
 		}
 
 		if (inode->mode().ifsock())
@@ -742,7 +767,7 @@ namespace Kernel
 		LockGuard _(m_mutex);
 		// NOTE: race condition with offset, its UB per POSIX
 		if (!validate_fd(fd).is_error())
-			m_open_files[fd].offset() = offset + nwrite;
+			m_open_files[fd]->offset = offset + nwrite;
 		return nwrite;
 	}
 
@@ -755,10 +780,10 @@ namespace Kernel
 			LockGuard _(m_mutex);
 			TRY(validate_fd(fd));
 			auto& open_file = m_open_files[fd];
-			if (!(open_file.status_flags() & O_RDONLY))
+			if (!(open_file->status_flags & O_RDONLY))
 				return BAN::Error::from_errno(EACCES);
-			inode = open_file.inode();
-			offset = open_file.offset();
+			inode = open_file->file.inode;
+			offset = open_file->offset;
 		}
 
 		for (;;)
@@ -773,7 +798,7 @@ namespace Kernel
 			LockGuard _(m_mutex);
 			// NOTE: race condition with offset, its UB per POSIX
 			if (!validate_fd(fd).is_error())
-				m_open_files[fd].offset() = offset;
+				m_open_files[fd]->offset = offset;
 			return ret;
 		}
 	}
@@ -787,10 +812,10 @@ namespace Kernel
 			LockGuard _(m_mutex);
 			TRY(validate_fd(fd));
 			auto& open_file = m_open_files[fd];
-			if (!open_file.inode()->mode().ifsock())
+			if (!open_file->file.inode->mode().ifsock())
 				return BAN::Error::from_errno(ENOTSOCK);
-			inode = open_file.inode();
-			is_nonblock = !!(open_file.status_flags() & O_NONBLOCK);
+			inode = open_file->file.inode;
+			is_nonblock = !!(open_file->status_flags & O_NONBLOCK);
 		}
 
 		LockGuard _(inode->m_mutex);
@@ -808,10 +833,10 @@ namespace Kernel
 			LockGuard _(m_mutex);
 			TRY(validate_fd(fd));
 			auto& open_file = m_open_files[fd];
-			if (!open_file.inode()->mode().ifsock())
+			if (!open_file->file.inode->mode().ifsock())
 				return BAN::Error::from_errno(ENOTSOCK);
-			inode = open_file.inode();
-			is_nonblock = !!(open_file.status_flags() & O_NONBLOCK);
+			inode = open_file->file.inode;
+			is_nonblock = !!(open_file->status_flags & O_NONBLOCK);
 		}
 
 		LockGuard _(inode->m_mutex);
@@ -830,7 +855,7 @@ namespace Kernel
 	{
 		LockGuard _(m_mutex);
 		TRY(validate_fd(fd));
-		return TRY(m_open_files[fd].description->file.clone());
+		return TRY(m_open_files[fd]->file.clone());
 	}
 
 	BAN::ErrorOr<BAN::String> OpenFileDescriptorSet::path_of(int fd) const
@@ -838,7 +863,7 @@ namespace Kernel
 		LockGuard _(m_mutex);
 		TRY(validate_fd(fd));
 		BAN::String path;
-		TRY(path.append(m_open_files[fd].path()));
+		TRY(path.append(m_open_files[fd]->file.canonical_path));
 		return path;
 	}
 
@@ -846,14 +871,14 @@ namespace Kernel
 	{
 		LockGuard _(m_mutex);
 		TRY(validate_fd(fd));
-		return m_open_files[fd].inode();
+		return m_open_files[fd]->file.inode;
 	}
 
 	BAN::ErrorOr<int> OpenFileDescriptorSet::status_flags_of(int fd) const
 	{
 		LockGuard _(m_mutex);
 		TRY(validate_fd(fd));
-		return m_open_files[fd].status_flags();
+		return m_open_files[fd]->status_flags;
 	}
 
 	BAN::ErrorOr<void> OpenFileDescriptorSet::validate_fd(int fd) const
@@ -861,7 +886,7 @@ namespace Kernel
 		LockGuard _(m_mutex);
 		if (fd < 0 || fd >= (int)m_open_files.size())
 			return BAN::Error::from_errno(EBADF);
-		if (!m_open_files[fd].description)
+		if (!m_open_files[fd])
 			return BAN::Error::from_errno(EBADF);
 		return {};
 	}
@@ -870,7 +895,7 @@ namespace Kernel
 	{
 		LockGuard _(m_mutex);
 		for (int fd = 0; fd < (int)m_open_files.size(); fd++)
-			if (!m_open_files[fd].description)
+			if (!m_open_files[fd])
 				return fd;
 		return BAN::Error::from_errno(EMFILE);
 	}
@@ -881,7 +906,7 @@ namespace Kernel
 		size_t found = 0;
 		for (int fd = 0; fd < (int)m_open_files.size(); fd++)
 		{
-			if (!m_open_files[fd].description)
+			if (!m_open_files[fd])
 				fds[found++] = fd;
 			if (found == 2)
 				return {};
@@ -929,7 +954,7 @@ namespace Kernel
 	{
 		LockGuard _(m_mutex);
 		TRY(validate_fd(fd));
-		return FDWrapper { m_open_files[fd].description };
+		return FDWrapper { m_open_files[fd] };
 	}
 
 	size_t OpenFileDescriptorSet::open_all_fd_wrappers(BAN::Span<FDWrapper> fd_wrappers)
@@ -943,8 +968,7 @@ namespace Kernel
 				return i;
 
 			const int fd = fd_or_error.release_value();
-			m_open_files[fd].description = BAN::move(fd_wrappers[i].m_description);
-			m_open_files[fd].descriptor_flags = 0;
+			m_open_files[fd] = BAN::move(fd_wrappers[i].m_description);
 			fd_wrappers[i].m_fd = fd;
 		}
 

kernel/kernel/Process.cpp

@@ -303,6 +303,8 @@ namespace Kernel
 
 	void Process::exit(int status, int signal)
 	{
+		ASSERT(Processor::get_interrupt_state() == InterruptState::Enabled);
+
 		bool expected = false;
 		if (!m_is_exiting.compare_exchange(expected, true))
 		{
@@ -310,9 +312,6 @@ namespace Kernel
 			ASSERT_NOT_REACHED();
 		}
 
-		const auto state = Processor::get_interrupt_state();
-		Processor::set_interrupt_state(InterruptState::Enabled);
-
 		if (m_parent)
 		{
 			Process* parent_process = nullptr;
@@ -369,8 +368,6 @@ namespace Kernel
 		while (m_threads.size() > 1)
 			Processor::yield();
 
-		Processor::set_interrupt_state(state);
-
 		Thread::current().on_exit();
 
 		ASSERT_NOT_REACHED();
@@ -2951,7 +2948,7 @@ namespace Kernel
 		for (;;)
 		{
 			while (Thread::current().will_exit_because_of_signal())
-				Thread::current().handle_signal();
+				Thread::current().handle_signal_if_interrupted();
 
 			SpinLockGuard guard(m_signal_lock);
 			if (!m_stopped)
@@ -3050,7 +3047,7 @@ namespace Kernel
 			TRY(read_from_user(user_act, &new_act, sizeof(struct sigaction)));
 
 		{
-			SpinLockGuard signal_lock_guard(m_signal_lock);
+			SpinLockGuard _(m_signal_lock);
 			old_act = m_signal_handlers[signal];
 			if (user_act != nullptr)
 				m_signal_handlers[signal] = new_act;
@@ -3064,7 +3061,14 @@ namespace Kernel
 
 	BAN::ErrorOr<long> Process::sys_sigpending(sigset_t* user_sigset)
 	{
-		const sigset_t sigset = (signal_pending_mask() | Thread::current().m_signal_pending_mask) & Thread::current().m_signal_block_mask;
+		sigset_t sigset;
+
+		{
+			auto& thread = Thread::current();
+			SpinLockGuard _(thread.m_signal_lock);
+			sigset = (signal_pending_mask() | thread.m_signal_pending_mask) & thread.m_signal_block_mask;
+		}
+
 		TRY(write_to_user(user_sigset, &sigset, sizeof(sigset_t)));
 		return 0;
 	}
@@ -3073,34 +3077,36 @@ namespace Kernel
 	{
 		LockGuard _(m_process_lock);
 
-		if (user_oset != nullptr)
-		{
-			const sigset_t current = Thread::current().m_signal_block_mask;
-			TRY(write_to_user(user_oset, &current, sizeof(sigset_t)));
-		}
+		auto& thread = Thread::current();
+
+		const sigset_t old_sigset = thread.m_signal_block_mask;
 
 		if (user_set != nullptr)
 		{
-			sigset_t set;
-			TRY(read_from_user(user_set, &set, sizeof(sigset_t)));
+			sigset_t mask;
+			TRY(read_from_user(user_set, &mask, sizeof(sigset_t)));
+			mask &= ~((1ull << SIGKILL) | (1ull << SIGSTOP));
 
-			const sigset_t mask = set & ~(SIGKILL | SIGSTOP);
+			SpinLockGuard _(thread.m_signal_lock);
 			switch (how)
 			{
 				case SIG_BLOCK:
-					Thread::current().m_signal_block_mask |= mask;
-					break;
-				case SIG_SETMASK:
-					Thread::current().m_signal_block_mask  = mask;
+					thread.m_signal_block_mask |= mask;
 					break;
 				case SIG_UNBLOCK:
-					Thread::current().m_signal_block_mask &= ~mask;
+					thread.m_signal_block_mask &= ~mask;
+					break;
+				case SIG_SETMASK:
+					thread.m_signal_block_mask = mask;
 					break;
 				default:
 					return BAN::Error::from_errno(EINVAL);
 			}
 		}
 
+		if (user_oset != nullptr)
+			TRY(write_to_user(user_oset, &old_sigset, sizeof(sigset_t)));
+
 		return 0;
 	}
 
@@ -3112,7 +3118,7 @@ namespace Kernel
 		LockGuard _(m_process_lock);
 
 		auto& thread = Thread::current();
-		thread.set_suspend_signal_mask(set & ~(SIGKILL | SIGSTOP));
+		thread.set_suspend_signal_mask(set & ~((1ull << SIGKILL) | (1ull << SIGSTOP)));
 
 		// FIXME: i *think* here is a race condition as kill doesnt hold process lock
 		while (!thread.is_interrupted_by_signal())
@@ -3305,7 +3311,9 @@ namespace Kernel
 
 	BAN::ErrorOr<long> Process::sys_set_fsbase(void* addr)
 	{
-		Thread::current().set_fsbase(reinterpret_cast<vaddr_t>(addr));
+		auto& thread = Thread::current();
+		thread.m_has_custom_fsbase = true;
+		thread.set_fsbase(reinterpret_cast<vaddr_t>(addr));
 		Processor::load_fsbase();
 		return 0;
 	}
@@ -3317,7 +3325,9 @@ namespace Kernel
 
 	BAN::ErrorOr<long> Process::sys_set_gsbase(void* addr)
 	{
-		Thread::current().set_gsbase(reinterpret_cast<vaddr_t>(addr));
+		auto& thread = Thread::current();
+		thread.m_has_custom_gsbase = true;
+		thread.set_gsbase(reinterpret_cast<vaddr_t>(addr));
 		Processor::load_gsbase();
 		return 0;
 	}
@@ -3887,237 +3897,45 @@ namespace Kernel
 		return region->allocate_page_containing(address, wants_write);
 	}
 
-	// TODO: The following 3 functions could be simplified into one generic helper function
+	extern "C" bool safe_user_memcpy(void*, const void*, size_t);
+	extern "C" bool safe_user_strncpy(void*, const void*, size_t);
+
+	static inline bool is_valid_user_address(const void* user_addr, size_t size)
+	{
+		const vaddr_t user_vaddr = reinterpret_cast<vaddr_t>(user_addr);
+		if (BAN::Math::will_addition_overflow<vaddr_t>(user_vaddr, size))
+			return false;
+		if (user_vaddr + size > USERSPACE_END)
+			return false;
+		return true;
+	}
 
 	BAN::ErrorOr<void> Process::read_from_user(const void* user_addr, void* out, size_t size)
 	{
-		const vaddr_t user_vaddr = reinterpret_cast<vaddr_t>(user_addr);
-
-		auto* out_u8 = static_cast<uint8_t*>(out);
-		size_t ncopied = 0;
-
-		{
-			RWLockRDGuard _(m_memory_region_lock);
-
-			const size_t first_index = find_mapped_region(user_vaddr);
-			for (size_t i = first_index; ncopied < size && i < m_mapped_regions.size(); i++)
-			{
-				auto& region = m_mapped_regions[i];
-				if (!region->contains(user_vaddr + ncopied))
+		if (!is_valid_user_address(user_addr, size))
+			return BAN::Error::from_errno(EFAULT);
+		if (!safe_user_memcpy(out, user_addr, size))
 			return BAN::Error::from_errno(EFAULT);
-
-				const size_t ncopy = BAN::Math::min<size_t>(
-					(region->vaddr() + region->size()) - (user_vaddr + ncopied),
-					size - ncopied
-				);
-
-				const size_t page_count = range_page_count(user_vaddr + ncopied, ncopy);
-				const vaddr_t page_base = (user_vaddr + ncopied) & PAGE_ADDR_MASK;
-				for (size_t p = 0; p < page_count; p++)
-				{
-					const auto flags = PageTable::UserSupervisor | PageTable::Present;
-					if ((m_page_table->get_page_flags(page_base + p * PAGE_SIZE) & flags) != flags)
-						goto read_from_user_with_allocation;
-				}
-
-				memcpy(out_u8 + ncopied, reinterpret_cast<void*>(user_vaddr + ncopied), ncopy);
-				ncopied += ncopy;
-			}
-
-			if (ncopied >= size)
 		return {};
-			if (ncopied > 0)
-				return BAN::Error::from_errno(EFAULT);
-		}
-
-	read_from_user_with_allocation:
-		RWLockWRGuard _(m_memory_region_lock);
-
-		const size_t first_index = find_mapped_region(user_vaddr + ncopied);
-		for (size_t i = first_index; ncopied < size && i < m_mapped_regions.size(); i++)
-		{
-			auto& region = m_mapped_regions[i];
-			if (!region->contains(user_vaddr + ncopied))
-				return BAN::Error::from_errno(EFAULT);
-
-			const size_t ncopy = BAN::Math::min<size_t>(
-				(region->vaddr() + region->size()) - (user_vaddr + ncopied),
-				size - ncopied
-			);
-
-			const size_t page_count = range_page_count(user_vaddr + ncopied, ncopy);
-			const vaddr_t page_base = (user_vaddr + ncopied) & PAGE_ADDR_MASK;
-			for (size_t p = 0; p < page_count; p++)
-			{
-				const auto flags = PageTable::UserSupervisor | PageTable::Present;
-				if ((m_page_table->get_page_flags(page_base + p * PAGE_SIZE) & flags) == flags)
-					continue;
-				if (!TRY(region->allocate_page_containing(page_base + p * PAGE_SIZE, false)))
-					return BAN::Error::from_errno(EFAULT);
-			}
-
-			memcpy(out_u8 + ncopied, reinterpret_cast<void*>(user_vaddr + ncopied), ncopy);
-			ncopied += ncopy;
-		}
-
-		if (ncopied >= size)
-			return {};
-		return BAN::Error::from_errno(EFAULT);
 	}
 
 	BAN::ErrorOr<void> Process::read_string_from_user(const char* user_addr, char* out, size_t max_size)
 	{
-		const vaddr_t user_vaddr = reinterpret_cast<vaddr_t>(user_addr);
-
-		size_t ncopied = 0;
-
-		{
-			RWLockRDGuard _(m_memory_region_lock);
-
-			const size_t first_index = find_mapped_region(user_vaddr);
-			for (size_t i = first_index; ncopied < max_size && i < m_mapped_regions.size(); i++)
-			{
-				auto& region = m_mapped_regions[i];
-				if (!region->contains(user_vaddr + ncopied))
+		max_size = BAN::Math::min<size_t>(max_size, USERSPACE_END - reinterpret_cast<vaddr_t>(user_addr));
+		if (!is_valid_user_address(user_addr, max_size))
+			return BAN::Error::from_errno(EFAULT);
+		if (!safe_user_strncpy(out, user_addr, max_size))
 			return BAN::Error::from_errno(EFAULT);
-
-				vaddr_t last_page = 0;
-
-				for (; ncopied < max_size; ncopied++)
-				{
-					const vaddr_t curr_page = (user_vaddr + ncopied) & PAGE_ADDR_MASK;
-					if (curr_page != last_page)
-					{
-						const auto flags = PageTable::UserSupervisor | PageTable::Present;
-						if ((m_page_table->get_page_flags(curr_page) & flags) != flags)
-							goto read_string_from_user_with_allocation;
-					}
-
-					out[ncopied] = user_addr[ncopied];
-					if (out[ncopied] == '\0')
 		return {};
-
-					last_page = curr_page;
-				}
-			}
-
-			if (ncopied >= max_size)
-				return BAN::Error::from_errno(ENAMETOOLONG);
-			if (ncopied > 0)
-				return BAN::Error::from_errno(EFAULT);
-		}
-
-	read_string_from_user_with_allocation:
-		RWLockWRGuard _(m_memory_region_lock);
-
-		const size_t first_index = find_mapped_region(user_vaddr + ncopied);
-		for (size_t i = first_index; ncopied < max_size && i < m_mapped_regions.size(); i++)
-		{
-			auto& region = m_mapped_regions[i];
-			if (!region->contains(user_vaddr + ncopied))
-				return BAN::Error::from_errno(EFAULT);
-
-			vaddr_t last_page = 0;
-
-			for (; ncopied < max_size; ncopied++)
-			{
-				const vaddr_t curr_page = (user_vaddr + ncopied) & PAGE_ADDR_MASK;
-				if (curr_page != last_page)
-				{
-					const auto flags = PageTable::UserSupervisor | PageTable::Present;
-					if ((m_page_table->get_page_flags(curr_page) & flags) == flags)
-						;
-					else if (!TRY(region->allocate_page_containing(curr_page, false)))
-						return BAN::Error::from_errno(EFAULT);
-				}
-
-				out[ncopied] = user_addr[ncopied];
-				if (out[ncopied] == '\0')
-					return {};
-
-				last_page = curr_page;
-			}
-		}
-
-		if (ncopied >= max_size)
-			return BAN::Error::from_errno(ENAMETOOLONG);
-		return BAN::Error::from_errno(EFAULT);
 	}
 
 	BAN::ErrorOr<void> Process::write_to_user(void* user_addr, const void* in, size_t size)
 	{
-		const vaddr_t user_vaddr = reinterpret_cast<vaddr_t>(user_addr);
-
-		const auto* in_u8 = static_cast<const uint8_t*>(in);
-		size_t ncopied = 0;
-
-		{
-			RWLockRDGuard _(m_memory_region_lock);
-
-			const size_t first_index = find_mapped_region(user_vaddr);
-			for (size_t i = first_index; ncopied < size && i < m_mapped_regions.size(); i++)
-			{
-				auto& region = m_mapped_regions[i];
-				if (!region->contains(user_vaddr + ncopied))
+		if (!is_valid_user_address(user_addr, size))
+			return BAN::Error::from_errno(EFAULT);
+		if (!safe_user_memcpy(user_addr, in, size))
 			return BAN::Error::from_errno(EFAULT);
-
-				const size_t ncopy = BAN::Math::min<size_t>(
-					(region->vaddr() + region->size()) - (user_vaddr + ncopied),
-					size - ncopied
-				);
-
-				const size_t page_count = range_page_count(user_vaddr + ncopied, ncopy);
-				const vaddr_t page_base = (user_vaddr + ncopied) & PAGE_ADDR_MASK;
-				for (size_t i = 0; i < page_count; i++)
-				{
-					const auto flags = PageTable::UserSupervisor | PageTable::ReadWrite | PageTable::Present;
-					if ((m_page_table->get_page_flags(page_base + i * PAGE_SIZE) & flags) != flags)
-						goto write_to_user_with_allocation;
-				}
-
-				memcpy(reinterpret_cast<void*>(user_vaddr + ncopied), in_u8 + ncopied, ncopy);
-				ncopied += ncopy;
-			}
-
-			if (ncopied >= size)
 		return {};
-			if (ncopied > 0)
-				return BAN::Error::from_errno(EFAULT);
-		}
-
-	write_to_user_with_allocation:
-		RWLockWRGuard _(m_memory_region_lock);
-
-		const size_t first_index = find_mapped_region(user_vaddr + ncopied);
-		for (size_t i = first_index; ncopied < size && i < m_mapped_regions.size(); i++)
-		{
-			auto& region = m_mapped_regions[i];
-			if (!region->contains(user_vaddr + ncopied))
-				return BAN::Error::from_errno(EFAULT);
-
-			const size_t ncopy = BAN::Math::min<size_t>(
-				(region->vaddr() + region->size()) - (user_vaddr + ncopied),
-				size - ncopied
-			);
-
-			const size_t page_count = range_page_count(user_vaddr + ncopied, ncopy);
-			const vaddr_t page_base = (user_vaddr + ncopied) & PAGE_ADDR_MASK;
-			for (size_t p = 0; p < page_count; p++)
-			{
-				const auto flags = PageTable::UserSupervisor | PageTable::ReadWrite | PageTable::Present;
-				if ((m_page_table->get_page_flags(page_base + p * PAGE_SIZE) & flags) == flags)
-					continue;
-				if (!TRY(region->allocate_page_containing(page_base + p * PAGE_SIZE, true)))
-					return BAN::Error::from_errno(EFAULT);
-			}
-
-			memcpy(reinterpret_cast<void*>(user_vaddr + ncopied), in_u8 + ncopied, ncopy);
-			ncopied += ncopy;
-		}
-
-		if (ncopied >= size)
-			return {};
-		return BAN::Error::from_errno(EFAULT);
 	}
 
 	BAN::ErrorOr<MemoryRegion*> Process::validate_and_pin_pointer_access(const void* ptr, size_t size, bool needs_write)

kernel/kernel/Processor.cpp

@@ -377,8 +377,7 @@ namespace Kernel
 				case SMPMessage::Type::FlushTLB:
 					if (message->flush_tlb.page_table && message->flush_tlb.page_table != processor.m_current_page_table)
 						break;
-					for (size_t i = 0; i < message->flush_tlb.page_count; i++)
-						asm volatile("invlpg (%0)" :: "r"(message->flush_tlb.vaddr + i * PAGE_SIZE) : "memory");
+					PageTable::current().invalidate_range(message->flush_tlb.vaddr, message->flush_tlb.page_count, false);
 					break;
 				case SMPMessage::Type::NewThread:
 					processor.m_scheduler->add_thread(message->new_thread);

kernel/kernel/Scheduler.cpp

@@ -139,6 +139,8 @@ namespace Kernel
 		if (Processor::count() > 1)
 			Processor::set_smp_enabled();
 
+		m_next_reschedule_ns = SystemTimer::get().ns_since_boot();
+
 		return {};
 	}
 
@@ -348,15 +350,12 @@ namespace Kernel
 
 		wake_up_sleeping_threads();
 
+		if (SystemTimer::get().ns_since_boot() >= m_next_reschedule_ns)
 		{
-			const uint64_t current_ns = SystemTimer::get().ns_since_boot();
-			if (current_ns >= m_last_reschedule_ns + s_reschedule_interval_ns)
-			{
-				m_last_reschedule_ns = current_ns;
+			m_next_reschedule_ns += s_reschedule_interval_ns;
 			Processor::yield();
 		}
 	}
-	}
 
 	void Scheduler::unblock_thread(SchedulerQueue::Node* node)
 	{

kernel/kernel/Syscall.cpp

@@ -7,6 +7,7 @@
 #include <kernel/Timer/Timer.h>
 
 #include <termios.h>
+#include <sys/syscall.h>
 
 #define DUMP_ALL_SYSCALLS 0
 #define DUMP_LONG_SYSCALLS 0
@@ -94,14 +95,12 @@ namespace Kernel
 
 		Process::current().wait_while_stopped();
 
-		Processor::set_interrupt_state(InterruptState::Disabled);
-
-		auto& current_thread = Thread::current();
-		if (current_thread.can_add_signal_to_execute())
-			if (current_thread.handle_signal())
+		if (Thread::current().handle_signal_if_interrupted())
 			if (ret.is_error() && ret.error().get_error_code() == EINTR && is_restartable_syscall(syscall))
 				ret = BAN::Error::from_errno(ERESTART);
 
+		Processor::set_interrupt_state(InterruptState::Disabled);
+
 		ASSERT(Kernel::Thread::current().state() == Kernel::Thread::State::Executing);
 
 		if (ret.is_error())

kernel/kernel/Thread.cpp

@@ -13,6 +13,12 @@
 namespace Kernel
 {
 
+#if ARCH(x86_64)
+	static constexpr vaddr_t s_user_stack_addr_start = 0x0000700000000000;
+#elif ARCH(i686)
+	static constexpr vaddr_t s_user_stack_addr_start = 0xB0000000;
+#endif
+
 	extern "C" [[noreturn]] void start_kernel_thread();
 	extern "C" [[noreturn]] void start_userspace_thread();
 
@@ -25,11 +31,6 @@ namespace Kernel
 		*(uintptr_t*)rsp = (uintptr_t)value;
 	}
 
-	extern "C" uintptr_t get_thread_start_sp()
-	{
-		return Thread::current().yield_registers().sp;
-	}
-
 	static pid_t s_next_tid = 1;
 
 	alignas(16) static uint8_t s_default_sse_storage[512];
@@ -205,15 +206,9 @@ namespace Kernel
 
 		thread->m_is_userspace = true;
 
-#if ARCH(x86_64)
-		static constexpr vaddr_t stack_addr_start = 0x0000700000000000;
-#elif ARCH(i686)
-		static constexpr vaddr_t stack_addr_start = 0xB0000000;
-#endif
-
 		thread->m_kernel_stack = TRY(VirtualRange::create_to_vaddr_range(
 			page_table,
-			stack_addr_start, USERSPACE_END,
+			s_user_stack_addr_start, USERSPACE_END,
 			kernel_stack_size,
 			PageTable::Flags::ReadWrite | PageTable::Flags::Present,
 			true, true
@@ -222,7 +217,7 @@ namespace Kernel
 		auto userspace_stack = TRY(MemoryBackedRegion::create(
 			page_table,
 			userspace_stack_size,
-			{ stack_addr_start, USERSPACE_END },
+			{ s_user_stack_addr_start, USERSPACE_END },
 			MemoryRegion::Type::PRIVATE,
 			PageTable::Flags::UserSupervisor | PageTable::Flags::ReadWrite | PageTable::Flags::Present,
 			O_RDWR
@@ -310,6 +305,14 @@ namespace Kernel
 		if (!is_userspace() || !has_process())
 			return;
 
+#if ARCH(x86_64)
+		if (m_has_custom_gsbase)
+			return;
+#elif ARCH(i686)
+		if (m_has_custom_fsbase)
+			return;
+#endif
+
 		const vaddr_t vaddr = process().shared_page_vaddr() + Processor::current_index();
 
 #if ARCH(x86_64)
@@ -351,7 +354,24 @@ namespace Kernel
 
 		thread->m_is_userspace = true;
 
-		thread->m_kernel_stack = TRY(m_kernel_stack->clone(new_process->page_table()));
+		thread->m_kernel_stack = TRY(VirtualRange::create_to_vaddr_range(
+			new_process->page_table(),
+			s_user_stack_addr_start, USERSPACE_END,
+			kernel_stack_size,
+			PageTable::Flags::ReadWrite | PageTable::Flags::Present,
+			true, true
+		));
+
+		// NOTE: copy [sp, stack_end] so fork return works
+		PageTable::with_fast_page(thread->m_kernel_stack->paddr_of(thread->kernel_stack_top() - PAGE_SIZE), [&] {
+			const size_t ncopy = kernel_stack_top() - sp;
+			ASSERT(ncopy <= PAGE_SIZE);
+			memcpy(
+				PageTable::fast_page_as_ptr(PAGE_SIZE - ncopy),
+				reinterpret_cast<void*>(sp),
+				ncopy
+			);
+		});
 
 		const auto stack_index = new_process->find_mapped_region(m_userspace_stack->vaddr());
 		thread->m_userspace_stack = static_cast<MemoryBackedRegion*>(new_process->m_mapped_regions[stack_index].ptr());
@@ -572,19 +592,6 @@ namespace Kernel
 		return false;
 	}
 
-	bool Thread::can_add_signal_to_execute() const
-	{
-		return is_interrupted_by_signal() && m_mutex_count == 0;
-	}
-
-	bool Thread::will_execute_signal() const
-	{
-		if (!is_userspace() || m_state != State::Executing)
-			return false;
-		auto& interrupt_stack = *reinterpret_cast<InterruptStack*>(kernel_stack_top() - sizeof(InterruptStack));
-		return interrupt_stack.ip == (uintptr_t)signal_trampoline;
-	}
-
 	bool Thread::will_exit_because_of_signal() const
 	{
 		const uint64_t full_pending_mask = m_signal_pending_mask | process().signal_pending_mask();
@@ -596,21 +603,17 @@ namespace Kernel
 		return false;
 	}
 
-	bool Thread::handle_signal(int signal, const siginfo_t& _signal_info)
+	bool Thread::handle_signal_if_interrupted()
 	{
-		ASSERT(&Thread::current() == this);
-		ASSERT(is_userspace());
+		int signal;
+		siginfo_t signal_info;
+		signal_handle_info_t handle_info;
 
-		auto state = m_signal_lock.lock();
-
-		auto& interrupt_stack = *reinterpret_cast<InterruptStack*>(kernel_stack_top() - sizeof(InterruptStack));
-		ASSERT(GDT::is_user_segment(interrupt_stack.cs));
-
-		auto signal_info = _signal_info;
-
-		if (signal == 0)
 		{
-			const uint64_t process_signal_pending_mask = process().signal_pending_mask();
+			SpinLockGuard _1(m_signal_lock);
+			SpinLockGuard _2(m_process->m_signal_lock);
+
+			const uint64_t process_signal_pending_mask = m_process->m_signal_pending_mask;
 			const uint64_t full_pending_mask = m_signal_pending_mask | process_signal_pending_mask;
 			for (signal = _SIGMIN; signal <= _SIGMAX; signal++)
 			{
@@ -618,42 +621,90 @@ namespace Kernel
 				if ((full_pending_mask & mask) && !(m_signal_block_mask & mask))
 					break;
 			}
-			ASSERT(signal <= _SIGMAX);
+			if (signal > _SIGMAX)
+				return false;
+
 			if (process_signal_pending_mask & (1ull << signal))
-				signal_info = process().m_signal_infos[signal];
+				signal_info = m_process->m_signal_infos[signal];
 			else
 				signal_info = m_signal_infos[signal];
+			signal_info.si_signo = signal;
+
+			handle_info = remove_signal_and_get_info(signal);
 		}
-		else
+
+		handle_signal_impl(signal, signal_info, handle_info);
+
+		return handle_info.has_sa_restart;
+	}
+
+	bool Thread::handle_signal(int signal, const siginfo_t& signal_info)
 	{
+		ASSERT(&Thread::current() == this);
+		ASSERT(is_userspace());
+
 		ASSERT(signal >= _SIGMIN);
 		ASSERT(signal <= _SIGMAX);
-		}
 
-		vaddr_t signal_handler;
-		bool has_sa_restart;
-		vaddr_t signal_stack_top = 0;
+		signal_handle_info_t handle_info;
+
+		// If this signal is blocked or ignored, terminate the process
+		bool terminate_process = false;
 
 		{
-			SpinLockGuard _(m_process->m_signal_lock);
+			SpinLockGuard _1(m_signal_lock);
+			SpinLockGuard _2(m_process->m_signal_lock);
+
+			if (m_signal_block_mask & (1ull << signal))
+				terminate_process = true;
+
+			handle_info = remove_signal_and_get_info(signal);
+
+			if (handle_info.handler == reinterpret_cast<vaddr_t>(SIG_IGN))
+				terminate_process = true;
+		}
+
+		if (terminate_process)
+		{
+			process().exit(128 + signal, signal | 0x80);
+			ASSERT_NOT_REACHED();
+		}
+
+		handle_signal_impl(signal, signal_info, handle_info);
+
+		return handle_info.has_sa_restart;
+	}
+
+	Thread::signal_handle_info_t Thread::remove_signal_and_get_info(int signal)
+	{
+		ASSERT(m_signal_lock.current_processor_has_lock());
+		ASSERT(m_process->m_signal_lock.current_processor_has_lock());
+
+		ASSERT(signal >= _SIGMIN);
+		ASSERT(signal <= _SIGMAX);
+
+		const uint64_t restore_sigmask = m_signal_block_mask;
 
 		auto& handler = m_process->m_signal_handlers[signal];
 
-			signal_handler = (handler.sa_flags & SA_SIGINFO)
+		const vaddr_t signal_handler = (handler.sa_flags & SA_SIGINFO)
 			? reinterpret_cast<vaddr_t>(handler.sa_sigaction)
 			: reinterpret_cast<vaddr_t>(handler.sa_handler);
-			has_sa_restart = !!(handler.sa_flags & SA_RESTART);
+		const bool has_sa_restart = !!(handler.sa_flags & SA_RESTART);
 
-			const auto& alt_stack = m_signal_alt_stack;
-			if (alt_stack.ss_flags != SS_DISABLE && (handler.sa_flags & SA_ONSTACK) && !currently_on_alternate_stack())
-				signal_stack_top = reinterpret_cast<vaddr_t>(alt_stack.ss_sp) + alt_stack.ss_size;
+		vaddr_t signal_stack_top = 0;
+		if (m_signal_alt_stack.ss_flags != SS_DISABLE && (handler.sa_flags & SA_ONSTACK) && !currently_on_alternate_stack())
+			signal_stack_top = reinterpret_cast<vaddr_t>(m_signal_alt_stack.ss_sp) + m_signal_alt_stack.ss_size;
+
+		m_signal_block_mask |= handler.sa_mask;
+		if (!(handler.sa_flags & SA_NODEFER))
+			m_signal_block_mask |= 1ull << signal;
 
 		if (handler.sa_flags & SA_RESETHAND)
 			handler = { .sa_handler = SIG_DFL, .sa_mask = 0, .sa_flags = 0 };
-		}
 
 		m_signal_pending_mask &= ~(1ull << signal);
-		process().remove_pending_signal(signal);
+		m_process->m_signal_pending_mask &= ~(1ull << signal);
 
 		if (m_signal_suspend_mask.has_value())
 		{
@@ -661,66 +712,54 @@ namespace Kernel
 			m_signal_suspend_mask.clear();
 		}
 
-		m_signal_lock.unlock(state);
+		return {
+			.handler = signal_handler,
+			.stack_top = signal_stack_top,
+			.restore_sigmask = restore_sigmask,
+			.has_sa_restart = has_sa_restart,
+		};
+	}
 
-		if (signal_handler == (vaddr_t)SIG_IGN)
+	void Thread::handle_signal_impl(int signal, const siginfo_t& signal_info, const signal_handle_info_t& handle_info)
+	{
+		ASSERT(this == &Thread::current());
+		ASSERT(is_userspace());
+		ASSERT(Processor::get_interrupt_state() == InterruptState::Enabled);
+
+		auto& interrupt_stack = *reinterpret_cast<InterruptStack*>(kernel_stack_top() - sizeof(InterruptStack));
+		ASSERT(GDT::is_user_segment(interrupt_stack.cs));
+
+		if (handle_info.handler == reinterpret_cast<vaddr_t>(SIG_IGN))
 			;
-		else if (signal_handler != (vaddr_t)SIG_DFL)
+		else if (handle_info.handler != reinterpret_cast<vaddr_t>(SIG_DFL))
 		{
 			// call userspace signal handlers
 #if ARCH(x86_64)
 			interrupt_stack.sp -= 128; // skip possible red-zone
 #endif
 
+			const auto write_to_stack =
+				[&]<typename T>(uintptr_t& sp, const T& value)
 				{
-				// Make sure stack is allocated
-
-				vaddr_t pages[3] {};
-				size_t page_count { 0 };
-
-				if (signal_stack_top == 0)
-				{
-					pages[0] = (interrupt_stack.sp - 1 * sizeof(uintptr_t)                    ) & PAGE_ADDR_MASK;
-					pages[1] = (interrupt_stack.sp - 5 * sizeof(uintptr_t) - sizeof(siginfo_t)) & PAGE_ADDR_MASK;
-					page_count = 2;
-				}
-				else
-				{
-					pages[0] = (interrupt_stack.sp - 1 * sizeof(uintptr_t)                    ) & PAGE_ADDR_MASK;
-					pages[2] = (signal_stack_top   - 1 * sizeof(uintptr_t)                    ) & PAGE_ADDR_MASK;
-					pages[1] = (signal_stack_top   - 4 * sizeof(uintptr_t) - sizeof(siginfo_t)) & PAGE_ADDR_MASK;
-					page_count = 3;
-				}
-
-				for (size_t i = 0; i < page_count; i++)
-				{
-					if (m_process->page_table().get_page_flags(pages[i]) & PageTable::Flags::Present)
-						continue;
-					Processor::set_interrupt_state(InterruptState::Enabled);
-					if (auto ret = m_process->allocate_page_for_demand_paging(pages[i], true, false); ret.is_error() || !ret.value())
-						m_process->exit(128 + SIGSEGV, SIGSEGV);
-					Processor::set_interrupt_state(InterruptState::Disabled);
-				}
-			}
+					static_assert(sizeof(T) >= sizeof(uintptr_t));
+					sp -= sizeof(T);
+					if (m_process->write_to_user(reinterpret_cast<void*>(sp), &value, sizeof(T)).is_error())
+						m_process->exit(128 + SIGSEGV, SIGSEGV | 0x80);
+				};
 
 			write_to_stack(interrupt_stack.sp, interrupt_stack.ip);
 			const vaddr_t old_stack = interrupt_stack.sp;
-			if (signal_stack_top)
-				interrupt_stack.sp = signal_stack_top;
+			if (handle_info.stack_top)
+				interrupt_stack.sp = handle_info.stack_top;
 			write_to_stack(interrupt_stack.sp, old_stack);
 			write_to_stack(interrupt_stack.sp, interrupt_stack.flags);
+			write_to_stack(interrupt_stack.sp, handle_info.restore_sigmask);
 
-			{
-				signal_info.si_signo = signal;
-				signal_info.si_addr = reinterpret_cast<void*>(interrupt_stack.ip);
+			ASSERT(signal_info.si_signo == signal);
+			write_to_stack(interrupt_stack.sp, signal_info);
 
-				interrupt_stack.sp -= sizeof(siginfo_t);
-				*reinterpret_cast<siginfo_t*>(interrupt_stack.sp) = signal_info;
-				static_assert(sizeof(siginfo_t) % sizeof(uintptr_t) == 0);
-			}
-
-			write_to_stack(interrupt_stack.sp, signal);
-			write_to_stack(interrupt_stack.sp, signal_handler);
+			write_to_stack(interrupt_stack.sp, static_cast<uintptr_t>(signal));
+			write_to_stack(interrupt_stack.sp, handle_info.handler);
 			interrupt_stack.ip = (uintptr_t)signal_trampoline;
 		}
 		else
@@ -752,8 +791,6 @@ namespace Kernel
 				panic("Executing unhandled signal {}", signal);
 			}
 		}
-
-		return has_sa_restart;
 	}
 
 	void Thread::add_signal(int signal, const siginfo_t& info)

kernel/kernel/USB/HID/Keyboard.cpp

@@ -342,6 +342,9 @@ namespace Kernel
 		s_scancode_to_keycode[0x4B] = keycode_function(18);
 		s_scancode_to_keycode[0x4E] = keycode_function(19);
 		s_scancode_to_keycode[0x47] = keycode_function(20);
+		s_scancode_to_keycode[0x7F] = keycode_function(21);
+		s_scancode_to_keycode[0x81] = keycode_function(22);
+		s_scancode_to_keycode[0x80] = keycode_function(23);
 
 		s_scancode_to_keycode[0x53] = keycode_numpad(0, 0);
 		s_scancode_to_keycode[0x54] = keycode_numpad(0, 1);

kernel/kernel/kernel.cpp

@@ -255,8 +255,8 @@ static void init2(void*)
 	VirtualFileSystem::initialize(cmdline.root);
 	dprintln("VFS initialized");
 
-	// FIXME: release memory used by modules. If modules are used
-	//        they are already loaded in here
+	// NOTE: All modules should be loaded
+	Heap::get().release_boot_modules();
 
 	TTY::initialize_devices();
 

kernel/klibc/arch/i686/string.S

@@ -0,0 +1,47 @@
+.align 16
+.global memcpy
+memcpy:
+	xchgl 4(%esp), %edi
+	xchgl 8(%esp), %esi
+	movl 12(%esp), %ecx
+	movl %edi, %edx
+	rep movsb
+	movl 4(%esp), %edi
+	movl 8(%esp), %esi
+	movl %edx, %eax
+	ret
+
+.align 16
+.global memmove
+memmove:
+	xchgl 4(%esp), %edi
+	xchgl 8(%esp), %esi
+	movl 12(%esp), %ecx
+	movl %edi, %edx
+	cmpl %edi, %esi
+	jb .memmove_slow
+	rep movsb
+ .memmove_done:
+	movl 4(%esp), %edi
+	movl 8(%esp), %esi
+	movl %edx, %eax
+	ret
+ .memmove_slow:
+	leal -1(%edi, %ecx), %edi
+	leal -1(%esi, %ecx), %esi
+	std
+	rep movsb
+	cld
+	jmp .memmove_done
+
+.align 16
+.global memset
+memset:
+	xchgl 4(%esp), %edi
+	movl  8(%esp), %eax
+	movl 12(%esp), %ecx
+	movl %edi, %edx
+	rep stosb
+	movl 4(%esp), %edi
+	movl %edx, %eax
+	ret

kernel/klibc/arch/x86_64/string.S

@@ -0,0 +1,31 @@
+.align 16
+.global memcpy
+memcpy:
+	movq %rdi, %rax
+	movq %rdx, %rcx
+	rep movsb
+	ret
+
+.align 16
+.global memmove
+memmove:
+	cmpq %rdi, %rsi
+	jae memcpy
+	movq %rdi, %rax
+	leaq -1(%rdi, %rdx), %rdi
+	leaq -1(%rsi, %rdx), %rsi
+	movq %rdx, %rcx
+	std
+	rep movsb
+	cld
+	ret
+
+.align 16
+.global memset
+memset:
+	movq %rdi, %r8
+	movb %sil, %al
+	movq %rdx, %rcx
+	rep stosb
+	movq %r8, %rax
+	ret

ports/SDL2/patches/0001-add-banan_os-support.patch

@@ -1,6 +1,6 @@
 diff -ruN SDL2-2.32.8/cmake/sdlplatform.cmake SDL2-2.32.8-banan_os/cmake/sdlplatform.cmake
 --- SDL2-2.32.8/cmake/sdlplatform.cmake	2024-08-14 13:35:43.000000000 +0300
-+++ SDL2-2.32.8-banan_os/cmake/sdlplatform.cmake	2026-01-07 19:04:34.332166371 +0200
++++ SDL2-2.32.8-banan_os/cmake/sdlplatform.cmake	2026-04-03 04:34:27.256800208 +0300
 @@ -28,6 +28,8 @@
        set(SDL_CMAKE_PLATFORM AIX)
      elseif(CMAKE_SYSTEM_NAME MATCHES "Minix.*")
@@ -12,7 +12,7 @@ diff -ruN SDL2-2.32.8/cmake/sdlplatform.cmake SDL2-2.32.8-banan_os/cmake/sdlplat
      endif()
 diff -ruN SDL2-2.32.8/CMakeLists.txt SDL2-2.32.8-banan_os/CMakeLists.txt
 --- SDL2-2.32.8/CMakeLists.txt	2025-06-03 02:00:39.000000000 +0300
-+++ SDL2-2.32.8-banan_os/CMakeLists.txt	2026-01-07 19:04:34.343116295 +0200
++++ SDL2-2.32.8-banan_os/CMakeLists.txt	2026-04-03 04:34:27.257159543 +0300
 @@ -14,7 +14,7 @@
    set(SDL2_SUBPROJECT ON)
  endif()
@@ -98,7 +98,7 @@ diff -ruN SDL2-2.32.8/CMakeLists.txt SDL2-2.32.8-banan_os/CMakeLists.txt
      file(GLOB MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/riscos/*.c)
 diff -ruN SDL2-2.32.8/include/SDL_config.h.cmake SDL2-2.32.8-banan_os/include/SDL_config.h.cmake
 --- SDL2-2.32.8/include/SDL_config.h.cmake	2025-01-01 17:47:53.000000000 +0200
-+++ SDL2-2.32.8-banan_os/include/SDL_config.h.cmake	2026-01-07 19:04:34.358682129 +0200
++++ SDL2-2.32.8-banan_os/include/SDL_config.h.cmake	2026-04-03 04:34:27.257563019 +0300
 @@ -307,6 +307,7 @@
  #cmakedefine SDL_AUDIO_DRIVER_FUSIONSOUND @SDL_AUDIO_DRIVER_FUSIONSOUND@
  #cmakedefine SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC @SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC@
@@ -125,7 +125,7 @@ diff -ruN SDL2-2.32.8/include/SDL_config.h.cmake SDL2-2.32.8-banan_os/include/SD
  #cmakedefine SDL_VIDEO_DRIVER_DIRECTFB @SDL_VIDEO_DRIVER_DIRECTFB@
 diff -ruN SDL2-2.32.8/include/SDL_platform.h SDL2-2.32.8-banan_os/include/SDL_platform.h
 --- SDL2-2.32.8/include/SDL_platform.h	2025-01-01 17:47:53.000000000 +0200
-+++ SDL2-2.32.8-banan_os/include/SDL_platform.h	2026-01-07 19:04:34.370086235 +0200
++++ SDL2-2.32.8-banan_os/include/SDL_platform.h	2026-04-03 04:34:27.257711782 +0300
 @@ -36,6 +36,10 @@
  #undef __HAIKU__
  #define __HAIKU__   1
@@ -139,8 +139,8 @@ diff -ruN SDL2-2.32.8/include/SDL_platform.h SDL2-2.32.8-banan_os/include/SDL_pl
  #define __BSDI__    1
 diff -ruN SDL2-2.32.8/src/audio/banan_os/SDL_banan_os_audio.cpp SDL2-2.32.8-banan_os/src/audio/banan_os/SDL_banan_os_audio.cpp
 --- SDL2-2.32.8/src/audio/banan_os/SDL_banan_os_audio.cpp	1970-01-01 02:00:00.000000000 +0200
-+++ SDL2-2.32.8-banan_os/src/audio/banan_os/SDL_banan_os_audio.cpp	2026-01-07 19:04:34.370691623 +0200
-@@ -0,0 +1,150 @@
++++ SDL2-2.32.8-banan_os/src/audio/banan_os/SDL_banan_os_audio.cpp	2026-04-03 16:06:27.541819001 +0300
+@@ -0,0 +1,134 @@
 +/*
 +  Simple DirectMedia Layer
 +  Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>
@@ -201,8 +201,8 @@ diff -ruN SDL2-2.32.8/src/audio/banan_os/SDL_banan_os_audio.cpp SDL2-2.32.8-bana
 +	DUMP_FUNCTION();
 +
 +	// TODO: try to accept already existing spec
-+	_this->spec.freq = 44100;
-+	_this->spec.format = AUDIO_S16LSB;
++	_this->spec.freq = 48000;
++	_this->spec.format = AUDIO_F32LSB;
 +	_this->spec.channels = 2;
 +	_this->spec.samples = 2048;
 +	SDL_CalculateAudioSpec(&_this->spec);
@@ -235,23 +235,10 @@ diff -ruN SDL2-2.32.8/src/audio/banan_os/SDL_banan_os_audio.cpp SDL2-2.32.8-bana
 +		return;
 +	}
 +
-+	static_assert(BAN::is_same_v<LibAudio::AudioBuffer::sample_t, double>);
-+
-+    const auto convert_sample = [](int16_t input) {
-+        return (static_cast<double>(input) - BAN::numeric_limits<int16_t>::min()) / BAN::numeric_limits<int16_t>::max() * 2.0 - 1.0;
-+    };
-+
-+	const size_t input_samples = _this->spec.size / sizeof(int16_t);
-+	size_t samples_queued = 0;
-+
-+	const int16_t* mixbuf = static_cast<const int16_t*>(_this->hidden->mixbuf);
-+	while (samples_queued < input_samples)
-+	{
-+		const size_t to_convert = BAN::Math::min(_this->hidden->conversion.size(), input_samples - samples_queued);
-+		for (size_t i = 0; i < to_convert; i++)
-+			_this->hidden->conversion[i] = convert_sample(mixbuf[samples_queued + i]);
-+
-+		auto sample_span = _this->hidden->conversion.span();
++	auto sample_span = BAN::Span(
++		static_cast<const float*>(_this->hidden->mixbuf),
++		_this->spec.size / sizeof(float)
++	);
 +	while (!sample_span.empty())
 +	{
 +		const size_t queued = _this->hidden->audio.queue_samples(sample_span);
@@ -259,9 +246,6 @@ diff -ruN SDL2-2.32.8/src/audio/banan_os/SDL_banan_os_audio.cpp SDL2-2.32.8-bana
 +			usleep(100);
 +		sample_span = sample_span.slice(queued);
 +	}
-+
-+		samples_queued += to_convert;
-+	}
 +}
 +
 +static Uint8* BANANOS_GetDeviceBuf(_THIS)
@@ -293,8 +277,8 @@ diff -ruN SDL2-2.32.8/src/audio/banan_os/SDL_banan_os_audio.cpp SDL2-2.32.8-bana
 +#endif
 diff -ruN SDL2-2.32.8/src/audio/banan_os/SDL_banan_os_audio.h SDL2-2.32.8-banan_os/src/audio/banan_os/SDL_banan_os_audio.h
 --- SDL2-2.32.8/src/audio/banan_os/SDL_banan_os_audio.h	1970-01-01 02:00:00.000000000 +0200
-+++ SDL2-2.32.8-banan_os/src/audio/banan_os/SDL_banan_os_audio.h	2026-01-07 19:04:34.370883199 +0200
-@@ -0,0 +1,34 @@
++++ SDL2-2.32.8-banan_os/src/audio/banan_os/SDL_banan_os_audio.h	2026-04-03 15:56:58.603415021 +0300
+@@ -0,0 +1,33 @@
 +/*
 +  Simple DirectMedia Layer
 +  Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>
@@ -327,11 +311,10 @@ diff -ruN SDL2-2.32.8/src/audio/banan_os/SDL_banan_os_audio.h SDL2-2.32.8-banan_
 +struct SDL_PrivateAudioData {
 +	LibAudio::Audio audio;
 +	void* mixbuf { nullptr };
-+	BAN::Array<LibAudio::AudioBuffer::sample_t, 4096> conversion;
 +};
 diff -ruN SDL2-2.32.8/src/audio/SDL_audio.c SDL2-2.32.8-banan_os/src/audio/SDL_audio.c
 --- SDL2-2.32.8/src/audio/SDL_audio.c	2025-01-01 17:47:53.000000000 +0200
-+++ SDL2-2.32.8-banan_os/src/audio/SDL_audio.c	2026-01-07 19:04:34.371410923 +0200
++++ SDL2-2.32.8-banan_os/src/audio/SDL_audio.c	2026-04-03 04:34:27.258080476 +0300
 @@ -87,6 +87,9 @@
  #ifdef SDL_AUDIO_DRIVER_HAIKU
      &HAIKUAUDIO_bootstrap,
@@ -344,7 +327,7 @@ diff -ruN SDL2-2.32.8/src/audio/SDL_audio.c SDL2-2.32.8-banan_os/src/audio/SDL_a
  #endif
 diff -ruN SDL2-2.32.8/src/audio/SDL_sysaudio.h SDL2-2.32.8-banan_os/src/audio/SDL_sysaudio.h
 --- SDL2-2.32.8/src/audio/SDL_sysaudio.h	2025-01-01 17:47:53.000000000 +0200
-+++ SDL2-2.32.8-banan_os/src/audio/SDL_sysaudio.h	2026-01-07 19:04:34.372150756 +0200
++++ SDL2-2.32.8-banan_os/src/audio/SDL_sysaudio.h	2026-04-03 04:34:27.258278128 +0300
 @@ -196,6 +196,7 @@
  extern AudioBootStrap WINMM_bootstrap;
  extern AudioBootStrap PAUDIO_bootstrap;
@@ -355,7 +338,7 @@ diff -ruN SDL2-2.32.8/src/audio/SDL_sysaudio.h SDL2-2.32.8-banan_os/src/audio/SD
  extern AudioBootStrap DUMMYAUDIO_bootstrap;
 diff -ruN SDL2-2.32.8/src/joystick/banan_os/SDL_banan_os_joystick.cpp SDL2-2.32.8-banan_os/src/joystick/banan_os/SDL_banan_os_joystick.cpp
 --- SDL2-2.32.8/src/joystick/banan_os/SDL_banan_os_joystick.cpp	1970-01-01 02:00:00.000000000 +0200
-+++ SDL2-2.32.8-banan_os/src/joystick/banan_os/SDL_banan_os_joystick.cpp	2026-01-07 19:07:12.677617077 +0200
++++ SDL2-2.32.8-banan_os/src/joystick/banan_os/SDL_banan_os_joystick.cpp	2026-04-03 04:34:27.258447075 +0300
 @@ -0,0 +1,296 @@
 +/*
 +Simple DirectMedia Layer
@@ -655,7 +638,7 @@ diff -ruN SDL2-2.32.8/src/joystick/banan_os/SDL_banan_os_joystick.cpp SDL2-2.32.
 +/* vi: set ts=4 sw=4 expandtab: */
 diff -ruN SDL2-2.32.8/src/joystick/SDL_joystick.c SDL2-2.32.8-banan_os/src/joystick/SDL_joystick.c
 --- SDL2-2.32.8/src/joystick/SDL_joystick.c	2025-01-01 17:47:53.000000000 +0200
-+++ SDL2-2.32.8-banan_os/src/joystick/SDL_joystick.c	2026-01-07 19:04:34.373890653 +0200
++++ SDL2-2.32.8-banan_os/src/joystick/SDL_joystick.c	2026-04-03 04:34:27.258656321 +0300
 @@ -85,6 +85,9 @@
  #ifdef SDL_JOYSTICK_HAIKU
      &SDL_HAIKU_JoystickDriver,
@@ -668,7 +651,7 @@ diff -ruN SDL2-2.32.8/src/joystick/SDL_joystick.c SDL2-2.32.8-banan_os/src/joyst
  #endif
 diff -ruN SDL2-2.32.8/src/joystick/SDL_sysjoystick.h SDL2-2.32.8-banan_os/src/joystick/SDL_sysjoystick.h
 --- SDL2-2.32.8/src/joystick/SDL_sysjoystick.h	2025-01-01 17:47:53.000000000 +0200
-+++ SDL2-2.32.8-banan_os/src/joystick/SDL_sysjoystick.h	2026-01-07 19:04:34.374337431 +0200
++++ SDL2-2.32.8-banan_os/src/joystick/SDL_sysjoystick.h	2026-04-03 04:34:27.259001479 +0300
 @@ -235,6 +235,7 @@
  
  /* The available joystick drivers */
@@ -679,7 +662,7 @@ diff -ruN SDL2-2.32.8/src/joystick/SDL_sysjoystick.h SDL2-2.32.8-banan_os/src/jo
  extern SDL_JoystickDriver SDL_DUMMY_JoystickDriver;
 diff -ruN SDL2-2.32.8/src/misc/banan_os/SDL_sysurl.cpp SDL2-2.32.8-banan_os/src/misc/banan_os/SDL_sysurl.cpp
 --- SDL2-2.32.8/src/misc/banan_os/SDL_sysurl.cpp	1970-01-01 02:00:00.000000000 +0200
-+++ SDL2-2.32.8-banan_os/src/misc/banan_os/SDL_sysurl.cpp	2026-01-07 19:04:34.379748697 +0200
++++ SDL2-2.32.8-banan_os/src/misc/banan_os/SDL_sysurl.cpp	2026-04-03 04:34:27.259173778 +0300
 @@ -0,0 +1,30 @@
 +/*
 +  Simple DirectMedia Layer
@@ -713,7 +696,7 @@ diff -ruN SDL2-2.32.8/src/misc/banan_os/SDL_sysurl.cpp SDL2-2.32.8-banan_os/src/
 +
 diff -ruN SDL2-2.32.8/src/video/banan_os/SDL_banan_os_clipboard.cpp SDL2-2.32.8-banan_os/src/video/banan_os/SDL_banan_os_clipboard.cpp
 --- SDL2-2.32.8/src/video/banan_os/SDL_banan_os_clipboard.cpp	1970-01-01 02:00:00.000000000 +0200
-+++ SDL2-2.32.8-banan_os/src/video/banan_os/SDL_banan_os_clipboard.cpp	2026-01-07 19:04:34.379995308 +0200
++++ SDL2-2.32.8-banan_os/src/video/banan_os/SDL_banan_os_clipboard.cpp	2026-04-03 04:34:27.259271557 +0300
 @@ -0,0 +1,51 @@
 +/*
 +  Simple DirectMedia Layer
@@ -768,7 +751,7 @@ diff -ruN SDL2-2.32.8/src/video/banan_os/SDL_banan_os_clipboard.cpp SDL2-2.32.8-
 +/* vi: set ts=4 sw=4 expandtab: */
 diff -ruN SDL2-2.32.8/src/video/banan_os/SDL_banan_os_clipboard.h SDL2-2.32.8-banan_os/src/video/banan_os/SDL_banan_os_clipboard.h
 --- SDL2-2.32.8/src/video/banan_os/SDL_banan_os_clipboard.h	1970-01-01 02:00:00.000000000 +0200
-+++ SDL2-2.32.8-banan_os/src/video/banan_os/SDL_banan_os_clipboard.h	2026-01-07 19:04:34.380137576 +0200
++++ SDL2-2.32.8-banan_os/src/video/banan_os/SDL_banan_os_clipboard.h	2026-04-03 04:34:27.259318700 +0300
 @@ -0,0 +1,43 @@
 +/*
 +  Simple DirectMedia Layer
@@ -815,7 +798,7 @@ diff -ruN SDL2-2.32.8/src/video/banan_os/SDL_banan_os_clipboard.h SDL2-2.32.8-ba
 +/* vi: set ts=4 sw=4 expandtab: */
 diff -ruN SDL2-2.32.8/src/video/banan_os/SDL_banan_os_message_box.cpp SDL2-2.32.8-banan_os/src/video/banan_os/SDL_banan_os_message_box.cpp
 --- SDL2-2.32.8/src/video/banan_os/SDL_banan_os_message_box.cpp	1970-01-01 02:00:00.000000000 +0200
-+++ SDL2-2.32.8-banan_os/src/video/banan_os/SDL_banan_os_message_box.cpp	2026-01-07 19:04:34.380308339 +0200
++++ SDL2-2.32.8-banan_os/src/video/banan_os/SDL_banan_os_message_box.cpp	2026-04-03 04:34:27.259375481 +0300
 @@ -0,0 +1,60 @@
 +/*
 +  Simple DirectMedia Layer
@@ -879,7 +862,7 @@ diff -ruN SDL2-2.32.8/src/video/banan_os/SDL_banan_os_message_box.cpp SDL2-2.32.
 +/* vi: set ts=4 sw=4 expandtab: */
 diff -ruN SDL2-2.32.8/src/video/banan_os/SDL_banan_os_message_box.h SDL2-2.32.8-banan_os/src/video/banan_os/SDL_banan_os_message_box.h
 --- SDL2-2.32.8/src/video/banan_os/SDL_banan_os_message_box.h	1970-01-01 02:00:00.000000000 +0200
-+++ SDL2-2.32.8-banan_os/src/video/banan_os/SDL_banan_os_message_box.h	2026-01-07 19:04:34.380550899 +0200
++++ SDL2-2.32.8-banan_os/src/video/banan_os/SDL_banan_os_message_box.h	2026-04-03 04:34:27.259437082 +0300
 @@ -0,0 +1,45 @@
 +/*
 +  Simple DirectMedia Layer
@@ -928,7 +911,7 @@ diff -ruN SDL2-2.32.8/src/video/banan_os/SDL_banan_os_message_box.h SDL2-2.32.8-
 +/* vi: set ts=4 sw=4 expandtab: */
 diff -ruN SDL2-2.32.8/src/video/banan_os/SDL_banan_os_video.cpp SDL2-2.32.8-banan_os/src/video/banan_os/SDL_banan_os_video.cpp
 --- SDL2-2.32.8/src/video/banan_os/SDL_banan_os_video.cpp	1970-01-01 02:00:00.000000000 +0200
-+++ SDL2-2.32.8-banan_os/src/video/banan_os/SDL_banan_os_video.cpp	2026-01-07 19:04:34.380720824 +0200
++++ SDL2-2.32.8-banan_os/src/video/banan_os/SDL_banan_os_video.cpp	2026-04-03 04:34:27.259503082 +0300
 @@ -0,0 +1,729 @@
 +/*
 +  Simple DirectMedia Layer
@@ -1661,7 +1644,7 @@ diff -ruN SDL2-2.32.8/src/video/banan_os/SDL_banan_os_video.cpp SDL2-2.32.8-bana
 +/* vi: set ts=4 sw=4 expandtab: */
 diff -ruN SDL2-2.32.8/src/video/SDL_sysvideo.h SDL2-2.32.8-banan_os/src/video/SDL_sysvideo.h
 --- SDL2-2.32.8/src/video/SDL_sysvideo.h	2025-05-20 00:24:41.000000000 +0300
-+++ SDL2-2.32.8-banan_os/src/video/SDL_sysvideo.h	2026-01-07 19:04:34.381316574 +0200
++++ SDL2-2.32.8-banan_os/src/video/SDL_sysvideo.h	2026-04-03 04:34:27.259743826 +0300
 @@ -462,6 +462,7 @@
  extern VideoBootStrap WINDOWS_bootstrap;
  extern VideoBootStrap WINRT_bootstrap;
@@ -1672,7 +1655,7 @@ diff -ruN SDL2-2.32.8/src/video/SDL_sysvideo.h SDL2-2.32.8-banan_os/src/video/SD
  extern VideoBootStrap Android_bootstrap;
 diff -ruN SDL2-2.32.8/src/video/SDL_video.c SDL2-2.32.8-banan_os/src/video/SDL_video.c
 --- SDL2-2.32.8/src/video/SDL_video.c	2025-05-20 00:24:41.000000000 +0300
-+++ SDL2-2.32.8-banan_os/src/video/SDL_video.c	2026-01-07 19:04:34.398132645 +0200
++++ SDL2-2.32.8-banan_os/src/video/SDL_video.c	2026-04-03 04:34:27.260110007 +0300
 @@ -96,6 +96,9 @@
  #ifdef SDL_VIDEO_DRIVER_HAIKU
      &HAIKU_bootstrap,

ports/bzip2/build.sh

@@ -0,0 +1,36 @@
+#!/bin/bash ../install.sh
+
+NAME='bzip2'
+VERSION='1.0.8'
+DOWNLOAD_URL="https://sourceware.org/pub/bzip2/bzip2-$VERSION.tar.gz#ab5a03176ee106d3f0fa90e381da478ddae405918153cca248e682cd0c4a2269"
+
+configure() {
+	:
+}
+
+build() {
+	make -j$(nproc) -f Makefile-libbz2_so CC="$CC" || exit 1
+}
+
+install() {
+	cp -v libbz2.so.$VERSION $BANAN_SYSROOT/usr/lib/ || exit 1
+	ln -svf libbz2.so.$VERSION $BANAN_SYSROOT/usr/lib/libbz2.so || exit 1
+	ln -svf libbz2.so.$VERSION $BANAN_SYSROOT/usr/lib/libbz2.so.1 || exit 1
+	ln -svf libbz2.so.$VERSION $BANAN_SYSROOT/usr/lib/libbz2.so.1.0 || exit 1
+
+	cp -v bzlib.h $BANAN_SYSROOT/usr/include/ || exit 1
+
+	cat > $BANAN_SYSROOT/usr/lib/pkgconfig/bzip2.pc << EOF
+prefix=/usr
+exec_prefix=\${prefix}
+bindir=\${exec_prefix}/bin
+libdir=\${exec_prefix}/lib
+includedir=\${prefix}/include
+
+Name: bzip2
+Description: A file compression library
+Version: $VERSION
+Libs: -L\${libdir} -lbz2
+Cflags: -I\${includedir}
+EOF
+}

ports/libarchive/build.sh

@@ -0,0 +1,23 @@
+#!/bin/bash ../install.sh
+
+NAME='libarchive'
+VERSION='3.8.6'
+DOWNLOAD_URL="https://github.com/libarchive/libarchive/releases/download/v$VERSION/libarchive-$VERSION.tar.xz#8ac57c1f5e99550948d1fe755c806d26026e71827da228f36bef24527e372e6f"
+DEPENDENCIES=('zlib' 'zstd' 'bzip2' 'xz')
+
+configure() {
+	cmake --fresh -B build -S . -G Ninja  \
+		--toolchain="$BANAN_TOOLCHAIN_DIR/Toolchain.txt" \
+		-DCMAKE_INSTALL_PREFIX=/usr \
+		-DCMAKE_BUILD_TYPE=Release \
+		-DENABLE_TEST=OFF \
+		|| exit 1
+}
+
+build() {
+	cmake --build build || exit 1
+}
+
+install() {
+	cmake --install build || exit 1
+}

ports/xbanan/build.sh

@@ -2,8 +2,8 @@
 
 NAME='xbanan'
 VERSION='git'
-DOWNLOAD_URL="https://git.bananymous.com/Bananymous/xbanan.git#b228ef13c41adff2738acaeda5db804ebf493bfd"
-DEPENDENCIES=('mesa' 'libX11' 'xorgproto')
+DOWNLOAD_URL="https://git.bananymous.com/Bananymous/xbanan.git#b2c642f03d2e498e9d6acd55cc89a5e76c220811"
+DEPENDENCIES=('xorgproto')
 
 configure() {
 	cmake --fresh -B build -S . -G Ninja \

ports/xz/build.sh

@@ -0,0 +1,24 @@
+#!/bin/bash ../install.sh
+
+NAME='xz'
+VERSION='5.8.2'
+DOWNLOAD_URL="https://github.com/tukaani-project/xz/releases/download/v5.8.2/xz-$VERSION.tar.xz#890966ec3f5d5cc151077879e157c0593500a522f413ac50ba26d22a9a145214"
+
+configure() {
+	cmake --fresh -B build -S . -G Ninja \
+		--toolchain="$BANAN_TOOLCHAIN_DIR/Toolchain.txt" \
+		-DCMAKE_INSTALL_PREFIX=/usr \
+		-DCMAKE_BUILD_TYPE=Release \
+		-DBUILD_SHARED_LIBS=ON \
+		-DXZ_NLS=OFF \
+		-DXZ_DOC=OFF \
+		 || exit 1
+}
+
+build() {
+	cmake --build build ||exit 1
+}
+
+install() {
+	cmake --install build ||exit 1
+}

userspace/libraries/LibAudio/Audio.cpp

@@ -145,7 +145,7 @@ namespace LibAudio
 
 		LibAudio::Packet packet {
 			.type = LibAudio::Packet::Notify,
-			.parameter = 0,
+			.parameter = {},
 		};
 
 		send(m_server_fd, &packet, sizeof(packet), 0);

userspace/libraries/LibAudio/include/LibAudio/Audio.h

@@ -11,7 +11,7 @@ namespace LibAudio
 
 	struct AudioBuffer
 	{
-		using sample_t = double;
+		using sample_t = float;
 
 		uint32_t sample_rate;
 		uint32_t channels;

userspace/libraries/LibAudio/include/LibAudio/Protocol.h

@@ -40,6 +40,14 @@ namespace LibAudio
 			SetPin,         // parameter: pin number
 			                // response: nothing
 							// set the active pin of the current device
+
+			GetVolume,      // parameter: ignored
+			                // response: 10 * volume percentage (uint32_t)
+							// get the volume of the current device
+
+			SetVolume,      // parameter: 10 * volume percentage (uint32_t)
+			                // response: nothing
+							// set the volume of the current device
 		} type;
 
 		uint64_t parameter;

userspace/libraries/LibC/CMakeLists.txt

@@ -7,7 +7,6 @@ set(LIBC_SOURCES
 	dlfcn.cpp
 	endian.cpp
 	environ.cpp
-	errno.cpp
 	fcntl.cpp
 	fenv.cpp
 	fnmatch.cpp
@@ -75,7 +74,7 @@ set(LIBC_SOURCES
 )
 
 add_library(objlibc OBJECT ${LIBC_SOURCES})
-target_compile_definitions(objlibc PRIVATE __arch=${BANAN_ARCH})
+target_compile_definitions(objlibc PRIVATE __arch=${BANAN_ARCH} __is_libc)
 
 target_compile_options(objlibc PRIVATE -O2 -g -Wstack-usage=512 -fno-exceptions -fno-rtti -fpic)
 target_compile_options(objlibc PUBLIC -Wall -Wextra -Werror -Wno-error=stack-usage=)

userspace/libraries/LibC/arch/i686/string.S

@@ -1,35 +1,4 @@
-.global memchr
-memchr:
-	xchgl 4(%esp), %edi
-	movl  8(%esp), %eax
-	movl 12(%esp), %ecx
-	movl $1, %edx
-	cmpl $1, %ecx # clear ZF if count is zero
-	repne scasb
-	cmovel %edi, %edx
-	leal -1(%edx), %eax
-	movl 4(%esp), %edi
-	ret
-
-.global memcmp
-memcmp:
-	xchgl 4(%esp), %edi
-	xchgl 8(%esp), %esi
-	movl 12(%esp), %ecx
-	testl %ecx, %ecx # set ZF if count is zero
-	repe cmpsb
-	jne .memcmp_not_equal
-	xorl %eax, %eax
-	jmp .memcmp_done
- .memcmp_not_equal:
-	movzbl -1(%edi), %eax
-	movzbl -1(%esi), %ecx
-	subl %ecx, %eax
- .memcmp_done:
-	movl 4(%esp), %edi
-	movl 8(%esp), %esi
-	ret
-
+.align 16
 .global memcpy
 memcpy:
 	xchgl 4(%esp), %edi
@@ -42,6 +11,7 @@ memcpy:
 	movl %edx, %eax
 	ret
 
+.align 16
 .global memmove
 memmove:
 	xchgl 4(%esp), %edi
@@ -64,6 +34,7 @@ memmove:
 	cld
 	jmp .memmove_done
 
+.align 16
 .global memset
 memset:
 	xchgl 4(%esp), %edi
@@ -74,14 +45,3 @@ memset:
 	movl 4(%esp), %edi
 	movl %edx, %eax
 	ret
-
-.global strlen
-strlen:
-	xchgl 4(%esp), %edi
-	xorb %al, %al
-	movl $-1, %ecx
-	repne scasb
-	movl 4(%esp), %edi
-	movl $-2, %eax
-	subl %ecx, %eax
-	ret

userspace/libraries/LibC/arch/x86_64/string.S

@@ -1,62 +1,312 @@
-.global memchr
-memchr:
-	movb %sil, %al
-	movq %rdx, %rcx
-	movq $1, %rdx
-	cmpq $1, %rcx # clear ZF if count is zero
-	repne scasb
-	cmoveq %rdi, %rdx
-	leaq -1(%rdx), %rax
-	ret
-
-.global memcmp
-memcmp:
-	movq %rdx, %rcx
-	testq %rcx, %rcx # set ZF if count is zero
-	repe cmpsb
-	jne .memcmp_not_equal
-	xorq %rax, %rax
-	ret
- .memcmp_not_equal:
-	movzbl -1(%rdi), %eax
-	movzbl -1(%rsi), %ecx
-	subq %rcx, %rax
-	ret
+.set nt_threshold, 32 * 1024
 
+.align 16
 .global memcpy
 memcpy:
+	cmpq $nt_threshold, %rdx
+	jae .Lmemcpy_nt
 	movq %rdi, %rax
 	movq %rdx, %rcx
 	rep movsb
 	ret
 
+ .Lmemcpy_nt:
+	movq %rdi, %rax
+
+	testq $63, %rdi
+	jz .Lmemcpy_nt_aligned
+
+	# NOTE: this unconditionally copies 64 bytes to align to 64 byte boundary
+	#       but as nt branch is only taken for huge buffers, it doesnt add much overhead
+
+	movdqu  0(%rsi), %xmm0
+	movdqu 16(%rsi), %xmm1
+	movdqu 32(%rsi), %xmm2
+	movdqu 48(%rsi), %xmm3
+
+	movdqu %xmm0,  0(%rdi)
+	movdqu %xmm1, 16(%rdi)
+	movdqu %xmm2, 32(%rdi)
+	movdqu %xmm3, 48(%rdi)
+
+	movq %rdi, %rcx
+	andq $63, %rcx
+	leaq -64(%rdx, %rcx), %rdx
+
+	negq %rcx
+	leaq 64(%rdi, %rcx), %rdi
+	leaq 64(%rsi, %rcx), %rsi
+
+ .Lmemcpy_nt_aligned:
+	movq %rdx, %rcx
+	shrq $6, %rdx
+
+ .align 16
+ .Lmemcpy_nt_loop:
+	prefetchnta    256(%rsi)
+	prefetchnta 32+256(%rsi)
+
+	movdqu  0(%rsi), %xmm0
+	movdqu 16(%rsi), %xmm1
+	movdqu 32(%rsi), %xmm2
+	movdqu 48(%rsi), %xmm3
+
+	movntdq %xmm0,  0(%rdi)
+	movntdq %xmm1, 16(%rdi)
+	movntdq %xmm2, 32(%rdi)
+	movntdq %xmm3, 48(%rdi)
+
+	addq $64, %rdi
+	addq $64, %rsi
+	subq $1, %rdx
+	jnz .Lmemcpy_nt_loop
+
+	andq $63, %rcx
+	rep movsb
+	sfence
+	ret
+
+.align 16
 .global memmove
 memmove:
-	cmpq %rdi, %rsi
-	jae memcpy
+	cmpq $nt_threshold, %rdx
+	jb .Lmemmove_small
+	leaq (%rdi, %rdx), %rax
+	cmpq %rax, %rsi
+	jae .Lmemcpy_nt
+	leaq (%rsi, %rdx), %rax
+	cmpq %rax, %rdi
+	jae .Lmemcpy_nt
+ .Lmemmove_small:
 	movq %rdi, %rax
+	movq %rdx, %rcx
+	cmpq %rdi, %rsi
+	jb .Lmemmove_backwards
+	rep movsb
+	ret
+ .Lmemmove_backwards:
 	leaq -1(%rdi, %rdx), %rdi
 	leaq -1(%rsi, %rdx), %rsi
-	movq %rdx, %rcx
 	std
 	rep movsb
 	cld
 	ret
 
+.align 16
 .global memset
 memset:
+	cmpq $nt_threshold, %rdx
+	jae .Lmemset_nt
 	movq %rdi, %r8
-	movb %sil, %al
 	movq %rdx, %rcx
+	movzbl %sil, %eax
 	rep stosb
 	movq %r8, %rax
 	ret
 
+ .Lmemset_nt:
+	movq %rdi, %rax
+
+	movzbl %sil, %esi
+	imul $0x01010101, %esi
+	movd %esi, %xmm0
+	pshufd $0, %xmm0, %xmm0
+
+	testq $63, %rdi
+	jz .Lmemset_nt_aligned
+
+	# NOTE: this unconditionally writes 64 bytes to align to 64 byte boundary
+	#       but as nt branch is only taken for huge buffers, it doesnt add much overhead
+
+	movdqu %xmm0,  0(%rdi)
+	movdqu %xmm0, 16(%rdi)
+	movdqu %xmm0, 32(%rdi)
+	movdqu %xmm0, 48(%rdi)
+
+	movq %rdi, %rcx
+	andq $63, %rcx
+	leaq -64(%rdx, %rcx), %rdx
+
+	negq %rcx
+	leaq 64(%rdi, %rcx), %rdi
+
+ .Lmemset_nt_aligned:
+	movq %rdx, %rcx
+	shrq $6, %rdx
+
+ .align 16
+ .Lmemset_nt_loop:
+	movntdq %xmm0,  0(%rdi)
+	movntdq %xmm0, 16(%rdi)
+	movntdq %xmm0, 32(%rdi)
+	movntdq %xmm0, 48(%rdi)
+
+	addq $64, %rdi
+	subq $1, %rdx
+	jnz .Lmemset_nt_loop
+
+	andq $63, %rcx
+	jnz .Lmemset_nt_bytes
+	sfence
+	ret
+
+ .Lmemset_nt_bytes:
+	movq %rax, %rdx
+	movzbl %sil, %eax
+	rep stosb
+	movq %rdx, %rax
+	sfence
+	ret
+
+.align 16
+.global memchr
+memchr:
+	testq %rdx, %rdx
+	jz .Lmemchr_no_match
+
+	movzbl %sil, %esi
+	imul $0x01010101, %esi
+	movd %esi, %xmm0
+	pshufd $0, %xmm0, %xmm0
+
+	movq %rdi, %rcx
+	andq $15, %rcx
+	jz .Lmemchr_loop
+
+	movq %rdi, %rsi
+	subq %rcx, %rsi
+	movdqa (%rsi), %xmm1
+	pcmpeqb %xmm0, %xmm1
+	pmovmskb %xmm1, %eax
+	shrl %cl, %eax
+	jnz .Lmemchr_match
+
+	leaq 16(%rsi), %rdi
+
+	addq %rcx, %rdx
+	subq $16, %rdx
+	jbe .Lmemchr_no_match
+
+ .align 16
+ .Lmemchr_loop:
+	movdqa (%rdi), %xmm1
+	pcmpeqb %xmm0, %xmm1
+	pmovmskb %xmm1, %eax
+	testl %eax, %eax
+	jnz .Lmemchr_match
+
+	addq $16, %rdi
+	subq $16, %rdx
+	ja .Lmemchr_loop
+
+ .Lmemchr_no_match:
+	xorq %rax, %rax
+	ret
+
+ .Lmemchr_match:
+	bsfl %eax, %eax
+	cmpq %rdx, %rax
+	jae .Lmemchr_no_match
+	addq %rdi, %rax
+	ret
+
+.align 16
+.global memcmp
+memcmp:
+	testq %rdx, %rdx
+	jz .Lmemcmp_equal
+
+	movq %rdi, %rax
+	movq %rsi, %rcx
+	andq $15, %rax
+	andq $15, %rcx
+	cmpq %rax, %rcx
+	cmovaq %rcx, %rax
+
+	testq %rax, %rax
+	jz .Lmemcmp_loop
+
+	movq $16, %rcx
+	subq %rax, %rcx
+
+	cmpq %rcx, %rdx
+	cmovbq %rdx, %rcx
+
+	subq %rcx, %rdx
+
+ .Lmemcmp_align_loop:
+	movzbl (%rdi), %eax
+	movzbl (%rsi), %r8d
+	subl %r8d, %eax
+	jnz .Lmemcmp_return
+
+	addq $1, %rdi
+	addq $1, %rsi
+	subq $1, %rcx
+	jnz .Lmemcmp_align_loop
+
+ .align 16
+ .Lmemcmp_loop:
+	movdqu (%rdi), %xmm0
+	movdqu (%rsi), %xmm1
+	pcmpeqb %xmm0, %xmm1
+	pmovmskb %xmm1, %eax
+	xorl $0xFFFF, %eax
+	jnz .Lmemcmp_differ
+
+	addq $16, %rdi
+	addq $16, %rsi
+	subq $16, %rdx
+	ja .Lmemcmp_loop
+
+ .Lmemcmp_equal:
+	xorl %eax, %eax
+ .Lmemcmp_return:
+	ret
+
+ .Lmemcmp_differ:
+	bsfl %eax, %ecx
+	cmpq %rdx, %rcx
+	jae .Lmemcmp_equal
+	movzbl (%rdi, %rcx), %eax
+	movzbl (%rsi, %rcx), %edx
+	subl %edx, %eax
+	ret
+
+.align 16
 .global strlen
 strlen:
-	xorb %al, %al
-	movq $-1, %rcx
-	repne scasb
-	movq $-2, %rax
-	subq %rcx, %rax
+	movq %rdi, %rsi
+
+	pxor %xmm0, %xmm0
+
+	movq %rsi, %rcx
+	andq $15, %rcx
+	jz .Lstrlen_loop
+
+	movq %rsi, %rdx
+	subq %rcx, %rdx
+	movdqa (%rdx), %xmm1
+	pcmpeqb %xmm0, %xmm1
+	pmovmskb %xmm1, %eax
+	shrl %cl, %eax
+	jnz .Lstrlen_null_found
+
+	leaq 16(%rdx), %rsi
+
+ .align 16
+ .Lstrlen_loop:
+	movdqa (%rsi), %xmm1
+	pcmpeqb %xmm0, %xmm1
+	pmovmskb %xmm1, %eax
+	testl %eax, %eax
+	jnz .Lstrlen_null_found
+
+	addq $16, %rsi
+	jmp .Lstrlen_loop
+
+ .Lstrlen_null_found:
+	bsfl %eax, %eax
+	addq %rsi, %rax
+	subq %rdi, %rax
 	ret

userspace/libraries/LibC/environ.cpp

@@ -14,6 +14,19 @@ static bool s_environ_malloced = false;
 static size_t s_environ_count = 0;          // only valid when s_environ_malloced == true
 static uint8_t* s_environ_bitmap = nullptr; // if bit i is set, environ[i] has to be freed
 
+static bool is_bitmap_bit_set(size_t index)
+{
+	return !!(s_environ_bitmap[index / 8] & (1 << (index % 8)));
+}
+
+static void set_bitmap_bit(size_t index, bool value)
+{
+	if (value)
+		s_environ_bitmap[index / 8] |=   1 << (index % 8);
+	else
+		s_environ_bitmap[index / 8] &= ~(1 << (index % 8));
+}
+
 static int malloc_environ()
 {
 	ASSERT(!s_environ_malloced);
@@ -28,7 +41,7 @@ static int malloc_environ()
 		return -1;
 	memset(new_bitmap, 0, bitmap_size);
 
-	char** new_environ = static_cast<char**>(malloc((environ_count + 1) * sizeof(char*)));
+	auto** new_environ = static_cast<char**>(malloc((environ_count + 1) * sizeof(char*)));
 	if (new_environ == nullptr)
 	{
 		free(new_bitmap);
@@ -60,53 +73,42 @@ static int putenv_impl(char* string, bool malloced)
 	}
 
 	const size_t namelen = eq_addr - string;
-	for (int i = 0; environ[i]; i++)
+	for (size_t i = 0; environ[i]; i++)
 	{
-		if (strncmp(environ[i], string, namelen + 1) == 0)
-		{
-			const size_t byte = i / 8;
-			const uint8_t mask = 1 << (i % 8);
+		if (strncmp(environ[i], string, namelen + 1) != 0)
+			continue;
 
-			if (s_environ_bitmap[byte] & mask)
+		if (is_bitmap_bit_set(i))
 			free(environ[i]);
-
-			if (malloced)
-				s_environ_bitmap[byte] |= mask;
-			else
-				s_environ_bitmap[byte] &= ~mask;
+		set_bitmap_bit(i, malloced);
 
 		environ[i] = string;
 		return 0;
 	}
-	}
 
 	if (s_environ_count % 8 == 0)
 	{
 		const size_t bytes = s_environ_count / 8 + 1;
 
-		void* new_bitmap = realloc(s_environ_bitmap, bytes);
+		auto* new_bitmap = static_cast<uint8_t*>(realloc(s_environ_bitmap, bytes));
 		if (new_bitmap == nullptr)
 			return -1;
 
-		s_environ_bitmap = static_cast<uint8_t*>(new_bitmap);
+		s_environ_bitmap = new_bitmap;
 		s_environ_bitmap[bytes - 1] = 0;
 	}
 
-	void* new_environ = realloc(environ, sizeof(char*) * (s_environ_count + 2));
+	auto** new_environ = static_cast<char**>(realloc(environ, (s_environ_count + 2) * sizeof(char*)));
 	if (new_environ == nullptr)
 		return -1;
 
-	environ = static_cast<char**>(new_environ);
+	environ = new_environ;
 	environ[s_environ_count] = string;
 	environ[s_environ_count + 1] = nullptr;
-	s_environ_count++;
 
-	if (malloced)
-	{
-		const size_t byte = s_environ_count / 8;
-		const size_t mask = 1 << (s_environ_count % 8);
-		s_environ_bitmap[byte] |= mask;
-	}
+	set_bitmap_bit(s_environ_count, malloced);
+
+	s_environ_count++;
 
 	return 0;
 }
@@ -116,15 +118,9 @@ int clearenv(void)
 	if (s_environ_malloced)
 	{
 		ASSERT(environ);
-
 		for (size_t i = 0; environ[i]; i++)
-		{
-			const size_t byte = i / 8;
-			const size_t mask = 1 << (i % 8);
-			if (s_environ_bitmap[byte] & mask)
+			if (is_bitmap_bit_set(i))
 				free(environ[i]);
-		}
-
 		free(s_environ_bitmap);
 		free(environ);
 	}
@@ -142,8 +138,7 @@ char* getenv(const char* name)
 		return nullptr;
 	const size_t namelen = strlen(name);
 	for (size_t i = 0; environ[i]; i++)
-		if (strncmp(name, environ[i], namelen) == 0)
-			if (environ[i][namelen] == '=')
+		if (strncmp(name, environ[i], namelen) == 0 && environ[i][namelen] == '=')
 			return environ[i] + namelen + 1;
 	return nullptr;
 }
@@ -162,7 +157,7 @@ int setenv(const char* name, const char* val, int overwrite)
 	const size_t namelen = strlen(name);
 	const size_t vallen = strlen(val);
 
-	char* string = (char*)malloc(namelen + vallen + 2);
+	auto* string = static_cast<char*>(malloc(namelen + vallen + 2));
 	memcpy(string, name, namelen);
 	string[namelen] = '=';
 	memcpy(string + namelen + 1, val, vallen);
@@ -189,13 +184,8 @@ int unsetenv(const char* name)
 	{
 		if (strncmp(environ[i], name, namelen) || environ[i][namelen] != '=')
 			continue;
-		if (!s_environ_malloced)
-			break;
-		const size_t byte = i / 8;
-		const size_t mask = 1 << (i % 8);
-		if (s_environ_bitmap[byte] & mask)
+		if (s_environ_malloced && is_bitmap_bit_set(i))
 			free(environ[i]);
-		s_environ_count--;
 		break;
 	}
 
@@ -204,17 +194,7 @@ int unsetenv(const char* name)
 		environ[i] = environ[i + 1];
 		if (!s_environ_malloced)
 			continue;
-
-		const size_t cbyte = i / 8;
-		const size_t cmask = 1 << (i % 8);
-
-		const size_t nbyte = (i + 1) / 8;
-		const size_t nmask = 1 << ((i + 1) % 8);
-
-		if (s_environ_bitmap[nbyte] & nmask)
-			s_environ_bitmap[cbyte] |= cmask;
-		else
-			s_environ_bitmap[cbyte] &= ~cmask;
+		set_bitmap_bit(i, is_bitmap_bit_set(i + 1));
 	}
 
 	if (environ[i])
@@ -223,9 +203,8 @@ int unsetenv(const char* name)
 
 		if (s_environ_malloced)
 		{
-			const size_t byte = i / 8;
-			const size_t mask = 1 << (i % 8);
-			s_environ_bitmap[byte] &= ~mask;
+			set_bitmap_bit(i, false);
+			s_environ_count--;
 		}
 	}
 

userspace/libraries/LibC/errno.cpp

@@ -1,7 +0,0 @@
-#include <errno.h>
-#include <pthread.h>
-
-int* __errno_location()
-{
-	return &_get_uthread()->errno_;
-}

userspace/libraries/LibC/fnmatch.cpp

@@ -1,3 +1,4 @@
+#include <ctype.h>
 #include <fnmatch.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -5,6 +6,8 @@
 
 static int fnmatch_impl(const char* pattern, const char* string, int flags, bool leading)
 {
+	const bool ignore_case = !!(flags & FNM_IGNORECASE);
+
 	while (*pattern)
 	{
 		if ((flags & FNM_PERIOD) && leading && *string == '.' && *pattern != '.')
@@ -34,9 +37,13 @@ static int fnmatch_impl(const char* pattern, const char* string, int flags, bool
 				uint8_t ch;
 				uint32_t bitmap[0x100 / 8] {};
 				while ((ch = *pattern++) != ']')
+				{
+					if (ignore_case)
+						ch = tolower(ch);
 					bitmap[ch / 32] |= 1 << (ch % 32);
+				}
 
-				ch = *string++;
+				ch = ignore_case ? tolower(*string++) : *string++;
 				if (!!(bitmap[ch / 32] & (1 << (ch % 32))) == negate)
 					return FNM_NOMATCH;
 
@@ -63,7 +70,10 @@ static int fnmatch_impl(const char* pattern, const char* string, int flags, bool
 		if (*pattern == '\0')
 			break;
 
-		if (*pattern != *string)
+		const char lhs = ignore_case ? tolower(*pattern) : *pattern;
+		const char rhs = ignore_case ? tolower(*string)  : *string;
+
+		if (lhs != rhs)
 			return FNM_NOMATCH;
 		if ((flags & FNM_PATHNAME) && *string == '/')
 			leading = true;

userspace/libraries/LibC/include/assert.h

@@ -1,3 +1,11 @@
+#ifndef assert
+#ifdef NDEBUG
+	#define assert(ignore) ((void)0)
+#else
+	#define assert(expr) ((expr) ? (void)0 : __assert_fail(#expr, __FILE__, __LINE__, __func__))
+#endif
+#endif
+
 #ifndef _ASSERT_H
 #define _ASSERT_H 1
 
@@ -5,12 +13,6 @@
 
 #include <sys/cdefs.h>
 
-#ifdef NDEBUG
-	#define assert(ignore) ((void)0)
-#else
-	#define assert(expr) ((expr) ? (void)0 : __assert_fail(#expr, __FILE__, __LINE__, __func__))
-#endif
-
 #if !defined(__cplusplus) && __STDC_VERSION__ >= 201112L && __STDC_VERSION__ < 202311L
 	#define static_assert _Static_assert
 #endif

userspace/libraries/LibC/include/bits/types/pthread_types.h

@@ -54,7 +54,6 @@ typedef struct
 } pthread_barrierattr_t;
 typedef struct
 {
-	pthread_barrierattr_t attr;
 	pthread_mutex_t lock;
 	pthread_cond_t cond;
 	unsigned target;
@@ -68,9 +67,11 @@ typedef struct
 } pthread_rwlockattr_t;
 typedef struct
 {
-	pthread_rwlockattr_t attr;
-	unsigned lockers;
-	unsigned writers;
+	pthread_mutex_t lock;
+	pthread_cond_t cond;
+	unsigned writers_waiting;
+	unsigned writer_active;
+	unsigned readers_active;
 } pthread_rwlock_t;
 
 __END_DECLS

userspace/libraries/LibC/include/bits/types/uthread.h

@@ -0,0 +1,55 @@
+#ifndef _BITS_TYPES_UTHREAD_H
+#define _BITS_TYPES_UTHREAD_H 1
+
+#include <sys/cdefs.h>
+
+__BEGIN_DECLS
+
+#define __need_size_t
+#include <sys/types.h>
+
+#include <bits/types/pthread_t.h>
+#include <stdint.h>
+
+typedef struct _pthread_cleanup_t
+{
+	void (*routine)(void*);
+	void* arg;
+	struct _pthread_cleanup_t* next;
+} _pthread_cleanup_t;
+
+typedef struct _dynamic_tls_entry_t
+{
+	void* master_addr;
+	size_t master_size;
+} _dynamic_tls_entry_t;
+
+typedef struct _dynamic_tls_t
+{
+	int lock;
+	size_t entry_count;
+	_dynamic_tls_entry_t* entries;
+} _dynamic_tls_t;
+
+struct uthread
+{
+	struct uthread* self;
+	void* master_tls_addr;
+	size_t master_tls_size;
+	size_t master_tls_module_count;
+	_dynamic_tls_t* dynamic_tls;
+	_pthread_cleanup_t* cleanup_stack;
+	pthread_t id;
+	int errno_;
+	int cancel_type;
+	int cancel_state;
+	volatile int canceled;
+	// FIXME: make this dynamic
+	uintptr_t dtv[1 + 256];
+};
+
+#define _get_uthread() ((struct uthread*)__builtin_thread_pointer())
+
+__END_DECLS
+
+#endif

userspace/libraries/LibC/include/errno.h

@@ -7,6 +7,10 @@
 
 __BEGIN_DECLS
 
+#include <bits/types/uthread.h>
+
+#define errno (_get_uthread()->errno_)
+
 #define E2BIG			1
 #define EACCES			2
 #define EADDRINUSE		3
@@ -94,10 +98,6 @@ __BEGIN_DECLS
 #define ERESTART        0xFE /* internal errno for SA_RESTART */
 #define EUNKNOWN		0xFF
 
-#define errno (*__errno_location())
-
-int* __errno_location(void);
-
 __END_DECLS
 
 #endif

userspace/libraries/LibC/include/fnmatch.h

@@ -11,6 +11,8 @@ __BEGIN_DECLS
 #define FNM_PATHNAME	0x01
 #define FNM_PERIOD		0x02
 #define FNM_NOESCAPE	0x04
+#define FNM_CASEFOLD	0x08
+#define FNM_IGNORECASE	FNM_CASEFOLD
 
 int fnmatch(const char* pattern, const char* string, int flags);
 

userspace/libraries/LibC/include/net/if.h

@@ -53,6 +53,13 @@ struct ifreq
 #define SIOCGIFFLAGS    9
 #define SIOCGIFMTU     10
 
+#define IFF_UP          0x01
+#define IFF_BROADCAST   0x02
+#define IFF_LOOPBACK    0x04
+#define IFF_POINTOPOINT 0x08
+#define IFF_RUNNING     0x10
+#define IFF_MULTICAST   0x20
+
 void					if_freenameindex(struct if_nameindex* ptr);
 char*					if_indextoname(unsigned ifindex, char* ifname);
 struct if_nameindex*	if_nameindex(void);

userspace/libraries/LibC/include/netinet/in.h

@@ -18,49 +18,26 @@ __BEGIN_DECLS
 #define IPPROTO_TCP    6
 #define IPPROTO_UDP    7
 
-enum
-{
-	IP_ADD_MEMBERSHIP,
-#define IP_ADD_MEMBERSHIP IP_ADD_MEMBERSHIP
-	IP_ADD_SOURCE_MEMBERSHIP,
-#define IP_ADD_SOURCE_MEMBERSHIP IP_ADD_SOURCE_MEMBERSHIP
-	IP_DROP_MEMBERSHIP,
-#define IP_DROP_MEMBERSHIP IP_DROP_MEMBERSHIP
-	IP_DROP_SOURCE_MEMBERSHIP,
-#define IP_DROP_SOURCE_MEMBERSHIP IP_DROP_SOURCE_MEMBERSHIP
-	IP_MULTICAST_IF,
-#define IP_MULTICAST_IF IP_MULTICAST_IF
-	IP_MULTICAST_LOOP,
-#define IP_MULTICAST_LOOP IP_MULTICAST_LOOP
-	IP_MULTICAST_TTL,
-#define IP_MULTICAST_TTL IP_MULTICAST_TTL
-	IP_TTL,
-#define IP_TTL IP_TTL
-	IP_TOS,
-#define IP_TOS IP_TOS
-};
+#define IP_ADD_MEMBERSHIP         0
+#define IP_ADD_SOURCE_MEMBERSHIP  1
+#define IP_DROP_MEMBERSHIP        2
+#define IP_DROP_SOURCE_MEMBERSHIP 3
+#define IP_MULTICAST_IF           4
+#define IP_MULTICAST_LOOP         5
+#define IP_MULTICAST_TTL          6
+#define IP_TTL                    7
+#define IP_TOS                    8
 
-enum
-{
-	IPV6_ADD_MEMBERSHIP,
-#define IPV6_ADD_MEMBERSHIP IPV6_ADD_MEMBERSHIP
-	IPV6_DROP_MEMBERSHIP,
-#define IPV6_DROP_MEMBERSHIP IPV6_DROP_MEMBERSHIP
-	IPV6_JOIN_GROUP,
-#define IPV6_JOIN_GROUP IPV6_JOIN_GROUP
-	IPV6_LEAVE_GROUP,
-#define IPV6_LEAVE_GROUP IPV6_LEAVE_GROUP
-	IPV6_MULTICAST_HOPS,
-#define IPV6_MULTICAST_HOPS IPV6_MULTICAST_HOPS
-	IPV6_MULTICAST_IF,
-#define IPV6_MULTICAST_IF IPV6_MULTICAST_IF
-	IPV6_MULTICAST_LOOP,
-#define IPV6_MULTICAST_LOOP IPV6_MULTICAST_LOOP
-	IPV6_UNICAST_HOPS,
-#define IPV6_UNICAST_HOPS IPV6_UNICAST_HOPS
-	IPV6_V6ONLY,
-#define IPV6_V6ONLY IPV6_V6ONLY
-};
+#define IPV6_ADD_MEMBERSHIP  0
+#define IPV6_DROP_MEMBERSHIP 1
+#define IPV6_JOIN_GROUP      2
+#define IPV6_LEAVE_GROUP     3
+#define IPV6_MULTICAST_HOPS  4
+#define IPV6_MULTICAST_IF    5
+#define IPV6_MULTICAST_LOOP  6
+#define IPV6_UNICAST_HOPS    7
+#define IPV6_V6ONLY          8
+#define IPV6_TCLASS          9
 
 #define IN_CLASSA(a)       ((((in_addr_t)(a)) & 0x80000000) == 0)
 #define IN_CLASSA_NET      0xFF000000

userspace/libraries/LibC/include/pthread.h

@@ -16,43 +16,7 @@ __BEGIN_DECLS
 #include <sys/types.h>
 
 #include <bits/types/pthread_types.h>
-
-typedef struct _pthread_cleanup_t
-{
-	void (*routine)(void*);
-	void* arg;
-	struct _pthread_cleanup_t* next;
-} _pthread_cleanup_t;
-
-typedef struct _dynamic_tls_entry_t
-{
-	void* master_addr;
-	size_t master_size;
-} _dynamic_tls_entry_t;
-
-typedef struct _dynamic_tls_t
-{
-	int lock;
-	size_t entry_count;
-	_dynamic_tls_entry_t* entries;
-} _dynamic_tls_t;
-
-struct uthread
-{
-	struct uthread* self;
-	void* master_tls_addr;
-	size_t master_tls_size;
-	size_t master_tls_module_count;
-	_dynamic_tls_t* dynamic_tls;
-	_pthread_cleanup_t* cleanup_stack;
-	pthread_t id;
-	int errno_;
-	int cancel_type;
-	int cancel_state;
-	int canceled;
-	// FIXME: make this dynamic
-	uintptr_t dtv[1 + 128];
-};
+#include <bits/types/uthread.h>
 
 #define PTHREAD_CANCELED				(void*)1
 
@@ -103,20 +67,6 @@ struct uthread
 #define _PTHREAD_ATFORK_CHILD   2
 void _pthread_call_atfork(int state);
 
-#if defined(__x86_64__)
-#define _get_uthread() ({ \
-		struct uthread* __tmp; \
-		asm volatile("movq %%fs:0, %0" : "=r"(__tmp)); \
-		__tmp; \
-	})
-#elif defined(__i686__)
-#define _get_uthread() ({ \
-		struct uthread* __tmp; \
-		asm volatile("movl %%gs:0, %0" : "=r"(__tmp)); \
-		__tmp; \
-	})
-#endif
-
 int			pthread_atfork(void (*prepare)(void), void (*parent)(void), void(*child)(void));
 int			pthread_attr_destroy(pthread_attr_t* attr);
 int			pthread_attr_getdetachstate(const pthread_attr_t* attr, int* detachstate);
@@ -159,7 +109,7 @@ int			pthread_condattr_setpshared(pthread_condattr_t* attr, int pshared);
 int			pthread_create(pthread_t* __restrict thread, const pthread_attr_t* __restrict attr, void *(*start_routine)(void*), void* __restrict arg);
 int			pthread_detach(pthread_t thread);
 int			pthread_equal(pthread_t t1, pthread_t t2);
-void		pthread_exit(void* value_ptr);
+void		pthread_exit(void* value_ptr) __attribute__((__noreturn__));
 int			pthread_getconcurrency(void);
 int			pthread_getcpuclockid(pthread_t thread_id, clockid_t* clock_id);
 int			pthread_getschedparam(pthread_t thread, int* __restrict policy, struct sched_param* __restrict param);
@@ -219,6 +169,14 @@ void		pthread_testcancel(void);
 void		pthread_cleanup_pop(int execute);
 void		pthread_cleanup_push(void (*routine)(void*), void* arg);
 
+#define _pthread_testcancel() do { \
+		struct uthread* uthread = _get_uthread(); \
+		if (__builtin_expect(uthread->cancel_state == PTHREAD_CANCEL_ENABLE, 1)) \
+			if (__builtin_expect(uthread->canceled, 0)) \
+				pthread_exit(PTHREAD_CANCELED); \
+	} while (0)
+#define pthread_testcancel() _pthread_testcancel()
+
 __END_DECLS
 
 #endif

userspace/libraries/LibC/include/sched.h

@@ -28,6 +28,8 @@ int sched_setparam(pid_t pid, const struct sched_param* param);
 int sched_setscheduler(pid_t pid, int, const struct sched_param* param);
 int sched_yield(void);
 
+int sched_getcpu(void);
+
 __END_DECLS
 
 #endif

userspace/libraries/LibC/include/string.h

@@ -42,9 +42,11 @@ char*	strndup(const char* s, size_t n);
 size_t	strnlen(const char* s, size_t maxlen);
 char*	strpbrk(const char* s1, const char* s2);
 char*	strrchr(const char* s, int c);
+char*	strsep(char** __restrict stringp, const char* __restrict delim);
 char*	strsignal(int signum);
 size_t	strspn(const char* s1, const char* s2);
 char*	strstr(const char* s1, const char* s2);
+char* 	strcasestr(const char* haystack, const char* needle);
 char*	strtok(char* __restrict s, const char* __restrict sep);
 char*	strtok_r(char* __restrict s, const char* __restrict sep, char** __restrict state);
 size_t	strxfrm(char* __restrict s1, const char* __restrict s2, size_t n);

userspace/libraries/LibC/include/sys/ioctl.h

@@ -5,6 +5,8 @@
 
 __BEGIN_DECLS
 
+#include <stdint.h>
+
 #define I_ATMARK	1
 #define I_CANPUT	2
 #define I_CKBAND	3
@@ -50,6 +52,13 @@ struct winsize
 #define TIOCGWINSZ	50
 #define TIOCSWINSZ	51
 
+struct snd_volume_info
+{
+	int32_t min_mdB;
+	int32_t max_mdB;
+	int32_t step_mdB;
+	int32_t mdB;
+};
 #define SND_GET_CHANNELS    60 /* stores number of channels to uint32_t argument */
 #define SND_GET_SAMPLE_RATE 61 /* stores sample rate to uint32_t argument */
 #define SND_RESET_BUFFER    62 /* stores the size of internal buffer to uint32_t argument and clears the buffer */
@@ -57,12 +66,23 @@ struct winsize
 #define SND_GET_TOTAL_PINS  64 /* gets the number of pins on the current device as uint32_t */
 #define SND_GET_PIN         65 /* gets the currently active pin as uint32_t */
 #define SND_SET_PIN         66 /* sets the currently active pin to uint32_t */
+#define SND_GET_VOLUME_INFO 67 /* gets the current volume as snd_volume_info */
+#define SND_SET_VOLUME_MDB  68 /* sets the current volume to int32_t dB */
 
 #define JOYSTICK_GET_LEDS   80 /* get controller led bitmap to uint8_t argument */
 #define JOYSTICK_SET_LEDS   81 /* set controller leds to uint8_t bitmap */
 #define JOYSTICK_GET_RUMBLE 82 /* get controller rumble strength to uint8_t argument */
 #define JOYSTICK_SET_RUMBLE 83 /* set controller rumble strength to uint8_t argument */
 
+struct fb_msync_region
+{
+	uint32_t min_x;
+	uint32_t min_y;
+	uint32_t max_x;
+	uint32_t max_y;
+};
+#define FB_MSYNC_RECTANGLE 90 /* msync a rectangular area in mmap'd framebuffer device */
+
 int ioctl(int, int, ...);
 
 __END_DECLS

userspace/libraries/LibC/include/unistd.h

@@ -494,6 +494,10 @@ enum
 #define _SC_XOPEN_UUCP _SC_XOPEN_UUCP
 	_SC_XOPEN_VERSION,
 #define _SC_XOPEN_VERSION _SC_XOPEN_VERSION
+	_SC_PHYS_PAGES,
+#define _SC_PHYS_PAGES _SC_PHYS_PAGES
+	_SC_AVPHYS_PAGES,
+#define _SC_AVPHYS_PAGES _SC_AVPHYS_PAGES
 };
 
 #define F_OK 0x01
@@ -604,6 +608,22 @@ char*				getpass(const char* prompt);
 
 long syscall(long syscall, ...);
 
+#ifdef __is_libc
+#include <kernel/API/Syscall.h>
+#include <errno.h>
+#define _syscall(...) ({ \
+		long _ret = -ERESTART; \
+		while (_ret == -ERESTART) \
+			_ret = _kas_syscall(__VA_ARGS__); \
+		if (_ret < 0) { \
+			errno = -_ret; \
+			_ret = -1; \
+		} \
+		_ret; \
+	})
+#define syscall _syscall
+#endif
+
 extern char** environ;
 
 __END_DECLS

userspace/libraries/LibC/math.cpp

@@ -256,7 +256,7 @@ FUNC_EXPR1(nearbyint, BAN::Math::rint(a))
 FUNC_EXPR2(nextafter, nextafter_impl(a, b))
 FUNC_EXPR2_TYPE(nexttoward, long double, nextafter_impl(a, b))
 FUNC_EXPR2(pow, ({ if (isnan(a)) return a; if (isnan(b)) return b; BAN::Math::pow(a, b); }))
-// remainder
+BAN_FUNC2(remainder)
 // remquo
 BAN_FUNC1(rint)
 FUNC_EXPR1(round, ({ if (!isfinite(a)) return a; BAN::Math::round(a); }))

userspace/libraries/LibC/pthread.cpp

@@ -22,7 +22,21 @@ struct pthread_trampoline_info_t
 	void* arg;
 };
 
-static constexpr unsigned rwlock_writer_locked = -1;
+static void _pthread_cancel_handler(int)
+{
+	uthread* uthread = _get_uthread();
+	uthread->canceled = true;
+	if (uthread->cancel_state == PTHREAD_CANCEL_DISABLE)
+		return;
+	if (uthread->cancel_type == PTHREAD_CANCEL_ASYNCHRONOUS)
+		pthread_exit(PTHREAD_CANCELED);
+}
+
+__attribute__((constructor))
+static void _install_main_thread_cancel_handler()
+{
+	signal(SIGCANCEL, &_pthread_cancel_handler);
+}
 
 // stack is 16 byte aligned on entry, this `call` is used to align it
 extern "C" void _pthread_trampoline(void*);
@@ -35,7 +49,6 @@ asm(
 	"call _pthread_trampoline_cpp"
 #elif ARCH(i686)
 "_pthread_trampoline:"
-	"ud2;"
 	"popl %edi;"
 	"andl $-16, %esp;"
 	"xorl %ebp, %ebp;"
@@ -57,6 +70,7 @@ extern "C" void _pthread_trampoline_cpp(void* arg)
 #error
 #endif
 	free(arg);
+	signal(SIGCANCEL, &_pthread_cancel_handler);
 	pthread_exit(info.start_routine(info.arg));
 	ASSERT_NOT_REACHED();
 }
@@ -613,25 +627,8 @@ int pthread_atfork(void (*prepare)(void), void (*parent)(void), void(*child)(voi
 	return 0;
 }
 
-static void pthread_cancel_handler(int)
-{
-	uthread* uthread = _get_uthread();
-	BAN::atomic_store(uthread->canceled, true);
-	if (BAN::atomic_load(uthread->cancel_state) != PTHREAD_CANCEL_ENABLE)
-		return;
-	switch (BAN::atomic_load(uthread->cancel_type))
-	{
-		case PTHREAD_CANCEL_ASYNCHRONOUS:
-			pthread_exit(PTHREAD_CANCELED);
-		case PTHREAD_CANCEL_DEFERRED:
-			return;
-	}
-	ASSERT_NOT_REACHED();
-}
-
 int pthread_cancel(pthread_t thread)
 {
-	signal(SIGCANCEL, &pthread_cancel_handler);
 	return pthread_kill(thread, SIGCANCEL);
 }
 
@@ -669,14 +666,10 @@ int pthread_setcanceltype(int type, int* oldtype)
 	return 0;
 }
 
+#undef pthread_testcancel
 void pthread_testcancel(void)
 {
-	uthread* uthread = _get_uthread();
-	if (BAN::atomic_load(uthread->cancel_state) != PTHREAD_CANCEL_ENABLE)
-		return;
-	if (!BAN::atomic_load(uthread->canceled))
-		return;
-	pthread_exit(PTHREAD_CANCELED);
+	_pthread_testcancel();
 }
 
 int pthread_getschedparam(pthread_t thread, int* __restrict policy, struct sched_param* __restrict param)
@@ -943,102 +936,100 @@ int pthread_rwlock_init(pthread_rwlock_t* __restrict rwlock, const pthread_rwloc
 	if (attr == nullptr)
 		attr = &default_attr;
 	*rwlock = {
-		.attr = *attr,
-		.lockers = 0,
-		.writers = 0,
+		.lock = PTHREAD_MUTEX_INITIALIZER,
+		.cond = PTHREAD_COND_INITIALIZER,
+		.writers_waiting = 0,
+		.writer_active = 0,
+		.readers_active = 0,
 	};
-	return 0;
-}
-
-// TODO: rewrite rwlock with futexes
-
-template<typename T>
-static int pthread_rwlock_timedlock(T* __restrict lock, const struct timespec* __restrict abstime, int (*trylock)(T*))
-{
-	if (trylock(lock) == 0)
-		return 0;
-
-	constexpr auto has_timed_out =
-		[](const struct timespec* abstime) -> bool
-		{
-			struct timespec curtime;
-			clock_gettime(CLOCK_REALTIME, &curtime);
-			if (curtime.tv_sec < abstime->tv_sec)
-				return false;
-			if (curtime.tv_sec > abstime->tv_sec)
-				return true;
-			return curtime.tv_nsec >= abstime->tv_nsec;
+	const pthread_mutexattr_t mattr {
+		.type = PTHREAD_MUTEX_DEFAULT,
+		.shared = attr->shared,
 	};
-
-	while (!has_timed_out(abstime))
-	{
-		if (trylock(lock) == 0)
+	pthread_mutex_init(&rwlock->lock, &mattr);
+	const pthread_condattr_t cattr {
+		.clock = CLOCK_REALTIME,
+		.shared = attr->shared,
+	};
+	pthread_cond_init(&rwlock->cond, &cattr);
 	return 0;
-		sched_yield();
-	}
-
-	return ETIMEDOUT;
 }
 
 int pthread_rwlock_rdlock(pthread_rwlock_t* rwlock)
 {
-	unsigned expected = BAN::atomic_load(rwlock->lockers);
-	for (;;)
-	{
-		if (expected == rwlock_writer_locked || BAN::atomic_load(rwlock->writers))
-			sched_yield();
-		else if (BAN::atomic_compare_exchange(rwlock->lockers, expected, expected + 1))
-			break;
-	}
-	return 0;
+	return pthread_rwlock_timedrdlock(rwlock, nullptr);
 }
 
 int pthread_rwlock_tryrdlock(pthread_rwlock_t* rwlock)
 {
-	unsigned expected = BAN::atomic_load(rwlock->lockers);
-	while (expected != rwlock_writer_locked && BAN::atomic_load(rwlock->writers) == 0)
-		if (BAN::atomic_compare_exchange(rwlock->lockers, expected, expected + 1))
-			return 0;
-	return EBUSY;
+	int ret = 0;
+	pthread_mutex_lock(&rwlock->lock);
+	if (!rwlock->writers_waiting && !rwlock->writer_active)
+		rwlock->readers_active++;
+	else
+		ret = EBUSY;
+	pthread_mutex_unlock(&rwlock->lock);
+	return ret;
 }
 
 int pthread_rwlock_timedrdlock(pthread_rwlock_t* __restrict rwlock, const struct timespec* __restrict abstime)
 {
-	return pthread_rwlock_timedlock(rwlock, abstime, &pthread_rwlock_tryrdlock);
+	int ret = 0;
+	pthread_mutex_lock(&rwlock->lock);
+	while (ret == 0 && (rwlock->writers_waiting || rwlock->writer_active))
+		ret = pthread_cond_timedwait(&rwlock->cond, &rwlock->lock, abstime);
+	if (ret == 0)
+		rwlock->readers_active++;
+	pthread_mutex_unlock(&rwlock->lock);
+	return ret;
 }
 
 int pthread_rwlock_wrlock(pthread_rwlock_t* rwlock)
 {
-	BAN::atomic_add_fetch(rwlock->writers, 1);
-	unsigned expected = 0;
-	while (!BAN::atomic_compare_exchange(rwlock->lockers, expected, rwlock_writer_locked))
-	{
-		sched_yield();
-		expected = 0;
-	}
-	BAN::atomic_sub_fetch(rwlock->writers, 1);
-	return 0;
+	return pthread_rwlock_timedwrlock(rwlock, nullptr);
 }
 
 int pthread_rwlock_trywrlock(pthread_rwlock_t* rwlock)
 {
-	unsigned expected = 0;
-	if (!BAN::atomic_compare_exchange(rwlock->lockers, expected, rwlock_writer_locked))
-		return EBUSY;
-	return 0;
+	int ret = 0;
+	pthread_mutex_lock(&rwlock->lock);
+	if (!rwlock->readers_active && !rwlock->writer_active)
+		rwlock->writer_active = 1;
+	else
+		ret = EBUSY;
+	pthread_mutex_unlock(&rwlock->lock);
+	return ret;
 }
 
 int pthread_rwlock_timedwrlock(pthread_rwlock_t* __restrict rwlock, const struct timespec* __restrict abstime)
 {
-	return pthread_rwlock_timedlock(rwlock, abstime, &pthread_rwlock_trywrlock);
+	int ret = 0;
+	pthread_mutex_lock(&rwlock->lock);
+	rwlock->writers_waiting++;
+	while (ret == 0 && (rwlock->readers_active || rwlock->writer_active))
+		ret = pthread_cond_timedwait(&rwlock->cond, &rwlock->lock, abstime);
+	rwlock->writers_waiting--;
+	if (ret == 0)
+		rwlock->writer_active = 1;
+	pthread_mutex_unlock(&rwlock->lock);
+	return ret;
 }
 
 int pthread_rwlock_unlock(pthread_rwlock_t* rwlock)
 {
-	if (BAN::atomic_load(rwlock->lockers) == rwlock_writer_locked)
-		BAN::atomic_store(rwlock->lockers, 0);
+	pthread_mutex_lock(&rwlock->lock);
+	if (rwlock->writer_active)
+	{
+		rwlock->writer_active = 0;
+		pthread_cond_broadcast(&rwlock->cond);
+	}
 	else
-		BAN::atomic_sub_fetch(rwlock->lockers, 1);
+	{
+		rwlock->readers_active--;
+		if (rwlock->readers_active == 0)
+			pthread_cond_broadcast(&rwlock->cond);
+	}
+	pthread_mutex_unlock(&rwlock->lock);
 	return 0;
 }
 
@@ -1167,16 +1158,14 @@ int pthread_cond_timedwait(pthread_cond_t* __restrict cond, pthread_mutex_t* __r
 
 	pthread_mutex_unlock(mutex);
 
-	while (BAN::atomic_load(block.futex) == 0)
+	int ret = 0;
+	while (ret == 0 && BAN::atomic_load(block.futex) == 0)
 	{
 		const int op = FUTEX_WAIT
 			| (cond->attr.shared ? 0 : FUTEX_PRIVATE)
 			| (cond->attr.clock == CLOCK_REALTIME ? FUTEX_REALTIME : 0);
 		if (futex(op, &block.futex, 0, abstime) == -1 && errno == ETIMEDOUT)
-		{
-			pthread_mutex_lock(mutex);
-			return ETIMEDOUT;
-		}
+			ret = ETIMEDOUT;
 	}
 
 	pthread_spin_lock(&cond->lock);
@@ -1192,7 +1181,7 @@ int pthread_cond_timedwait(pthread_cond_t* __restrict cond, pthread_mutex_t* __r
 	pthread_spin_unlock(&cond->lock);
 
 	pthread_mutex_lock(mutex);
-	return 0;
+	return ret;
 }
 
 int pthread_barrierattr_destroy(pthread_barrierattr_t* attr)
@@ -1245,13 +1234,22 @@ int pthread_barrier_init(pthread_barrier_t* __restrict barrier, const pthread_ba
 	if (attr == nullptr)
 		attr = &default_attr;
 	*barrier = {
-		.attr = *attr,
 		.lock = PTHREAD_MUTEX_INITIALIZER,
 		.cond = PTHREAD_COND_INITIALIZER,
 		.target = count,
 		.waiting = 0,
 		.generation = 0,
 	};
+	const pthread_mutexattr_t mattr {
+		.type = PTHREAD_MUTEX_DEFAULT,
+		.shared = attr->shared,
+	};
+	pthread_mutex_init(&barrier->lock, &mattr);
+	const pthread_condattr_t cattr {
+		.clock = CLOCK_REALTIME,
+		.shared = attr->shared,
+	};
+	pthread_cond_init(&barrier->cond, &cattr);
 	return 0;
 }
 

userspace/libraries/LibC/sched.cpp

@@ -2,6 +2,10 @@
 #include <sys/syscall.h>
 #include <unistd.h>
 
+#include <kernel/API/SharedPage.h>
+
+extern volatile Kernel::API::SharedPage* g_shared_page;
+
 int sched_get_priority_max(int policy)
 {
 	(void)policy;
@@ -18,3 +22,17 @@ int sched_yield(void)
 {
 	return syscall(SYS_YIELD);
 }
+
+int sched_getcpu(void)
+{
+	if (g_shared_page == nullptr)
+		return -1;
+
+	uint8_t cpu;
+#if defined(__x86_64__)
+	asm volatile("movb %%gs:0, %0" : "=r"(cpu));
+#elif defined(__i686__)
+	asm volatile("movb %%fs:0, %0" : "=q"(cpu));
+#endif
+	return cpu;
+}

userspace/libraries/LibC/semaphore.cpp

@@ -49,8 +49,12 @@ int sem_timedwait(sem_t* __restrict sem, const struct timespec* __restrict absti
 	for (;;)
 	{
 		uint32_t expected = BAN::atomic_load(sem->value);
-		if (expected > 0 && BAN::atomic_compare_exchange(sem->value, expected, expected - 1))
+		if (expected > 0)
+		{
+			if (!BAN::atomic_compare_exchange(sem->value, expected, expected - 1))
+				continue;
 			return 0;
+		}
 
 		const int op = FUTEX_WAIT | (sem->shared ? 0 : FUTEX_PRIVATE) | FUTEX_REALTIME;
 		if (futex(op, &sem->value, expected, abstime) == -1 && (errno == EINTR || errno == ETIMEDOUT))

userspace/libraries/LibC/stdio.cpp

@@ -169,7 +169,7 @@ static mode_t parse_mode_string(const char* mode_str)
 		return 0;
 	if (len == 3 && mode_str[1] == mode_str[2])
 		return 0;
-	if (strspn(mode_str + 1, "b+") != len - 1)
+	if (strspn(mode_str + 1, "tb+") != len - 1)
 		return 0;
 	bool plus = (mode_str[1] == '+' || mode_str[2] == '+');
 	switch (mode_str[0])

userspace/libraries/LibC/string.cpp

@@ -274,6 +274,25 @@ char* strrchr(const char* str, int c)
 	return (*str == c) ? (char*)str : nullptr;
 }
 
+char* strsep(char** __restrict stringp, const char* __restrict delim)
+{
+	if (*stringp == nullptr)
+		return nullptr;
+
+	char* original = *stringp;
+
+	char* match = strpbrk(*stringp, delim);
+	if (match == nullptr)
+		*stringp = nullptr;
+	else
+	{
+		*stringp = match + 1;
+		*match = '\0';
+	}
+
+	return original;
+}
+
 char* strstr(const char* haystack, const char* needle)
 {
 	const size_t needle_len = strlen(needle);
@@ -285,6 +304,17 @@ char* strstr(const char* haystack, const char* needle)
 	return nullptr;
 }
 
+char* strcasestr(const char* haystack, const char* needle)
+{
+	const size_t needle_len = strlen(needle);
+	if (needle_len == 0)
+		return const_cast<char*>(haystack);
+	for (size_t i = 0; haystack[i]; i++)
+		if (strncasecmp(haystack + i, needle, needle_len) == 0)
+			return const_cast<char*>(haystack + i);
+	return nullptr;
+}
+
 #define CHAR_UCHAR(ch) \
 	static_cast<unsigned char>(ch)
 

userspace/libraries/LibC/time.cpp

@@ -8,6 +8,7 @@
 #include <errno.h>
 #include <langinfo.h>
 #include <pthread.h>
+#include <stdlib.h>
 #include <string.h>
 #include <sys/syscall.h>
 #include <time.h>
@@ -626,3 +627,91 @@ size_t strftime(char* __restrict s, size_t maxsize, const char* __restrict forma
 	s[len++] = '\0';
 	return len;
 }
+
+static int parse_tm_name(const char* buf, const char** out, int ab, int full, size_t count) {
+    int tm_name = -1;
+    for(size_t i = 0; i < count; ++i) {
+        const char *smol = nl_langinfo(ab + i),
+                   *big = nl_langinfo(full + i);
+
+        size_t smol_len = strlen(smol),
+               big_len = strlen(big);
+        if(strncasecmp(buf, big, big_len) == 0) {
+            buf += big_len;
+            tm_name = i;
+            break;
+        }
+        if(strncasecmp(buf, smol, smol_len) == 0) {
+            buf += smol_len;
+            tm_name = i;
+            break;
+        }
+    }
+    *out = buf;
+    return tm_name;
+}
+
+char* strptime(const char* buf, const char* format, struct tm* tm) {
+    for(;;) {
+        while(*format && *format != '%') {
+            if(isspace(*format)) {
+                while(isspace(*buf)) buf++;
+                format++;
+            } else if(*buf++ != *format++) return NULL;
+        }
+        if(*format == '\0') break;
+        format++;
+        char fmt_chr = *format++;
+        switch(fmt_chr) {
+        case '%': if(*buf != '%') return NULL; break;
+        case 'a': case 'A': {
+            int day = parse_tm_name(buf, &buf, ABDAY_1, DAY_1, 7);
+            if(day == -1) return NULL;
+            tm->tm_wday = day;
+        } break;
+        case 'b': case 'B': case 'h': {
+            int mon = parse_tm_name(buf, &buf, ABMON_1, MON_1, 12);
+            if(mon == -1) return NULL;
+            tm->tm_mon = mon;
+        } break;
+        case 'd': case 'e': {
+            errno = 0;
+            long day = strtol(buf, (char**)&buf, 10);
+            if(errno) return NULL;
+            if(day < 1 || day > 31) return NULL;
+            tm->tm_mday = day;
+        } break;
+        case 'Y': {
+            errno = 0;
+            long year = strtol(buf, (char**)&buf, 10);
+            if(errno) return NULL;
+            tm->tm_year = year - 1900;
+        } break;
+        case 'H': {
+            errno = 0;
+            long hour = strtol(buf, (char**)&buf, 10);
+            if(errno) return NULL;
+            if(hour < 0 || hour > 23) return NULL;
+            tm->tm_hour = hour;
+        } break;
+        case 'M': {
+            errno = 0;
+            long minute = strtol(buf, (char**)&buf, 10);
+            if(errno) return NULL;
+            if(minute < 0 || minute > 59) return NULL;
+            tm->tm_min = minute;
+        } break;
+        case 'S': {
+            errno = 0;
+            long sec = strtol(buf, (char**)&buf, 10);
+            if(errno) return NULL;
+            if(sec < 0 || sec > 60) return NULL;
+            tm->tm_sec = sec;
+        } break;
+        default:
+            derrorln("TODO: strptime fmt {}", fmt_chr);
+            ASSERT_NOT_REACHED();
+        }
+    }
+    return (char*)buf;
+}

userspace/libraries/LibC/unistd.cpp

@@ -19,6 +19,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/banan-os.h>
 #include <sys/stat.h>
 #include <sys/syscall.h>
 #include <sys/time.h>
@@ -192,7 +193,7 @@ static void __dump_symbol(int fd, const void* address)
 #endif
 }
 
-static void __dump_backtrace(int sig, siginfo_t* info, void* context)
+static void __dump_backtrace(int sig, siginfo_t*, void* context)
 {
 	constexpr auto signal_name =
 		[](int signal) -> const char*
@@ -207,6 +208,23 @@ static void __dump_backtrace(int sig, siginfo_t* info, void* context)
 			return "unknown signal";
 		};
 
+	const auto* ucontext = static_cast<ucontext_t*>(context);
+#if defined(__x86_64__)
+	const uintptr_t stack_base = ucontext->uc_mcontext.gregs[REG_RBP];
+	const uintptr_t instruction = ucontext->uc_mcontext.gregs[REG_RIP];
+#elif defined(__i686__)
+	const uintptr_t stack_base = ucontext->uc_mcontext.gregs[REG_EBP];
+	const uintptr_t instruction = ucontext->uc_mcontext.gregs[REG_EIP];
+#endif
+
+	struct stackframe
+	{
+		const stackframe* bp;
+		void* ip;
+	};
+
+	const auto* stackframe = reinterpret_cast<struct stackframe*>(stack_base);
+
 	// NOTE: we cannot use stddbf as that is not async-signal-safe.
 	//       POSIX says dprintf isn't either but our implementation is!
 
@@ -219,23 +237,7 @@ static void __dump_backtrace(int sig, siginfo_t* info, void* context)
 
 	dprintf(fd, "received %s, backtrace:\n", signal_name(sig));
 
-	__dump_symbol(fd, info->si_addr);
-
-	struct stackframe
-	{
-		const stackframe* bp;
-		void* ip;
-	};
-
-	const auto* ucontext = static_cast<ucontext_t*>(context);
-#if defined(__x86_64__)
-	const uintptr_t stack_base = ucontext->uc_mcontext.gregs[REG_RBP];
-#elif defined(__i686__)
-	const uintptr_t stack_base = ucontext->uc_mcontext.gregs[REG_EBP];
-#endif
-
-	const auto* stackframe = reinterpret_cast<struct stackframe*>(stack_base);
-
+	__dump_symbol(fd, reinterpret_cast<void*>(instruction));
 	for (size_t i = 0; i < 128 && stackframe; i++)
 	{
 		__dump_symbol(fd, stackframe->ip);
@@ -253,32 +255,21 @@ void _exit(int status)
 	ASSERT_NOT_REACHED();
 }
 
+#undef syscall
 long syscall(long syscall, ...)
 {
 	va_list args;
 	va_start(args, syscall);
-
 	uintptr_t arg1 = va_arg(args, uintptr_t);
 	uintptr_t arg2 = va_arg(args, uintptr_t);
 	uintptr_t arg3 = va_arg(args, uintptr_t);
 	uintptr_t arg4 = va_arg(args, uintptr_t);
 	uintptr_t arg5 = va_arg(args, uintptr_t);
-
 	va_end(args);
 
-	long ret;
-	do
-		ret = Kernel::syscall(syscall, arg1, arg2, arg3, arg4, arg5);
-	while (ret == -ERESTART);
-
-	if (ret < 0)
-	{
-		errno = -ret;
-		return -1;
-	}
-
-	return ret;
+	return _syscall(syscall, arg1, arg2, arg3, arg4, arg5);
 }
+#define syscall _syscall
 
 int close(int fd)
 {
@@ -1180,6 +1171,25 @@ long sysconf(int name)
 		case _SC_GETGR_R_SIZE_MAX: return 1024;
 		case _SC_GETPW_R_SIZE_MAX: return 1024;
 		case _SC_THREAD_STACK_MIN: return PTHREAD_STACK_MIN;
+
+		case _SC_PHYS_PAGES:
+		case _SC_AVPHYS_PAGES:
+		{
+			int fd = open("/proc/meminfo", O_RDONLY);
+			if (fd == -1)
+				return -1;
+
+			full_meminfo_t meminfo;
+			const size_t nread = read(fd, &meminfo, sizeof(meminfo));
+			close(fd);
+
+			if (nread != sizeof(meminfo))
+				return -1;
+			if (name == _SC_PHYS_PAGES)
+				return meminfo.free_pages + meminfo.used_pages;
+			if (name == _SC_AVPHYS_PAGES)
+				return meminfo.free_pages;
+		}
 	}
 
 	errno = EINVAL;

userspace/libraries/LibC/wchar.cpp

@@ -24,10 +24,17 @@ int wcwidth(wchar_t wc)
 	return wc != '\0';
 }
 
+int mbsinit(const mbstate_t* ps)
+{
+	(void)ps;
+	return 1;
+}
+
 wchar_t* wcstok(wchar_t* __restrict, const wchar_t* __restrict, wchar_t** __restrict) { ASSERT_NOT_REACHED(); }
 long wcstol(const wchar_t* __restrict, wchar_t** __restrict, int) { ASSERT_NOT_REACHED(); }
 unsigned long wcstoul(const wchar_t* __restrict, wchar_t** __restrict, int) { ASSERT_NOT_REACHED(); }
 int swprintf(wchar_t* __restrict, size_t, const wchar_t* __restrict, ...) { ASSERT_NOT_REACHED(); }
+size_t wcsrtombs(char* __restrict, const wchar_t** __restrict, size_t, mbstate_t* __restrict) { ASSERT_NOT_REACHED(); }
 
 size_t wcrtomb(char* __restrict s, wchar_t ws, mbstate_t* __restrict ps)
 {

userspace/libraries/LibDEFLATE/Decompressor.cpp

@@ -1,5 +1,6 @@
 #include <LibDEFLATE/Decompressor.h>
 #include <LibDEFLATE/Utils.h>
+#include <BAN/ScopeGuard.h>
 
 namespace LibDEFLATE
 {
@@ -21,6 +22,26 @@ namespace LibDEFLATE
 		};
 	};
 
+	struct crc32_table_t
+	{
+		consteval crc32_table_t()
+		{
+			for (uint32_t i = 0; i < 256; i++)
+			{
+				uint32_t crc32 = i;
+				for (size_t j = 0; j < 8; j++) {
+					if (crc32 & 1)
+						crc32 = (crc32 >> 1) ^ 0xEDB88320;
+					else
+						crc32 >>= 1;
+				}
+				table[i] = crc32;
+			}
+		}
+		uint32_t table[256];
+	};
+	static constexpr crc32_table_t s_crc32_table;
+
 	BAN::ErrorOr<uint16_t> Decompressor::read_symbol(const HuffmanTree& tree)
 	{
 		const uint8_t instant_bits = tree.instant_bits();
@@ -46,57 +67,6 @@ namespace LibDEFLATE
 		return BAN::Error::from_errno(EINVAL);
 	}
 
-	BAN::ErrorOr<void> Decompressor::inflate_block(const HuffmanTree& length_tree, const HuffmanTree& distance_tree)
-	{
-		uint16_t symbol;
-		while ((symbol = TRY(read_symbol(length_tree))) != 256)
-		{
-			if (symbol < 256)
-			{
-				TRY(m_output.push_back(symbol));
-				continue;
-			}
-
-			constexpr uint16_t length_base[] {
-				3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258
-			};
-			constexpr uint8_t length_extra_bits[] {
-				0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
-			};
-
-			constexpr uint16_t distance_base[] {
-				1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577
-			};
-			constexpr uint8_t distance_extra_bits[] {
-				0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13
-			};
-
-			if (symbol > 285)
-				return BAN::Error::from_errno(EINVAL);
-			symbol -= 257;
-
-			const uint16_t length = length_base[symbol] + TRY(m_stream.take_bits(length_extra_bits[symbol]));
-
-			uint16_t distance_code;
-			if (distance_tree.empty())
-				distance_code = reverse_bits(TRY(m_stream.take_bits(5)), 5);
-			else
-				distance_code = TRY(read_symbol(distance_tree));
-			if (distance_code > 29)
-				return BAN::Error::from_errno(EINVAL);
-
-			const uint16_t distance = distance_base[distance_code] + TRY(m_stream.take_bits(distance_extra_bits[distance_code]));
-
-			const size_t orig_size = m_output.size();
-			const size_t offset = orig_size - distance;
-			TRY(m_output.resize(orig_size + length));
-			for (size_t i = 0; i < length; i++)
-				m_output[orig_size + i] = m_output[offset + i];
-		}
-
-		return {};
-	}
-
 	BAN::ErrorOr<void> Decompressor::handle_header()
 	{
 		switch (m_type)
@@ -127,6 +97,12 @@ namespace LibDEFLATE
 					TRY(m_stream.take_bits(16));
 				}
 
+				m_stream_info.zlib = {
+					.s1 = 1,
+					.s2 = 0,
+					.adler32 = 0,
+				};
+
 				return {};
 			}
 			case StreamType::GZip:
@@ -179,6 +155,11 @@ namespace LibDEFLATE
 				if (flg & (1 << 1))
 					TRY(m_stream.take_bits(16));
 
+				m_stream_info.gzip = {
+					.crc32 = 0xFFFFFFFF,
+					.isize = 0,
+				};
+
 				return {};
 			}
 		}
@@ -200,9 +181,12 @@ namespace LibDEFLATE
 				for (size_t i = 0; i < 4; i++)
 					adler32 = (adler32 << 8) | TRY(m_stream.take_bits(8));
 
-				if (adler32 != calculate_adler32(m_output.span()))
+				auto& zlib = m_stream_info.zlib;
+				zlib.adler32 = (zlib.s2 << 16) | zlib.s1;
+
+				if (adler32 != zlib.adler32)
 				{
-					dwarnln("zlib final adler32 checksum failed");
+					dwarnln("zlib final adler32 checksum failed {8h} vs {8h}", adler32, zlib.adler32);
 					return BAN::Error::from_errno(EINVAL);
 				}
 
@@ -212,13 +196,16 @@ namespace LibDEFLATE
 			{
 				m_stream.skip_to_byte_boundary();
 
+				auto& gzip = m_stream_info.gzip;
+				gzip.crc32 ^= 0xFFFFFFFF;
+
 				const uint32_t crc32 =
 					static_cast<uint32_t>(TRY(m_stream.take_bits(16))) |
 					static_cast<uint32_t>(TRY(m_stream.take_bits(16))) << 16;
 
-				if (crc32 != calculate_crc32(m_output.span()))
+				if (crc32 != gzip.crc32)
 				{
-					dwarnln("gzip final crc32 checksum failed");
+					dwarnln("gzip final crc32 checksum failed {8h} vs {8h}", crc32, gzip.crc32);
 					return BAN::Error::from_errno(EINVAL);
 				}
 
@@ -226,9 +213,9 @@ namespace LibDEFLATE
 					static_cast<uint32_t>(TRY(m_stream.take_bits(16))) |
 					static_cast<uint32_t>(TRY(m_stream.take_bits(16))) << 16;
 
-				if (isize != m_output.size() % UINT32_MAX)
+				if (isize != gzip.isize)
 				{
-					dwarnln("gzip final isize does not match {} vs {}", isize, m_output.size());
+					dwarnln("gzip final isize does not match {} vs {}", isize, gzip.isize);
 					return BAN::Error::from_errno(EINVAL);
 				}
 
@@ -239,30 +226,7 @@ namespace LibDEFLATE
 		ASSERT_NOT_REACHED();
 	}
 
-	BAN::ErrorOr<void> Decompressor::decompress_type0()
-	{
-		m_stream.skip_to_byte_boundary();
-		const uint16_t len = TRY(m_stream.take_bits(16));
-		const uint16_t nlen = TRY(m_stream.take_bits(16));
-		if (len != 0xFFFF - nlen)
-			return BAN::Error::from_errno(EINVAL);
-
-		const size_t orig_size = m_output.size();
-		TRY(m_output.resize(orig_size + len));
-		TRY(m_stream.take_byte_aligned(&m_output[orig_size], len));
-
-		return {};
-	}
-
-	BAN::ErrorOr<void> Decompressor::decompress_type1()
-	{
-		if (!m_fixed_tree.has_value())
-			m_fixed_tree = TRY(HuffmanTree::fixed_tree());
-		TRY(inflate_block(m_fixed_tree.value(), {}));
-		return {};
-	}
-
-	BAN::ErrorOr<void> Decompressor::decompress_type2()
+	BAN::ErrorOr<void> Decompressor::handle_dynamic_header()
 	{
 		constexpr uint8_t code_length_order[] {
 			16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
@@ -315,41 +279,412 @@ namespace LibDEFLATE
 			last_symbol = symbol;
 		}
 
-		TRY(inflate_block(
-			TRY(HuffmanTree::create({ bit_lengths,        hlit  })),
-			TRY(HuffmanTree::create({ bit_lengths + hlit, hdist }))
-		));
+		m_length_tree   = TRY(HuffmanTree::create({ bit_lengths,        hlit  }));
+		m_distance_tree = TRY(HuffmanTree::create({ bit_lengths + hlit, hdist }));
 
 		return {};
 	}
 
-	BAN::ErrorOr<BAN::Vector<uint8_t>> Decompressor::decompress()
+	BAN::ErrorOr<void> Decompressor::handle_symbol()
 	{
-		TRY(handle_header());
+		uint16_t symbol = TRY(read_symbol(m_length_tree));
+		if (symbol == 256)
+		{
+			m_state = State::BlockHeader;
+			return {};
+		}
 
-		bool bfinal = false;
-		while (!bfinal)
+		if (symbol < 256)
 		{
-			bfinal = TRY(m_stream.take_bits(1));
-			switch (TRY(m_stream.take_bits(2)))
+			m_window[(m_window_tail + m_window_size) % total_window_size] = symbol;
+
+			m_produced_bytes++;
+			if (m_window_size < total_window_size)
+				m_window_size++;
+			else
+				m_window_tail = (m_window_tail + 1) % total_window_size;
+
+			return {};
+		}
+
+		constexpr uint16_t length_base[] {
+			3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258
+		};
+		constexpr uint8_t length_extra_bits[] {
+			0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
+		};
+
+		constexpr uint16_t distance_base[] {
+			1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577
+		};
+		constexpr uint8_t distance_extra_bits[] {
+			0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13
+		};
+
+		if (symbol > 285)
+			return BAN::Error::from_errno(EINVAL);
+		symbol -= 257;
+
+		const uint16_t length = length_base[symbol] + TRY(m_stream.take_bits(length_extra_bits[symbol]));
+
+		uint16_t distance_code;
+		if (m_distance_tree.empty())
+			distance_code = reverse_bits(TRY(m_stream.take_bits(5)), 5);
+		else
+			distance_code = TRY(read_symbol(m_distance_tree));
+		if (distance_code > 29)
+			return BAN::Error::from_errno(EINVAL);
+
+		const uint16_t distance = distance_base[distance_code] + TRY(m_stream.take_bits(distance_extra_bits[distance_code]));
+		if (distance > m_window_size)
+			return BAN::Error::from_errno(EINVAL);
+
+		const size_t offset = m_window_size - distance;
+		for (size_t i = 0; i < length; i++)
+			m_window[(m_window_tail + m_window_size + i) % total_window_size] = m_window[(m_window_tail + offset + i) % total_window_size];
+
+		m_window_size += length;
+		m_produced_bytes += length;
+		if (m_window_size > total_window_size)
+		{
+			const size_t extra = m_window_size - total_window_size;
+			m_window_tail = (m_window_tail + extra) % total_window_size;
+			m_window_size = total_window_size;
+		}
+
+		return {};
+	}
+
+	void Decompressor::write_data_to_output(BAN::ByteSpan& output)
+	{
+		if (m_produced_bytes == 0)
+			return;
+
+		ASSERT(m_produced_bytes <= m_window_size);
+
+		const size_t unwritten_tail = (m_window_tail + m_window_size - m_produced_bytes) % total_window_size;
+
+		const size_t to_write = BAN::Math::min(output.size(), m_produced_bytes);
+
+		const size_t before_wrap = BAN::Math::min(total_window_size - unwritten_tail, to_write);
+		memcpy(output.data(), m_window.data() + unwritten_tail, before_wrap);
+		if (const size_t after_wrap = to_write - before_wrap)
+			memcpy(output.data() + before_wrap, m_window.data(), after_wrap);
+
+		switch (m_type)
+		{
+			case StreamType::Raw:
+				break;
+			case StreamType::Zlib:
+			{
+				auto& zlib = m_stream_info.zlib;
+				for (size_t i = 0; i < to_write; i++)
+				{
+					zlib.s1 = (zlib.s1 + output[i]) % 65521;
+					zlib.s2 = (zlib.s2 + zlib.s1)   % 65521;
+				}
+				break;
+			}
+			case StreamType::GZip:
+			{
+				auto& gzip = m_stream_info.gzip;
+				gzip.isize += to_write;
+				for (size_t i = 0; i < to_write; i++)
+					gzip.crc32 = (gzip.crc32 >> 8) ^ s_crc32_table.table[(gzip.crc32 ^ output[i]) & 0xFF];
+				break;
+			}
+		}
+
+		m_produced_bytes -= to_write;
+		output = output.slice(to_write);
+	}
+
+	BAN::ErrorOr<BAN::Vector<uint8_t>> Decompressor::decompress(BAN::ConstByteSpan input)
+	{
+		BAN::Vector<uint8_t> full_output;
+		TRY(full_output.resize(2 * input.size()));
+
+		size_t total_output_size { 0 };
+		for (;;)
+		{
+			size_t input_consumed, output_produced;
+			const auto status = TRY(decompress(input, input_consumed, full_output.span().slice(total_output_size), output_produced));
+			input = input.slice(input_consumed);
+			total_output_size += output_produced;
+
+			switch (status)
+			{
+				case Status::Done:
+					TRY(full_output.resize(total_output_size));
+					(void)full_output.shrink_to_fit();
+					return full_output;
+				case Status::NeedMoreOutput:
+					TRY(full_output.resize(full_output.size() * 2));
+					break;
+				case Status::NeedMoreInput:
+					return BAN::Error::from_errno(EINVAL);
+			}
+		}
+	}
+
+	BAN::ErrorOr<BAN::Vector<uint8_t>> Decompressor::decompress(BAN::Span<const BAN::ConstByteSpan> input)
+	{
+		size_t total_input_size = 0;
+		for (const auto& buffer : input)
+			total_input_size += buffer.size();
+
+		BAN::Vector<uint8_t> full_output;
+		TRY(full_output.resize(2 * total_input_size));
+
+		BAN::Vector<uint8_t> input_buffer;
+		TRY(input_buffer.resize(BAN::Math::min<size_t>(32 * 1024, total_input_size)));
+
+		size_t input_buffer_index = 0;
+		size_t input_buffer_size = 0;
+
+		const auto append_input_data =
+			[&]() -> bool
+			{
+				bool did_append = false;
+				while (!input.empty() && input_buffer_size < input_buffer.size())
+				{
+					if (input_buffer_index >= input[0].size())
+					{
+						input_buffer_index = 0;
+						input = input.slice(1);
+						continue;
+					}
+
+					const size_t to_copy = BAN::Math::min(input[0].size() - input_buffer_index, input_buffer.size() - input_buffer_size);
+					memcpy(input_buffer.data() + input_buffer_size, input[0].data() + input_buffer_index, to_copy);
+					input_buffer_size += to_copy;
+					input_buffer_index += to_copy;
+					did_append = true;
+				}
+				return did_append;
+			};
+
+		append_input_data();
+
+		size_t total_output_size = 0;
+		for (;;)
+		{
+			size_t input_consumed, output_produced;
+			const auto status = TRY(decompress(
+				input_buffer.span().slice(0, input_buffer_size),
+				input_consumed,
+				full_output.span().slice(total_output_size),
+				output_produced
+			));
+
+			if (input_consumed)
+			{
+				memmove(input_buffer.data(), input_buffer.data() + input_consumed, input_buffer_size - input_consumed);
+				input_buffer_size -= input_consumed;
+			}
+
+			total_output_size += output_produced;
+
+			switch (status)
+			{
+				case Status::Done:
+					TRY(full_output.resize(total_output_size));
+					(void)full_output.shrink_to_fit();
+					return full_output;
+				case Status::NeedMoreOutput:
+					TRY(full_output.resize(full_output.size() * 2));
+					break;
+				case Status::NeedMoreInput:
+					if (!append_input_data())
+						return BAN::Error::from_errno(EINVAL);
+					break;
+			}
+		}
+	}
+
+	BAN::ErrorOr<Decompressor::Status> Decompressor::decompress(BAN::ConstByteSpan input, size_t& input_consumed, BAN::ByteSpan output, size_t& output_produced)
+	{
+		const size_t original_input_size = input.size();
+		const size_t original_output_size = output.size();
+		BAN::ScopeGuard _([&] {
+			input_consumed = original_input_size - m_stream.unprocessed_bytes();
+			output_produced = original_output_size - output.size();
+			m_stream.drop_unprocessed_data();
+		});
+
+		m_stream.set_data(input);
+
+		if (m_window.empty())
+			TRY(m_window.resize(total_window_size));
+
+		write_data_to_output(output);
+		if (m_produced_bytes > 0)
+			return Status::NeedMoreOutput;
+
+		while (m_state != State::Done)
+		{
+			bool need_more_input = false;
+			bool restore_saved_stream = false;
+
+			auto saved_stream = m_stream;
+
+			switch (m_state)
+			{
+				case State::Done:
+					ASSERT_NOT_REACHED();
+				case State::StreamHeader:
+				{
+					if (auto ret = handle_header(); !ret.is_error())
+						m_state = State::BlockHeader;
+					else
+					{
+						if (ret.error().get_error_code() != ENOBUFS)
+							return ret.release_error();
+						need_more_input = true;
+						restore_saved_stream = true;
+					}
+					break;
+				}
+				case State::StreamFooter:
+				{
+					if (auto ret = handle_footer(); !ret.is_error())
+						m_state = State::Done;
+					else
+					{
+						if (ret.error().get_error_code() != ENOBUFS)
+							return ret.release_error();
+						need_more_input = true;
+						restore_saved_stream = true;
+					}
+					break;
+				}
+				case State::BlockHeader:
+				{
+					if (m_bfinal)
+					{
+						m_state = State::StreamFooter;
+						break;
+					}
+
+					if (m_stream.available_bits() < 3)
+					{
+						need_more_input = true;
+						break;
+					}
+
+					m_bfinal = MUST(m_stream.take_bits(1));
+					switch (MUST(m_stream.take_bits(2)))
 					{
 						case 0b00:
-					TRY(decompress_type0());
+							m_state = State::LiteralHeader;
 							break;
 						case 0b01:
-					TRY(decompress_type1());
+							m_length_tree = TRY(HuffmanTree::fixed_tree());
+							m_distance_tree = {};
+							m_state = State::Symbol;
 							break;
 						case 0b10:
-					TRY(decompress_type2());
+							m_state = State::DynamicHeader;
 							break;
 						default:
 							return BAN::Error::from_errno(EINVAL);
 					}
+
+					break;
+				}
+				case State::LiteralHeader:
+				{
+					if (m_stream.available_bytes() < 4)
+					{
+						need_more_input = true;
+						break;
 					}
 
-		TRY(handle_footer());
+					m_stream.skip_to_byte_boundary();
+					const uint16_t len = MUST(m_stream.take_bits(16));
+					const uint16_t nlen = MUST(m_stream.take_bits(16));
+					if (len != 0xFFFF - nlen)
+						return BAN::Error::from_errno(EINVAL);
 
-		return BAN::move(m_output);
+					m_raw_bytes_left = len;
+					m_state = State::ReadRaw;
+					break;
+				}
+				case State::DynamicHeader:
+				{
+					if (auto ret = handle_dynamic_header(); !ret.is_error())
+						m_state = State::Symbol;
+					else
+					{
+						if (ret.error().get_error_code() != ENOBUFS)
+							return ret.release_error();
+						need_more_input = true;
+						restore_saved_stream = true;
+					}
+					break;
+				}
+				case State::ReadRaw:
+				{
+					const size_t window_head = (m_window_tail + m_window_size) % total_window_size;
+
+					// FIXME: m_raw_bytes_left can be up to 64KB
+					const size_t max_bytes_to_read = BAN::Math::min<size_t>(m_raw_bytes_left, total_window_size);
+
+					const size_t can_read = BAN::Math::min(max_bytes_to_read, m_stream.available_bytes());
+					const size_t before_wrap = BAN::Math::min(total_window_size - window_head, can_read);
+					MUST(m_stream.take_byte_aligned(BAN::ByteSpan(m_window.span()).slice(window_head, before_wrap)));
+					if (const size_t after_wrap = can_read - before_wrap)
+						MUST(m_stream.take_byte_aligned(BAN::ByteSpan(m_window.span()).slice(0, after_wrap)));
+
+					m_window_size += can_read;
+					m_produced_bytes += can_read;
+					if (m_window_size > total_window_size)
+					{
+						const size_t extra = m_window_size - total_window_size;
+						m_window_tail = (m_window_tail + extra) % total_window_size;
+						m_window_size = total_window_size;
+					}
+
+					m_raw_bytes_left -= can_read;
+
+					if (m_raw_bytes_left == 0)
+						m_state = State::BlockHeader;
+					else if (m_stream.available_bytes() == 0)
+						need_more_input = true;
+
+					break;
+				}
+				case State::Symbol:
+				{
+					while (m_produced_bytes + 258 < total_window_size && m_state == State::Symbol)
+					{
+						saved_stream = m_stream;
+						if (auto ret = handle_symbol(); ret.is_error())
+						{
+							if (ret.error().get_error_code() != ENOBUFS)
+								return ret.release_error();
+							need_more_input = true;
+							restore_saved_stream = true;
+							break;
+						}
+					}
+					break;
+				}
+			}
+
+			if (need_more_input)
+			{
+				if (restore_saved_stream)
+					m_stream = saved_stream;
+				return Status::NeedMoreInput;
+			}
+
+			write_data_to_output(output);
+			if (m_produced_bytes > 0)
+				return Status::NeedMoreOutput;
+		}
+
+		return Status::Done;
 	}
 
 }

userspace/libraries/LibDEFLATE/include/LibDEFLATE/BitStream.h

@@ -1,7 +1,9 @@
 #pragma once
 
-#include <BAN/Vector.h>
 #include <BAN/ByteSpan.h>
+#include <BAN/Vector.h>
+
+#include <string.h>
 
 namespace LibDEFLATE
 {
@@ -9,6 +11,7 @@ namespace LibDEFLATE
 	class BitInputStream
 	{
 	public:
+		BitInputStream() = default;
 		BitInputStream(BAN::ConstByteSpan data)
 			: m_data(data)
 		{ }
@@ -37,22 +40,24 @@ namespace LibDEFLATE
 			return result;
 		}
 
-		BAN::ErrorOr<void> take_byte_aligned(uint8_t* output, size_t bytes)
+		BAN::ErrorOr<void> take_byte_aligned(BAN::ByteSpan output)
 		{
-			ASSERT(m_bit_buffer % 8 == 0);
+			ASSERT(m_bit_buffer_len % 8 == 0);
 
-			while (m_bit_buffer_len && bytes)
+			while (m_bit_buffer_len && !output.empty())
 			{
-				*output++ = m_bit_buffer;
+				output[0] = m_bit_buffer;
 				m_bit_buffer >>= 8;
 				m_bit_buffer_len -= 8;
-				bytes--;
+				output = output.slice(1);
 			}
 
-			if (bytes > m_data.size())
-				return BAN::Error::from_errno(EINVAL);
-			memcpy(output, m_data.data(), bytes);
-			m_data = m_data.slice(bytes);
+			if (m_data.size() < output.size())
+				return BAN::Error::from_errno(ENOBUFS);
+
+			memcpy(output.data(), m_data.data(), output.size());
+
+			m_data = m_data.slice(output.size());
 
 			return {};
 		}
@@ -64,10 +69,35 @@ namespace LibDEFLATE
 			m_bit_buffer_len -= bits_to_remove;
 		}
 
+		size_t available_bits() const
+		{
+			return unprocessed_bytes() * 8 + m_bit_buffer_len;
+		}
+
+		size_t available_bytes() const
+		{
+			return unprocessed_bytes() + m_bit_buffer_len / 8;
+		}
+
+		size_t unprocessed_bytes() const
+		{
+			return m_data.size();
+		}
+
+		void set_data(BAN::ConstByteSpan data)
+		{
+			m_data = data;
+		}
+
+		void drop_unprocessed_data()
+		{
+			m_data = {};
+		}
+
 	private:
 		BAN::ConstByteSpan m_data;
 		uint32_t m_bit_buffer { 0 };
-		uint8_t m_bit_buffer_len { 0 };
+		uint32_t m_bit_buffer_len { 0 };
 	};
 
 	class BitOutputStream