统一 VirtIO 驱动 More...

#include <virtio_driver.hpp>

Collaboration diagram for VirtioDriver:

Public Types
enum class	DeviceId : uint32_t { kNet = 1 , kBlock = 2 , kConsole = 3 , kEntropy = 4 , kGpu = 16 , kInput = 18 }
	VirtIO 设备类型枚举（来自 VirtIO 1.2 规范） More...

Public Member Functions
auto	Probe (DeviceNode &node) -> Expected< void >
	初始化 VirtIO 设备

auto	Remove (DeviceNode &node) -> Expected< void >
	卸载所有 VirtIO 块设备

auto	GetBlkDevice () -> virtio::blk::VirtioBlk<> *
	获取第一个 VirtIO 块设备实例

auto	GetIrq () const -> uint32_t
	获取第一个块设备的 IRQ 号

template<typename CompletionCallback >
auto	HandleInterrupt (CompletionCallback &&on_complete) -> void
	处理所有块设备中断

构造/析构函数
	VirtioDriver ()=default

	VirtioDriver (const VirtioDriver &)=delete

	VirtioDriver (VirtioDriver &&)=delete

auto	operator= (const VirtioDriver &) -> VirtioDriver &=delete

auto	operator= (VirtioDriver &&) -> VirtioDriver &=delete

	~VirtioDriver ()=default

Static Public Member Functions
static auto	GetEntry () -> const DriverEntry &
	返回驱动注册入口

static auto	MatchStatic (DeviceNode &node) -> bool
	硬件检测：验证 VirtIO magic number

Static Public Attributes
static constexpr uint32_t	kDefaultQueueCount = 1

static constexpr uint32_t	kDefaultQueueSize = 128

static constexpr size_t	kMinDmaBufferSize = 32768

Private Attributes
std::array< std::optional< virtio::blk::VirtioBlk<> >, kMaxBlkDevices >	blk_devices_

std::array< etl::unique_ptr< IoBuffer >, kMaxBlkDevices >	dma_buffers_

std::array< etl::unique_ptr< IoBuffer >, kMaxBlkDevices >	slot_buffers_

std::array< uint32_t, kMaxBlkDevices >	irqs_ {}

size_t	blk_device_count_ {0}

std::array< std::optional< virtio::blk::VirtioBlkVfsAdapter >, kMaxBlkDevices >	blk_adapters_

size_t	blk_adapter_count_ {0}

Static Private Attributes
static constexpr MatchEntry	kMatchTable []

static constexpr size_t	kMaxBlkDevices = 4

Detailed Description

统一 VirtIO 驱动

Copyright: Copyright The SimpleKernel Contributors

匹配所有 virtio,mmio 和 virtio,pci 兼容设备。 Probe() 运行期读取 device_id 寄存器，自动分发到对应设备实现并注册到 DeviceManager。调用方无需关心具体 VirtIO 设备类型。

Definition at line 32 of file virtio_driver.hpp.

Member Enumeration Documentation

◆ DeviceId

enum class VirtioDriver::DeviceId : uint32_t

strong

VirtIO 设备类型枚举（来自 VirtIO 1.2 规范）

Enumerator
kNet
kBlock
kConsole
kEntropy
kGpu
kInput

Definition at line 35 of file virtio_driver.hpp.

                      : uint32_t {
    kNet = 1,
    kBlock = 2,
    kConsole = 3,
    kEntropy = 4,
    kGpu = 16,
    kInput = 18,
  };

Constructor & Destructor Documentation

◆ VirtioDriver() [1/3]

VirtioDriver::VirtioDriver ( )

default

Here is the caller graph for this function:

◆ VirtioDriver() [2/3]

VirtioDriver::VirtioDriver ( const VirtioDriver & )

delete

◆ VirtioDriver() [3/3]

VirtioDriver::VirtioDriver ( VirtioDriver && )

delete

◆ ~VirtioDriver()

VirtioDriver::~VirtioDriver ( )

default

Member Function Documentation

◆ GetBlkDevice()

auto VirtioDriver::GetBlkDevice ( ) -> virtio::blk::VirtioBlk<>*

inline

获取第一个 VirtIO 块设备实例

Returns: 设备实例指针，若不存在则返回 nullptr

Definition at line 111 of file virtio_driver.hpp.

                                                             {
    return (blk_device_count_ > 0 && blk_devices_[0].has_value())
               ? &blk_devices_[0].value()
               : nullptr;
  }

◆ GetEntry()

static auto VirtioDriver::GetEntry ( ) -> const DriverEntry&

inlinestatic

返回驱动注册入口

匹配 virtio,mmio 兼容字符串；MatchStatic 检查 VirtIO magic number。

Definition at line 53 of file virtio_driver.hpp.

                                                             {
    static const DriverEntry entry{
        .name = "virtio",
        .match_table = etl::span<const MatchEntry>(kMatchTable),
        .match = etl::delegate<bool(
            DeviceNode&)>::create<&VirtioDriver::MatchStatic>(),
        .probe = etl::delegate<Expected<void>(DeviceNode&)>::create<
            VirtioDriver, &VirtioDriver::Probe>(
            etl::singleton<VirtioDriver>::instance()),
        .remove = etl::delegate<Expected<void>(DeviceNode&)>::create<
            VirtioDriver, &VirtioDriver::Remove>(
            etl::singleton<VirtioDriver>::instance()),
    };
    return entry;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetIrq()

auto VirtioDriver::GetIrq ( ) const -> uint32_t

inline

获取第一个块设备的 IRQ 号

Returns: IRQ 号，若无设备则返回 0

Definition at line 121 of file virtio_driver.hpp.

                                                {
    return blk_device_count_ > 0 ? irqs_[0] : 0;
  }

◆ HandleInterrupt()

template<typename CompletionCallback >

auto VirtioDriver::HandleInterrupt ( CompletionCallback && on_complete ) -> void

inline

处理所有块设备中断

Template Parameters

CompletionCallback 完成回调类型

Parameters

on_complete 回调函数

Definition at line 131 of file virtio_driver.hpp.

                                                                 {
    for (size_t i = 0; i < blk_device_count_; ++i) {
      if (blk_devices_[i].has_value()) {
        blk_devices_[i].value().HandleInterrupt(
            static_cast<CompletionCallback&&>(on_complete));
      }
    }
  }

◆ MatchStatic()

auto VirtioDriver::MatchStatic ( DeviceNode & node ) -> bool

static

硬件检测：验证 VirtIO magic number

只检查 magic number（0x74726976），不检查 device_id—— device_id 的分发在 Probe() 中完成。

Precondition: node.mmio_base != 0

Returns: true 如果设备响应 VirtIO magic

Copyright: Copyright The SimpleKernel Contributors

Definition at line 16 of file virtio_driver.cpp.

                                                                        {
  return node.mmio_base != 0 && node.mmio_size != 0;
}

Here is the caller graph for this function:

◆ operator=() [1/2]

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

delete

◆ operator=() [2/2]

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

delete

◆ Probe()

auto VirtioDriver::Probe ( DeviceNode & node ) -> Expected<void>

初始化 VirtIO 设备

运行期读取 device_id，分发到对应设备实现，创建并注册设备。

Precondition: node.mmio_base != 0，MatchStatic() 已返回 true

Postcondition: 设备已注册到 DeviceManager（node.block_device 已填入适配器指针）

Definition at line 20 of file virtio_driver.cpp.

                                                           {
  if (node.mmio_size == 0) {
    klog::Err("VirtioDriver: FDT reg property missing size for node '{}'",
              node.name);
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
  auto ctx = mmio_helper::Prepare(node, node.mmio_size);
  if (!ctx) {
    return std::unexpected(ctx.error());
  }
 
  etl::io_port_ro<uint32_t> magic_reg{reinterpret_cast<void*>(ctx->base)};
  if (magic_reg.read() != virtio::kMmioMagicValue) {
    return std::unexpected(Error(ErrorCode::kNotSupported));
  }
 
  // 读取 device_id
  etl::io_port_ro<uint32_t> device_id_reg{reinterpret_cast<void*>(
      ctx->base +
      std::to_underlying(virtio::MmioTransport::MmioReg::kDeviceId))};
  const auto device_id = static_cast<DeviceId>(device_id_reg.read());
 
  switch (device_id) {
    case DeviceId::kBlock: {
      if (blk_device_count_ >= kMaxBlkDevices) {
        klog::Warn(
            "VirtioDriver: blk device pool full, device at {:#x} skipped",
            ctx->base);
        return std::unexpected(Error(ErrorCode::kOutOfMemory));
      }
      const size_t idx = blk_device_count_;
 
      // 分配 DMA buffer
      dma_buffers_[idx] = kstd::make_unique<IoBuffer>(kMinDmaBufferSize);
      if (!dma_buffers_[idx] || !dma_buffers_[idx]->IsValid() ||
          dma_buffers_[idx]->GetBuffer().size() < kMinDmaBufferSize) {
        klog::Err("VirtioDriver: failed to allocate DMA buffer at {:#x}",
                  ctx->base);
        return std::unexpected(Error(ErrorCode::kOutOfMemory));
      }
 
      // Allocate slot DMA buffer
      auto [slot_size, slot_align] =
          virtio::blk::VirtioBlk<>::GetRequiredSlotMemSize();
      slot_buffers_[idx] = kstd::make_unique<IoBuffer>(slot_size, slot_align);
      if (!slot_buffers_[idx] || !slot_buffers_[idx]->IsValid()) {
        klog::Err("VirtioDriver: failed to allocate slot DMA buffer at {:#x}",
                  ctx->base);
        dma_buffers_[idx].reset();
        return std::unexpected(Error(ErrorCode::kOutOfMemory));
      }
 
      uint64_t extra_features =
          static_cast<uint64_t>(virtio::blk::BlkFeatureBit::kSegMax) |
          static_cast<uint64_t>(virtio::blk::BlkFeatureBit::kSizeMax) |
          static_cast<uint64_t>(virtio::blk::BlkFeatureBit::kBlkSize) |
          static_cast<uint64_t>(virtio::blk::BlkFeatureBit::kFlush) |
          static_cast<uint64_t>(virtio::blk::BlkFeatureBit::kGeometry);
 
      auto vq_dma = dma_buffers_[idx]->ToDmaRegion();
      auto slot_dma = slot_buffers_[idx]->ToDmaRegion();
 
      auto result = virtio::blk::VirtioBlk<>::Create(
          ctx->base, vq_dma, slot_dma, IdentityVirtToPhys, kDefaultQueueCount,
          kDefaultQueueSize, extra_features);
      if (!result.has_value()) {
        klog::Err("VirtioDriver: VirtioBlk Create failed at {:#x}", ctx->base);
        dma_buffers_[idx].reset();
        slot_buffers_[idx].reset();
        return std::unexpected(Error(result.error().code));
      }
 
      blk_devices_[idx].emplace(std::move(*result));
      node.type = DeviceType::kBlock;
      irqs_[idx] = node.irq;
 
      // Register adapter in pool and expose via DeviceNode.
      if (blk_adapter_count_ < kMaxBlkDevices) {
        const auto adapter_idx = static_cast<uint32_t>(blk_adapter_count_);
        blk_adapters_[blk_adapter_count_].emplace(&blk_devices_[idx].value(),
                                                  adapter_idx);
        node.block_device = &blk_adapters_[blk_adapter_count_].value();
        ++blk_adapter_count_;
      } else {
        klog::Warn(
            "VirtioDriver: blk adapter pool full, device at {:#x} skipped",
            ctx->base);
      }
 
      ++blk_device_count_;
      klog::Info(
          "VirtioDriver: block device at {:#x}, capacity={} sectors, irq={}",
          ctx->base, blk_devices_[idx].value().GetCapacity(), irqs_[idx]);
      return {};
    }
 
    default:
      return std::unexpected(Error(ErrorCode::kNotSupported));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Remove()

auto VirtioDriver::Remove ( DeviceNode & node ) -> Expected<void>

inline

卸载所有 VirtIO 块设备

Parameters

node 设备节点

Returns: Expected<void> 成功返回空值

Definition at line 95 of file virtio_driver.hpp.

                        {
    for (size_t i = 0; i < blk_device_count_; ++i) {
      blk_devices_[i].reset();
      dma_buffers_[i].reset();
      slot_buffers_[i].reset();
    }
    blk_device_count_ = 0;
    blk_adapter_count_ = 0;
    return {};
  }

Here is the caller graph for this function:

Member Data Documentation

◆ blk_adapter_count_

size_t VirtioDriver::blk_adapter_count_ {0}

private

Definition at line 167 of file virtio_driver.hpp.

167{0};

◆ blk_adapters_

std::array<std::optional<virtio::blk::VirtioBlkVfsAdapter>, kMaxBlkDevices> VirtioDriver::blk_adapters_

private

Definition at line 166 of file virtio_driver.hpp.

◆ blk_device_count_

size_t VirtioDriver::blk_device_count_ {0}

private

Definition at line 162 of file virtio_driver.hpp.

162{0};

◆ blk_devices_

std::array<std::optional<virtio::blk::VirtioBlk<> >, kMaxBlkDevices> VirtioDriver::blk_devices_

private

Definition at line 158 of file virtio_driver.hpp.

◆ dma_buffers_

std::array<etl::unique_ptr<IoBuffer>, kMaxBlkDevices> VirtioDriver::dma_buffers_

private

Definition at line 159 of file virtio_driver.hpp.

◆ irqs_

std::array<uint32_t, kMaxBlkDevices> VirtioDriver::irqs_ {}

private

Definition at line 161 of file virtio_driver.hpp.

161{};

◆ kDefaultQueueCount

constexpr uint32_t VirtioDriver::kDefaultQueueCount = 1

staticconstexpr

Definition at line 44 of file virtio_driver.hpp.

◆ kDefaultQueueSize

constexpr uint32_t VirtioDriver::kDefaultQueueSize = 128

staticconstexpr

Definition at line 45 of file virtio_driver.hpp.

◆ kMatchTable

constexpr MatchEntry VirtioDriver::kMatchTable[]

staticconstexprprivate

Initial value:

= {
      {BusType::kPlatform, "virtio,mmio"},
  }

Definition at line 151 of file virtio_driver.hpp.

                                              {
      {BusType::kPlatform, "virtio,mmio"},
  };

◆ kMaxBlkDevices

constexpr size_t VirtioDriver::kMaxBlkDevices = 4

staticconstexprprivate

Definition at line 155 of file virtio_driver.hpp.

◆ kMinDmaBufferSize

constexpr size_t VirtioDriver::kMinDmaBufferSize = 32768

staticconstexpr

Definition at line 46 of file virtio_driver.hpp.

◆ slot_buffers_

std::array<etl::unique_ptr<IoBuffer>, kMaxBlkDevices> VirtioDriver::slot_buffers_

private

Definition at line 160 of file virtio_driver.hpp.

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

/workspaces/SimpleKernel/src/device/virtio/virtio_driver.hpp
/workspaces/SimpleKernel/src/device/virtio/virtio_driver.cpp

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

◆ DeviceId

Constructor & Destructor Documentation

◆ VirtioDriver() [1/3]

◆ VirtioDriver() [2/3]

◆ VirtioDriver() [3/3]

◆ ~VirtioDriver()

Member Function Documentation

◆ GetBlkDevice()

◆ GetEntry()

◆ GetIrq()

◆ HandleInterrupt()

◆ MatchStatic()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ Probe()

◆ Remove()

Member Data Documentation

◆ blk_adapter_count_

◆ blk_adapters_

◆ blk_device_count_

◆ blk_devices_

◆ dma_buffers_

◆ irqs_

◆ kDefaultQueueCount

◆ kDefaultQueueSize

◆ kMatchTable

◆ kMaxBlkDevices

◆ kMinDmaBufferSize

◆ slot_buffers_