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__)

kernel/CMakeLists.txt

@@ -168,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);
+		invalidate_range(vaddr, page_count, true);
+	}
 
-		Processor::broadcast_smp_message({
-			.type = Processor::SMPMessage::Type::FlushTLB,
-			.flush_tlb = {
-				.vaddr      = vaddr,
-				.page_count = page_count,
-				.page_table = vaddr < KERNEL_OFFSET ? this : nullptr,
+	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,48 +605,47 @@ 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))
-					{
-						vaddr_t vaddr = 0;
-						vaddr |= (vaddr_t)pdpte << 30;
-						vaddr |= (vaddr_t)pde   << 21;
-						vaddr |= (vaddr_t)pte   << 12;
-						ASSERT(reserve_page(vaddr));
-						return vaddr;
-					}
+					if (pt[pte] & Flags::Used)
+						continue;
+					vaddr_t vaddr = 0;
+					vaddr |= (vaddr_t)pdpte << 30;
+					vaddr |= (vaddr_t)pde   << 21;
+					vaddr |= (vaddr_t)pte   << 12;
+					ASSERT(reserve_page(vaddr));
+					return vaddr;
 				}
+				pte = 0;
 			}
+			pde = 0;
 		}
 
 		// Find any free page
@@ -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/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);
+		invalidate_range(vaddr, page_count, true);
+	}
 
-		Processor::broadcast_smp_message({
-			.type = Processor::SMPMessage::Type::FlushTLB,
-			.flush_tlb = {
-				.vaddr      = vaddr,
-				.page_count = page_count,
-				.page_table = vaddr < KERNEL_OFFSET ? this : nullptr,
+	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;
 	}
 
@@ -868,7 +938,7 @@ namespace Kernel
 		ASSERT(is_canonical(first_address));
 		ASSERT(is_canonical(last_address - 1));
 		const vaddr_t uc_vaddr_start = uncanonicalize(first_address);
-		const vaddr_t uc_vaddr_end   = uncanonicalize(last_address);
+		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,22 +976,24 @@ 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))
-						{
-							vaddr_t vaddr = 0;
-							vaddr |= static_cast<uint64_t>(pml4e) << 39;
-							vaddr |= static_cast<uint64_t>(pdpte) << 30;
-							vaddr |= static_cast<uint64_t>(pde)   << 21;
-							vaddr |= static_cast<uint64_t>(pte)   << 12;
-							vaddr = canonicalize(vaddr);
-							ASSERT(reserve_page(vaddr));
-							return vaddr;
-						}
+						if (pt[pte] & Flags::Used)
+							continue;
+						vaddr_t vaddr = 0;
+						vaddr |= static_cast<uint64_t>(pml4e) << 39;
+						vaddr |= static_cast<uint64_t>(pdpte) << 30;
+						vaddr |= static_cast<uint64_t>(pde)   << 21;
+						vaddr |= static_cast<uint64_t>(pte)   << 12;
+						vaddr = canonicalize(vaddr);
+						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)
@@ -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/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/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/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/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,94 +1,262 @@
 #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 m_data_size;
+		}
+
+		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;
+
+			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);
+				});
+				m_data_size += to_copy;
+				m_offset += to_copy;
+			}
+
+			return true;
+		}
+
+		uint64_t bytes_consumed() const override
+		{
+			return bytes_produced();
+		}
+
+	private:
+		const BootModule& m_module;
+		size_t m_offset { 0 };
+	};
+
+	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;
 		}
 
-		if (module.size < 512)
-			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" : ""
+		);
 
-		bool has_ustar_signature;
-		PageTable::with_fast_page(module.start, [&] {
-			has_ustar_signature = memcmp(PageTable::fast_page_as_ptr(257), "ustar", 5) == 0;
-		});
+		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();
 
-		return has_ustar_signature;
+		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_filesystem(BAN::RefPtr<FileSystem> filesystem, const BootModule& module)
+	BAN::ErrorOr<void> unpack_boot_module_into_directory(BAN::RefPtr<Inode> root_inode, DataSource& data_source)
 	{
-		ASSERT(is_ustar_boot_module(module));
-
-		auto root_inode = filesystem->root_inode();
-
-		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); });
-
 		BAN::String next_file_name;
 		BAN::String next_link_name;
 
-		size_t offset = 0;
-		while (offset + 512 <= module.size)
+		constexpr uint32_t print_interval_ms = 1000;
+		auto next_print_ms = SystemTimer::get().ms_since_boot() + print_interval_ms;
+
+		while (TRY(data_source.produce_data()), data_source.data_size() >= 512)
 		{
-			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] {};
-
-			PageTable::with_fast_page((module.start + offset) & PAGE_ADDR_MASK, [&] {
-				const size_t page_off = offset % PAGE_SIZE;
-
-				const auto parse_octal =
-					[page_off](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);
-							if (ch == '\0')
-								break;
-							result = (result * 8) + (ch - '0');
-						}
-						return result;
-					};
-
-				if (memcmp(PageTable::fast_page_as_ptr(page_off + 257), "ustar", 5)) {
-					file_size = SIZE_MAX;
-					return;
+			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;
+			}
 
-				memcpy(file_path, PageTable::fast_page_as_ptr(page_off + 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);
+			const auto parse_octal =
+				[&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 = data_source.data()[offset + i];
+						if (ch == '\0')
+							break;
+						result = (result * 8) + (ch - '0');
+					}
+					return result;
+				};
 
-				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);
-			});
-
-			if (file_size == SIZE_MAX)
-				break;
-			if (offset + 512 + file_size > module.size)
+			if (memcmp(&data_source.data()[257], "ustar", 5) != 0)
 				break;
 
-			auto parent_inode = filesystem->root_inode();
+			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, &data_source.data()[0], 100);
+
+			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];
+
+			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
+				else if (file_size)
 				{
-					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)
 					{
-						auto inode = TRY(parent_inode->find_inode(file_name_sv));
+						TRY(data_source.produce_data());
+						ASSERT(data_source.data_size() > 0); // what to do?
 
-						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);
-							});
+						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;
 
-							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 }));
-							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

@@ -221,7 +221,13 @@ 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;
 				}
 
@@ -321,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
 
@@ -352,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;
@@ -359,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");
@@ -366,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
 		{
@@ -401,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)
@@ -428,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];
@@ -476,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/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,38 +32,75 @@ 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);
+
+			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);
 
-		// Zero out the new page
-		PageTable::with_fast_page(paddr, [&] {
-			memset(PageTable::fast_page_as_ptr(), 0x00, PAGE_SIZE);
+		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;
 	}
 
@@ -67,16 +108,20 @@ namespace Kernel
 	{
 		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;
 	}

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,13 +350,10 @@ 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;
-				Processor::yield();
-			}
+			m_next_reschedule_ns += s_reschedule_interval_ns;
+			Processor::yield();
 		}
 	}
 

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,13 +95,11 @@ namespace Kernel
 
 		Process::current().wait_while_stopped();
 
-		Processor::set_interrupt_state(InterruptState::Disabled);
+		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);
 
-		auto& current_thread = Thread::current();
-		if (current_thread.can_add_signal_to_execute())
-			if (current_thread.handle_signal())
-				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);
 

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];
-		}
-		else
-		{
-			ASSERT(signal >= _SIGMIN);
-			ASSERT(signal <= _SIGMAX);
+			signal_info.si_signo = signal;
+
+			handle_info = remove_signal_and_get_info(signal);
 		}
 
-		vaddr_t signal_handler;
-		bool has_sa_restart;
+		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);
+
+		signal_handle_info_t handle_info;
+
+		// If this signal is blocked or ignored, terminate the process
+		bool terminate_process = false;
+
+		{
+			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];
+
+		const vaddr_t signal_handler = (handler.sa_flags & SA_SIGINFO)
+			? reinterpret_cast<vaddr_t>(handler.sa_sigaction)
+			: reinterpret_cast<vaddr_t>(handler.sa_handler);
+		const bool has_sa_restart = !!(handler.sa_flags & SA_RESTART);
+
 		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;
 
-		{
-			SpinLockGuard _(m_process->m_signal_lock);
+		m_signal_block_mask |= handler.sa_mask;
+		if (!(handler.sa_flags & SA_NODEFER))
+			m_signal_block_mask |= 1ull << signal;
 
-			auto& handler = m_process->m_signal_handlers[signal];
-
-			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 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;
-
-			if (handler.sa_flags & SA_RESETHAND)
-				handler = { .sa_handler = SIG_DFL, .sa_mask = 0, .sa_flags = 0 };
-		}
+		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
 
-			{
-				// Make sure stack is allocated
-
-				vaddr_t pages[3] {};
-				size_t page_count { 0 };
-
-				if (signal_stack_top == 0)
+			const auto write_to_stack =
+				[&]<typename T>(uintptr_t& sp, const T& value)
 				{
-					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/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>
@@ -154,11 +154,11 @@ diff -ruN SDL2-2.32.8/src/audio/banan_os/SDL_banan_os_audio.cpp SDL2-2.32.8-bana
 +  freely, subject to the following restrictions:
 +
 +  1. The origin of this software must not be misrepresented; you must not
-+     claim that you wrote the original software. If you use this software
-+     in a product, an acknowledgment in the product documentation would be
-+     appreciated but is not required.
++	 claim that you wrote the original software. If you use this software
++	 in a product, an acknowledgment in the product documentation would be
++	 appreciated but is not required.
 +  2. Altered source versions must be plainly marked as such, and must not be
-+     misrepresented as being the original software.
++	 misrepresented as being the original software.
 +  3. This notice may not be removed or altered from any source distribution.
 +*/
 +#include "../../SDL_internal.h"
@@ -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);
@@ -229,38 +229,22 @@ diff -ruN SDL2-2.32.8/src/audio/banan_os/SDL_banan_os_audio.cpp SDL2-2.32.8-bana
 +
 +	const bool should_play = SDL_AtomicGet(&_this->enabled) && !SDL_AtomicGet(&_this->paused);
 +	_this->hidden->audio.set_paused(!should_play);
-+    if (!should_play)
++	if (!should_play)
 +	{
 +		usleep(100);
 +		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)
++	auto sample_span = BAN::Span(
++		static_cast<const float*>(_this->hidden->mixbuf),
++		_this->spec.size / sizeof(float)
++	);
++	while (!sample_span.empty())
 +	{
-+		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();
-+		while (!sample_span.empty())
-+		{
-+			const size_t queued = _this->hidden->audio.queue_samples(sample_span);
-+			if (queued == 0)
-+				usleep(100);
-+			sample_span = sample_span.slice(queued);
-+		}
-+
-+		samples_queued += to_convert;
++		const size_t queued = _this->hidden->audio.queue_samples(sample_span);
++		if (queued == 0)
++			usleep(100);
++		sample_span = sample_span.slice(queued);
 +	}
 +}
 +
@@ -268,33 +252,33 @@ diff -ruN SDL2-2.32.8/src/audio/banan_os/SDL_banan_os_audio.cpp SDL2-2.32.8-bana
 +{
 +	DUMP_FUNCTION();
 +
-+    return static_cast<Uint8*>(_this->hidden->mixbuf);
++	return static_cast<Uint8*>(_this->hidden->mixbuf);
 +}
 +
 +static SDL_bool BANANOS_Init(SDL_AudioDriverImpl* impl)
 +{
-+    impl->OpenDevice = BANANOS_OpenDevice;
-+    impl->CloseDevice = BANANOS_CloseDevice;
-+    impl->PlayDevice = BANANOS_PlayDevice;
++	impl->OpenDevice = BANANOS_OpenDevice;
++	impl->CloseDevice = BANANOS_CloseDevice;
++	impl->PlayDevice = BANANOS_PlayDevice;
 +	impl->GetDeviceBuf = BANANOS_GetDeviceBuf;
 +
-+    impl->ProvidesOwnCallbackThread  = SDL_FALSE;
-+    impl->HasCaptureSupport          = SDL_FALSE;
-+    impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
-+    impl->SupportsNonPow2Samples     = SDL_TRUE;
++	impl->ProvidesOwnCallbackThread  = SDL_FALSE;
++	impl->HasCaptureSupport          = SDL_FALSE;
++	impl->OnlyHasDefaultOutputDevice = SDL_TRUE;
++	impl->SupportsNonPow2Samples     = SDL_TRUE;
 +
-+    return SDL_TRUE;
++	return SDL_TRUE;
 +}
 +
 +AudioBootStrap BANANOSAUDIO_bootstrap = {
-+    "banan-os", "banan-os AudioServer", BANANOS_Init, SDL_FALSE
++	"banan-os", "banan-os AudioServer", BANANOS_Init, SDL_FALSE
 +};
 +
 +#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/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/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,3 +1,4 @@
+.align 16
 .global memcpy
 memcpy:
 	xchgl 4(%esp), %edi
@@ -10,6 +11,7 @@ memcpy:
 	movl %edx, %eax
 	ret
 
+.align 16
 .global memmove
 memmove:
 	xchgl 4(%esp), %edi
@@ -32,6 +34,7 @@ memmove:
 	cld
 	jmp .memmove_done
 
+.align 16
 .global memset
 memset:
 	xchgl 4(%esp), %edi

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

@@ -1,48 +1,177 @@
+.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
 
-#if defined(__SSE2__)
+	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 .memchr_no_match
+	jz .Lmemchr_no_match
 
+	movzbl %sil, %esi
+	imul $0x01010101, %esi
 	movd %esi, %xmm0
-	punpcklbw %xmm0, %xmm0
-	punpcklwd %xmm0, %xmm0
 	pshufd $0, %xmm0, %xmm0
 
 	movq %rdi, %rcx
 	andq $15, %rcx
-	jz .memchr_loop
+	jz .Lmemchr_loop
 
 	movq %rdi, %rsi
 	subq %rcx, %rsi
@@ -50,40 +179,42 @@ memchr:
 	pcmpeqb %xmm0, %xmm1
 	pmovmskb %xmm1, %eax
 	shrl %cl, %eax
-	jnz .memchr_match
+	jnz .Lmemchr_match
 
 	leaq 16(%rsi), %rdi
 
 	addq %rcx, %rdx
 	subq $16, %rdx
-	jbe .memchr_no_match
+	jbe .Lmemchr_no_match
 
- .memchr_loop:
+ .align 16
+ .Lmemchr_loop:
 	movdqa (%rdi), %xmm1
 	pcmpeqb %xmm0, %xmm1
 	pmovmskb %xmm1, %eax
 	testl %eax, %eax
-	jnz .memchr_match
+	jnz .Lmemchr_match
 
 	addq $16, %rdi
 	subq $16, %rdx
-	ja .memchr_loop
+	ja .Lmemchr_loop
 
- .memchr_no_match:
+ .Lmemchr_no_match:
 	xorq %rax, %rax
 	ret
 
- .memchr_match:
+ .Lmemchr_match:
 	bsfl %eax, %eax
 	cmpq %rdx, %rax
-	jae .memchr_no_match
+	jae .Lmemchr_no_match
 	addq %rdi, %rax
 	ret
 
+.align 16
 .global memcmp
 memcmp:
 	testq %rdx, %rdx
-	jz .memcmp_equal
+	jz .Lmemcmp_equal
 
 	movq %rdi, %rax
 	movq %rsi, %rcx
@@ -93,7 +224,7 @@ memcmp:
 	cmovaq %rcx, %rax
 
 	testq %rax, %rax
-	jz .memcmp_loop
+	jz .Lmemcmp_loop
 
 	movq $16, %rcx
 	subq %rax, %rcx
@@ -103,44 +234,46 @@ memcmp:
 
 	subq %rcx, %rdx
 
- .memcmp_align_loop:
+ .Lmemcmp_align_loop:
 	movzbl (%rdi), %eax
 	movzbl (%rsi), %r8d
 	subl %r8d, %eax
-	jnz .memcmp_return
+	jnz .Lmemcmp_return
 
-	incq %rdi
-	incq %rsi
-	decq %rcx
-	jnz .memcmp_align_loop
+	addq $1, %rdi
+	addq $1, %rsi
+	subq $1, %rcx
+	jnz .Lmemcmp_align_loop
 
- .memcmp_loop:
+ .align 16
+ .Lmemcmp_loop:
 	movdqu (%rdi), %xmm0
 	movdqu (%rsi), %xmm1
 	pcmpeqb %xmm0, %xmm1
 	pmovmskb %xmm1, %eax
 	xorl $0xFFFF, %eax
-	jnz .memcmp_differ
+	jnz .Lmemcmp_differ
 
 	addq $16, %rdi
 	addq $16, %rsi
 	subq $16, %rdx
-	ja .memcmp_loop
+	ja .Lmemcmp_loop
 
- .memcmp_equal:
+ .Lmemcmp_equal:
 	xorl %eax, %eax
- .memcmp_return:
+ .Lmemcmp_return:
 	ret
 
- .memcmp_differ:
+ .Lmemcmp_differ:
 	bsfl %eax, %ecx
 	cmpq %rdx, %rcx
-	jae .memcmp_equal
+	jae .Lmemcmp_equal
 	movzbl (%rdi, %rcx), %eax
 	movzbl (%rsi, %rcx), %edx
 	subl %edx, %eax
 	ret
 
+.align 16
 .global strlen
 strlen:
 	movq %rdi, %rsi
@@ -149,7 +282,7 @@ strlen:
 
 	movq %rsi, %rcx
 	andq $15, %rcx
-	jz .strlen_loop
+	jz .Lstrlen_loop
 
 	movq %rsi, %rdx
 	subq %rcx, %rdx
@@ -157,24 +290,23 @@ strlen:
 	pcmpeqb %xmm0, %xmm1
 	pmovmskb %xmm1, %eax
 	shrl %cl, %eax
-	jnz .strlen_null_found
+	jnz .Lstrlen_null_found
 
 	leaq 16(%rdx), %rsi
 
- .strlen_loop:
+ .align 16
+ .Lstrlen_loop:
 	movdqa (%rsi), %xmm1
 	pcmpeqb %xmm0, %xmm1
 	pmovmskb %xmm1, %eax
 	testl %eax, %eax
-	jnz .strlen_null_found
+	jnz .Lstrlen_null_found
 
 	addq $16, %rsi
-	jmp .strlen_loop
+	jmp .Lstrlen_loop
 
- .strlen_null_found:
+ .Lstrlen_null_found:
 	bsfl %eax, %eax
 	addq %rsi, %rax
 	subq %rdi, %rax
 	ret
-
-#endif

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)
-				free(environ[i]);
+		if (is_bitmap_bit_set(i))
+			free(environ[i]);
+		set_bitmap_bit(i, malloced);
 
-			if (malloced)
-				s_environ_bitmap[byte] |= mask;
-			else
-				s_environ_bitmap[byte] &= ~mask;
-
-			environ[i] = string;
-			return 0;
-		}
+		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,9 +138,8 @@ 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] == '=')
-				return environ[i] + namelen + 1;
+		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/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/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/string.h

@@ -46,6 +46,7 @@ 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

@@ -74,6 +74,15 @@ struct snd_volume_info
 #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

@@ -608,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/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,
 	};
+	const pthread_mutexattr_t mattr {
+		.type = PTHREAD_MUTEX_DEFAULT,
+		.shared = attr->shared,
+	};
+	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;
 }
 
-// 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;
-		};
-
-	while (!has_timed_out(abstime))
-	{
-		if (trylock(lock) == 0)
-			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/string.cpp

@@ -304,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

@@ -193,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*
@@ -208,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!
 
@@ -220,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);
@@ -254,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)
 {

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());
-
-		bool bfinal = false;
-		while (!bfinal)
+		uint16_t symbol = TRY(read_symbol(m_length_tree));
+		if (symbol == 256)
 		{
-			bfinal = TRY(m_stream.take_bits(1));
-			switch (TRY(m_stream.take_bits(2)))
+			m_state = State::BlockHeader;
+			return {};
+		}
+
+		if (symbol < 256)
+		{
+			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:
 			{
-				case 0b00:
-					TRY(decompress_type0());
-					break;
-				case 0b01:
-					TRY(decompress_type1());
-					break;
-				case 0b10:
-					TRY(decompress_type2());
-					break;
-				default:
-					return BAN::Error::from_errno(EINVAL);
+				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;
 			}
 		}
 
-		TRY(handle_footer());
+		m_produced_bytes -= to_write;
+		output = output.slice(to_write);
+	}
 
-		return BAN::move(m_output);
+	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:
+							m_state = State::LiteralHeader;
+							break;
+						case 0b01:
+							m_length_tree = TRY(HuffmanTree::fixed_tree());
+							m_distance_tree = {};
+							m_state = State::Symbol;
+							break;
+						case 0b10:
+							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;
+					}
+
+					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);
+
+					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

userspace/libraries/LibDEFLATE/include/LibDEFLATE/Decompressor.h

@@ -1,6 +1,5 @@
 #pragma once
 
-
 #include <BAN/ByteSpan.h>
 #include <BAN/NoCopyMove.h>
 #include <BAN/Vector.h>
@@ -18,29 +17,77 @@ namespace LibDEFLATE
 		BAN_NON_MOVABLE(Decompressor);
 
 	public:
-		Decompressor(BAN::ConstByteSpan data, StreamType type)
+		enum class Status
+		{
+			Done,
+			NeedMoreInput,
+			NeedMoreOutput,
+		};
+
+	public:
+		Decompressor(StreamType type)
 			: m_type(type)
-			, m_stream(data)
 		{ }
 
-		BAN::ErrorOr<BAN::Vector<uint8_t>> decompress();
+		BAN::ErrorOr<BAN::Vector<uint8_t>> decompress(BAN::ConstByteSpan input);
+		BAN::ErrorOr<BAN::Vector<uint8_t>> decompress(BAN::Span<const BAN::ConstByteSpan> input);
+
+		BAN::ErrorOr<Status> decompress(BAN::ConstByteSpan input, size_t& input_consumed, BAN::ByteSpan output, size_t& output_produced);
 
 	private:
 		BAN::ErrorOr<uint16_t> read_symbol(const HuffmanTree& tree);
-		BAN::ErrorOr<void> inflate_block(const HuffmanTree& length_tree, const HuffmanTree& distance_tree);
-
-		BAN::ErrorOr<void> decompress_type0();
-		BAN::ErrorOr<void> decompress_type1();
-		BAN::ErrorOr<void> decompress_type2();
 
 		BAN::ErrorOr<void> handle_header();
 		BAN::ErrorOr<void> handle_footer();
+		BAN::ErrorOr<void> handle_dynamic_header();
+		BAN::ErrorOr<void> handle_symbol();
+
+		void write_data_to_output(BAN::ByteSpan&);
+
+	private:
+		enum class State
+		{
+			StreamHeader,
+			StreamFooter,
+			BlockHeader,
+			LiteralHeader,
+			DynamicHeader,
+			ReadRaw,
+			Symbol,
+			Done,
+		};
 
 	private:
 		const StreamType m_type;
+
+		State m_state { State::StreamHeader };
+
 		BitInputStream m_stream;
-		BAN::Vector<uint8_t> m_output;
-		BAN::Optional<HuffmanTree> m_fixed_tree;
+
+		static constexpr size_t total_window_size = 32 * 1024;
+		BAN::Vector<uint8_t> m_window;
+		size_t m_window_size { 0 };
+		size_t m_window_tail { 0 };
+		size_t m_produced_bytes { 0 };
+
+		bool m_bfinal { false };
+		HuffmanTree m_length_tree;
+		HuffmanTree m_distance_tree;
+
+		uint16_t m_raw_bytes_left { 0 };
+
+		union
+		{
+			struct {
+				uint32_t s1;
+				uint32_t s2;
+				uint32_t adler32;
+			} zlib;
+			struct {
+				uint32_t crc32;
+				uint32_t isize;
+			} gzip;
+		} m_stream_info;
 	};
 
 }

userspace/libraries/LibFont/Font.cpp

@@ -8,6 +8,9 @@
 #endif
 
 #include <fcntl.h>
+#include <limits.h>
+#include <sys/stat.h>
+#include <unistd.h>
 
 #if __is_kernel
 extern uint8_t _binary_font_prefs_psf_start[];

userspace/libraries/LibGUI/Window.cpp

@@ -9,52 +9,14 @@
 #include <sys/mman.h>
 #include <sys/socket.h>
 #include <sys/un.h>
+#include <time.h>
 #include <unistd.h>
 
+#include <emmintrin.h>
+
 namespace LibGUI
 {
 
-	struct ReceivePacket
-	{
-		PacketType type;
-		BAN::Vector<uint8_t> data_with_type;
-	};
-
-	static BAN::ErrorOr<ReceivePacket> recv_packet(int socket)
-	{
-		uint32_t packet_size;
-
-		{
-			const ssize_t nrecv = recv(socket, &packet_size, sizeof(uint32_t), 0);
-			if (nrecv < 0)
-				return BAN::Error::from_errno(errno);
-			if (nrecv == 0)
-				return BAN::Error::from_errno(ECONNRESET);
-		}
-
-		if (packet_size < sizeof(uint32_t))
-			return BAN::Error::from_literal("invalid packet, does not fit packet id");
-
-		BAN::Vector<uint8_t> packet_data;
-		TRY(packet_data.resize(packet_size));
-
-		size_t total_recv = 0;
-		while (total_recv < packet_size)
-		{
-			const ssize_t nrecv = recv(socket, packet_data.data() + total_recv, packet_size - total_recv, 0);
-			if (nrecv < 0)
-				return BAN::Error::from_errno(errno);
-			if (nrecv == 0)
-				return BAN::Error::from_errno(ECONNRESET);
-			total_recv += nrecv;
-		}
-
-		return ReceivePacket {
-			*reinterpret_cast<PacketType*>(packet_data.data()),
-			packet_data
-		};
-	}
-
 	Window::~Window()
 	{
 		cleanup();
@@ -62,7 +24,7 @@ namespace LibGUI
 
 	BAN::ErrorOr<BAN::UniqPtr<Window>> Window::create(uint32_t width, uint32_t height, BAN::StringView title, Attributes attributes)
 	{
-		int server_fd = socket(AF_UNIX, SOCK_STREAM, 0);
+		int server_fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
 		if (server_fd == -1)
 			return BAN::Error::from_errno(errno);
 		BAN::ScopeGuard server_closer([server_fd] { close(server_fd); });
@@ -72,16 +34,10 @@ namespace LibGUI
 			return BAN::Error::from_errno(errno);
 		BAN::ScopeGuard epoll_closer([epoll_fd] { close(epoll_fd); });
 
-		epoll_event epoll_event {
-			.events = EPOLLIN,
-			.data = { .fd = server_fd },
-		};
+		epoll_event epoll_event { .events = EPOLLIN, .data = { .fd = server_fd } };
 		if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &epoll_event) == -1)
 			return BAN::Error::from_errno(errno);
 
-		if (fcntl(server_fd, F_SETFD, fcntl(server_fd, F_GETFD) | FD_CLOEXEC) == -1)
-			return BAN::Error::from_errno(errno);
-
 		timespec start_time;
 		clock_gettime(CLOCK_MONOTONIC, &start_time);
 
@@ -105,19 +61,23 @@ namespace LibGUI
 			nanosleep(&sleep_time, nullptr);
 		}
 
+		auto window = TRY(BAN::UniqPtr<Window>::create(server_fd, epoll_fd, attributes));
+
 		WindowPacket::WindowCreate create_packet;
 		create_packet.width = width;
 		create_packet.height = height;
 		create_packet.attributes = attributes;
 		TRY(create_packet.title.append(title));
-		TRY(create_packet.send_serialized(server_fd));
-
-		auto window = TRY(BAN::UniqPtr<Window>::create(server_fd, epoll_fd, attributes));
+		window->send_packet(create_packet, __FUNCTION__);
 
 		bool resized = false;
 		window->set_resize_window_event_callback([&]() { resized = true; });
 		while (!resized)
+		{
+			// FIXME: timeout?
+			window->wait_events();
 			window->poll_events();
+		}
 		window->set_resize_window_event_callback({});
 
 		server_closer.disable();
@@ -126,6 +86,30 @@ namespace LibGUI
 		return window;
 	}
 
+	template<typename T>
+	void Window::send_packet(const T& packet, BAN::StringView function)
+	{
+		const size_t serialized_size = packet.serialized_size();
+		if (serialized_size > m_out_buffer.size())
+		{
+			dwarnln("cannot to send {} byte packet", serialized_size);
+			return on_socket_error(function);
+		}
+
+		packet.serialize(m_out_buffer.span());
+
+		size_t total_sent = 0;
+		while (total_sent < serialized_size)
+		{
+			const ssize_t nsend = send(m_server_fd, m_out_buffer.data() + total_sent, serialized_size - total_sent, 0);
+			if (nsend < 0)
+				dwarnln("send: {}", strerror(errno));
+			if (nsend <= 0)
+				return on_socket_error(function);
+			total_sent += nsend;
+		}
+	}
+
 	BAN::ErrorOr<void> Window::set_root_widget(BAN::RefPtr<Widget::Widget> widget)
 	{
 		TRY(widget->set_fixed_geometry({ 0, 0, m_width, m_height }));
@@ -137,49 +121,75 @@ namespace LibGUI
 		return {};
 	}
 
+	static void* copy_pixels_and_set_max_alpha(void* dst, const void* src, size_t bytes)
+	{
+		size_t pixels = bytes / sizeof(uint32_t);
+
+		      __m128i* dst128 = static_cast<      __m128i*>(dst);
+		const __m128i* src128 = static_cast<const __m128i*>(src);
+		const __m128i alpha_mask = _mm_set1_epi32(0xFF000000);
+		for (; pixels >= 4; pixels -= 4)
+			_mm_storeu_si128(dst128++, _mm_or_si128(_mm_loadu_si128(src128++), alpha_mask));
+
+		      uint32_t* dst32 = reinterpret_cast<      uint32_t*>(dst128);
+		const uint32_t* src32 = reinterpret_cast<const uint32_t*>(src128);
+		for (; pixels; pixels--)
+			*dst32++ = *src32++ | 0xFF000000;
+
+		return nullptr;
+	}
+
 	void Window::invalidate(int32_t x, int32_t y, uint32_t width, uint32_t height)
 	{
 		if (!m_texture.clamp_to_texture(x, y, width, height))
 			return;
 
-		for (uint32_t i = 0; i < height; i++)
-			memcpy(&m_framebuffer_smo[(y + i) * m_width + x], &m_texture.pixels()[(y + i) * m_width + x], width * sizeof(uint32_t));
+		const auto copy_func = m_attributes.alpha_channel ? memcpy : copy_pixels_and_set_max_alpha;
+
+		if (width == m_width)
+		{
+			copy_func(
+				&m_framebuffer_smo[y * m_width],
+				&m_texture.pixels()[y * m_width],
+				width * height * sizeof(uint32_t)
+			);
+		}
+		else for (uint32_t y_off = 0; y_off < height; y_off++)
+		{
+			copy_func(
+				&m_framebuffer_smo[(y + y_off) * m_width + x],
+				&m_texture.pixels()[(y + y_off) * m_width + x],
+				width * sizeof(uint32_t)
+			);
+		}
 
 		WindowPacket::WindowInvalidate packet;
 		packet.x = x;
 		packet.y = y;
 		packet.width = width;
 		packet.height = height;
-
-		if (auto ret = packet.send_serialized(m_server_fd); ret.is_error())
-			return on_socket_error(__FUNCTION__);
+		send_packet(packet, __FUNCTION__);
 	}
 
 	void Window::set_mouse_relative(bool enabled)
 	{
 		WindowPacket::WindowSetMouseRelative packet;
 		packet.enabled = enabled;
-
-		if (auto ret = packet.send_serialized(m_server_fd); ret.is_error())
-			return on_socket_error(__FUNCTION__);
+		send_packet(packet, __FUNCTION__);
 	}
 
 	void Window::set_fullscreen(bool fullscreen)
 	{
 		WindowPacket::WindowSetFullscreen packet;
 		packet.fullscreen = fullscreen;
-
-		if (auto ret = packet.send_serialized(m_server_fd); ret.is_error())
-			return on_socket_error(__FUNCTION__);
+		send_packet(packet, __FUNCTION__);
 	}
 
 	void Window::set_title(BAN::StringView title)
 	{
 		WindowPacket::WindowSetTitle packet;
 		MUST(packet.title.append(title));
-
-		if (auto ret = packet.send_serialized(m_server_fd); ret.is_error())
-			return on_socket_error(__FUNCTION__);
+		send_packet(packet, __FUNCTION__);
 	}
 
 	void Window::set_position(int32_t x, int32_t y)
@@ -187,9 +197,7 @@ namespace LibGUI
 		WindowPacket::WindowSetPosition packet;
 		packet.x = x;
 		packet.y = y;
-
-		if (auto ret = packet.send_serialized(m_server_fd); ret.is_error())
-			return on_socket_error(__FUNCTION__);
+		send_packet(packet, __FUNCTION__);
 	}
 
 	void Window::set_cursor_visible(bool visible)
@@ -211,9 +219,7 @@ namespace LibGUI
 		MUST(packet.pixels.resize(pixels.size()));
 		for (size_t i = 0; i < packet.pixels.size(); i++)
 			packet.pixels[i] = pixels[i];
-
-		if (auto ret = packet.send_serialized(m_server_fd); ret.is_error())
-			return on_socket_error(__FUNCTION__);
+		send_packet(packet, __FUNCTION__);
 	}
 
 	void Window::set_min_size(uint32_t width, uint32_t height)
@@ -221,9 +227,7 @@ namespace LibGUI
 		WindowPacket::WindowSetMinSize packet;
 		packet.width = width;
 		packet.height = height;
-
-		if (auto ret = packet.send_serialized(m_server_fd); ret.is_error())
-			return on_socket_error(__FUNCTION__);
+		send_packet(packet, __FUNCTION__);
 	}
 
 	void Window::set_max_size(uint32_t width, uint32_t height)
@@ -231,19 +235,14 @@ namespace LibGUI
 		WindowPacket::WindowSetMaxSize packet;
 		packet.width = width;
 		packet.height = height;
-
-		if (auto ret = packet.send_serialized(m_server_fd); ret.is_error())
-			return on_socket_error(__FUNCTION__);
+		send_packet(packet, __FUNCTION__);
 	}
 
 	void Window::set_attributes(Attributes attributes)
 	{
 		WindowPacket::WindowSetAttributes packet;
 		packet.attributes = attributes;
-
-		if (auto ret = packet.send_serialized(m_server_fd); ret.is_error())
-			return on_socket_error(__FUNCTION__);
-
+		send_packet(packet, __FUNCTION__);
 		m_attributes = attributes;
 	}
 
@@ -252,9 +251,7 @@ namespace LibGUI
 		WindowPacket::WindowSetSize packet;
 		packet.width = width;
 		packet.height = height;
-
-		if (auto ret = packet.send_serialized(m_server_fd); ret.is_error())
-			return on_socket_error(__FUNCTION__);
+		send_packet(packet, __FUNCTION__);
 	}
 
 	void Window::on_socket_error(BAN::StringView function)
@@ -311,82 +308,120 @@ namespace LibGUI
 
 	void Window::poll_events()
 	{
-#define TRY_OR_BREAK(...) ({ auto&& e = (__VA_ARGS__); if (e.is_error()) break; e.release_value(); })
 		for (;;)
 		{
 			epoll_event event;
 			if (epoll_wait(m_epoll_fd, &event, 1, 0) == 0)
 				break;
 
-			auto packet_or_error = recv_packet(m_server_fd);
-			if (packet_or_error.is_error())
+			if (event.events & (EPOLLHUP | EPOLLERR))
 				return on_socket_error(__FUNCTION__);
 
-			const auto [packet_type, packet_data] = packet_or_error.release_value();
-			switch (packet_type)
+			ASSERT(event.events & EPOLLIN);
+
 			{
-				case PacketType::DestroyWindowEvent:
-					exit(1);
-				case PacketType::CloseWindowEvent:
-					if (m_close_window_event_callback)
-						m_close_window_event_callback();
-					else
-						exit(0);
+				const ssize_t nrecv = recv(m_server_fd, m_in_buffer.data() + m_in_buffer_size, m_in_buffer.size() - m_in_buffer_size, 0);
+				if (nrecv <= 0)
+					return on_socket_error(__FUNCTION__);
+				if (nrecv > 0)
+					m_in_buffer_size += nrecv;
+			}
+
+			BAN::ConstByteSpan in_span = m_in_buffer.span().slice(0, m_in_buffer_size);
+			while (in_span.size() >= sizeof(PacketHeader))
+			{
+				const auto header = in_span.as<const PacketHeader>();
+				if (in_span.size() < header.size || header.size < sizeof(LibGUI::PacketHeader))
 					break;
-				case PacketType::ResizeWindowEvent:
+
+				const auto packet_span = in_span.slice(0, header.size);
+				switch (header.type)
 				{
-					MUST(handle_resize_event(TRY_OR_BREAK(EventPacket::ResizeWindowEvent::deserialize(packet_data.span()))));
-					if (m_resize_window_event_callback)
-						m_resize_window_event_callback();
-					break;
-				}
-				case PacketType::WindowShownEvent:
-					if (m_window_shown_event_callback)
-						m_window_shown_event_callback(TRY_OR_BREAK(EventPacket::WindowShownEvent::deserialize(packet_data.span())).event);
-					break;
-				case PacketType::WindowFocusEvent:
-					if (m_window_focus_event_callback)
-						m_window_focus_event_callback(TRY_OR_BREAK(EventPacket::WindowFocusEvent::deserialize(packet_data.span())).event);
-					break;
-				case PacketType::WindowFullscreenEvent:
-					if (m_window_fullscreen_event_callback)
-						m_window_fullscreen_event_callback(TRY_OR_BREAK(EventPacket::WindowFullscreenEvent::deserialize(packet_data.span())).event);
-					break;
-				case PacketType::KeyEvent:
-					if (m_key_event_callback)
-						m_key_event_callback(TRY_OR_BREAK(EventPacket::KeyEvent::deserialize(packet_data.span())).event);
-					break;
-				case PacketType::MouseButtonEvent:
-				{
-					auto event = TRY_OR_BREAK(EventPacket::MouseButtonEvent::deserialize(packet_data.span())).event;
-					if (m_mouse_button_event_callback)
-						m_mouse_button_event_callback(event);
-					if (m_root_widget)
-						m_root_widget->on_mouse_button(event);
-					break;
-				}
-				case PacketType::MouseMoveEvent:
-				{
-					auto event = TRY_OR_BREAK(EventPacket::MouseMoveEvent::deserialize(packet_data.span())).event;
-					if (m_mouse_move_event_callback)
-						m_mouse_move_event_callback(event);
-					if (m_root_widget)
+#define TRY_OR_BREAK(...) ({ auto&& e = (__VA_ARGS__); if (e.is_error()) break; e.release_value(); })
+					case PacketType::DestroyWindowEvent:
+						exit(1);
+					case PacketType::CloseWindowEvent:
+						if (m_close_window_event_callback)
+							m_close_window_event_callback();
+						else
+							exit(0);
+						break;
+					case PacketType::ResizeWindowEvent:
 					{
-						m_root_widget->before_mouse_move();
-						m_root_widget->on_mouse_move(event);
-						m_root_widget->after_mouse_move();
+						MUST(handle_resize_event(TRY_OR_BREAK(EventPacket::ResizeWindowEvent::deserialize(packet_span))));
+						if (m_resize_window_event_callback)
+							m_resize_window_event_callback();
+						break;
 					}
-					break;
+					case PacketType::WindowShownEvent:
+						if (m_window_shown_event_callback)
+							m_window_shown_event_callback(TRY_OR_BREAK(EventPacket::WindowShownEvent::deserialize(packet_span)).event);
+						break;
+					case PacketType::WindowFocusEvent:
+						if (m_window_focus_event_callback)
+							m_window_focus_event_callback(TRY_OR_BREAK(EventPacket::WindowFocusEvent::deserialize(packet_span)).event);
+						break;
+					case PacketType::WindowFullscreenEvent:
+						if (m_window_fullscreen_event_callback)
+							m_window_fullscreen_event_callback(TRY_OR_BREAK(EventPacket::WindowFullscreenEvent::deserialize(packet_span)).event);
+						break;
+					case PacketType::KeyEvent:
+						if (m_key_event_callback)
+							m_key_event_callback(TRY_OR_BREAK(EventPacket::KeyEvent::deserialize(packet_span)).event);
+						break;
+					case PacketType::MouseButtonEvent:
+					{
+						auto event = TRY_OR_BREAK(EventPacket::MouseButtonEvent::deserialize(packet_span)).event;
+						if (m_mouse_button_event_callback)
+							m_mouse_button_event_callback(event);
+						if (m_root_widget)
+							m_root_widget->on_mouse_button(event);
+						break;
+					}
+					case PacketType::MouseMoveEvent:
+					{
+						auto event = TRY_OR_BREAK(EventPacket::MouseMoveEvent::deserialize(packet_span)).event;
+						if (m_mouse_move_event_callback)
+							m_mouse_move_event_callback(event);
+						if (m_root_widget)
+						{
+							m_root_widget->before_mouse_move();
+							m_root_widget->on_mouse_move(event);
+							m_root_widget->after_mouse_move();
+						}
+						break;
+					}
+					case PacketType::MouseScrollEvent:
+						if (m_mouse_scroll_event_callback)
+							m_mouse_scroll_event_callback(TRY_OR_BREAK(EventPacket::MouseScrollEvent::deserialize(packet_span)).event);
+						break;
+#undef TRY_OR_BREAK
+					default:
+						dprintln("unhandled packet type: {}", static_cast<uint32_t>(header.type));
+						break;
+				}
+
+				in_span = in_span.slice(header.size);
+			}
+
+			// NOTE: this will only move a single partial packet, so this is fine
+			memmove(
+				m_in_buffer.data(),
+				in_span.data(),
+				in_span.size()
+			);
+			m_in_buffer_size = in_span.size();
+
+			if (m_in_buffer_size >= sizeof(LibGUI::PacketHeader))
+			{
+				const auto header = BAN::ConstByteSpan(m_in_buffer.span()).as<const LibGUI::PacketHeader>();
+				if (header.size < sizeof(LibGUI::PacketHeader) || header.size > m_in_buffer.size())
+				{
+					dwarnln("server tried to send a {} byte packet", header.size);
+					return on_socket_error(__FUNCTION__);
 				}
-				case PacketType::MouseScrollEvent:
-					if (m_mouse_scroll_event_callback)
-						m_mouse_scroll_event_callback(TRY_OR_BREAK(EventPacket::MouseScrollEvent::deserialize(packet_data.span())).event);
-					break;
-				default:
-					break;
 			}
 		}
-#undef TRY_OR_BREAK
 
 		if (m_root_widget)
 		{

userspace/libraries/LibGUI/include/LibGUI/Packet.h

@@ -1,15 +1,13 @@
 #pragma once
 
+#include <BAN/ByteSpan.h>
 #include <BAN/String.h>
 #include <BAN/StringView.h>
-#include <BAN/ByteSpan.h>
+#include <BAN/Vector.h>
 
 #include <LibInput/KeyEvent.h>
 #include <LibInput/MouseEvent.h>
 
-#include <sys/banan-os.h>
-#include <sys/socket.h>
-
 #define FOR_EACH_0(macro)
 #define FOR_EACH_2(macro, type, name)      macro(type, name)
 #define FOR_EACH_4(macro, type, name, ...) macro(type, name) FOR_EACH_2(macro, __VA_ARGS__)
@@ -31,39 +29,38 @@
 
 #define FIELD_DECL(type, name) type name;
 #define ADD_SERIALIZED_SIZE(type, name) serialized_size += Serialize::serialized_size_impl<type>(this->name);
-#define SEND_SERIALIZED(type, name) TRY(Serialize::send_serialized_impl<type>(socket, this->name));
+#define SERIALIZE(type, name) Serialize::serialize_impl<type>(buffer, this->name);
 #define DESERIALIZE(type, name) value.name = TRY(Serialize::deserialize_impl<type>(buffer));
 
 #define DEFINE_PACKET_EXTRA(name, extra, ...) \
 	struct name \
 	{ \
-		static constexpr PacketType type = PacketType::name; \
-		static constexpr uint32_t type_u32 = static_cast<uint32_t>(type); \
- \
 		extra; \
  \
 		FOR_EACH(FIELD_DECL, __VA_ARGS__) \
  \
-		size_t serialized_size() \
+		size_t serialized_size() const \
 		{ \
-			size_t serialized_size = Serialize::serialized_size_impl<uint32_t>(type_u32); \
+			size_t serialized_size = 0; \
+			serialized_size += Serialize::serialized_size_impl(PacketHeader {}); \
 			FOR_EACH(ADD_SERIALIZED_SIZE, __VA_ARGS__) \
 			return serialized_size; \
 		} \
  \
-		BAN::ErrorOr<void> send_serialized(int socket) \
+		void serialize(BAN::ByteSpan buffer) const \
 		{ \
 			const uint32_t serialized_size = this->serialized_size(); \
-			TRY(Serialize::send_serialized_impl<uint32_t>(socket, serialized_size)); \
-			TRY(Serialize::send_serialized_impl<uint32_t>(socket, type_u32)); \
-			FOR_EACH(SEND_SERIALIZED, __VA_ARGS__) \
-			return {}; \
+			Serialize::serialize_impl(buffer, PacketHeader { \
+				.size = serialized_size, \
+				.type = PacketType::name, \
+			}); \
+			FOR_EACH(SERIALIZE, __VA_ARGS__); \
 		} \
  \
 		static BAN::ErrorOr<name> deserialize(BAN::ConstByteSpan buffer) \
 		{ \
-			const uint32_t type_u32 = TRY(Serialize::deserialize_impl<uint32_t>(buffer)); \
-			if (type_u32 != name::type_u32) \
+			const auto header = TRY(Serialize::deserialize_impl<PacketHeader>(buffer)); \
+			if (header.type != PacketType::name || header.size != buffer.size() + sizeof(PacketHeader)) \
 				return BAN::Error::from_errno(EINVAL); \
 			name value; \
 			FOR_EACH(DESERIALIZE, __VA_ARGS__) \
@@ -90,19 +87,11 @@ namespace LibGUI
 	namespace Serialize
 	{
 
-		inline BAN::ErrorOr<void> send_raw_data(int socket, BAN::ConstByteSpan data)
+		inline void append_raw_data(BAN::ByteSpan& buffer, BAN::ConstByteSpan data)
 		{
-			size_t send_done = 0;
-			while (send_done < data.size())
-			{
-				const ssize_t nsend = ::send(socket, data.data() + send_done, data.size() - send_done, 0);
-				if (nsend < 0)
-					return BAN::Error::from_errno(errno);
-				if (nsend == 0)
-					return BAN::Error::from_errno(ECONNRESET);
-				send_done += nsend;
-			}
-			return {};
+			ASSERT(buffer.size() >= data.size());
+			memcpy(buffer.data(), data.data(), data.size());
+			buffer = buffer.slice(data.size());
 		}
 
 		template<typename T> requires BAN::is_pod_v<T>
@@ -112,10 +101,9 @@ namespace LibGUI
 		}
 
 		template<typename T> requires BAN::is_pod_v<T>
-		inline BAN::ErrorOr<void> send_serialized_impl(int socket, const T& value)
+		inline void serialize_impl(BAN::ByteSpan& buffer, const T& value)
 		{
-			TRY(send_raw_data(socket, BAN::ConstByteSpan::from(value)));
-			return {};
+			append_raw_data(buffer, BAN::ConstByteSpan::from(value));
 		}
 
 		template<typename T> requires BAN::is_pod_v<T>
@@ -135,13 +123,12 @@ namespace LibGUI
 		}
 
 		template<typename T> requires BAN::is_same_v<T, BAN::String>
-		inline BAN::ErrorOr<void> send_serialized_impl(int socket, const T& value)
+		inline void serialize_impl(BAN::ByteSpan& buffer, const T& value)
 		{
 			const uint32_t value_size = value.size();
-			TRY(send_raw_data(socket, BAN::ConstByteSpan::from(value_size)));
+			append_raw_data(buffer, BAN::ConstByteSpan::from(value_size));
 			auto* u8_data = reinterpret_cast<const uint8_t*>(value.data());
-			TRY(send_raw_data(socket, BAN::ConstByteSpan(u8_data, value.size())));
-			return {};
+			append_raw_data(buffer, BAN::ConstByteSpan(u8_data, value.size()));
 		}
 
 		template<typename T> requires BAN::is_same_v<T, BAN::String>
@@ -173,13 +160,12 @@ namespace LibGUI
 		}
 
 		template<detail::Vector T>
-		inline BAN::ErrorOr<void> send_serialized_impl(int socket, const T& vector)
+		inline void serialize_impl(BAN::ByteSpan& buffer, const T& vector)
 		{
 			const uint32_t value_size = vector.size();
-			TRY(send_raw_data(socket, BAN::ConstByteSpan::from(value_size)));
+			append_raw_data(buffer, BAN::ConstByteSpan::from(value_size));
 			for (const auto& element : vector)
-				TRY(send_serialized_impl(socket, element));
-			return {};
+				serialize_impl(buffer, element);
 		}
 
 		template<detail::Vector T>
@@ -226,6 +212,12 @@ namespace LibGUI
 		MouseScrollEvent,
 	};
 
+	struct PacketHeader
+	{
+		uint32_t size;
+		PacketType type;
+	};
+
 	namespace WindowPacket
 	{
 

userspace/libraries/LibGUI/include/LibGUI/Window.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <BAN/Array.h>
 #include <BAN/Function.h>
 #include <BAN/StringView.h>
 #include <BAN/UniqPtr.h>
@@ -93,6 +94,9 @@ namespace LibGUI
 
 		BAN::ErrorOr<void> handle_resize_event(const EventPacket::ResizeWindowEvent&);
 
+		template<typename T>
+		void send_packet(const T& packet, BAN::StringView function);
+
 	private:
 		const int m_server_fd;
 		const int m_epoll_fd;
@@ -119,6 +123,11 @@ namespace LibGUI
 		BAN::Function<void(EventPacket::MouseMoveEvent::event_t)>        m_mouse_move_event_callback;
 		BAN::Function<void(EventPacket::MouseScrollEvent::event_t)>      m_mouse_scroll_event_callback;
 
+		size_t m_in_buffer_size { 0 };
+		BAN::Array<uint8_t, 64 * 1024> m_in_buffer;
+
+		BAN::Array<uint8_t, 64 * 1024> m_out_buffer;
+
 		friend class BAN::UniqPtr<Window>;
 	};
 

userspace/libraries/LibImage/Image.cpp

@@ -7,6 +7,8 @@
 
 #include <fcntl.h>
 #include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
 
 #include <immintrin.h>
 

userspace/libraries/LibImage/PNG.cpp

@@ -420,36 +420,19 @@ namespace LibImage
 			}
 		}
 
-		BAN::Vector<uint8_t> zlib_stream_buf;
-		BAN::ConstByteSpan zlib_stream_span;
-
 		if (zlib_stream.empty())
 		{
 			dwarnln_if(DEBUG_PNG, "PNG does not have zlib stream");
 			return BAN::Error::from_errno(EINVAL);
 		}
 
-		if (zlib_stream.size() == 1)
-			zlib_stream_span = zlib_stream.front();
-		else
-		{
-			for (auto stream : zlib_stream)
-			{
-				const size_t old_size = zlib_stream_buf.size();
-				TRY(zlib_stream_buf.resize(old_size + stream.size()));
-				for (size_t i = 0; i < stream.size(); i++)
-					zlib_stream_buf[old_size + i] = stream[i];
-			}
-			zlib_stream_span = zlib_stream_buf.span();
-		}
-
 		uint64_t total_size = 0;
 		for (auto stream : zlib_stream)
 			total_size += stream.size();
 		dprintln_if(DEBUG_PNG, "PNG has {} byte zlib stream", total_size);
 
-		LibDEFLATE::Decompressor decompressor(zlib_stream_span, LibDEFLATE::StreamType::Zlib);
-		auto inflated_buffer = TRY(decompressor.decompress());
+		LibDEFLATE::Decompressor decompressor(LibDEFLATE::StreamType::Zlib);
+		auto inflated_buffer = TRY(decompressor.decompress(zlib_stream.span()));
 		auto inflated_data = inflated_buffer.span();
 
 		dprintln_if(DEBUG_PNG, "  uncompressed size {}", inflated_data.size());

userspace/libraries/LibInput/KeyboardLayout.cpp

@@ -6,10 +6,12 @@
 
 #if __is_kernel
 #include <kernel/FS/VirtualFileSystem.h>
+#include <kernel/Process.h>
 #else
 #include <fcntl.h>
 #include <limits.h>
 #include <sys/stat.h>
+#include <unistd.h>
 #endif
 
 #include <ctype.h>
@@ -128,8 +130,8 @@ namespace LibInput
 
 #if __is_kernel
 		{
-			// FIXME: This does not account for chroot
-			auto file = TRY(Kernel::VirtualFileSystem::get().file_from_absolute_path(Kernel::VirtualFileSystem::get().root_inode(), { 0, 0, 0, 0 }, path, 0));
+			auto& process = Kernel::Process::current();
+			auto file = TRY(Kernel::VirtualFileSystem::get().file_from_absolute_path(process.root_file().inode, process.credentials(), path, O_RDONLY));
 			TRY(file_data.resize(file.inode->size()));
 			TRY(file.inode->read(0, BAN::ByteSpan { reinterpret_cast<uint8_t*>(file_data.data()), file_data.size() }));
 			canonical_path = file.canonical_path;

userspace/programs/DynamicLoader/main.cpp

@@ -207,7 +207,7 @@ struct LoadedElf
 	const uint8_t* real_strtab_addr;
 };
 
-static constexpr size_t s_max_loaded_files = 128;
+static constexpr size_t s_max_loaded_files = sizeof(uthread::dtv) / sizeof(*uthread::dtv) - 1;
 static LoadedElf s_loaded_files[s_max_loaded_files];
 static size_t s_loaded_file_count = 0;
 
@@ -223,14 +223,14 @@ constexpr uintptr_t SYM_NOT_FOUND = -1;
 
 static void lock_global_lock()
 {
-	const pthread_t tid = syscall<>(SYS_PTHREAD_SELF);
+	const pthread_t tid = syscall(SYS_PTHREAD_SELF);
 
 	pthread_t expected = 0;
 	while (!s_global_locker.compare_exchange(expected, tid))
 	{
 		if (expected == tid)
 			break;
-		syscall<>(SYS_YIELD);
+		syscall(SYS_YIELD);
 		expected = 0;
 	}
 
@@ -455,15 +455,15 @@ static void handle_tls_relocation(const LoadedElf& elf, const RelocT& reloc)
 #elif defined(__i686__)
 	switch (ELF32_R_TYPE(reloc.r_info))
 	{
-		case R_386_TLS_TPOFF:
-			*reinterpret_cast<uint32_t*>(elf.base + reloc.r_offset) = symbol_offset - symbol_elf->tls_offset;
-			break;
 		case R_386_TLS_DTPMOD32:
 			*reinterpret_cast<uint32_t*>(elf.base + reloc.r_offset) = symbol_elf->tls_module;
 			break;
 		case R_386_TLS_DTPOFF32:
 			*reinterpret_cast<uint32_t*>(elf.base + reloc.r_offset) = symbol_offset;
 			break;
+		case R_386_TLS_TPOFF:
+			*reinterpret_cast<uint32_t*>(elf.base + reloc.r_offset) = symbol_offset - symbol_elf->tls_offset;
+			break;
 		default:
 			print(STDERR_FILENO, "unsupported tls reloc type ");
 			print_uint(STDERR_FILENO, ELF32_R_TYPE(reloc.r_info));
@@ -589,7 +589,7 @@ static uintptr_t handle_relocation(const LoadedElf& elf, const RelocT& reloc, bo
 			break;
 		case R_386_PC32:
 			size = 4;
-			value = symbol_address - reloc.r_offset;
+			value = symbol_address - (elf.base + reloc.r_offset);
 			add_addend = true;
 			break;
 		case R_386_GLOB_DAT:
@@ -1393,7 +1393,7 @@ static void initialize_tls(MasterTLS master_tls)
 		.master_tls_module_count = master_tls.module_count,
 		.dynamic_tls = s_dynamic_tls,
 		.cleanup_stack = nullptr,
-		.id = static_cast<pthread_t>(syscall<>(SYS_PTHREAD_SELF)),
+		.id = static_cast<pthread_t>(syscall(SYS_PTHREAD_SELF)),
 		.errno_ = 0,
 		.cancel_type = PTHREAD_CANCEL_DEFERRED,
 		.cancel_state = PTHREAD_CANCEL_ENABLE,
@@ -1565,7 +1565,7 @@ static void load_dynamic_tls(LoadedElf& elf)
 	int expected = 0;
 	while (!BAN::atomic_compare_exchange(s_dynamic_tls->lock, expected, 1))
 	{
-		syscall<>(SYS_YIELD);
+		syscall(SYS_YIELD);
 		expected = 0;
 	}
 

userspace/programs/DynamicLoader/utils.cpp

@@ -2,6 +2,7 @@
 
 #include <errno.h>
 #include <fcntl.h>
+#include <sys/syscall.h>
 #include <unistd.h>
 
 void print(int fd, const char* buffer)

userspace/programs/DynamicLoader/utils.h

@@ -1,10 +1,18 @@
 #pragma once
 
 #include <BAN/Traits.h>
+
+#include <unistd.h> // make sure syscall function is declared before defining it
+
+#include <errno.h>
 #include <kernel/API/Syscall.h>
 
-#include <stddef.h>
-#include <stdint.h>
+#define syscall(...) ({ \
+		long _ret = -ERESTART; \
+		while (_ret == -ERESTART) \
+			_ret = _kas_syscall(__VA_ARGS__); \
+		_ret; \
+	})
 
 template<typename T>
 inline constexpr T min(T a, T b)
@@ -18,12 +26,6 @@ inline constexpr T max(T a, T b)
 	return a > b ? a : b;
 }
 
-template<typename... Ts> requires (sizeof...(Ts) <= 5) && ((BAN::is_integral_v<Ts> || BAN::is_pointer_v<Ts>) && ...)
-inline auto syscall(long syscall, Ts... args)
-{
-	return Kernel::syscall(syscall, (uintptr_t)args...);
-}
-
 void print(int fd, const char* buffer);
 
 [[noreturn]] void print_error_and_exit(const char* message, int error);

userspace/programs/Terminal/Terminal.cpp

@@ -7,9 +7,11 @@
 
 #include <ctype.h>
 #include <fcntl.h>
+#include <signal.h>
 #include <stdlib.h>
 #include <sys/ioctl.h>
 #include <sys/select.h>
+#include <time.h>
 #include <unistd.h>
 
 static constexpr uint32_t s_colors_dark[] {

userspace/programs/WindowServer/Utils.h

@@ -13,55 +13,133 @@ struct Position
 
 struct Rectangle
 {
-	int32_t x;
-	int32_t y;
-	int32_t width;
-	int32_t height;
+	int32_t min_x;
+	int32_t min_y;
+	int32_t max_x;
+	int32_t max_y;
+
+	int32_t width() const
+	{
+		return max_x - min_x;
+	}
+
+	int32_t height() const
+	{
+		return max_y - min_y;
+	}
+
+	int32_t area() const
+	{
+		return width() * height();
+	}
 
 	bool contains(Position position) const
 	{
-		if (position.x < x || position.x >= x + width)
+		if (position.x < min_x || position.x >= max_x)
 			return false;
-		if (position.y < y || position.y >= y + height)
+		if (position.y < min_y || position.y >= max_y)
 			return false;
 		return true;
 	}
 
 	BAN::Optional<Rectangle> get_overlap(Rectangle other) const
 	{
-		if (height == 0 || width == 0 || other.width == 0 || other.height == 0)
+		if (width() == 0 || height() == 0 || other.width() == 0 || other.height() == 0)
 			return {};
-		const auto min_x = BAN::Math::max(x, other.x);
-		const auto min_y = BAN::Math::max(y, other.y);
-		const auto max_x = BAN::Math::min(x + width, other.x + other.width);
-		const auto max_y = BAN::Math::min(y + height, other.y + other.height);
+		const auto min_x = BAN::Math::max(this->min_x, other.min_x);
+		const auto min_y = BAN::Math::max(this->min_y, other.min_y);
+		const auto max_x = BAN::Math::min(this->max_x, other.max_x);
+		const auto max_y = BAN::Math::min(this->max_y, other.max_y);
 		if (min_x >= max_x || min_y >= max_y)
 			return {};
 		return Rectangle {
-			.x = min_x,
-			.y = min_y,
-			.width = max_x - min_x,
-			.height = max_y - min_y,
+			.min_x = min_x,
+			.min_y = min_y,
+			.max_x = max_x,
+			.max_y = max_y,
 		};
 	}
 
 	Rectangle get_bounding_box(Rectangle other) const
 	{
-		const auto min_x = BAN::Math::min(x, other.x);
-		const auto min_y = BAN::Math::min(y, other.y);
-		const auto max_x = BAN::Math::max(x + width, other.x + other.width);
-		const auto max_y = BAN::Math::max(y + height, other.y + other.height);
+		const auto min_x = BAN::Math::min(this->min_x, other.min_x);
+		const auto min_y = BAN::Math::min(this->min_y, other.min_y);
+		const auto max_x = BAN::Math::max(this->max_x, other.max_x);
+		const auto max_y = BAN::Math::max(this->max_y, other.max_y);
 		return Rectangle {
-			.x = min_x,
-			.y = min_y,
-			.width = max_x - min_x,
-			.height = max_y - min_y,
+			.min_x = min_x,
+			.min_y = min_y,
+			.max_x = max_x,
+			.max_y = max_y,
 		};
 	}
 
+	size_t split_along_edges_of(const Rectangle& other, Rectangle out[9]) const
+	{
+		out[0] = *this;
+
+		size_t vertical = 1;
+
+		if (min_x < other.min_x && other.min_x < max_x)
+		{
+			auto& rect1 = out[vertical - 1];
+			auto& rect2 = out[vertical - 0];
+			rect2 = rect1;
+
+			rect1.max_x = other.min_x;
+			rect2.min_x = other.min_x;
+
+			vertical++;
+		}
+
+		if (min_x < other.max_x && other.max_x < max_x)
+		{
+			auto& rect1 = out[vertical - 1];
+			auto& rect2 = out[vertical - 0];
+			rect2 = rect1;
+
+			rect1.max_x = other.max_x;
+			rect2.min_x = other.max_x;
+
+			vertical++;
+		}
+
+		size_t horizontal = 1;
+
+		if (min_y < other.min_y && other.min_y < max_y)
+		{
+			for (size_t i = 0; i < vertical; i++)
+			{
+				auto& rect1 = out[vertical * (horizontal - 1) + i];
+				auto& rect2 = out[vertical * (horizontal - 0) + i];
+				rect2 = rect1;
+
+				rect1.max_y = other.min_y;
+				rect2.min_y = other.min_y;
+			}
+			horizontal++;
+		}
+
+		if (min_y < other.max_y && other.max_y < max_y)
+		{
+			for (size_t i = 0; i < vertical; i++)
+			{
+				auto& rect1 = out[vertical * (horizontal - 1) + i];
+				auto& rect2 = out[vertical * (horizontal - 0) + i];
+				rect2 = rect1;
+
+				rect1.max_y = other.max_y;
+				rect2.min_y = other.max_y;
+			}
+			horizontal++;
+		}
+
+		return vertical * horizontal;
+	}
+
 	bool operator==(const Rectangle& other) const
 	{
-		return x == other.x && y == other.y && width == other.width && height == other.height;
+		return min_x == other.min_x && min_y == other.min_y && max_x == other.max_x && max_y == other.max_y;
 	}
 
 };
@@ -80,32 +158,3 @@ struct Circle
 	}
 
 };
-
-struct Range
-{
-	uint32_t start { 0 };
-	uint32_t count { 0 };
-
-	bool is_continuous_with(const Range& range) const
-	{
-		return start <= range.start + range.count && range.start <= start + count;
-	}
-
-	uint32_t distance_between(const Range& range) const
-	{
-		if (is_continuous_with(range))
-			return 0;
-		if (start < range.start)
-			return range.start - (start + count);
-		return start - (range.start + range.count);
-	}
-
-	void merge_with(const Range& range)
-	{
-		const uint32_t new_start = BAN::Math::min(start, range.start);
-		const uint32_t new_end   = BAN::Math::max(start + count, range.start + range.count);
-
-		start = new_start;
-		count = new_end - new_start;
-	}
-};

userspace/programs/WindowServer/Window.cpp

@@ -16,7 +16,22 @@ Window::~Window()
 	smo_delete(m_smo_key);
 
 	LibGUI::EventPacket::DestroyWindowEvent packet;
-	(void)packet.send_serialized(m_client_fd);
+
+	BAN::Vector<uint8_t> buffer;
+	if (!buffer.resize(packet.serialized_size()).is_error())
+	{
+		packet.serialize(buffer.span());
+
+		size_t total_sent = 0;
+		while (total_sent < buffer.size())
+		{
+			const ssize_t nsend = send(m_client_fd, buffer.data() + total_sent, buffer.size() - total_sent, 0);
+			if (nsend <= 0)
+				break;
+			total_sent += nsend;
+		}
+	}
+
 	close(m_client_fd);
 }
 
@@ -46,8 +61,8 @@ BAN::ErrorOr<void> Window::resize(uint32_t width, uint32_t height)
 	{
 		const auto old_area = m_client_area;
 
-		m_client_area.width = width;
-		m_client_area.height = height;
+		m_client_area.max_x = m_client_area.min_x + width;
+		m_client_area.max_y = m_client_area.min_y + height;
 		auto title_bar_ret = prepare_title_bar();
 		m_client_area = old_area;
 
@@ -65,8 +80,9 @@ BAN::ErrorOr<void> Window::resize(uint32_t width, uint32_t height)
 
 	m_fb_addr = fb_addr;
 	m_smo_key = smo_key;
-	m_client_area.width = width;
-	m_client_area.height = height;
+
+	m_client_area.max_x = m_client_area.min_x + width;
+	m_client_area.max_y = m_client_area.min_y + height;
 
 	return {};
 }
@@ -83,7 +99,7 @@ BAN::ErrorOr<void> Window::prepare_title_bar()
 
 	const auto text_area = title_text_area();
 
-	for (size_t i = 0; i < m_title.size() && (i + 1) * font_w < static_cast<uint32_t>(text_area.width); i++)
+	for (size_t i = 0; i < m_title.size() && (i + 1) * font_w < static_cast<uint32_t>(text_area.width()); i++)
 	{
 		const auto* glyph = m_font.glyph(m_title[i]);
 		if (glyph == nullptr)
@@ -97,7 +113,7 @@ BAN::ErrorOr<void> Window::prepare_title_bar()
 				break;
 			for (int32_t x = 0; (uint32_t)x < font_w; x++)
 			{
-				if (x + x_off >= text_area.width)
+				if (x + x_off >= text_area.width())
 					break;
 				const uint8_t bitmask = 1 << (font_w - x - 1);
 				if (glyph[y * font_p] & bitmask)

userspace/programs/WindowServer/Window.h

@@ -31,17 +31,23 @@ public:
 
 	void set_position(Position position)
 	{
-		m_client_area.x = position.x;
-		m_client_area.y = position.y;
+		const auto width = m_client_area.width();
+		const auto height = m_client_area.height();
+		m_client_area = {
+			.min_x = position.x,
+			.min_y = position.y,
+			.max_x = position.x + width,
+			.max_y = position.y + height,
+		};
 	}
 
 	int client_fd() const { return m_client_fd; }
 	long smo_key() const { return m_smo_key; }
 
-	int32_t client_x() const { return m_client_area.x; }
-	int32_t client_y() const { return m_client_area.y; }
-	int32_t client_width() const { return m_client_area.width; }
-	int32_t client_height() const { return m_client_area.height; }
+	int32_t client_x() const { return m_client_area.min_x; }
+	int32_t client_y() const { return m_client_area.min_y; }
+	int32_t client_width() const { return m_client_area.width(); }
+	int32_t client_height() const { return m_client_area.height(); }
 	Rectangle client_size() const { return { 0, 0, client_width(), client_height() }; }
 	Rectangle client_area() const { return m_client_area; }
 
@@ -50,14 +56,14 @@ public:
 	int32_t title_bar_width() const { return client_width(); }
 	int32_t title_bar_height() const { return m_attributes.title_bar ? m_title_bar_height : 0; }
 	Rectangle title_bar_size() const { return { 0, 0, title_bar_width(), title_bar_height() }; }
-	Rectangle title_bar_area() const { return { title_bar_x(), title_bar_y(), title_bar_width(), title_bar_height() }; }
+	Rectangle title_bar_area() const { return { title_bar_x(), title_bar_y(), title_bar_x() + title_bar_width(), title_bar_y() + title_bar_height() }; }
 
 	int32_t full_x() const { return title_bar_x(); }
 	int32_t full_y() const { return title_bar_y(); }
 	int32_t full_width() const { return client_width(); }
 	int32_t full_height() const { return client_height() + title_bar_height(); }
 	Rectangle full_size() const { return { 0, 0, full_width(), full_height() }; }
-	Rectangle full_area() const { return { full_x(), full_y(), full_width(), full_height() }; }
+	Rectangle full_area() const { return { full_x(), full_y(), full_x() + full_width(), full_y() + full_height() }; }
 
 	bool has_cursor() const { return m_cursor.has_value(); }
 	const Cursor& cursor() const { return m_cursor.value(); }
@@ -90,7 +96,7 @@ public:
 	}
 
 	Circle close_button_area() const { return { title_bar_x() + title_bar_width() - title_bar_height() / 2, title_bar_y() + title_bar_height() / 2, title_bar_height() * 3 / 8 }; }
-	Rectangle title_text_area() const { return { title_bar_x(), title_bar_y(), title_bar_width() - title_bar_height(), title_bar_height() }; }
+	Rectangle title_text_area() const { return { title_bar_x(), title_bar_y(), title_bar_x() + title_bar_width() - title_bar_height(), title_bar_y() + title_bar_height() }; }
 
 	BAN::ErrorOr<void> initialize(BAN::StringView title, uint32_t width, uint32_t height);
 	BAN::ErrorOr<void> resize(uint32_t width, uint32_t height);

userspace/programs/WindowServer/WindowServer.h

@@ -20,8 +20,10 @@ class WindowServer
 public:
 	struct ClientData
 	{
-		size_t packet_buffer_nread = 0;
-		BAN::Vector<uint8_t> packet_buffer;
+		size_t in_buffer_size { 0 };
+		BAN::Array<uint8_t, 64 * 1024> in_buffer;
+		size_t out_buffer_size { 0 };
+		BAN::Array<uint8_t, 64 * 1024> out_buffer;
 	};
 
 public:
@@ -54,30 +56,29 @@ public:
 	Rectangle cursor_area() const;
 	Rectangle resize_area(Position cursor) const;
 
-	void add_client_fd(int fd);
+	BAN::ErrorOr<void> add_client_fd(int fd);
 	void remove_client_fd(int fd);
 	ClientData& get_client_data(int fd);
 
+	bool is_damaged() const { return m_damaged_area_count > 0 || m_is_bouncing_window; }
 	bool is_stopped() const { return m_is_stopped; }
 
 private:
 	void on_mouse_move_impl(int32_t new_x, int32_t new_y);
 
-	void mark_pending_sync(Rectangle area);
+	void merge_damaged_areas();
+	void add_damaged_area(Rectangle area);
+	void add_damaged_area_impl(Rectangle area);
 
-	bool resize_window(BAN::RefPtr<Window> window, uint32_t width, uint32_t height) const;
+	bool resize_window(BAN::RefPtr<Window> window, uint32_t width, uint32_t height);
 
 	BAN::RefPtr<Window> find_window_with_fd(int fd) const;
 	BAN::RefPtr<Window> find_hovered_window() const;
 
-private:
-	struct RangeList
-	{
-		size_t range_count { 0 };
-		BAN::Array<Range, 32> ranges;
-		void add_range(const Range& range);
-	};
+	template<typename T>
+	BAN::ErrorOr<void> append_serialized_packet(const T& packet, int fd);
 
+private:
 	enum class State
 	{
 		Normal,
@@ -94,9 +95,12 @@ private:
 
 	const int32_t m_corner_radius;
 
-	BAN::Vector<RangeList> m_pending_syncs;
+	static constexpr size_t m_max_damaged_areas = 32;
+	size_t m_damaged_area_count { 0 };
+	BAN::Array<Rectangle, m_max_damaged_areas> m_damaged_areas;
 
-	BAN::UniqPtr<LibImage::Image> m_background_image;
+	// NOTE: same size as framebuffer
+	BAN::Vector<uint32_t> m_background_image;
 
 	State m_state { State::Normal };
 	bool m_is_mod_key_held { false };

userspace/programs/WindowServer/main.cpp

@@ -7,6 +7,8 @@
 #include <LibInput/KeyboardLayout.h>
 
 #include <fcntl.h>
+#include <limits.h>
+#include <signal.h>
 #include <stdlib.h>
 #include <sys/banan-os.h>
 #include <sys/epoll.h>
@@ -14,6 +16,7 @@
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/un.h>
+#include <time.h>
 #include <unistd.h>
 
 struct Config
@@ -145,6 +148,8 @@ int open_server_fd()
 	return server_fd;
 }
 
+int g_epoll_fd = -1;
+
 int main()
 {
 	srand(time(nullptr));
@@ -157,8 +162,8 @@ int main()
 		return 1;
 	}
 
-	int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
-	if (epoll_fd == -1)
+	g_epoll_fd = epoll_create1(EPOLL_CLOEXEC);
+	if (g_epoll_fd == -1)
 	{
 		dwarnln("epoll_create1: {}", strerror(errno));
 		return 1;
@@ -169,7 +174,7 @@ int main()
 			.events = EPOLLIN,
 			.data = { .fd = server_fd },
 		};
-		if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &event) == -1)
+		if (epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, server_fd, &event) == -1)
 		{
 			dwarnln("epoll_ctl server: {}", strerror(errno));
 			return 1;
@@ -214,7 +219,7 @@ int main()
 			.events = EPOLLIN,
 			.data = { .fd = keyboard_fd },
 		};
-		if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, keyboard_fd, &event) == -1)
+		if (epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, keyboard_fd, &event) == -1)
 		{
 			dwarnln("epoll_ctl keyboard: {}", strerror(errno));
 			close(keyboard_fd);
@@ -231,7 +236,7 @@ int main()
 			.events = EPOLLIN,
 			.data = { .fd = mouse_fd },
 		};
-		if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, mouse_fd, &event) == -1)
+		if (epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, mouse_fd, &event) == -1)
 		{
 			dwarnln("epoll_ctl mouse: {}", strerror(errno));
 			close(mouse_fd);
@@ -241,7 +246,7 @@ int main()
 
 	dprintln("Window server started");
 
-	if (access("/usr/bin/xbanan", O_EXEC) == 0)
+	if (access("/usr/bin/xbanan", X_OK) == 0)
 	{
 		if (fork() == 0)
 		{
@@ -271,19 +276,26 @@ int main()
 	uint64_t last_sync_us = get_current_us() - sync_interval_us;
 	while (!window_server.is_stopped())
 	{
-		const auto current_us = get_current_us();
-		if (current_us - last_sync_us > sync_interval_us)
-		{
-			window_server.sync();
-			last_sync_us += sync_interval_us;
-		}
+		timespec* ptimeout = nullptr;
 
 		timespec timeout = {};
-		if (auto current_us = get_current_us(); current_us - last_sync_us < sync_interval_us)
-			timeout.tv_nsec = (sync_interval_us - (current_us - last_sync_us)) * 1000;
+		if (window_server.is_damaged())
+		{
+			if (const auto current_us = get_current_us(); current_us - last_sync_us > sync_interval_us)
+			{
+				window_server.sync();
+
+				const auto full_intervals = (current_us - last_sync_us) / sync_interval_us;
+				last_sync_us += full_intervals * sync_interval_us;
+			}
+
+			if (const auto current_us = get_current_us(); current_us - last_sync_us < sync_interval_us)
+				timeout.tv_nsec = (sync_interval_us - (current_us - last_sync_us)) * 1000;
+			ptimeout = &timeout;
+		}
 
 		epoll_event events[16];
-		int epoll_events = epoll_pwait2(epoll_fd, events, 16, &timeout, nullptr);
+		int epoll_events = epoll_pwait2(g_epoll_fd, events, 16, ptimeout, nullptr);
 		if (epoll_events == -1 && errno != EINTR)
 		{
 			dwarnln("epoll_pwait2: {}", strerror(errno));
@@ -296,25 +308,28 @@ int main()
 			{
 				ASSERT(events[i].events & EPOLLIN);
 
-				int window_fd = accept4(server_fd, nullptr, nullptr, SOCK_NONBLOCK | SOCK_CLOEXEC);
-				if (window_fd == -1)
+				int client_fd = accept4(server_fd, nullptr, nullptr, SOCK_NONBLOCK | SOCK_CLOEXEC);
+				if (client_fd == -1)
 				{
 					dwarnln("accept: {}", strerror(errno));
 					continue;
 				}
 
-				epoll_event event {
-					.events = EPOLLIN,
-					.data = { .fd = window_fd },
-				};
-				if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, window_fd, &event) == -1)
+				epoll_event event { .events = EPOLLIN, .data = { .fd = client_fd } };
+				if (epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, client_fd, &event) == -1)
 				{
 					dwarnln("epoll_ctl: {}", strerror(errno));
-					close(window_fd);
+					close(client_fd);
+					continue;
+				}
+
+				if (auto ret = window_server.add_client_fd(client_fd); ret.is_error())
+				{
+					dwarnln("add_client: {}", ret.error());
+					close(client_fd);
 					continue;
 				}
 
-				window_server.add_client_fd(window_fd);
 				continue;
 			}
 
@@ -361,99 +376,127 @@ int main()
 			}
 
 			const int client_fd = events[i].data.fd;
-			if (events[i].events & EPOLLHUP)
+			if (events[i].events & (EPOLLHUP | EPOLLERR))
 			{
-				epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, nullptr);
+				epoll_ctl(g_epoll_fd, EPOLL_CTL_DEL, client_fd, nullptr);
 				window_server.remove_client_fd(client_fd);
 				continue;
 			}
 
-			ASSERT(events[i].events & EPOLLIN);
-
 			auto& client_data = window_server.get_client_data(client_fd);
 
-			if (client_data.packet_buffer.empty())
+			if (events[i].events & EPOLLOUT)
 			{
-				uint32_t packet_size;
-				const ssize_t nrecv = recv(client_fd, &packet_size, sizeof(uint32_t), 0);
-				if (nrecv < 0)
-					dwarnln("recv 1: {}", strerror(errno));
-				if (nrecv > 0 && nrecv != sizeof(uint32_t))
-					dwarnln("could not read packet size with a single recv call, closing connection...");
-				if (nrecv != sizeof(uint32_t))
+				ASSERT(client_data.out_buffer_size > 0);
+
+				const ssize_t nsend = send(client_fd, client_data.out_buffer.data(), client_data.out_buffer_size, 0);
+				if (nsend < 0 && !(errno == EWOULDBLOCK || errno == EAGAIN))
 				{
-					epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, nullptr);
+					dwarnln("send: {}", strerror(errno));
+					epoll_ctl(g_epoll_fd, EPOLL_CTL_DEL, client_fd, nullptr);
 					window_server.remove_client_fd(client_fd);
 					break;
 				}
 
-				if (packet_size < 4)
+				if (nsend > 0)
 				{
-					dwarnln("client sent invalid packet, closing connection...");
-					epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, nullptr);
-					window_server.remove_client_fd(client_fd);
-					break;
+					client_data.out_buffer_size -= nsend;
+					if (client_data.out_buffer_size == 0)
+					{
+						epoll_event event { .events = EPOLLIN, .data = { .fd = client_fd } };
+						if (epoll_ctl(g_epoll_fd, EPOLL_CTL_MOD, client_fd, &event) == -1)
+							dwarnln("epoll_ctl remove EPOLLOUT: {}", strerror(errno));
+					}
+					else
+					{
+						// TODO: maybe use a ring buffer so we don't have to memmove everything not sent
+						memmove(
+							client_data.out_buffer.data(),
+							client_data.out_buffer.data() + nsend,
+							client_data.out_buffer_size
+						);
+					}
 				}
-
-				// this is a bit harsh, but i don't want to work on skipping streaming packets
-				if (client_data.packet_buffer.resize(packet_size).is_error())
-				{
-					dwarnln("could not allocate memory for client packet, closing connection...");
-					epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, nullptr);
-					window_server.remove_client_fd(client_fd);
-					break;
-				}
-
-				client_data.packet_buffer_nread = 0;
-				continue;
 			}
 
-			const ssize_t nrecv = recv(
-				client_fd,
-				client_data.packet_buffer.data() + client_data.packet_buffer_nread,
-				client_data.packet_buffer.size() - client_data.packet_buffer_nread,
-				0
-			);
-			if (nrecv < 0)
-				dwarnln("recv 2: {}", strerror(errno));
-			if (nrecv <= 0)
-			{
-				epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, nullptr);
-				window_server.remove_client_fd(client_fd);
-				break;
-			}
-
-			client_data.packet_buffer_nread += nrecv;
-			if (client_data.packet_buffer_nread < client_data.packet_buffer.size())
+			if (!(events[i].events & EPOLLIN))
 				continue;
 
-			ASSERT(client_data.packet_buffer.size() >= sizeof(uint32_t));
-
-			switch (*reinterpret_cast<LibGUI::PacketType*>(client_data.packet_buffer.data()))
 			{
+				const ssize_t nrecv = recv(
+					client_fd,
+					client_data.in_buffer.data() + client_data.in_buffer_size,
+					client_data.in_buffer.size() - client_data.in_buffer_size,
+					0
+				);
+				if (nrecv < 0 && !(errno == EWOULDBLOCK || errno == EAGAIN))
+				{
+					dwarnln("recv: {}", strerror(errno));
+					epoll_ctl(g_epoll_fd, EPOLL_CTL_DEL, client_fd, nullptr);
+					window_server.remove_client_fd(client_fd);
+					break;
+				}
+				if (nrecv > 0)
+					client_data.in_buffer_size += nrecv;
+			}
+
+			size_t bytes_handled = 0;
+			while (client_data.in_buffer_size - bytes_handled >= sizeof(LibGUI::PacketHeader))
+			{
+				BAN::ConstByteSpan packet_span = client_data.in_buffer.span().slice(bytes_handled, client_data.in_buffer_size - bytes_handled);
+				const auto header = packet_span.as<const LibGUI::PacketHeader>();
+				if (packet_span.size() < header.size || header.size < sizeof(LibGUI::PacketHeader))
+					break;
+				packet_span = packet_span.slice(0, header.size);
+
+				switch (header.type)
+				{
 #define WINDOW_PACKET_CASE(enum, function) \
-				case LibGUI::PacketType::enum: \
-					if (auto ret = LibGUI::WindowPacket::enum::deserialize(client_data.packet_buffer.span()); !ret.is_error()) \
-						window_server.function(client_fd, ret.release_value()); \
-					break
-				WINDOW_PACKET_CASE(WindowCreate,           on_window_create);
-				WINDOW_PACKET_CASE(WindowInvalidate,       on_window_invalidate);
-				WINDOW_PACKET_CASE(WindowSetPosition,      on_window_set_position);
-				WINDOW_PACKET_CASE(WindowSetAttributes,    on_window_set_attributes);
-				WINDOW_PACKET_CASE(WindowSetMouseRelative, on_window_set_mouse_relative);
-				WINDOW_PACKET_CASE(WindowSetSize,          on_window_set_size);
-				WINDOW_PACKET_CASE(WindowSetMinSize,       on_window_set_min_size);
-				WINDOW_PACKET_CASE(WindowSetMaxSize,       on_window_set_max_size);
-				WINDOW_PACKET_CASE(WindowSetFullscreen,    on_window_set_fullscreen);
-				WINDOW_PACKET_CASE(WindowSetTitle,         on_window_set_title);
-				WINDOW_PACKET_CASE(WindowSetCursor,        on_window_set_cursor);
+					case LibGUI::PacketType::enum: \
+						if (auto ret = LibGUI::WindowPacket::enum::deserialize(packet_span); !ret.is_error()) \
+							window_server.function(client_fd, ret.release_value()); \
+						else \
+							derrorln("invalid packet: {}", ret.error()); \
+						break
+					WINDOW_PACKET_CASE(WindowCreate,           on_window_create);
+					WINDOW_PACKET_CASE(WindowInvalidate,       on_window_invalidate);
+					WINDOW_PACKET_CASE(WindowSetPosition,      on_window_set_position);
+					WINDOW_PACKET_CASE(WindowSetAttributes,    on_window_set_attributes);
+					WINDOW_PACKET_CASE(WindowSetMouseRelative, on_window_set_mouse_relative);
+					WINDOW_PACKET_CASE(WindowSetSize,          on_window_set_size);
+					WINDOW_PACKET_CASE(WindowSetMinSize,       on_window_set_min_size);
+					WINDOW_PACKET_CASE(WindowSetMaxSize,       on_window_set_max_size);
+					WINDOW_PACKET_CASE(WindowSetFullscreen,    on_window_set_fullscreen);
+					WINDOW_PACKET_CASE(WindowSetTitle,         on_window_set_title);
+					WINDOW_PACKET_CASE(WindowSetCursor,        on_window_set_cursor);
 #undef WINDOW_PACKET_CASE
-				default:
-					dprintln("unhandled packet type: {}", *reinterpret_cast<uint32_t*>(client_data.packet_buffer.data()));
+					default:
+						dprintln("unhandled packet type: {}", static_cast<uint32_t>(header.type));
+						break;
+				}
+
+				bytes_handled += header.size;
 			}
 
-			client_data.packet_buffer.clear();
-			client_data.packet_buffer_nread = 0;
+			// NOTE: this will only move a single partial packet, so this is fine
+			client_data.in_buffer_size -= bytes_handled;
+			memmove(
+				client_data.in_buffer.data(),
+				client_data.in_buffer.data() + bytes_handled,
+				client_data.in_buffer_size
+			);
+
+			if (client_data.in_buffer_size >= sizeof(LibGUI::PacketHeader))
+			{
+				const auto header = BAN::ConstByteSpan(client_data.in_buffer.span()).as<const LibGUI::PacketHeader>();
+				if (header.size < sizeof(LibGUI::PacketHeader) || header.size > client_data.in_buffer.size())
+				{
+					dwarnln("client tried to send a {} byte packet", header.size);
+					epoll_ctl(g_epoll_fd, EPOLL_CTL_DEL, client_fd, nullptr);
+					window_server.remove_client_fd(client_fd);
+					break;
+				}
+			}
 		}
 	}
 }