blob: 06efc27d7ba130cd3d21a7ac86e20cff002a5db9 (
plain)
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
|
#include <kernel/devices/storage/management.hpp>
#include <kernel/devices/storage/controller.hpp>
#include <kernel/devices/storage/ram_disk/controller.hpp>
#include <kapi/boot_modules.hpp>
#include <kapi/devices/device.hpp>
#include <kapi/system.hpp>
#include <kstd/memory>
#include <kstd/vector>
#include <algorithm>
#include <cstddef>
#include <optional>
#include <ranges>
namespace
{
constexpr size_t static minors_per_device = 16;
constexpr size_t static start_major = 1;
constinit size_t static next_free_major = start_major;
constinit auto static storage_management = std::optional<kernel::devices::storage::management>{};
} // namespace
namespace kernel::devices::storage
{
auto management::init() -> void
{
if (storage_management)
{
kapi::system::panic("[DEVICES] Storage management has already been initialized.");
}
storage_management.emplace(management{});
auto ram_disk_controller = kstd::make_shared<ram_disk::controller>(&kapi::boot_modules::get_boot_module_registry());
storage_management->add_controller(ram_disk_controller);
std::ranges::for_each(storage_management->m_controllers, [](auto controller) { controller->probe(); });
}
auto management::get() -> management &
{
if (!storage_management)
{
kapi::system::panic("[DEVICES] Storage management has not been initialized.");
}
return *storage_management;
}
auto management::add_controller(kstd::shared_ptr<controller> const & controller) -> void
{
controller->set_ids(next_free_major++, minors_per_device);
m_controllers.push_back(controller);
}
auto management::all_controllers() const -> kstd::vector<kstd::shared_ptr<controller>> const &
{
return m_controllers;
}
auto management::device_by_major_minor(size_t major, size_t minor) -> kstd::shared_ptr<kapi::devices::device>
{
auto found = std::ranges::find_if(m_controllers, [=](auto const & controller) {
if (controller != nullptr && controller->major() == major)
{
return controller->device_by_minor(minor) != nullptr;
}
return false;
});
if (found != std::ranges::cend(m_controllers))
{
return found->get()->device_by_minor(minor);
}
return nullptr;
}
auto management::determine_boot_device() -> kstd::shared_ptr<kapi::devices::device>
{
return device_by_major_minor(start_major, 0);
}
} // namespace kernel::devices::storage
namespace kernel::tests::devices::storage::management
{
auto deinit() -> void
{
storage_management.reset();
next_free_major = start_major;
}
} // namespace kernel::tests::devices::storage::management
|
