1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
#include <kapi/devices/interface_registry.hpp>
#include <kapi/devices.hpp>
#include <kapi/system.hpp>
#include <kapi/test_support/devices.hpp>
#include <kstd/memory.hpp>
#include <kstd/result.hpp>
#include <kstd/string.hpp>
#include <kstd/system_error.hpp>
#include <kstd/vector.hpp>
#include <algorithm>
#include <optional>
#include <string_view>
#include <utility>
namespace kapi::devices
{
namespace
{
constinit auto static registry = std::optional<interface_registry>{};
}
auto interface_registry::init() -> void
{
if (registry.has_value())
{
system::panic("[kernel] Device interface registry has already been initialized.");
}
registry.emplace();
}
auto interface_registry::get() -> interface_registry &
{
if (!registry)
{
system::panic("[kernel] Device interface registry has not been initialized.");
}
return *registry;
}
auto interface_registry::do_publish(kstd::shared_ptr<device> device, kstd::string name, interface interface,
void * implementation) -> kstd::result<void>
{
erase_if(m_entries, [interface](auto e) { return e.interface() == interface && e.device().expired(); });
if (!device || !implementation || name.empty())
{
return kstd::failure(make_error_code(kstd::errc::invalid_argument));
}
auto published = std::ranges::any_of(m_entries, [&](auto const & entry) {
return entry.interface() == interface && entry.device().lock().get() == device.get();
});
if (published)
{
return kstd::failure(make_error_code(kstd::errc::file_exists));
}
m_entries.emplace_back(device, std::move(name), interface, implementation);
return kstd::success();
}
auto interface_registry::unpublish(device const & device, interface interface) -> void
{
erase_if(m_entries, [&](auto e) {
auto locked_device = e.device().lock();
return e.interface() == interface && locked_device && locked_device.get() == &device;
});
}
auto interface_registry::all(interface interface) const -> kstd::vector<entry>
{
auto filtered = m_entries;
erase_if(filtered, [&](auto e) {
auto locked_device = e.device().lock();
return !(e.interface() == interface && locked_device);
});
return filtered;
}
auto interface_registry::find(interface interface, std::string_view name) const -> kstd::result<entry>
{
auto found = std::ranges::find_if(
m_entries, [&](auto e) { return e.interface() == interface && e.name() == name && e.device().lock(); });
if (found == m_entries.cend())
{
return kstd::failure(make_error_code(kstd::errc::no_such_device));
}
return *found;
}
} // namespace kapi::devices
namespace kapi::test_support::devices
{
auto deinit_interface_registry() -> void
{
kapi::devices::registry.reset();
}
} // namespace kapi::test_support::devices
|
