Kernel: Implement locking for AML

Now global lock uses the actual global lock. Currenly if no lock
can be acquired, we just panic the kernel so that I remember to
implement it properly once AML is running concurrently.

kernel/include/kernel/ACPI/AML/Mutex.h

@@ -1,14 +1,18 @@
 #pragma once
 
 #include <kernel/ACPI/AML/Bytes.h>
+#include <kernel/ACPI/AML/Integer.h>
 #include <kernel/ACPI/AML/NamedObject.h>
 #include <kernel/ACPI/AML/ParseContext.h>
+#include <kernel/Lock/Mutex.h>
+#include <kernel/Timer/Timer.h>
 
 namespace Kernel::ACPI::AML
 {
 
 	struct Mutex : public AML::NamedObject
 	{
+		Kernel::Mutex mutex;
 		uint8_t sync_level;
 
 		Mutex(NameSeg name, uint8_t sync_level)
@@ -17,6 +21,33 @@ namespace Kernel::ACPI::AML
 		{}
 
 		static ParseResult parse(ParseContext& context)
+		{
+			ASSERT(context.aml_data.size() >= 2);
+			ASSERT(static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::ExtOpPrefix);
+
+			switch (static_cast<AML::ExtOp>(context.aml_data[1]))
+			{
+				case AML::ExtOp::MutexOp:
+					return parse_mutex(context);
+				case AML::ExtOp::AcquireOp:
+					return parse_acquire(context);
+				case AML::ExtOp::ReleaseOp:
+					return parse_release(context);
+				default:
+					ASSERT_NOT_REACHED();
+			}
+		}
+
+		virtual void debug_print(int indent) const override
+		{
+			AML_DEBUG_PRINT_INDENT(indent);
+			AML_DEBUG_PRINT("Mutex ");
+			name.debug_print();
+			AML_DEBUG_PRINT(" (SyncLevel: {})", sync_level);
+		}
+
+	private:
+		static ParseResult parse_mutex(ParseContext& context)
 		{
 			ASSERT(context.aml_data.size() >= 2);
 			ASSERT(static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::ExtOpPrefix);
@@ -50,13 +81,86 @@ namespace Kernel::ACPI::AML
 			return ParseResult::Success;
 		}
 
-		virtual void debug_print(int indent) const override
+		static ParseResult parse_acquire(ParseContext& context)
 		{
-			AML_DEBUG_PRINT_INDENT(indent);
-			AML_DEBUG_PRINT("Mutex ");
-			name.debug_print();
-			AML_DEBUG_PRINT(" (SyncLevel: {})", sync_level);
+			ASSERT(context.aml_data.size() >= 2);
+			ASSERT(static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::ExtOpPrefix);
+			ASSERT(static_cast<AML::ExtOp>(context.aml_data[1]) == AML::ExtOp::AcquireOp);
+			context.aml_data = context.aml_data.slice(2);
+
+			auto mutex_result = AML::parse_object(context);
+			if (!mutex_result.success() || !mutex_result.node() || mutex_result.node()->type != AML::Node::Type::Mutex)
+			{
+				AML_ERROR("Acquire does not name a valid mutex");
+				return ParseResult::Failure;
+			}
+
+			auto* mutex = static_cast<AML::Mutex*>(mutex_result.node().ptr());
+			if (mutex->sync_level < context.sync_level())
+			{
+				AML_ERROR("Trying to acquire mutex with lower sync level than current sync level");
+				return ParseResult::Failure;
+			}
+
+			if (context.aml_data.size() < 2)
+			{
+				AML_ERROR("Missing timeout value");
+				return ParseResult::Failure;
+			}
+			uint16_t timeout = context.aml_data[0] | (context.aml_data[1] << 8);
+			context.aml_data = context.aml_data.slice(2);
+
+			if (timeout >= 0xFFFF)
+				mutex->mutex.lock();
+			else
+			{
+				// FIXME: This is a very inefficient way to wait for a mutex
+				uint64_t wake_time = SystemTimer::get().ms_since_boot() + timeout;
+				while (!mutex->mutex.try_lock())
+				{
+					if (SystemTimer::get().ms_since_boot() >= wake_time)
+						return ParseResult(MUST(BAN::RefPtr<AML::Integer>::create(AML::Integer::Ones)));
+					SystemTimer::get().sleep(1);
+				}
+			}
+
+			MUST(context.sync_stack.push_back(mutex->sync_level));
+			return ParseResult(MUST(BAN::RefPtr<AML::Integer>::create(0)));
 		}
+
+		static ParseResult parse_release(ParseContext& context)
+		{
+			ASSERT(context.aml_data.size() >= 2);
+			ASSERT(static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::ExtOpPrefix);
+			ASSERT(static_cast<AML::ExtOp>(context.aml_data[1]) == AML::ExtOp::ReleaseOp);
+			context.aml_data = context.aml_data.slice(2);
+
+			auto mutex_result = AML::parse_object(context);
+			if (!mutex_result.success() || !mutex_result.node() || mutex_result.node()->type != AML::Node::Type::Mutex)
+			{
+				AML_ERROR("Release does not name a valid mutex");
+				return ParseResult::Failure;
+			}
+
+			if (context.sync_stack.empty())
+			{
+				AML_ERROR("Trying to release mutex without having acquired it");
+				return ParseResult::Failure;
+			}
+
+			auto* mutex = static_cast<AML::Mutex*>(mutex_result.node().ptr());
+			if (mutex->sync_level != context.sync_level())
+			{
+				AML_ERROR("Trying to release mutex with different sync level than current sync level");
+				return ParseResult::Failure;
+			}
+
+			mutex->mutex.unlock();
+			context.sync_stack.pop_back();
+
+			return ParseResult::Success;
+		}
+
 	};
 
 }