kernel/arch/x86_64/IDT.cpp

@@ -189,7 +189,6 @@ namespace Kernel::IDT
 				else
 				{
 					derrorln("Stack pointer out of bounds!");
-					derrorln("rip {H}", interrupt_stack.rip);
 					derrorln("rsp {H}, stack {H}->{H}, istack {H}->{H}",
 						interrupt_stack.rsp,
 						stack.vaddr(), stack.vaddr() + stack.size(),
@@ -219,23 +218,6 @@ namespace Kernel::IDT
 					}
 				}
 			}
-#if __enable_sse
-			else if (isr == ISR::DeviceNotAvailable)
-			{
-				asm volatile(
-					"movq %cr0, %rax;"
-					"andq $~(1 << 3), %rax;"
-					"movq %rax, %cr0;"
-				);
-				if (auto* current = &Thread::current(); current != Thread::sse_thread())
-				{
-					if (auto* sse = Thread::sse_thread())
-						sse->save_sse();
-					current->load_sse();
-				}
-				goto done;
-			}
-#endif
 		}
 
 		if (PageTable::current().get_page_flags(interrupt_stack.rip & PAGE_ADDR_MASK) & PageTable::Flags::Present)
@@ -277,6 +259,7 @@ namespace Kernel::IDT
 			int signal = 0;
 			switch (isr)
 			{
+			case ISR::DeviceNotAvailable:
 			case ISR::DivisionError:
 			case ISR::SIMDFloatingPointException:
 			case ISR::x87FloatingPointException:
@@ -307,11 +290,22 @@ namespace Kernel::IDT
 		ASSERT(Thread::current().state() != Thread::State::Terminated);
 	
 done:
+#if __enable_sse
+		if (from_userspace)
+		{
+			ASSERT(Thread::current().state() == Thread::State::Executing);
+			Thread::current().load_sse();
+		}
+#endif
 		return;
 	}
 
 	extern "C" void cpp_irq_handler(uint64_t irq, InterruptStack& interrupt_stack)
 	{
+#if __enable_sse
+		Thread::current().save_sse();
+#endif
+
 		if (Scheduler::current_tid())
 		{
 			Thread::current().set_return_rsp(interrupt_stack.rsp);
@@ -332,6 +326,10 @@ done:
 		Scheduler::get().reschedule_if_idling();
 
 		ASSERT(Thread::current().state() != Thread::State::Terminated);
+
+#if __enable_sse
+		Thread::current().load_sse();
+#endif
 	}
 
 	static void flush_idt()

kernel/include/kernel/Thread.h

@@ -87,9 +87,8 @@ namespace Kernel
 		size_t physical_page_count() const { return virtual_page_count(); }
 
 #if __enable_sse
-		void save_sse();
-		void load_sse();
-		static Thread* sse_thread();
+		void save_sse() { asm volatile("fxsave %0" :: "m"(m_sse_storage)); }
+		void load_sse() { asm volatile("fxrstor %0" :: "m"(m_sse_storage)); }
 #endif
 
 	private:

kernel/kernel/Scheduler.cpp

@@ -231,17 +231,6 @@ namespace Kernel
 
 		Thread* current = &current_thread();
 
-#if __enable_sse
-		if (current != Thread::sse_thread())
-		{
-			asm volatile(
-				"movq %cr0, %rax;"
-				"orq $(1 << 3), %rax;"
-				"movq %rax, %cr0"
-			);
-		}
-#endif
-
 		while (current->state() == Thread::State::Terminated)
 		{
 			Thread* thread = m_current_thread->thread;

kernel/kernel/Syscall.cpp

@@ -26,6 +26,10 @@ namespace Kernel
 		Thread::current().set_return_rsp(interrupt_stack.rsp);
 		Thread::current().set_return_rip(interrupt_stack.rip);
 
+#if __enable_sse
+		Thread::current().save_sse();
+#endif
+
 		asm volatile("sti");
 
 		(void)arg1;
@@ -217,9 +221,6 @@ namespace Kernel
 
 		asm volatile("cli");
 
-		if (ret.is_error() && ret.error().get_error_code() == ENOTSUP)
-			dprintln("ENOTSUP {}", syscall);
-
 		if (ret.is_error() && ret.error().is_kernel_error())
 			Kernel::panic("Kernel error while returning to userspace {}", ret.error());
 
@@ -229,6 +230,10 @@ namespace Kernel
 
 		ASSERT(Kernel::Thread::current().state() == Kernel::Thread::State::Executing);
 
+#if __enable_sse
+		current_thread.load_sse();
+#endif
+
 		if (ret.is_error())
 			return -ret.error().get_error_code();
 		return ret.value();

kernel/kernel/Thread.cpp

@@ -101,16 +101,7 @@ namespace Kernel
 		: m_tid(tid), m_process(process)
 	{
 #if __enable_sse
-		uintptr_t cr0;
-		asm volatile(
-			"movq %%cr0, %%rax;"
-			"movq %%rax, %%rbx;"
-			"andq $~(1 << 3), %%rax;"
-			"movq %%rax, %%cr0;"
-			: "=b"(cr0)
-		);
 		save_sse();
-		asm volatile("movq %0, %%cr0" :: "r"(cr0));
 #endif
 	}
 
@@ -370,24 +361,4 @@ namespace Kernel
 		ASSERT_NOT_REACHED();
 	}
 
-#if __enable_sse
-	static Thread* s_sse_thread = nullptr;
-
-	void Thread::save_sse()
-	{
-		asm volatile("fxsave %0" :: "m"(m_sse_storage));
-	}
-
-	void Thread::load_sse()
-	{
-		asm volatile("fxrstor %0" :: "m"(m_sse_storage));
-		s_sse_thread = this;
-	}
-
-	Thread* Thread::sse_thread()
-	{
-		return s_sse_thread;
-	}
-#endif
-
 }

libc/stdlib.cpp

@@ -13,9 +13,6 @@ extern "C" char** environ;
 
 extern "C" void _fini();
 
-static void (*at_exit_funcs[64])();
-static uint32_t at_exit_funcs_count = 0;
-
 void abort(void)
 {
 	fflush(nullptr);
@@ -25,8 +22,6 @@ void abort(void)
 
 void exit(int status)
 {
-	for (uint32_t i = at_exit_funcs_count; i > 0; i--)
-		at_exit_funcs[i - 1]();
 	fflush(nullptr);
 	__cxa_finalize(nullptr);
 	_fini();
@@ -39,16 +34,10 @@ int abs(int val)
 	return val < 0 ? -val : val;
 }
 
-int atexit(void (*func)(void))
+int atexit(void(*)(void))
 {
-	if (at_exit_funcs_count > sizeof(at_exit_funcs) / sizeof(*at_exit_funcs))
-	{
-		errno = ENOBUFS;
 	return -1;
 }
-	at_exit_funcs[at_exit_funcs_count++] = func;
-	return 0;
-}
 
 int atoi(const char* str)
 {