Implemented thread_ctrl::interrupt

Utilities/Thread.h

@@ -94,6 +94,9 @@ private:
 	// Thread join contention counter
 	atomic_t<u32> m_joining{};
 
+	// Thread interrupt guard counter
+	u32 m_guard = 0x80000000;
+
 	// Thread internals
 	atomic_t<internal*> m_data{};
 
@@ -187,6 +190,42 @@ public:
 	// Set exception (internal data must be initialized, thread mutex must be locked)
 	void set_exception(std::exception_ptr);
 
+	// Internal
+	static void handle_interrupt();
+
+	// Interrupt thread with specified handler call (thread mutex must be locked)
+	void interrupt(void(*handler)());
+
+	// Interrupt guard recursive enter
+	void guard_enter()
+	{
+		m_guard++;
+	}
+
+	// Interrupt guard recursive leave
+	void guard_leave()
+	{
+		if (UNLIKELY(--m_guard & 0x40000000))
+		{
+			test_interrupt();
+		}
+	}
+
+	// Allow interrupts
+	void interrupt_enable()
+	{
+		m_guard &= ~0x80000000;
+	}
+
+	// Disable and discard any interrupt
+	void interrupt_disable()
+	{
+		m_guard |= 0x80000000;
+	}
+
+	// Check interrupt if delayed by guard scope
+	void test_interrupt();
+
 	// Current thread sleeps for specified amount of microseconds.
 	// Wrapper for std::this_thread::sleep, doesn't require valid thread_ctrl.
 	[[deprecated]] static void sleep(u64 useconds);
@@ -352,6 +391,36 @@ public:
 	}
 };
 
+// Interrupt guard scope
+class thread_guard final
+{
+	thread_ctrl* m_thread;
+
+public:
+	thread_guard(const thread_guard&) = delete;
+
+	thread_guard(thread_ctrl* thread)
+		: m_thread(thread)
+	{
+		m_thread->guard_enter();
+	}
+
+	thread_guard(named_thread& thread)
+		: thread_guard(thread.operator->())
+	{
+	}
+
+	thread_guard()
+		: thread_guard(thread_ctrl::get_current())
+	{
+	}
+
+	~thread_guard() noexcept(false)
+	{
+		m_thread->guard_leave();
+	}
+};
+
 // Wrapper for named thread, joins automatically in the destructor, can only be used in function scope
 class scope_thread final
 {