DeviceManager Class Reference

设备管理器 — 管理所有设备节点和驱动程序。 More...

#include <device_manager.hpp>

Collaboration diagram for DeviceManager:

Public Member Functions
template<Bus B>
auto	RegisterBus (B &bus) -> Expected< void >
	注册总线并立即枚举其设备。
auto	ProbeAll () -> Expected< void >
	匹配已注册的驱动程序并探测所有未绑定的设备。
auto	FindDevice (const char *name) -> Expected< DeviceNode * >
	根据名称查找设备。
auto	FindDevicesByType (DeviceType type, DeviceNode **out, size_t max) -> size_t
	按类型枚举设备。
auto	GetRegistry () -> DriverRegistry &
	访问驱动注册表。
构造 / 析构
	DeviceManager ()=default
	~DeviceManager ()=default
	DeviceManager (const DeviceManager &)=delete
	DeviceManager (DeviceManager &&)=delete
auto	operator= (const DeviceManager &) -> DeviceManager &=delete
auto	operator= (DeviceManager &&) -> DeviceManager &=delete

Private Attributes
DeviceNode	devices_ [kMaxDevices] {}
size_t	device_count_ {0}
uint32_t	next_dev_id_ {0}
DriverRegistry	registry_
SpinLock	lock_ {"device_manager"}
etl::flat_map< const char *, size_t, kMaxDevices, CStrLess >	name_index_

Static Private Attributes
static constexpr size_t	kMaxDevices = 64

Detailed Description

设备管理器 — 管理所有设备节点和驱动程序。

Copyright

Copyright The SimpleKernel Contributors

Precondition

调用任何方法前，内存子系统必须已完成初始化

Postcondition

ProbeAll() 执行完成后，已绑定的设备可供使用

Definition at line 23 of file device_manager.hpp.

Constructor & Destructor Documentation

DeviceManager() [1/3]

DeviceManager::DeviceManager ( )

default

~DeviceManager()

DeviceManager::~DeviceManager ( )

default

DeviceManager() [2/3]

DeviceManager::DeviceManager ( const DeviceManager &  )

delete

DeviceManager() [3/3]

DeviceManager::DeviceManager ( DeviceManager &&  )

delete

Member Function Documentation

FindDevice()

auto DeviceManager::FindDevice

(

const char *

name

)

-> Expected<DeviceNode*>

根据名称查找设备。

Note

只读路径 — 枚举完成后 device_count_ 和 devices_ 稳定， 并发调用者可安全使用。

Parameters

name

设备名称

Returns

Expected<DeviceNode*> 设备指针，或 kDeviceNotFound

Definition at line 49 of file device_manager.cpp.

                                                                        {
  assert(name != nullptr && "FindDevice: name must not be null");
  LockGuard guard(lock_);
  const auto it = name_index_.find(name);
  if (it != name_index_.end()) {
    return &devices_[it->second];
  }
  return std::unexpected(Error(ErrorCode::kDeviceNotFound));
}

FindDevicesByType()

auto DeviceManager::FindDevicesByType	(	DeviceType	type,
		DeviceNode **	out,
		size_t	max
	)		-> size_t

按类型枚举设备。

Parameters

type	设备类型
out	输出的设备节点指针数组
max	最大结果数量

Returns

size_t 找到的匹配设备数量

Definition at line 59 of file device_manager.cpp.

                                                            {
  assert((out != nullptr || max == 0) &&
         "FindDevicesByType: out must not be null when max > 0");
  LockGuard guard(lock_);
  size_t found = 0;
  for (size_t i = 0; i < device_count_ && found < max; ++i) {
    if (devices_[i].type == type) {
      out[found++] = &devices_[i];
    }
  }
  return found;
}

GetRegistry()

auto DeviceManager::GetRegistry ( ) -> DriverRegistry&

inline

访问驱动注册表。

Returns

DriverRegistry& 驱动注册表实例

Definition at line 96 of file device_manager.hpp.

{ return registry_; }

operator=() [1/2]

auto DeviceManager::operator= ( const DeviceManager &  ) -> DeviceManager &=delete

delete

operator=() [2/2]

auto DeviceManager::operator= ( DeviceManager &&  ) -> DeviceManager &=delete

delete

ProbeAll()

auto DeviceManager::ProbeAll

(

)

-> Expected<void>

匹配已注册的驱动程序并探测所有未绑定的设备。

Returns

Expected<void> 成功返回 void，失败返回错误

Copyright

Copyright The SimpleKernel Contributors

Definition at line 11 of file device_manager.cpp.

                                               {
  LockGuard guard(lock_);
 
  size_t probed = 0;
  size_t no_driver_count = 0;
  for (size_t i = 0; i < device_count_; ++i) {
    auto& node = devices_[i];
 
    const auto* drv = registry_.FindDriver(node);
    if (drv == nullptr) {
      ++no_driver_count;
      continue;
    }
 
    if (!drv->match(node)) {
      continue;
    }
 
    if (node.bound) {
      continue;
    }
    node.bound = true;
 
    drv->probe(node).or_else([&](auto&& err) {
      klog::Err("DeviceManager: probe '{}' failed: {}", node.name,
                err.message());
      node.bound = false;
      return Expected<void>{};
    });
 
    ++probed;
  }
 
  klog::Info("DeviceManager: probed {} device(s), {} skipped (no driver)",
             probed, no_driver_count);
  return {};
}

Here is the call graph for this function:

RegisterBus()

template<Bus B>

auto DeviceManager::RegisterBus ( B &  bus ) -> Expected<void>

inline

注册总线并立即枚举其设备。

Template Parameters

B	总线类型（必须满足 Bus 概念约束）

Parameters

bus

总线实例

Returns

Expected<void> 成功返回 void，失败返回错误

Definition at line 33 of file device_manager.hpp.

                                             {
    LockGuard guard(lock_);
 
    if (device_count_ >= kMaxDevices) {
      return std::unexpected(Error(ErrorCode::kOutOfMemory));
    }
 
    size_t remaining = kMaxDevices - device_count_;
    auto result = bus.Enumerate(devices_ + device_count_, remaining);
    if (!result.has_value()) {
      klog::Err("DeviceManager: bus '{}' enumeration failed: {}", B::GetName(),
                result.error().message());
      return std::unexpected(result.error());
    }
 
    size_t count = result.value();
    for (size_t i = 0; i < count; ++i) {
      devices_[device_count_ + i].dev_id = next_dev_id_++;
      if (!name_index_.full()) {
        name_index_.insert(
            {devices_[device_count_ + i].name, device_count_ + i});
      }
    }
    device_count_ += count;
 
    klog::Info("DeviceManager: bus '{}' enumerated {} device(s)", B::GetName(),
               count);
    return {};
  }

Here is the call graph for this function:

Member Data Documentation

device_count_

size_t DeviceManager::device_count_ {0}

private

Definition at line 111 of file device_manager.hpp.

{0};

devices_

DeviceNode DeviceManager::devices_[kMaxDevices] {}

private

Definition at line 110 of file device_manager.hpp.

{};

kMaxDevices

constexpr size_t DeviceManager::kMaxDevices = 64

staticconstexprprivate

Definition at line 109 of file device_manager.hpp.

lock_

SpinLock DeviceManager::lock_ {"device_manager"}

private

Definition at line 114 of file device_manager.hpp.

{"device_manager"};

name_index_

etl::flat_map<const char*, size_t, kMaxDevices, CStrLess> DeviceManager::name_index_

private

Definition at line 115 of file device_manager.hpp.

next_dev_id_

uint32_t DeviceManager::next_dev_id_ {0}

private

Definition at line 112 of file device_manager.hpp.

{0};

registry_

DriverRegistry DeviceManager::registry_

private

Definition at line 113 of file device_manager.hpp.

---

The documentation for this class was generated from the following files:

• /workspaces/SimpleKernel/src/device/include/device_manager.hpp
• /workspaces/SimpleKernel/src/device/device_manager.cpp