[feat] 添加动态驱动支持，更新依赖项并实现 GICv2 和 GICv3 驱动

[fix] 优化错误处理格式，简化 MMIO 区域映射失败的错误信息

feat(axdriver): update rdrive dependency and add block driver support

- Updated rdrive dependency version from 0.14 to 0.14.4 in Cargo.toml.
- Introduced a new block driver module with implementations for block operations.
- Added virtio block driver support with MMIO transport.
- Refactored interrupt controller (GIC) driver probes to use OnProbeError for error handling.
- Enhanced dynamic driver probing to include block devices when the "block" feature is enabled.
- Improved error handling in block driver operations by mapping errors between driver and I/O layers.

Author: ZR233

Cargo.lock

@@ -52,6 +52,7 @@ display = ["alloc", "paging", "axdriver/virtio-gpu", "dep:axdisplay", "axruntime
 rtc = ["axhal/rtc", "axruntime/rtc"]
 
 # Device drivers
+driver-dyn = ["axruntime/driver","axdriver?/dyn"]
 bus-mmio = ["axdriver?/bus-mmio"]
 bus-pci = ["axdriver?/bus-pci"]
 driver-ramdisk = ["axdriver?/ramdisk", "axfs?/use-ramdisk"]

api/axfeat/Cargo.toml

@@ -10,7 +10,7 @@ repository = "https://github.com/arceos-org/arceos/tree/main/modules/axdriver"
 documentation = "https://arceos-org.github.io/arceos/axdriver/index.html"
 
 [features]
-dyn = []
+dyn = ["dep:rdrive", "dep:axmm", "dep:arm-gic-driver"]
 bus-mmio = []
 bus-pci = ["dep:axdriver_pci", "dep:axhal", "dep:axconfig"]
 net = ["axdriver_net"]
@@ -46,3 +46,8 @@ axalloc = { workspace = true, optional = true }
 axhal = { workspace = true, optional = true }
 axconfig = { workspace = true, optional = true }
 axdma = { workspace = true, optional = true }
+rdrive = { version = "0.15", optional = true }
+axmm = { workspace = true, optional = true }
+
+[target.'cfg(target_arch = "aarch64")'.dependencies]
+arm-gic-driver = { version = "0.14", optional = true }

modules/axdriver/Cargo.toml

@@ -1,4 +1,6 @@
 #[cfg(bus = "mmio")]
+#[allow(unused)]
 mod mmio;
 #[cfg(bus = "pci")]
+#[allow(unused)]
 mod pci;

modules/axdriver/src/bus/mod.rs

@@ -0,0 +1,103 @@
+use axdriver_base::{BaseDriverOps, DevError, DevResult, DeviceType};
+use axdriver_block::BlockDriverOps;
+use rdrive::{Device, driver::block::io};
+
+#[cfg(feature = "virtio-blk")]
+mod virtio;
+
+pub struct Block(Device<rdrive::driver::Block>);
+
+impl BaseDriverOps for Block {
+    fn device_type(&self) -> DeviceType {
+        DeviceType::Block
+    }
+    fn device_name(&self) -> &str {
+        self.0.descriptor().name
+    }
+}
+
+impl BlockDriverOps for Block {
+    fn num_blocks(&self) -> u64 {
+        self.0.lock().unwrap().num_blocks() as _
+    }
+    fn block_size(&self) -> usize {
+        self.0.lock().unwrap().block_size()
+    }
+    fn flush(&mut self) -> DevResult {
+        self.0.lock().unwrap().flush().map_err(io_error_to_deverror)
+    }
+
+    fn read_block(&mut self, block_id: u64, buf: &mut [u8]) -> DevResult {
+        self.0
+            .lock()
+            .unwrap()
+            .read_block(block_id as _, buf)
+            .map_err(io_error_to_deverror)
+    }
+
+    fn write_block(&mut self, block_id: u64, buf: &[u8]) -> DevResult {
+        self.0
+            .lock()
+            .unwrap()
+            .write_block(block_id as _, buf)
+            .map_err(io_error_to_deverror)
+    }
+}
+
+impl From<Device<rdrive::driver::Block>> for Block {
+    fn from(base: Device<rdrive::driver::Block>) -> Self {
+        Self(base)
+    }
+}
+
+fn io_error_to_deverror(err: io::Error) -> DevError {
+    match err.kind {
+        io::ErrorKind::Other(_error) => DevError::Io,
+        io::ErrorKind::NotAvailable => DevError::BadState,
+        io::ErrorKind::BrokenPipe => DevError::BadState,
+        io::ErrorKind::InvalidParameter { name: _ } => DevError::InvalidParam,
+        io::ErrorKind::InvalidData => DevError::InvalidParam,
+        io::ErrorKind::TimedOut => DevError::Io,
+        io::ErrorKind::Interrupted => DevError::Again,
+        io::ErrorKind::Unsupported => DevError::Unsupported,
+        io::ErrorKind::OutOfMemory => DevError::NoMemory,
+        io::ErrorKind::WriteZero => DevError::InvalidParam,
+    }
+}
+
+fn deverror_to_io_error(err: DevError) -> io::Error {
+    match err {
+        DevError::Again => io::Error {
+            kind: io::ErrorKind::Interrupted,
+            success_pos: 0,
+        },
+        DevError::AlreadyExists => io::Error {
+            kind: io::ErrorKind::Other("Already exists".into()),
+            success_pos: 0,
+        },
+        DevError::BadState => io::Error {
+            kind: io::ErrorKind::BrokenPipe,
+            success_pos: 0,
+        },
+        DevError::InvalidParam => io::Error {
+            kind: io::ErrorKind::InvalidData,
+            success_pos: 0,
+        },
+        DevError::Io => io::Error {
+            kind: io::ErrorKind::Other("I/O error".into()),
+            success_pos: 0,
+        },
+        DevError::NoMemory => io::Error {
+            kind: io::ErrorKind::OutOfMemory,
+            success_pos: 0,
+        },
+        DevError::ResourceBusy => io::Error {
+            kind: io::ErrorKind::Other("Resource busy".into()),
+            success_pos: 0,
+        },
+        DevError::Unsupported => io::Error {
+            kind: io::ErrorKind::Unsupported,
+            success_pos: 0,
+        },
+    }
+}

modules/axdriver/src/dyn_drivers/blk/mod.rs

@@ -0,0 +1,112 @@
+extern crate alloc;
+
+use alloc::format;
+use axdriver_base::DeviceType;
+use axdriver_block::BlockDriverOps;
+use axdriver_virtio::MmioTransport;
+use axhal::mem::{MemoryAddr, PhysAddr};
+use core::ptr::NonNull;
+use rdrive::{
+    DriverGeneric, PlatformDevice, driver::block::*, module_driver, probe::OnProbeError,
+    register::FdtInfo,
+};
+
+use crate::dyn_drivers::blk::deverror_to_io_error;
+use crate::dyn_drivers::iomap;
+use crate::virtio::VirtIoHalImpl;
+
+type Device<T> = axdriver_virtio::VirtIoBlkDev<VirtIoHalImpl, T>;
+
+module_driver!(
+    name: "Virtio Block",
+    level: ProbeLevel::PostKernel,
+    priority: ProbePriority::DEFAULT,
+    probe_kinds: &[
+        ProbeKind::Fdt {
+            compatibles: &["virtio,mmio"],
+            on_probe: probe
+        }
+    ],
+);
+
+fn probe(info: FdtInfo<'_>, plat_dev: PlatformDevice) -> Result<(), OnProbeError> {
+    let mut reg = info.node.reg().ok_or(OnProbeError::other(alloc::format!(
+        "[{}] has no reg",
+        info.node.name()
+    )))?;
+
+    let base_reg = reg.next().unwrap();
+    let mmio_size = base_reg.size.unwrap_or(0x1000);
+    let mmio_base = PhysAddr::from_usize(base_reg.address as usize);
+    let aligned_base = mmio_base.align_down_4k();
+    let offset = mmio_base - aligned_base;
+
+    let aligned_end = (mmio_base + mmio_size).align_up_4k();
+    let aligned_mmio_size = aligned_end - aligned_base;
+
+    let aligned_mmio_base: NonNull<u8> = iomap(aligned_base, aligned_mmio_size)?;
+    let mmio_base = unsafe { aligned_mmio_base.as_ptr().add(offset) };
+
+    debug!(
+        "virtio block device MMIO base address: {:?}, size: {}",
+        mmio_base, mmio_size
+    );
+
+    let (ty, transport) =
+        axdriver_virtio::probe_mmio_device(mmio_base, mmio_size).ok_or(OnProbeError::NotMatch)?;
+
+    if ty != DeviceType::Block {
+        return Err(OnProbeError::NotMatch);
+    }
+
+    let dev = Device::try_new(transport).map_err(|e| {
+        OnProbeError::other(format!(
+            "failed to initialize Virtio Block device at [PA:{:?},): {:?}",
+            mmio_base, e
+        ))
+    })?;
+
+    let dev = BlockDivce(dev);
+
+    plat_dev.register_block(dev);
+
+    debug!("virtio block device registered successfully");
+
+    Ok(())
+}
+
+struct BlockDivce(Device<MmioTransport>);
+
+impl DriverGeneric for BlockDivce {
+    fn open(&mut self) -> Result<(), rdrive::KError> {
+        Ok(())
+    }
+
+    fn close(&mut self) -> Result<(), rdrive::KError> {
+        Ok(())
+    }
+}
+
+impl rdrive::driver::block::Interface for BlockDivce {
+    fn num_blocks(&self) -> usize {
+        self.0.num_blocks() as _
+    }
+
+    fn block_size(&self) -> usize {
+        self.0.block_size()
+    }
+
+    fn read_block(&mut self, block_id: usize, buf: &mut [u8]) -> Result<(), io::Error> {
+        self.0
+            .read_block(block_id as u64, buf)
+            .map_err(deverror_to_io_error)
+    }
+    fn write_block(&mut self, block_id: usize, buf: &[u8]) -> Result<(), io::Error> {
+        self.0
+            .write_block(block_id as u64, buf)
+            .map_err(deverror_to_io_error)
+    }
+    fn flush(&mut self) -> Result<(), io::Error> {
+        self.0.flush().map_err(deverror_to_io_error)
+    }
+}

modules/axdriver/src/dyn_drivers/blk/virtio.rs

@@ -0,0 +1,44 @@
+extern crate alloc;
+
+use alloc::format;
+use arm_gic_driver::v2::Gic;
+use rdrive::{PlatformDevice, module_driver, probe::OnProbeError, register::FdtInfo};
+
+use crate::dyn_drivers::iomap;
+
+module_driver!(
+    name: "GICv2",
+    level: ProbeLevel::PreKernel,
+    priority: ProbePriority::INTC,
+    probe_kinds: &[
+        ProbeKind::Fdt {
+            compatibles: &["arm,cortex-a15-gic", "arm,gic-400"],
+            on_probe: probe_gic
+        },
+    ] ,
+);
+
+fn probe_gic(info: FdtInfo<'_>, dev: PlatformDevice) -> Result<(), OnProbeError> {
+    let mut reg = info.node.reg().ok_or(OnProbeError::other(format!(
+        "[{}] has no reg",
+        info.node.name()
+    )))?;
+
+    let gicd_reg = reg.next().unwrap();
+    let gicc_reg = reg.next().unwrap();
+
+    let gicd = iomap(
+        (gicd_reg.address as usize).into(),
+        gicd_reg.size.unwrap_or(0x1000),
+    )?;
+    let gicc = iomap(
+        (gicc_reg.address as usize).into(),
+        gicc_reg.size.unwrap_or(0x1000),
+    )?;
+
+    let gic = Gic::new(gicd, gicc);
+
+    dev.register_intc(gic);
+
+    Ok(())
+}

modules/axdriver/src/dyn_drivers/intc/gicv2.rs

@@ -0,0 +1,44 @@
+extern crate alloc;
+
+use alloc::format;
+use arm_gic_driver::v3::Gic;
+use rdrive::{PlatformDevice, module_driver, probe::OnProbeError, register::FdtInfo};
+
+use crate::dyn_drivers::iomap;
+
+module_driver!(
+    name: "GICv3",
+    level: ProbeLevel::PreKernel,
+    priority: ProbePriority::INTC,
+    probe_kinds: &[
+        ProbeKind::Fdt {
+            compatibles: &["arm,gic-v3"],
+            on_probe: probe_gic
+        }
+    ],
+);
+
+fn probe_gic(info: FdtInfo<'_>, dev: PlatformDevice) -> Result<(), OnProbeError> {
+    let mut reg = info.node.reg().ok_or(OnProbeError::other(format!(
+        "[{}] has no reg",
+        info.node.name()
+    )))?;
+
+    let gicd_reg = reg.next().unwrap();
+    let gicr_reg = reg.next().unwrap();
+
+    let gicd = iomap(
+        (gicd_reg.address as usize).into(),
+        gicd_reg.size.unwrap_or(0x1000),
+    )?;
+    let gicr = iomap(
+        (gicr_reg.address as usize).into(),
+        gicr_reg.size.unwrap_or(0x1000),
+    )?;
+
+    let gic = Gic::new(gicd, gicr, Default::default());
+
+    dev.register_intc(gic);
+
+    Ok(())
+}

modules/axdriver/src/dyn_drivers/intc/gicv3.rs

@@ -0,0 +1,4 @@
+#[cfg(target_arch = "aarch64")]
+mod gicv2;
+#[cfg(target_arch = "aarch64")]
+mod gicv3;

modules/axdriver/src/dyn_drivers/intc/mod.rs

@@ -0,0 +1,37 @@
+use core::{error::Error, ptr::NonNull};
+
+use alloc::{boxed::Box, format};
+use axhal::{
+    mem::{MemoryAddr, PhysAddr, phys_to_virt},
+    paging::MappingFlags,
+};
+use axmm::AxError;
+
+mod intc;
+
+#[cfg(feature = "block")]
+pub mod blk;
+
+#[allow(unused)]
+/// maps a mmio physical address to a virtual address.
+fn iomap(addr: PhysAddr, size: usize) -> Result<NonNull<u8>, Box<dyn Error>> {
+    let end = (addr.as_usize() + size).align_up_4k();
+    let start = addr.align_down_4k();
+    let size = end - start.as_usize();
+
+    let start_virt = phys_to_virt(start);
+
+    match axmm::kernel_aspace().lock().map_linear(
+        start_virt,
+        addr,
+        size,
+        MappingFlags::READ | MappingFlags::WRITE | MappingFlags::DEVICE,
+    ) {
+        Ok(_) | Err(AxError::AlreadyExists) => {}
+        Err(e) => {
+            Err(format!("Failed to map MMIO region {:?}: {}", start_virt, e))?;
+        }
+    }
+
+    Ok(NonNull::new(start_virt.as_mut_ptr()).unwrap())
+}