1
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+ 8
+ 9
+ 10
+ 11
+ 12
+ 13
+ 14
+ 15
+ 16
+ 17
+ 18
+ 19
+ 20
+ 21
+ 22
+ 23
+ 24
+ 25
+ 26
+ 27
+ 28
+ 29
+ 30
+ 31
+ 32
+ 33
+ 34
+ 35
+ 36
+ 37
+ 38
+ 39
+ 40
+ 41
+ 42
+ 43
+ 44
+ 45
+ 46
+ 47
+ 48
+ 49
+ 50
+ 51
+ 52
+ 53
+ 54
+ 55
+ 56
+ 57
+ 58
+ 59
+ 60
+ 61
+ 62
+ 63
+ 64
+ 65
+ 66
+ 67
+ 68
+ 69
+ 70
+ 71
+ 72
+ 73
+ 74
+ 75
+ 76
+ 77
+ 78
+ 79
+ 80
+ 81
+ 82
+ 83
+ 84
+ 85
+ 86
+ 87
+ 88
+ 89
+ 90
+ 91
+ 92
+ 93
+ 94
+ 95
+ 96
+ 97
+ 98
+ 99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+253
+254
+255
+256
+257
+258
+259
+260
+261
+262
+263
+264
+265
+266
+267
+268
+269
+270
+271
+272
+273
+274
+275
+276
+277
+278
+279
+280
+281
+282
+283
+284
+285
+286
+287
+288
+289
+290
+291
+292
+293
+294
+295
+296
+297
+298
+299
+300
+301
+302
+303
+304
+305
+306
+307
+308
+309
+310
+311
+312
+313
+314
+315
+316
+317
+318
+319
+320
+321
+322
+323
+324
+325
+326
+327
+328
+329
+330
+331
+332
+333
+334
+335
+336
+337
+338
+339
+340
+341
+342
+343
+344
+345
+346
+347
+348
+349
+350
+351
+352
+353
+354
+355
+356
+357
+358
+359
+360
+361
+362
+363
+364
+365
+366
+367
+368
+369
+370
+371
+372
+373
+374
+375
+376
+377
+378
+379
+380
+381
+382
+383
+384
+385
+386
+
use super::{frame_alloc, FrameTracker};
+use super::{PTEFlags, PageTable, PageTableEntry};
+use super::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum};
+use super::{StepByOne, VPNRange};
+use crate::config::{MEMORY_END, MMIO, PAGE_SIZE, TRAMPOLINE};
+use crate::sync::UPIntrFreeCell;
+use alloc::collections::BTreeMap;
+use alloc::sync::Arc;
+use alloc::vec::Vec;
+use core::arch::asm;
+use lazy_static::*;
+use riscv::register::satp;
+
+extern "C" {
+ fn stext();
+ fn etext();
+ fn srodata();
+ fn erodata();
+ fn sdata();
+ fn edata();
+ fn sbss_with_stack();
+ fn ebss();
+ fn ekernel();
+ fn strampoline();
+}
+
+lazy_static! {
+ pub static ref KERNEL_SPACE: Arc<UPIntrFreeCell<MemorySet>> =
+ Arc::new(unsafe { UPIntrFreeCell::new(MemorySet::new_kernel()) });
+}
+
+pub fn kernel_token() -> usize {
+ KERNEL_SPACE.exclusive_access().token()
+}
+
+pub struct MemorySet {
+ page_table: PageTable,
+ areas: Vec<MapArea>,
+}
+
+impl MemorySet {
+ pub fn new_bare() -> Self {
+ Self {
+ page_table: PageTable::new(),
+ areas: Vec::new(),
+ }
+ }
+ pub fn token(&self) -> usize {
+ self.page_table.token()
+ }
+
+ pub fn insert_framed_area(
+ &mut self,
+ start_va: VirtAddr,
+ end_va: VirtAddr,
+ permission: MapPermission,
+ ) {
+ self.push(
+ MapArea::new(start_va, end_va, MapType::Framed, permission),
+ None,
+ );
+ }
+ pub fn remove_area_with_start_vpn(&mut self, start_vpn: VirtPageNum) {
+ if let Some((idx, area)) = self
+ .areas
+ .iter_mut()
+ .enumerate()
+ .find(|(_, area)| area.vpn_range.get_start() == start_vpn)
+ {
+ area.unmap(&mut self.page_table);
+ self.areas.remove(idx);
+ }
+ }
+ fn push(&mut self, mut map_area: MapArea, data: Option<&[u8]>) {
+ map_area.map(&mut self.page_table);
+ if let Some(data) = data {
+ map_area.copy_data(&mut self.page_table, data);
+ }
+ self.areas.push(map_area);
+ }
+
+ fn map_trampoline(&mut self) {
+ self.page_table.map(
+ VirtAddr::from(TRAMPOLINE).into(),
+ PhysAddr::from(strampoline as usize).into(),
+ PTEFlags::R | PTEFlags::X,
+ );
+ }
+
+ pub fn new_kernel() -> Self {
+ kprintln!("[KERN] mm::memory_set::MemorySet::new_kernel() begin");
+ let mut memory_set = Self::new_bare();
+
+ memory_set.map_trampoline();
+
+ println!("[KERN] .text [{:#x}, {:#x})", stext as usize, etext as usize);
+ println!("[KERN] .rodata [{:#x}, {:#x})", srodata as usize, erodata as usize);
+ println!("[KERN] .data [{:#x}, {:#x})", sdata as usize, edata as usize);
+ println!(
+ "[KERN] .bss [{:#x}, {:#x})",
+ sbss_with_stack as usize, ebss as usize
+ );
+ println!("[KERN] mapping .text section");
+ memory_set.push(
+ MapArea::new(
+ (stext as usize).into(),
+ (etext as usize).into(),
+ MapType::Identical,
+ MapPermission::R | MapPermission::X,
+ ),
+ None,
+ );
+ println!("[KERN] mapping .rodata section");
+ memory_set.push(
+ MapArea::new(
+ (srodata as usize).into(),
+ (erodata as usize).into(),
+ MapType::Identical,
+ MapPermission::R,
+ ),
+ None,
+ );
+ println!("[KERN] mapping .data section");
+ memory_set.push(
+ MapArea::new(
+ (sdata as usize).into(),
+ (edata as usize).into(),
+ MapType::Identical,
+ MapPermission::R | MapPermission::W,
+ ),
+ None,
+ );
+ println!("[KERN] mapping .bss section");
+ memory_set.push(
+ MapArea::new(
+ (sbss_with_stack as usize).into(),
+ (ebss as usize).into(),
+ MapType::Identical,
+ MapPermission::R | MapPermission::W,
+ ),
+ None,
+ );
+ println!("[KERN] mapping physical memory");
+ memory_set.push(
+ MapArea::new(
+ (ekernel as usize).into(),
+ MEMORY_END.into(),
+ MapType::Identical,
+ MapPermission::R | MapPermission::W,
+ ),
+ None,
+ );
+ println!("[KERN] mapping memory-mapped registers");
+ for pair in MMIO {
+ memory_set.push(
+ MapArea::new(
+ (*pair).0.into(),
+ ((*pair).0 + (*pair).1).into(),
+ MapType::Identical,
+ MapPermission::R | MapPermission::W,
+ ),
+ None,
+ );
+ }
+ kprintln!("[KERN] mm::memory_set::MemorySet::new_kernel() end");
+ memory_set
+ }
+
+
+ pub fn from_elf(elf_data: &[u8]) -> (Self, usize, usize) {
+ kprintln!("[KERN] mm::memory_set::MemorySet::from_elf() begin");
+ let mut memory_set = Self::new_bare();
+
+ memory_set.map_trampoline();
+
+ let elf = xmas_elf::ElfFile::new(elf_data).unwrap();
+ let elf_header = elf.header;
+ let magic = elf_header.pt1.magic;
+ assert_eq!(magic, [0x7f, 0x45, 0x4c, 0x46], "invalid elf!");
+ let ph_count = elf_header.pt2.ph_count();
+ let mut max_end_vpn = VirtPageNum(0);
+ for i in 0..ph_count {
+ let ph = elf.program_header(i).unwrap();
+ if ph.get_type().unwrap() == xmas_elf::program::Type::Load {
+ let start_va: VirtAddr = (ph.virtual_addr() as usize).into();
+ let end_va: VirtAddr = ((ph.virtual_addr() + ph.mem_size()) as usize).into();
+ let mut map_perm = MapPermission::U;
+ let ph_flags = ph.flags();
+ if ph_flags.is_read() {
+ map_perm |= MapPermission::R;
+ }
+ if ph_flags.is_write() {
+ map_perm |= MapPermission::W;
+ }
+ if ph_flags.is_execute() {
+ map_perm |= MapPermission::X;
+ }
+ let map_area = MapArea::new(start_va, end_va, MapType::Framed, map_perm);
+ max_end_vpn = map_area.vpn_range.get_end();
+ memory_set.push(
+ map_area,
+ Some(&elf.input[ph.offset() as usize..(ph.offset() + ph.file_size()) as usize]),
+ );
+ }
+ }
+ let max_end_va: VirtAddr = max_end_vpn.into();
+ let mut user_stack_base: usize = max_end_va.into();
+ user_stack_base += PAGE_SIZE;
+ kprintln!("[KERN] mm::memory_set::MemorySet::from_elf() end");
+ (
+ memory_set,
+ user_stack_base,
+ elf.header.pt2.entry_point() as usize,
+ )
+ }
+ pub fn from_existed_user(user_space: &MemorySet) -> MemorySet {
+ kprintln!("[KERN] mm::memory_set::MemorySet::from_existed_user() begin");
+ let mut memory_set = Self::new_bare();
+
+ memory_set.map_trampoline();
+
+ for area in user_space.areas.iter() {
+ let new_area = MapArea::from_another(area);
+ memory_set.push(new_area, None);
+
+ for vpn in area.vpn_range {
+ let src_ppn = user_space.translate(vpn).unwrap().ppn();
+ let dst_ppn = memory_set.translate(vpn).unwrap().ppn();
+ dst_ppn
+ .get_bytes_array()
+ .copy_from_slice(src_ppn.get_bytes_array());
+ }
+ }
+ kprintln!("[KERN] mm::memory_set::MemorySet::from_existed_user() end");
+ memory_set
+ }
+ pub fn activate(&self) {
+ kprintln!("[KERN] mm::memory_set::MemorySet::activate() begin");
+ let satp = self.page_table.token();
+ unsafe {
+ satp::write(satp);
+ asm!("sfence.vma");
+ }
+ kprintln!("[KERN] mm::memory_set::MemorySet::activate() begin");
+ }
+ pub fn translate(&self, vpn: VirtPageNum) -> Option<PageTableEntry> {
+ self.page_table.translate(vpn)
+ }
+ pub fn recycle_data_pages(&mut self) {
+
+ self.areas.clear();
+ }
+}
+
+pub struct MapArea {
+ vpn_range: VPNRange,
+ data_frames: BTreeMap<VirtPageNum, FrameTracker>,
+ map_type: MapType,
+ map_perm: MapPermission,
+}
+
+impl MapArea {
+ pub fn new(
+ start_va: VirtAddr,
+ end_va: VirtAddr,
+ map_type: MapType,
+ map_perm: MapPermission,
+ ) -> Self {
+ kprintln!("[KERN] mm::memory_set::MapArea::new() begin");
+ let start_vpn: VirtPageNum = start_va.floor();
+ let end_vpn: VirtPageNum = end_va.ceil();
+ kprintln!("[KERN] mm::memory_set::MapArea::new(start_vpn: {:?}, end_vpn: {:?}) end", start_vpn, end_vpn);
+ Self {
+ vpn_range: VPNRange::new(start_vpn, end_vpn),
+ data_frames: BTreeMap::new(),
+ map_type,
+ map_perm,
+ }
+ }
+ pub fn from_another(another: &MapArea) -> Self {
+ Self {
+ vpn_range: VPNRange::new(another.vpn_range.get_start(), another.vpn_range.get_end()),
+ data_frames: BTreeMap::new(),
+ map_type: another.map_type,
+ map_perm: another.map_perm,
+ }
+ }
+ pub fn map_one(&mut self, page_table: &mut PageTable, vpn: VirtPageNum) {
+ let ppn: PhysPageNum;
+ match self.map_type {
+ MapType::Identical => {
+ ppn = PhysPageNum(vpn.0);
+ }
+ MapType::Framed => {
+ let frame = frame_alloc().unwrap();
+ ppn = frame.ppn;
+ self.data_frames.insert(vpn, frame);
+ }
+ }
+ let pte_flags = PTEFlags::from_bits(self.map_perm.bits).unwrap();
+ page_table.map(vpn, ppn, pte_flags);
+ }
+ pub fn unmap_one(&mut self, page_table: &mut PageTable, vpn: VirtPageNum) {
+ if self.map_type == MapType::Framed {
+ self.data_frames.remove(&vpn);
+ }
+ page_table.unmap(vpn);
+ }
+ pub fn map(&mut self, page_table: &mut PageTable) {
+ kprintln!("[KERN] mm::memory_set::MapArea::map() begin");
+ for vpn in self.vpn_range {
+ self.map_one(page_table, vpn);
+ }
+ kprintln!("[KERN] mm::memory_set::MapArea::map() end");
+ }
+ pub fn unmap(&mut self, page_table: &mut PageTable) {
+ kprintln!("[KERN] mm::memory_set::MapArea::unmap() begin");
+ for vpn in self.vpn_range {
+ self.unmap_one(page_table, vpn);
+ }
+ kprintln!("[KERN] mm::memory_set::MapArea::unmap() end");
+ }
+
+
+ pub fn copy_data(&mut self, page_table: &mut PageTable, data: &[u8]) {
+ kprintln!("[KERN] mm::memory_set::MapArea::copy_data() begin");
+ assert_eq!(self.map_type, MapType::Framed);
+ let mut start: usize = 0;
+ let mut current_vpn = self.vpn_range.get_start();
+ let len = data.len();
+ loop {
+ let src = &data[start..len.min(start + PAGE_SIZE)];
+ let dst = &mut page_table
+ .translate(current_vpn)
+ .unwrap()
+ .ppn()
+ .get_bytes_array()[..src.len()];
+ dst.copy_from_slice(src);
+ start += PAGE_SIZE;
+ if start >= len {
+ break;
+ }
+ current_vpn.step();
+ }
+ kprintln!("[KERN] mm::memory_set::MapArea::copy_data() end");
+ }
+}
+
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub enum MapType {
+ Identical,
+ Framed,
+}
+
+bitflags! {
+ pub struct MapPermission: u8 {
+ const R = 1 << 1;
+ const W = 1 << 2;
+ const X = 1 << 3;
+ const U = 1 << 4;
+ }
+}
+
+#[allow(unused)]
+pub fn remap_test() {
+ let mut kernel_space = KERNEL_SPACE.exclusive_access();
+ let mid_text: VirtAddr = ((stext as usize + etext as usize) / 2).into();
+ let mid_rodata: VirtAddr = ((srodata as usize + erodata as usize) / 2).into();
+ let mid_data: VirtAddr = ((sdata as usize + edata as usize) / 2).into();
+ assert!(!kernel_space
+ .page_table
+ .translate(mid_text.floor())
+ .unwrap()
+ .writable(),);
+ assert!(!kernel_space
+ .page_table
+ .translate(mid_rodata.floor())
+ .unwrap()
+ .writable(),);
+ assert!(!kernel_space
+ .page_table
+ .translate(mid_data.floor())
+ .unwrap()
+ .executable(),);
+ println!("remap_test passed!");
+}
+
