tg_kernel_vm/space/
mod.rs

1mod mapper;
2mod visitor;
3
4extern crate alloc;
5
6use crate::PageManager;
7use alloc::vec::Vec;
8use core::{fmt, ops::Range, ptr::NonNull};
9use mapper::Mapper;
10use page_table::{PageTable, PageTableFormatter, Pos, VAddr, VmFlags, VmMeta, PPN, VPN};
11use visitor::Visitor;
12
13/// 地址空间。
14pub struct AddressSpace<Meta: VmMeta, M: PageManager<Meta>> {
15    /// 虚拟地址块
16    pub areas: Vec<Range<VPN<Meta>>>,
17    page_manager: M,
18}
19
20impl<Meta: VmMeta, M: PageManager<Meta>> AddressSpace<Meta, M> {
21    /// 创建新地址空间。
22    #[inline]
23    pub fn new() -> Self {
24        Self {
25            areas: Vec::new(),
26            page_manager: M::new_root(),
27        }
28    }
29
30    /// 地址空间根页表的物理页号。
31    #[inline]
32    pub fn root_ppn(&self) -> PPN<Meta> {
33        self.page_manager.root_ppn()
34    }
35
36    /// 地址空间根页表
37    #[inline]
38    pub fn root(&self) -> PageTable<Meta> {
39        // SAFETY: page_manager.root_ptr() 返回的是有效的根页表指针，
40        // 由 PageManager::new_root() 创建时保证其有效性
41        unsafe { PageTable::from_root(self.page_manager.root_ptr()) }
42    }
43
44    /// 向地址空间增加映射关系。
45    pub fn map_extern(&mut self, range: Range<VPN<Meta>>, pbase: PPN<Meta>, flags: VmFlags<Meta>) {
46        self.areas.push(range.start..range.end);
47        let count = range.end.val() - range.start.val();
48        let mut root = self.root();
49        let mut mapper = Mapper::new(self, pbase..pbase + count, flags);
50        root.walk_mut(Pos::new(range.start, 0), &mut mapper);
51        if !mapper.ans() {
52            // 映射失败，需要回滚吗？
53            todo!()
54        }
55    }
56
57    /// 分配新的物理页，拷贝数据并建立映射。
58    pub fn map(
59        &mut self,
60        range: Range<VPN<Meta>>,
61        data: &[u8],
62        offset: usize,
63        mut flags: VmFlags<Meta>,
64    ) {
65        let count = range.end.val() - range.start.val();
66        let size = count << Meta::PAGE_BITS;
67        assert!(size >= data.len() + offset);
68        let page = self.page_manager.allocate(count, &mut flags);
69        // SAFETY: page 是刚分配的有效内存，大小为 size 字节。
70        // 我们按顺序填充：[0, offset) 清零，[offset, offset+data.len()) 拷贝数据，
71        // [offset+data.len(), size) 清零。
72        unsafe {
73            use core::slice::from_raw_parts_mut as slice;
74            let mut ptr = page.as_ptr();
75            slice(ptr, offset).fill(0);
76            ptr = ptr.add(offset);
77            slice(ptr, data.len()).copy_from_slice(data);
78            ptr = ptr.add(data.len());
79            slice(ptr, page.as_ptr().add(size).offset_from(ptr) as _).fill(0);
80        }
81        self.map_extern(range, self.page_manager.v_to_p(page), flags)
82    }
83
84    /// 取消指定 VPN 范围的映射
85    pub fn unmap(&mut self, range: Range<VPN<Meta>>) {
86        // 从 areas 中移除该范围（可能需要拆分现有区域）
87        let mut new_areas = Vec::new();
88        for area in self.areas.drain(..) {
89            if area.end <= range.start || area.start >= range.end {
90                // 不重叠，保留原区域
91                new_areas.push(area);
92            } else {
93                // 有重叠，需要拆分
94                if area.start < range.start {
95                    new_areas.push(area.start..range.start);
96                }
97                if area.end > range.end {
98                    new_areas.push(range.end..area.end);
99                }
100            }
101        }
102        self.areas = new_areas;
103
104        // 清除页表项（将 PTE 设为无效，即写入 0）
105        let mut vpn = range.start;
106        while vpn < range.end {
107            // 使用 visitor 找到 PTE 并清除
108            if let Some(pte_ptr) = self.find_pte_mut(vpn) {
109                unsafe {
110                    core::ptr::write_bytes(
111                        pte_ptr as *mut u8,
112                        0,
113                        core::mem::size_of::<page_table::Pte<Meta>>(),
114                    )
115                };
116            }
117            vpn = vpn + 1;
118        }
119
120        // 刷新地址空间
121        #[cfg(target_arch = "riscv64")]
122        unsafe {
123            core::arch::asm!("sfence.vma")
124        };
125    }
126
127    /// 查找指定 VPN 的 PTE 指针（用于修改）
128    fn find_pte_mut(&self, vpn: VPN<Meta>) -> Option<*mut page_table::Pte<Meta>> {
129        let mut current = self.page_manager.root_ptr();
130
131        for level in (0..=Meta::MAX_LEVEL).rev() {
132            let idx = vpn.index_in(level);
133            let pte_ptr = unsafe { current.as_ptr().add(idx) };
134            let pte = unsafe { *pte_ptr };
135
136            if level == 0 {
137                return Some(pte_ptr);
138            }
139
140            if !pte.is_valid() {
141                return None;
142            }
143
144            // 如果是叶子节点（大页），也返回
145            // 检查 R 或 X 位来判断是否是叶子节点
146            let flags_raw = pte.flags().val();
147            let is_leaf = (flags_raw & 0b1010) != 0; // R=bit1, X=bit3
148            if is_leaf {
149                return Some(pte_ptr);
150            }
151
152            current = self.page_manager.p_to_v(pte.ppn());
153        }
154        None
155    }
156
157    /// 检查 `flags` 的属性要求，然后将地址空间中的一个虚地址翻译成当前地址空间中的指针。
158    pub fn translate<T>(&self, addr: VAddr<Meta>, flags: VmFlags<Meta>) -> Option<NonNull<T>> {
159        let mut visitor = Visitor::new(self);
160        self.root().walk(Pos::new(addr.floor(), 0), &mut visitor);
161        visitor
162            .ans()
163            .filter(|pte| pte.flags().contains(flags))
164            .map(|pte| {
165                // SAFETY: pte 是有效的页表项，ppn 对应有效的物理页。
166                // p_to_v 返回当前地址空间中的有效指针。
167                // add(addr.offset()) 计算页内偏移，不会越界（offset < PAGE_SIZE）。
168                // 使用 new_unchecked 是因为 p_to_v 返回的是 NonNull，不可能为空。
169                unsafe {
170                    NonNull::new_unchecked(
171                        self.page_manager
172                            .p_to_v::<u8>(pte.ppn())
173                            .as_ptr()
174                            .add(addr.offset())
175                            .cast(),
176                    )
177                }
178            })
179    }
180
181    /// 遍历地址空间，将其中的地址映射添加进自己的地址空间中，重新分配物理页并拷贝所有数据及代码
182    pub fn cloneself(&self, new_addrspace: &mut AddressSpace<Meta, M>) {
183        let root = self.root();
184        let areas = &self.areas;
185        for (_, range) in areas.iter().enumerate() {
186            let mut visitor = Visitor::new(self);
187            // 虚拟地址块的首地址的 vpn
188            let vpn = range.start;
189            // 利用 visitor 访问页表，并获取这个虚拟地址块的页属性
190            root.walk(Pos::new(vpn, 0), &mut visitor);
191            // 利用 visitor 获取这个虚拟地址块的页属性，以及起始地址
192            let (mut flags, mut data_ptr) = visitor
193                .ans()
194                .filter(|pte| pte.is_valid())
195                .map(|pte| {
196                    // SAFETY: pte 是有效的页表项，p_to_v 返回有效的指针
197                    (pte.flags(), unsafe {
198                        NonNull::new_unchecked(self.page_manager.p_to_v::<u8>(pte.ppn()).as_ptr())
199                    })
200                })
201                .unwrap();
202            let vpn_range = range.start..range.end;
203            // 虚拟地址块中页数量
204            let count = range.end.val() - range.start.val();
205            let size = count << Meta::PAGE_BITS;
206            // 分配 count 个 flags 属性的物理页面
207            let paddr = new_addrspace.page_manager.allocate(count, &mut flags);
208            let ppn = new_addrspace.page_manager.v_to_p(paddr);
209            // SAFETY: data_ptr 指向源地址空间中 size 字节的有效数据，
210            // paddr 指向新分配的 size 字节内存，两者不重叠
211            unsafe {
212                use core::slice::from_raw_parts_mut as slice;
213                let data = slice(data_ptr.as_mut(), size);
214                let ptr = paddr.as_ptr();
215                slice(ptr, size).copy_from_slice(data);
216            }
217            new_addrspace.map_extern(vpn_range, ppn, flags);
218        }
219    }
220}
221
222impl<Meta: VmMeta, P: PageManager<Meta>> fmt::Debug for AddressSpace<Meta, P> {
223    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
224        writeln!(f, "root: {:#x}", self.root_ppn().val())?;
225        write!(
226            f,
227            "{:?}",
228            PageTableFormatter {
229                pt: self.root(),
230                f: |ppn| self.page_manager.p_to_v(ppn)
231            }
232        )
233    }
234}
tg_kernel_vm/space/mod.rs

tg_kernel_vm/space/
mod.rs
