mirror of
https://github.com/DragonOS-Community/DragonOS.git
synced 2025-06-10 16:26:48 +00:00
216 lines
6.3 KiB
Rust
216 lines
6.3 KiB
Rust
use system_error::SystemError;
|
||
|
||
use crate::{
|
||
arch::MMArch,
|
||
libs::{
|
||
align::{page_align_down, page_align_up},
|
||
spinlock::SpinLock,
|
||
},
|
||
mm::no_init::{pseudo_map_phys, pseudo_map_phys_ro, pseudo_unmap_phys},
|
||
};
|
||
|
||
use super::{allocator::page_frame::PageFrameCount, MemoryManagementArch, PhysAddr, VirtAddr};
|
||
|
||
static SLOTS: SpinLock<[Slot; EarlyIoRemap::SLOT_CNT]> =
|
||
SpinLock::new([Slot::DEFAULT; EarlyIoRemap::SLOT_CNT]);
|
||
|
||
/// 早期IO映射机制
|
||
///
|
||
/// 该机制在内存管理初始化之前,提供IO重映射的功能。
|
||
///
|
||
/// ## 注意
|
||
///
|
||
/// 该机制使用固定大小的slot来记录所有的映射,
|
||
/// 而这些映射空间是有限的,由MMArch::FIXMAP_SIZE指定
|
||
pub struct EarlyIoRemap;
|
||
|
||
impl EarlyIoRemap {
|
||
const SLOT_CNT: usize = MMArch::FIXMAP_SIZE / MMArch::PAGE_SIZE;
|
||
|
||
/// 把物理内存映射到虚拟内存中(物理地址不要求对齐
|
||
///
|
||
/// ## 参数
|
||
///
|
||
/// - phys: 物理内存地址(不需要对齐)
|
||
/// - size: 映射的内存大小
|
||
/// - read_only: 映射区与是否只读
|
||
///
|
||
/// ## 返回值
|
||
///
|
||
/// - 成功: (phys对应的虚拟内存地址)
|
||
/// - Err(SystemError::ENOMEM): 可用的slot不足
|
||
#[allow(dead_code)]
|
||
pub fn map_not_aligned(
|
||
mut phys: PhysAddr,
|
||
mut size: usize,
|
||
read_only: bool,
|
||
) -> Result<VirtAddr, SystemError> {
|
||
// debug!("map not aligned phys:{phys:?}, size:{size:?}, read_only:{read_only:?}");
|
||
|
||
let offset = phys.data() - page_align_down(phys.data());
|
||
size += offset;
|
||
phys -= offset;
|
||
|
||
let (map_vaddr, _) = Self::map(phys, size, read_only)?;
|
||
return Ok(map_vaddr + offset);
|
||
}
|
||
|
||
/// 把物理内存映射到虚拟内存中
|
||
///
|
||
/// ## 说明
|
||
///
|
||
/// 虚拟内存由early io remap机制自动分配。
|
||
///
|
||
/// ## 参数
|
||
///
|
||
/// - phys: 物理内存地址(需要按页对齐)
|
||
/// - size: 映射的内存大小
|
||
/// - read_only: 映射区与是否只读
|
||
///
|
||
/// ## 返回值
|
||
///
|
||
/// - 成功: (虚拟内存地址, 映射的内存大小)
|
||
/// - Err(SystemError::ENOMEM): 可用的slot不足
|
||
/// - Err(SystemError::EINVAL): 传入的物理地址没有对齐
|
||
#[allow(dead_code)]
|
||
pub fn map(
|
||
phys: PhysAddr,
|
||
size: usize,
|
||
read_only: bool,
|
||
) -> Result<(VirtAddr, usize), SystemError> {
|
||
if !phys.check_aligned(MMArch::PAGE_SIZE) {
|
||
return Err(SystemError::EINVAL);
|
||
}
|
||
|
||
// debug!("Early io remap:{phys:?}, size:{size}");
|
||
|
||
let mut slot_guard = SLOTS.lock();
|
||
|
||
let slot_count = PageFrameCount::from_bytes(page_align_up(size))
|
||
.unwrap()
|
||
.data();
|
||
// 寻找连续的slot
|
||
let mut start_slot = None;
|
||
for i in 0..(Self::SLOT_CNT - slot_count + 1) {
|
||
let mut is_continuous = true;
|
||
|
||
for j in 0..slot_count {
|
||
let slot_idx = i + j;
|
||
if slot_guard[slot_idx].start_idx.is_some() {
|
||
is_continuous = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if is_continuous {
|
||
start_slot = Some(i);
|
||
break;
|
||
}
|
||
}
|
||
|
||
let start_slot = start_slot.ok_or(SystemError::ENOMEM)?;
|
||
let vaddr = Self::idx_to_virt(start_slot);
|
||
|
||
// debug!("start_slot:{start_slot}, vaddr: {vaddr:?}, slot_count: {slot_count:?}");
|
||
let page_count = PageFrameCount::new(slot_count);
|
||
// 执行映射
|
||
if read_only {
|
||
unsafe { pseudo_map_phys_ro(vaddr, phys, page_count) }
|
||
} else {
|
||
unsafe { pseudo_map_phys(vaddr, phys, page_count) }
|
||
}
|
||
|
||
// debug!("map ok");
|
||
|
||
// 更新slot信息
|
||
let map_size = slot_count * MMArch::PAGE_SIZE;
|
||
for i in 0..slot_count {
|
||
let slot_idx = start_slot + i;
|
||
slot_guard[slot_idx].start_idx = Some(start_slot as u32);
|
||
|
||
if i == 0 {
|
||
slot_guard[slot_idx].size = map_size as u32;
|
||
slot_guard[slot_idx].phys = phys;
|
||
}
|
||
}
|
||
|
||
return Ok((vaddr, map_size));
|
||
}
|
||
|
||
/// 取消映射
|
||
///
|
||
/// ## 参数
|
||
///
|
||
/// - virt: 映射范围内的任意虚拟地址
|
||
///
|
||
/// ## 返回值
|
||
///
|
||
/// - Ok: 成功
|
||
/// - Err(SystemError::EINVAL): 传入的虚拟地址不在early io remap范围内,
|
||
/// 或者虚拟地址未映射
|
||
#[allow(dead_code)]
|
||
pub fn unmap(virt: VirtAddr) -> Result<(), SystemError> {
|
||
if virt < MMArch::FIXMAP_START_VADDR || virt >= MMArch::FIXMAP_END_VADDR {
|
||
return Err(SystemError::EINVAL);
|
||
}
|
||
|
||
let mut slot_guard = SLOTS.lock();
|
||
let mut idx = None;
|
||
|
||
// 寻找虚拟地址对应的区域的第一个slot
|
||
for slot_idx in 0..Self::SLOT_CNT {
|
||
let slot = &mut slot_guard[slot_idx];
|
||
if let Some(start_idx) = slot.start_idx {
|
||
if start_idx == slot_idx as u32 {
|
||
let vaddr_start = Self::idx_to_virt(start_idx as usize);
|
||
let vaddr_end = vaddr_start + slot.size as usize;
|
||
if vaddr_start <= virt && virt < vaddr_end {
|
||
// 找到区域了
|
||
idx = Some(slot_idx);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
let idx = idx.ok_or(SystemError::EINVAL)?;
|
||
|
||
let vaddr = Self::idx_to_virt(idx);
|
||
let count = PageFrameCount::from_bytes(slot_guard[idx].size as usize).unwrap();
|
||
|
||
// 取消映射
|
||
unsafe { pseudo_unmap_phys(vaddr, count) };
|
||
|
||
for i in 0..count.data() {
|
||
let slot_idx = idx + i;
|
||
let slot = &mut slot_guard[slot_idx];
|
||
*slot = Slot::DEFAULT;
|
||
}
|
||
|
||
return Ok(());
|
||
}
|
||
|
||
/// 把slot下标转换为这个slot对应的虚拟地址
|
||
fn idx_to_virt(idx: usize) -> VirtAddr {
|
||
MMArch::FIXMAP_START_VADDR + idx * MMArch::PAGE_SIZE
|
||
}
|
||
}
|
||
|
||
#[derive(Debug, Clone, Copy)]
|
||
struct Slot {
|
||
/// 连续映射的起始槽位号
|
||
start_idx: Option<u32>,
|
||
/// 连续映射的区域大小(仅在起始槽位中设置)
|
||
size: u32,
|
||
/// 映射的起始物理地址
|
||
phys: PhysAddr,
|
||
}
|
||
|
||
impl Slot {
|
||
const DEFAULT: Self = Self {
|
||
start_idx: None,
|
||
size: 0,
|
||
phys: PhysAddr::new(0),
|
||
};
|
||
}
|