Kernel: Move Spinlock functions back to arch independent Locking folder

Now that the Spinlock code is not dependent on architectural specific
code anymore, we can move it back to the Locking folder. This also means
that the Spinlock implemenation is now used for the aarch64 kernel.

Kernel/Locking/Spinlock.h

@@ -8,11 +8,73 @@
 
 #include <AK/Atomic.h>
 #include <AK/Types.h>
-#include <Kernel/Arch/Spinlock.h>
+#include <Kernel/Arch/Processor.h>
 #include <Kernel/Locking/LockRank.h>
 
 namespace Kernel {
 
+class Spinlock {
+    AK_MAKE_NONCOPYABLE(Spinlock);
+    AK_MAKE_NONMOVABLE(Spinlock);
+
+public:
+    Spinlock(LockRank rank)
+        : m_rank(rank)
+    {
+    }
+
+    InterruptsState lock();
+    void unlock(InterruptsState);
+
+    [[nodiscard]] ALWAYS_INLINE bool is_locked() const
+    {
+        return m_lock.load(AK::memory_order_relaxed) != 0;
+    }
+
+    ALWAYS_INLINE void initialize()
+    {
+        m_lock.store(0, AK::memory_order_relaxed);
+    }
+
+private:
+    Atomic<u8> m_lock { 0 };
+    const LockRank m_rank;
+};
+
+class RecursiveSpinlock {
+    AK_MAKE_NONCOPYABLE(RecursiveSpinlock);
+    AK_MAKE_NONMOVABLE(RecursiveSpinlock);
+
+public:
+    RecursiveSpinlock(LockRank rank)
+        : m_rank(rank)
+    {
+    }
+
+    InterruptsState lock();
+    void unlock(InterruptsState);
+
+    [[nodiscard]] ALWAYS_INLINE bool is_locked() const
+    {
+        return m_lock.load(AK::memory_order_relaxed) != 0;
+    }
+
+    [[nodiscard]] ALWAYS_INLINE bool is_locked_by_current_processor() const
+    {
+        return m_lock.load(AK::memory_order_relaxed) == FlatPtr(&Processor::current());
+    }
+
+    ALWAYS_INLINE void initialize()
+    {
+        m_lock.store(0, AK::memory_order_relaxed);
+    }
+
+private:
+    Atomic<FlatPtr> m_lock { 0 };
+    u32 m_recursions { 0 };
+    const LockRank m_rank;
+};
+
 template<typename LockType>
 class [[nodiscard]] SpinlockLocker {
     AK_MAKE_NONCOPYABLE(SpinlockLocker);