Kernel: Implement SpinLock without CriticalScope

This actually is not even spinlock since it yields the current
thread. It will become one when I get to SMP though...

BAN/include/BAN/Atomic.h

@@ -35,6 +35,8 @@ namespace BAN
 		inline T operator--(int) volatile { return __atomic_fetch_sub(&m_value, 1, MEM_ORDER); }
 		inline T operator++(int) volatile { return __atomic_fetch_add(&m_value, 1, MEM_ORDER); }
 
+		inline bool compare_exchange(T expected, T desired) volatile { return __atomic_compare_exchange_n(&m_value, &expected, desired, false, MEM_ORDER, MEM_ORDER); }
+
 	private:
 		T m_value;
 	};

kernel/include/kernel/SpinLock.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <BAN/Atomic.h>
 #include <BAN/NoCopyMove.h>
 
 #include <sys/types.h>
@@ -19,7 +20,7 @@ namespace Kernel
 		bool is_locked() const;
 
 	private:
-		volatile pid_t m_locker = -1;
+		BAN::Atomic<pid_t> m_locker = -1;
 	};
 
 	class RecursiveSpinLock
@@ -34,8 +35,8 @@ namespace Kernel
 		bool is_locked() const;
 
 	private:
-		pid_t m_locker = -1;
-		uint32_t m_lock_depth = 0;
+		BAN::Atomic<pid_t> m_locker = -1;
+		BAN::Atomic<uint32_t> m_lock_depth = 0;
 		SpinLock m_lock;
 	};
 

kernel/kernel/SpinLock.cpp

@@ -1,6 +1,5 @@
 #include <kernel/Scheduler.h>
 #include <kernel/SpinLock.h>
-#include <kernel/CriticalScope.h>
 
 namespace Kernel
 {
@@ -8,31 +7,18 @@ namespace Kernel
 	void SpinLock::lock()
 	{
 		pid_t tid = Scheduler::current_tid();
-		while (true)
-		{
-			{
-				CriticalScope _;
-				ASSERT(m_locker != tid);
-				if (m_locker == -1)
-				{
-					m_locker = tid;
-					break;
-				}
-			}
+		while (!m_locker.compare_exchange(-1, tid))
 			Scheduler::get().reschedule();
-		}
 	}
 
 	void SpinLock::unlock()
 	{
-		CriticalScope _;
 		ASSERT(m_locker == Scheduler::current_tid());
 		m_locker = -1;
 	}
 
 	bool SpinLock::is_locked() const
 	{
-		CriticalScope _;
 		return m_locker != -1;
 	}