243 lines
6.3 KiB
C++
243 lines
6.3 KiB
C++
#include <kernel/ACPI/AML/Namespace.h>
|
|
#include <kernel/ACPI/AML/ParseContext.h>
|
|
#include <kernel/ACPI/AML/Region.h>
|
|
|
|
namespace Kernel::ACPI
|
|
{
|
|
|
|
BAN::Optional<AML::NameString> AML::Namespace::resolve_path(const AML::NameString& relative_base, const AML::NameString& relative_path)
|
|
{
|
|
// Base must be non-empty absolute path
|
|
ASSERT(relative_base.prefix == "\\"sv || relative_base.path.empty());
|
|
|
|
// Do absolute path lookup
|
|
if (!relative_path.prefix.empty() || relative_path.path.size() != 1)
|
|
{
|
|
AML::NameString absolute_path;
|
|
MUST(absolute_path.prefix.push_back('\\'));
|
|
|
|
// Resolve root and parent references
|
|
if (relative_path.prefix == "\\"sv)
|
|
;
|
|
else
|
|
{
|
|
if (relative_path.prefix.size() > relative_base.path.size())
|
|
{
|
|
AML_ERROR("Trying to resolve parent of root object");
|
|
return {};
|
|
}
|
|
for (size_t i = 0; i < relative_base.path.size() - relative_path.prefix.size(); i++)
|
|
MUST(absolute_path.path.push_back(relative_base.path[i]));
|
|
}
|
|
|
|
// Append relative path
|
|
for (const auto& seg : relative_path.path)
|
|
MUST(absolute_path.path.push_back(seg));
|
|
|
|
// Validate path
|
|
BAN::RefPtr<AML::NamedObject> current_node = this;
|
|
for (const auto& seg : absolute_path.path)
|
|
{
|
|
if (!current_node->is_scope())
|
|
return {};
|
|
|
|
auto* current_scope = static_cast<AML::Scope*>(current_node.ptr());
|
|
auto it = current_scope->objects.find(seg);
|
|
if (it == current_scope->objects.end())
|
|
return {};
|
|
|
|
current_node = it->value;
|
|
}
|
|
return absolute_path;
|
|
}
|
|
|
|
|
|
// Resolve with namespace search rules (ACPI Spec 6.4 - Section 5.3)
|
|
|
|
AML::NameString last_match_path;
|
|
AML::NameSeg target_seg = relative_path.path.back();
|
|
|
|
BAN::RefPtr<AML::Scope> current_scope = this;
|
|
AML::NameString current_path;
|
|
|
|
// Check root namespace
|
|
{
|
|
// If scope contains object with the same name as the segment, update last match
|
|
if (current_scope->objects.contains(target_seg))
|
|
{
|
|
last_match_path = current_path;
|
|
MUST(last_match_path.path.push_back(target_seg));
|
|
}
|
|
}
|
|
|
|
// Check base base path
|
|
for (const auto& seg : relative_base.path)
|
|
{
|
|
auto next_node = current_scope->objects[seg];
|
|
ASSERT(next_node && next_node->is_scope());
|
|
|
|
current_scope = static_cast<AML::Scope*>(next_node.ptr());
|
|
MUST(current_path.path.push_back(seg));
|
|
|
|
// If scope contains object with the same name as the segment, update last match
|
|
if (current_scope->objects.contains(target_seg))
|
|
{
|
|
last_match_path = current_path;
|
|
MUST(last_match_path.path.push_back(target_seg));
|
|
}
|
|
}
|
|
|
|
if (!last_match_path.path.empty())
|
|
{
|
|
MUST(last_match_path.prefix.push_back('\\'));
|
|
return last_match_path;
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
BAN::RefPtr<AML::NamedObject> AML::Namespace::find_object(const AML::NameString& relative_base, const AML::NameString& relative_path)
|
|
{
|
|
auto canonical_path = resolve_path(relative_base, relative_path);
|
|
if (!canonical_path.has_value())
|
|
return nullptr;
|
|
if (canonical_path->path.empty())
|
|
return this;
|
|
|
|
BAN::RefPtr<NamedObject> node = this;
|
|
for (const auto& seg : canonical_path->path)
|
|
{
|
|
// Resolve path validates that all nodes are scopes
|
|
ASSERT(node->is_scope());
|
|
node = static_cast<Scope*>(node.ptr())->objects[seg];
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
bool AML::Namespace::add_named_object(ParseContext& parse_context, const AML::NameString& object_path, BAN::RefPtr<NamedObject> object)
|
|
{
|
|
ASSERT(!object_path.path.empty());
|
|
ASSERT(object_path.path.back() == object->name);
|
|
|
|
auto parent_path = object_path;
|
|
parent_path.path.pop_back();
|
|
|
|
auto parent_object = find_object(parse_context.scope, parent_path);
|
|
if (!parent_object)
|
|
{
|
|
AML_ERROR("Parent object not found");
|
|
return false;
|
|
}
|
|
|
|
if (!parent_object->is_scope())
|
|
{
|
|
AML_ERROR("Parent object is not a scope");
|
|
return false;
|
|
}
|
|
|
|
auto* parent_scope = static_cast<Scope*>(parent_object.ptr());
|
|
if (parent_scope->objects.contains(object->name))
|
|
{
|
|
AML_ERROR("Object already exists");
|
|
return false;
|
|
}
|
|
|
|
MUST(parent_scope->objects.insert(object->name, object));
|
|
|
|
auto canonical_scope = resolve_path(parse_context.scope, object_path);
|
|
ASSERT(canonical_scope.has_value());
|
|
if (object->is_scope())
|
|
{
|
|
auto* scope = static_cast<Scope*>(object.ptr());
|
|
scope->scope = canonical_scope.value();
|
|
}
|
|
MUST(parse_context.created_objects.push_back(BAN::move(canonical_scope.release_value())));
|
|
|
|
return true;
|
|
}
|
|
|
|
bool AML::Namespace::remove_named_object(const AML::NameString& absolute_path)
|
|
{
|
|
auto canonical_path = resolve_path({}, absolute_path);
|
|
if (!canonical_path.has_value())
|
|
{
|
|
AML_ERROR("Failed to resolve path");
|
|
return false;
|
|
}
|
|
|
|
if (canonical_path->path.empty())
|
|
{
|
|
AML_ERROR("Trying to remove root object");
|
|
return false;
|
|
}
|
|
|
|
BAN::RefPtr<NamedObject> parent_object = this;
|
|
|
|
for (size_t i = 0; i < canonical_path->path.size() - 1; i++)
|
|
{
|
|
if (!parent_object->is_scope())
|
|
{
|
|
AML_ERROR("Parent object is not a scope");
|
|
return false;
|
|
}
|
|
|
|
auto* parent_scope = static_cast<Scope*>(parent_object.ptr());
|
|
|
|
auto it = parent_scope->objects.find(canonical_path->path[i]);
|
|
if (it == parent_scope->objects.end())
|
|
{
|
|
AML_ERROR("Object not found");
|
|
return false;
|
|
}
|
|
|
|
parent_object = it->value;
|
|
ASSERT(parent_object);
|
|
}
|
|
|
|
if (!parent_object->is_scope())
|
|
{
|
|
AML_ERROR("Parent object is not a scope");
|
|
return false;
|
|
}
|
|
|
|
auto* parent_scope = static_cast<Scope*>(parent_object.ptr());
|
|
parent_scope->objects.remove(canonical_path->path.back());
|
|
|
|
return true;
|
|
}
|
|
|
|
BAN::RefPtr<AML::Namespace> AML::Namespace::parse(BAN::ConstByteSpan aml_data)
|
|
{
|
|
auto result = MUST(BAN::RefPtr<Namespace>::create(NameSeg("\\"sv)));
|
|
|
|
AML::ParseContext context;
|
|
context.scope = AML::NameString("\\"sv);
|
|
context.aml_data = aml_data;
|
|
context.root_namespace = result.ptr();
|
|
|
|
// Add predefined namespaces
|
|
#define ADD_PREDEFIED_NAMESPACE(NAME) \
|
|
ASSERT(result->add_named_object(context, AML::NameString("\\" NAME), MUST(BAN::RefPtr<AML::Namespace>::create(NameSeg(NAME)))));
|
|
ADD_PREDEFIED_NAMESPACE("_GPE"sv);
|
|
ADD_PREDEFIED_NAMESPACE("_PR"sv);
|
|
ADD_PREDEFIED_NAMESPACE("_SB"sv);
|
|
ADD_PREDEFIED_NAMESPACE("_SI"sv);
|
|
ADD_PREDEFIED_NAMESPACE("_TZ"sv);
|
|
#undef ADD_PREDEFIED_NAMESPACE
|
|
|
|
while (context.aml_data.size() > 0)
|
|
{
|
|
auto result = AML::parse_object(context);
|
|
if (!result.success())
|
|
{
|
|
AML_ERROR("Failed to parse object");
|
|
return {};
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
}
|