1 pub mod barrier; 2 pub mod bump; 3 mod c_adapter; 4 5 use alloc::vec::Vec; 6 use hashbrown::HashSet; 7 use x86::time::rdtsc; 8 use x86_64::registers::model_specific::EferFlags; 9 10 use crate::driver::tty::serial::serial8250::send_to_default_serial8250_port; 11 use crate::filesystem::procfs::kmsg::kmsg_init; 12 use crate::include::bindings::bindings::{ 13 multiboot2_get_load_base, multiboot2_get_memory, multiboot2_iter, multiboot_mmap_entry_t, 14 multiboot_tag_load_base_addr_t, 15 }; 16 use crate::libs::align::page_align_up; 17 use crate::libs::lib_ui::screen_manager::scm_disable_put_to_window; 18 use crate::libs::printk::PrintkWriter; 19 use crate::libs::spinlock::SpinLock; 20 21 use crate::mm::allocator::page_frame::{FrameAllocator, PageFrameCount, PageFrameUsage}; 22 use crate::mm::memblock::mem_block_manager; 23 use crate::mm::mmio_buddy::mmio_init; 24 use crate::{ 25 arch::MMArch, 26 mm::allocator::{buddy::BuddyAllocator, bump::BumpAllocator}, 27 }; 28 29 use crate::mm::kernel_mapper::KernelMapper; 30 use crate::mm::page::{PageEntry, PageFlags}; 31 use crate::mm::{MemoryManagementArch, PageTableKind, PhysAddr, VirtAddr}; 32 use crate::{kdebug, kinfo, kwarn}; 33 use system_error::SystemError; 34 35 use core::arch::asm; 36 use core::ffi::c_void; 37 use core::fmt::{Debug, Write}; 38 use core::mem::{self}; 39 40 use core::sync::atomic::{compiler_fence, AtomicBool, Ordering}; 41 42 use super::kvm::vmx::vmcs::VmcsFields; 43 use super::kvm::vmx::vmx_asm_wrapper::vmx_vmread; 44 45 pub type PageMapper = 46 crate::mm::page::PageMapper<crate::arch::x86_64::mm::X86_64MMArch, LockedFrameAllocator>; 47 48 /// 初始的CR3寄存器的值，用于内存管理初始化时，创建的第一个内核页表的位置 49 static mut INITIAL_CR3_VALUE: PhysAddr = PhysAddr::new(0); 50 51 /// 内核的第一个页表在pml4中的索引 52 /// 顶级页表的[256, 512)项是内核的页表 53 static KERNEL_PML4E_NO: usize = (X86_64MMArch::PHYS_OFFSET & ((1 << 48) - 1)) >> 39; 54 55 static INNER_ALLOCATOR: SpinLock<Option<BuddyAllocator<MMArch>>> = SpinLock::new(None); 56 57 #[derive(Clone, Copy, Debug)] 58 pub struct X86_64MMBootstrapInfo { 59 kernel_load_base_paddr: usize, 60 kernel_code_start: usize, 61 kernel_code_end: usize, 62 kernel_data_end: usize, 63 kernel_rodata_end: usize, 64 start_brk: usize, 65 } 66 67 pub(super) static mut BOOTSTRAP_MM_INFO: Option<X86_64MMBootstrapInfo> = None; 68 69 /// @brief X86_64的内存管理架构结构体 70 #[derive(Debug, Clone, Copy, Hash)] 71 pub struct X86_64MMArch; 72 73 /// XD标志位是否被保留 74 static XD_RESERVED: AtomicBool = AtomicBool::new(false); 75 76 impl MemoryManagementArch for X86_64MMArch { 77 /// 4K页 78 const PAGE_SHIFT: usize = 12; 79 80 /// 每个页表项占8字节，总共有512个页表项 81 const PAGE_ENTRY_SHIFT: usize = 9; 82 83 /// 四级页表（PML4T、PDPT、PDT、PT） 84 const PAGE_LEVELS: usize = 4; 85 86 /// 页表项的有效位的index。在x86_64中，页表项的第[0, 47]位表示地址和flag， 87 /// 第[48, 51]位表示保留。因此，有效位的index为52。 88 /// 请注意，第63位是XD位，表示是否允许执行。 89 const ENTRY_ADDRESS_SHIFT: usize = 52; 90 91 const ENTRY_FLAG_DEFAULT_PAGE: usize = Self::ENTRY_FLAG_PRESENT; 92 93 const ENTRY_FLAG_DEFAULT_TABLE: usize = Self::ENTRY_FLAG_PRESENT; 94 95 const ENTRY_FLAG_PRESENT: usize = 1 << 0; 96 97 const ENTRY_FLAG_READONLY: usize = 0; 98 99 const ENTRY_FLAG_READWRITE: usize = 1 << 1; 100 101 const ENTRY_FLAG_USER: usize = 1 << 2; 102 103 const ENTRY_FLAG_WRITE_THROUGH: usize = 1 << 3; 104 105 const ENTRY_FLAG_CACHE_DISABLE: usize = 1 << 4; 106 107 const ENTRY_FLAG_NO_EXEC: usize = 1 << 63; 108 /// x86_64不存在EXEC标志位，只有NO_EXEC（XD）标志位 109 const ENTRY_FLAG_EXEC: usize = 0; 110 111 const ENTRY_FLAG_ACCESSED: usize = 0; 112 const ENTRY_FLAG_DIRTY: usize = 0; 113 114 /// 物理地址与虚拟地址的偏移量 115 /// 0xffff_8000_0000_0000 116 const PHYS_OFFSET: usize = Self::PAGE_NEGATIVE_MASK + (Self::PAGE_ADDRESS_SIZE >> 1); 117 118 const USER_END_VADDR: VirtAddr = VirtAddr::new(0x0000_7eff_ffff_ffff); 119 const USER_BRK_START: VirtAddr = VirtAddr::new(0x700000000000); 120 const USER_STACK_START: VirtAddr = VirtAddr::new(0x6ffff0a00000); 121 122 const FIXMAP_START_VADDR: VirtAddr = VirtAddr::new(0xffffb00000000000); 123 /// 设置FIXMAP区域大小为1M 124 const FIXMAP_SIZE: usize = 256 * 4096; 125 126 /// @brief 获取物理内存区域 127 unsafe fn init() { 128 extern "C" { 129 fn _text(); 130 fn _etext(); 131 fn _edata(); 132 fn _erodata(); 133 fn _end(); 134 } 135 136 Self::init_xd_rsvd(); 137 let load_base_paddr = Self::get_load_base_paddr(); 138 139 let bootstrap_info = X86_64MMBootstrapInfo { 140 kernel_load_base_paddr: load_base_paddr.data(), 141 kernel_code_start: _text as usize, 142 kernel_code_end: _etext as usize, 143 kernel_data_end: _edata as usize, 144 kernel_rodata_end: _erodata as usize, 145 start_brk: _end as usize, 146 }; 147 148 unsafe { 149 BOOTSTRAP_MM_INFO = Some(bootstrap_info); 150 } 151 152 // 初始化物理内存区域(从multiboot2中获取) 153 Self::init_memory_area_from_multiboot2().expect("init memory area failed"); 154 155 send_to_default_serial8250_port("x86 64 init end\n\0".as_bytes()); 156 } 157 158 /// @brief 刷新TLB中，关于指定虚拟地址的条目 159 unsafe fn invalidate_page(address: VirtAddr) { 160 compiler_fence(Ordering::SeqCst); 161 asm!("invlpg [{0}]", in(reg) address.data(), options(nostack, preserves_flags)); 162 compiler_fence(Ordering::SeqCst); 163 } 164 165 /// @brief 刷新TLB中，所有的条目 166 unsafe fn invalidate_all() { 167 compiler_fence(Ordering::SeqCst); 168 // 通过设置cr3寄存器，来刷新整个TLB 169 Self::set_table(PageTableKind::User, Self::table(PageTableKind::User)); 170 compiler_fence(Ordering::SeqCst); 171 } 172 173 /// @brief 获取顶级页表的物理地址 174 unsafe fn table(table_kind: PageTableKind) -> PhysAddr { 175 match table_kind { 176 PageTableKind::Kernel | PageTableKind::User => { 177 let paddr: usize; 178 compiler_fence(Ordering::SeqCst); 179 asm!("mov {}, cr3", out(reg) paddr, options(nomem, nostack, preserves_flags)); 180 compiler_fence(Ordering::SeqCst); 181 return PhysAddr::new(paddr); 182 } 183 PageTableKind::EPT => { 184 let eptp = 185 vmx_vmread(VmcsFields::CTRL_EPTP_PTR as u32).expect("Failed to read eptp"); 186 return PhysAddr::new(eptp as usize); 187 } 188 } 189 } 190 191 /// @brief 设置顶级页表的物理地址到处理器中 192 unsafe fn set_table(_table_kind: PageTableKind, table: PhysAddr) { 193 compiler_fence(Ordering::SeqCst); 194 asm!("mov cr3, {}", in(reg) table.data(), options(nostack, preserves_flags)); 195 compiler_fence(Ordering::SeqCst); 196 } 197 198 /// @brief 判断虚拟地址是否合法 199 fn virt_is_valid(virt: VirtAddr) -> bool { 200 return virt.is_canonical(); 201 } 202 203 /// 获取内存管理初始化时，创建的第一个内核页表的地址 204 fn initial_page_table() -> PhysAddr { 205 unsafe { 206 return INITIAL_CR3_VALUE; 207 } 208 } 209 210 /// @brief 创建新的顶层页表 211 /// 212 /// 该函数会创建页表并复制内核的映射到新的页表中 213 /// 214 /// @return 新的页表 215 fn setup_new_usermapper() -> Result<crate::mm::ucontext::UserMapper, SystemError> { 216 let new_umapper: crate::mm::page::PageMapper<X86_64MMArch, LockedFrameAllocator> = unsafe { 217 PageMapper::create(PageTableKind::User, LockedFrameAllocator) 218 .ok_or(SystemError::ENOMEM)? 219 }; 220 221 let current_ktable: KernelMapper = KernelMapper::lock(); 222 let copy_mapping = |pml4_entry_no| unsafe { 223 let entry: PageEntry<X86_64MMArch> = current_ktable 224 .table() 225 .entry(pml4_entry_no) 226 .unwrap_or_else(|| panic!("entry {} not found", pml4_entry_no)); 227 new_umapper.table().set_entry(pml4_entry_no, entry) 228 }; 229 230 // 复制内核的映射 231 for pml4_entry_no in KERNEL_PML4E_NO..512 { 232 copy_mapping(pml4_entry_no); 233 } 234 235 return Ok(crate::mm::ucontext::UserMapper::new(new_umapper)); 236 } 237 238 const PAGE_SIZE: usize = 1 << Self::PAGE_SHIFT; 239 240 const PAGE_OFFSET_MASK: usize = Self::PAGE_SIZE - 1; 241 242 const PAGE_MASK: usize = !(Self::PAGE_OFFSET_MASK); 243 244 const PAGE_ADDRESS_SHIFT: usize = Self::PAGE_LEVELS * Self::PAGE_ENTRY_SHIFT + Self::PAGE_SHIFT; 245 246 const PAGE_ADDRESS_SIZE: usize = 1 << Self::PAGE_ADDRESS_SHIFT; 247 248 const PAGE_ADDRESS_MASK: usize = Self::PAGE_ADDRESS_SIZE - Self::PAGE_SIZE; 249 250 const PAGE_ENTRY_SIZE: usize = 1 << (Self::PAGE_SHIFT - Self::PAGE_ENTRY_SHIFT); 251 252 const PAGE_ENTRY_NUM: usize = 1 << Self::PAGE_ENTRY_SHIFT; 253 254 const PAGE_ENTRY_MASK: usize = Self::PAGE_ENTRY_NUM - 1; 255 256 const PAGE_NEGATIVE_MASK: usize = !((Self::PAGE_ADDRESS_SIZE) - 1); 257 258 const ENTRY_ADDRESS_SIZE: usize = 1 << Self::ENTRY_ADDRESS_SHIFT; 259 260 const ENTRY_ADDRESS_MASK: usize = Self::ENTRY_ADDRESS_SIZE - Self::PAGE_SIZE; 261 262 const ENTRY_FLAGS_MASK: usize = !Self::ENTRY_ADDRESS_MASK; 263 264 unsafe fn read<T>(address: VirtAddr) -> T { 265 return core::ptr::read(address.data() as *const T); 266 } 267 268 unsafe fn write<T>(address: VirtAddr, value: T) { 269 core::ptr::write(address.data() as *mut T, value); 270 } 271 272 unsafe fn write_bytes(address: VirtAddr, value: u8, count: usize) { 273 core::ptr::write_bytes(address.data() as *mut u8, value, count); 274 } 275 276 unsafe fn phys_2_virt(phys: PhysAddr) -> Option<VirtAddr> { 277 if let Some(vaddr) = phys.data().checked_add(Self::PHYS_OFFSET) { 278 return Some(VirtAddr::new(vaddr)); 279 } else { 280 return None; 281 } 282 } 283 284 unsafe fn virt_2_phys(virt: VirtAddr) -> Option<PhysAddr> { 285 if let Some(paddr) = virt.data().checked_sub(Self::PHYS_OFFSET) { 286 return Some(PhysAddr::new(paddr)); 287 } else { 288 return None; 289 } 290 } 291 292 #[inline(always)] 293 fn make_entry(paddr: PhysAddr, page_flags: usize) -> usize { 294 return paddr.data() | page_flags; 295 } 296 } 297 298 impl X86_64MMArch { 299 unsafe fn get_load_base_paddr() -> PhysAddr { 300 let mut mb2_lb_info: [multiboot_tag_load_base_addr_t; 512] = mem::zeroed(); 301 send_to_default_serial8250_port("get_load_base_paddr begin\n\0".as_bytes()); 302 303 let mut mb2_count: u32 = 0; 304 multiboot2_iter( 305 Some(multiboot2_get_load_base), 306 &mut mb2_lb_info as *mut [multiboot_tag_load_base_addr_t; 512] as usize as *mut c_void, 307 &mut mb2_count, 308 ); 309 310 if mb2_count == 0 { 311 send_to_default_serial8250_port( 312 "get_load_base_paddr mb2_count == 0, default to 1MB\n\0".as_bytes(), 313 ); 314 return PhysAddr::new(0x100000); 315 } 316 317 let phys = mb2_lb_info[0].load_base_addr as usize; 318 319 return PhysAddr::new(phys); 320 } 321 unsafe fn init_memory_area_from_multiboot2() -> Result<usize, SystemError> { 322 // 这个数组用来存放内存区域的信息（从C获取） 323 let mut mb2_mem_info: [multiboot_mmap_entry_t; 512] = mem::zeroed(); 324 send_to_default_serial8250_port("init_memory_area_from_multiboot2 begin\n\0".as_bytes()); 325 326 let mut mb2_count: u32 = 0; 327 multiboot2_iter( 328 Some(multiboot2_get_memory), 329 &mut mb2_mem_info as *mut [multiboot_mmap_entry_t; 512] as usize as *mut c_void, 330 &mut mb2_count, 331 ); 332 send_to_default_serial8250_port("init_memory_area_from_multiboot2 2\n\0".as_bytes()); 333 334 let mb2_count = mb2_count as usize; 335 let mut areas_count = 0usize; 336 let mut total_mem_size = 0usize; 337 for i in 0..mb2_count { 338 // Only use the memory area if its type is 1 (RAM) 339 if mb2_mem_info[i].type_ == 1 { 340 // Skip the memory area if its len is 0 341 if mb2_mem_info[i].len == 0 { 342 continue; 343 } 344 345 total_mem_size += mb2_mem_info[i].len as usize; 346 347 mem_block_manager() 348 .add_block( 349 PhysAddr::new(mb2_mem_info[i].addr as usize), 350 mb2_mem_info[i].len as usize, 351 ) 352 .unwrap_or_else(|e| { 353 kwarn!( 354 "Failed to add memory block: base={:#x}, size={:#x}, error={:?}", 355 mb2_mem_info[i].addr, 356 mb2_mem_info[i].len, 357 e 358 ); 359 }); 360 areas_count += 1; 361 } 362 } 363 send_to_default_serial8250_port("init_memory_area_from_multiboot2 end\n\0".as_bytes()); 364 kinfo!("Total memory size: {} MB, total areas from multiboot2: {mb2_count}, valid areas: {areas_count}", total_mem_size / 1024 / 1024); 365 return Ok(areas_count); 366 } 367 368 fn init_xd_rsvd() { 369 // 读取ia32-EFER寄存器的值 370 let efer: EferFlags = x86_64::registers::model_specific::Efer::read(); 371 if !efer.contains(EferFlags::NO_EXECUTE_ENABLE) { 372 // NO_EXECUTE_ENABLE是false，那么就设置xd_reserved为true 373 kdebug!("NO_EXECUTE_ENABLE is false, set XD_RESERVED to true"); 374 XD_RESERVED.store(true, Ordering::Relaxed); 375 } 376 compiler_fence(Ordering::SeqCst); 377 } 378 379 /// 判断XD标志位是否被保留 380 pub fn is_xd_reserved() -> bool { 381 // return XD_RESERVED.load(Ordering::Relaxed); 382 383 // 由于暂时不支持execute disable，因此直接返回true 384 // 不支持的原因是，目前好像没有能正确的设置page-level的xd位，会触发page fault 385 return true; 386 } 387 } 388 389 impl VirtAddr { 390 /// @brief 判断虚拟地址是否合法 391 #[inline(always)] 392 pub fn is_canonical(self) -> bool { 393 let x = self.data() & X86_64MMArch::PHYS_OFFSET; 394 // 如果x为0，说明虚拟地址的高位为0，是合法的用户地址 395 // 如果x为PHYS_OFFSET，说明虚拟地址的高位全为1，是合法的内核地址 396 return x == 0 || x == X86_64MMArch::PHYS_OFFSET; 397 } 398 } 399 400 /// @brief 初始化内存管理模块 401 pub fn mm_init() { 402 send_to_default_serial8250_port("mm_init\n\0".as_bytes()); 403 PrintkWriter 404 .write_fmt(format_args!("mm_init() called\n")) 405 .unwrap(); 406 // printk_color!(GREEN, BLACK, "mm_init() called\n"); 407 static _CALL_ONCE: AtomicBool = AtomicBool::new(false); 408 if _CALL_ONCE 409 .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst) 410 .is_err() 411 { 412 send_to_default_serial8250_port("mm_init err\n\0".as_bytes()); 413 panic!("mm_init() can only be called once"); 414 } 415 416 unsafe { X86_64MMArch::init() }; 417 kdebug!("bootstrap info: {:?}", unsafe { BOOTSTRAP_MM_INFO }); 418 kdebug!("phys[0]=virt[0x{:x}]", unsafe { 419 MMArch::phys_2_virt(PhysAddr::new(0)).unwrap().data() 420 }); 421 422 // 初始化内存管理器 423 unsafe { allocator_init() }; 424 // enable mmio 425 mmio_init(); 426 // enable KMSG 427 kmsg_init(); 428 } 429 430 unsafe fn allocator_init() { 431 let virt_offset = BOOTSTRAP_MM_INFO.unwrap().start_brk; 432 let phy_offset = 433 unsafe { MMArch::virt_2_phys(VirtAddr::new(page_align_up(virt_offset))) }.unwrap(); 434 435 let mut bump_allocator = BumpAllocator::<X86_64MMArch>::new(phy_offset.data()); 436 kdebug!( 437 "BumpAllocator created, offset={:?}", 438 bump_allocator.offset() 439 ); 440 441 // 暂存初始在head.S中指定的页表的地址，后面再考虑是否需要把它加到buddy的可用空间里面！ 442 // 现在不加的原因是，我担心会有安全漏洞问题：这些初始的页表，位于内核的数据段。如果归还到buddy， 443 // 可能会产生一定的安全风险（有的代码可能根据虚拟地址来进行安全校验） 444 let _old_page_table = MMArch::table(PageTableKind::Kernel); 445 446 let new_page_table: PhysAddr; 447 // 使用bump分配器，把所有的内存页都映射到页表 448 { 449 // 用bump allocator创建新的页表 450 let mut mapper: crate::mm::page::PageMapper<MMArch, &mut BumpAllocator<MMArch>> = 451 crate::mm::page::PageMapper::<MMArch, _>::create( 452 PageTableKind::Kernel, 453 &mut bump_allocator, 454 ) 455 .expect("Failed to create page mapper"); 456 new_page_table = mapper.table().phys(); 457 kdebug!("PageMapper created"); 458 459 // 取消最开始时候，在head.S中指定的映射(暂时不刷新TLB) 460 { 461 let table = mapper.table(); 462 let empty_entry = PageEntry::<MMArch>::from_usize(0); 463 for i in 0..MMArch::PAGE_ENTRY_NUM { 464 table 465 .set_entry(i, empty_entry) 466 .expect("Failed to empty page table entry"); 467 } 468 } 469 kdebug!("Successfully emptied page table"); 470 471 let total_num = mem_block_manager().total_initial_memory_regions(); 472 for i in 0..total_num { 473 let area = mem_block_manager().get_initial_memory_region(i).unwrap(); 474 // kdebug!("area: base={:?}, size={:#x}, end={:?}", area.base, area.size, area.base + area.size); 475 for i in 0..((area.size + MMArch::PAGE_SIZE - 1) / MMArch::PAGE_SIZE) { 476 let paddr = area.base.add(i * MMArch::PAGE_SIZE); 477 let vaddr = unsafe { MMArch::phys_2_virt(paddr) }.unwrap(); 478 let flags = kernel_page_flags::<MMArch>(vaddr); 479 480 let flusher = mapper 481 .map_phys(vaddr, paddr, flags) 482 .expect("Failed to map frame"); 483 // 暂时不刷新TLB 484 flusher.ignore(); 485 } 486 } 487 488 // 添加低地址的映射（在smp完成初始化之前，需要使用低地址的映射.初始化之后需要取消这一段映射） 489 LowAddressRemapping::remap_at_low_address(&mut mapper); 490 } 491 492 unsafe { 493 INITIAL_CR3_VALUE = new_page_table; 494 } 495 kdebug!( 496 "After mapping all physical memory, DragonOS used: {} KB", 497 bump_allocator.offset() / 1024 498 ); 499 500 // 初始化buddy_allocator 501 let buddy_allocator = unsafe { BuddyAllocator::<X86_64MMArch>::new(bump_allocator).unwrap() }; 502 // 设置全局的页帧分配器 503 unsafe { set_inner_allocator(buddy_allocator) }; 504 kinfo!("Successfully initialized buddy allocator"); 505 // 关闭显示输出 506 scm_disable_put_to_window(); 507 508 // make the new page table current 509 { 510 let mut binding = INNER_ALLOCATOR.lock(); 511 let mut allocator_guard = binding.as_mut().unwrap(); 512 kdebug!("To enable new page table."); 513 compiler_fence(Ordering::SeqCst); 514 let mapper = crate::mm::page::PageMapper::<MMArch, _>::new( 515 PageTableKind::Kernel, 516 new_page_table, 517 &mut allocator_guard, 518 ); 519 compiler_fence(Ordering::SeqCst); 520 mapper.make_current(); 521 compiler_fence(Ordering::SeqCst); 522 kdebug!("New page table enabled"); 523 } 524 kdebug!("Successfully enabled new page table"); 525 } 526 527 #[no_mangle] 528 pub extern "C" fn rs_test_buddy() { 529 test_buddy(); 530 } 531 pub fn test_buddy() { 532 // 申请内存然后写入数据然后free掉 533 // 总共申请200MB内存 534 const TOTAL_SIZE: usize = 200 * 1024 * 1024; 535 536 for i in 0..10 { 537 kdebug!("Test buddy, round: {i}"); 538 // 存放申请的内存块 539 let mut v: Vec<(PhysAddr, PageFrameCount)> = Vec::with_capacity(60 * 1024); 540 // 存放已经申请的内存块的地址（用于检查重复） 541 let mut addr_set: HashSet<PhysAddr> = HashSet::new(); 542 543 let mut allocated = 0usize; 544 545 let mut free_count = 0usize; 546 547 while allocated < TOTAL_SIZE { 548 let mut random_size = 0u64; 549 unsafe { x86::random::rdrand64(&mut random_size) }; 550 // 一次最多申请4M 551 random_size = random_size % (1024 * 4096); 552 if random_size == 0 { 553 continue; 554 } 555 let random_size = 556 core::cmp::min(page_align_up(random_size as usize), TOTAL_SIZE - allocated); 557 let random_size = PageFrameCount::from_bytes(random_size.next_power_of_two()).unwrap(); 558 // 获取帧 559 let (paddr, allocated_frame_count) = 560 unsafe { LockedFrameAllocator.allocate(random_size).unwrap() }; 561 assert!(allocated_frame_count.data().is_power_of_two()); 562 assert!(paddr.data() % MMArch::PAGE_SIZE == 0); 563 unsafe { 564 assert!(MMArch::phys_2_virt(paddr) 565 .as_ref() 566 .unwrap() 567 .check_aligned(allocated_frame_count.data() * MMArch::PAGE_SIZE)); 568 } 569 allocated += allocated_frame_count.data() * MMArch::PAGE_SIZE; 570 v.push((paddr, allocated_frame_count)); 571 assert!(addr_set.insert(paddr), "duplicate address: {:?}", paddr); 572 573 // 写入数据 574 let vaddr = unsafe { MMArch::phys_2_virt(paddr).unwrap() }; 575 let slice = unsafe { 576 core::slice::from_raw_parts_mut( 577 vaddr.data() as *mut u8, 578 allocated_frame_count.data() * MMArch::PAGE_SIZE, 579 ) 580 }; 581 for i in 0..slice.len() { 582 slice[i] = ((i + unsafe { rdtsc() } as usize) % 256) as u8; 583 } 584 585 // 随机释放一个内存块 586 if v.len() > 0 { 587 let mut random_index = 0u64; 588 unsafe { x86::random::rdrand64(&mut random_index) }; 589 // 70%概率释放 590 if random_index % 10 > 7 { 591 continue; 592 } 593 random_index = random_index % v.len() as u64; 594 let random_index = random_index as usize; 595 let (paddr, allocated_frame_count) = v.remove(random_index); 596 assert!(addr_set.remove(&paddr)); 597 unsafe { LockedFrameAllocator.free(paddr, allocated_frame_count) }; 598 free_count += allocated_frame_count.data() * MMArch::PAGE_SIZE; 599 } 600 } 601 602 kdebug!( 603 "Allocated {} MB memory, release: {} MB, no release: {} bytes", 604 allocated / 1024 / 1024, 605 free_count / 1024 / 1024, 606 (allocated - free_count) 607 ); 608 609 kdebug!("Now, to release buddy memory"); 610 // 释放所有的内存 611 for (paddr, allocated_frame_count) in v { 612 unsafe { LockedFrameAllocator.free(paddr, allocated_frame_count) }; 613 assert!(addr_set.remove(&paddr)); 614 free_count += allocated_frame_count.data() * MMArch::PAGE_SIZE; 615 } 616 617 kdebug!("release done!, allocated: {allocated}, free_count: {free_count}"); 618 } 619 } 620 621 /// 全局的页帧分配器 622 #[derive(Debug, Clone, Copy, Hash)] 623 pub struct LockedFrameAllocator; 624 625 impl FrameAllocator for LockedFrameAllocator { 626 unsafe fn allocate(&mut self, count: PageFrameCount) -> Option<(PhysAddr, PageFrameCount)> { 627 if let Some(ref mut allocator) = *INNER_ALLOCATOR.lock_irqsave() { 628 return allocator.allocate(count); 629 } else { 630 return None; 631 } 632 } 633 634 unsafe fn free(&mut self, address: crate::mm::PhysAddr, count: PageFrameCount) { 635 assert!(count.data().is_power_of_two()); 636 if let Some(ref mut allocator) = *INNER_ALLOCATOR.lock_irqsave() { 637 return allocator.free(address, count); 638 } 639 } 640 641 unsafe fn usage(&self) -> PageFrameUsage { 642 if let Some(ref mut allocator) = *INNER_ALLOCATOR.lock_irqsave() { 643 return allocator.usage(); 644 } else { 645 panic!("usage error"); 646 } 647 } 648 } 649 650 /// 获取内核地址默认的页面标志 651 pub unsafe fn kernel_page_flags<A: MemoryManagementArch>(virt: VirtAddr) -> PageFlags<A> { 652 let info: X86_64MMBootstrapInfo = BOOTSTRAP_MM_INFO.clone().unwrap(); 653 654 if virt.data() >= info.kernel_code_start && virt.data() < info.kernel_code_end { 655 // Remap kernel code execute 656 return PageFlags::new().set_execute(true).set_write(true); 657 } else if virt.data() >= info.kernel_data_end && virt.data() < info.kernel_rodata_end { 658 // Remap kernel rodata read only 659 return PageFlags::new().set_execute(true); 660 } else { 661 return PageFlags::new().set_write(true).set_execute(true); 662 } 663 } 664 665 unsafe fn set_inner_allocator(allocator: BuddyAllocator<MMArch>) { 666 static FLAG: AtomicBool = AtomicBool::new(false); 667 if FLAG 668 .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst) 669 .is_err() 670 { 671 panic!("Cannot set inner allocator twice!"); 672 } 673 *INNER_ALLOCATOR.lock() = Some(allocator); 674 } 675 676 /// 低地址重映射的管理器 677 /// 678 /// 低地址重映射的管理器，在smp初始化完成之前，需要使用低地址的映射，因此需要在smp初始化完成之后，取消这一段映射 679 pub struct LowAddressRemapping; 680 681 impl LowAddressRemapping { 682 // 映射32M 683 const REMAP_SIZE: usize = 32 * 1024 * 1024; 684 685 pub unsafe fn remap_at_low_address( 686 mapper: &mut crate::mm::page::PageMapper<MMArch, &mut BumpAllocator<MMArch>>, 687 ) { 688 for i in 0..(Self::REMAP_SIZE / MMArch::PAGE_SIZE) { 689 let paddr = PhysAddr::new(i * MMArch::PAGE_SIZE); 690 let vaddr = VirtAddr::new(i * MMArch::PAGE_SIZE); 691 let flags = kernel_page_flags::<MMArch>(vaddr); 692 693 let flusher = mapper 694 .map_phys(vaddr, paddr, flags) 695 .expect("Failed to map frame"); 696 // 暂时不刷新TLB 697 flusher.ignore(); 698 } 699 } 700 701 /// 取消低地址的映射 702 pub unsafe fn unmap_at_low_address(flush: bool) { 703 let mut mapper = KernelMapper::lock(); 704 assert!(mapper.as_mut().is_some()); 705 for i in 0..(Self::REMAP_SIZE / MMArch::PAGE_SIZE) { 706 let vaddr = VirtAddr::new(i * MMArch::PAGE_SIZE); 707 let (_, _, flusher) = mapper 708 .as_mut() 709 .unwrap() 710 .unmap_phys(vaddr, true) 711 .expect("Failed to unmap frame"); 712 if flush == false { 713 flusher.ignore(); 714 } 715 } 716 } 717 } 718 #[no_mangle] 719 pub extern "C" fn rs_mm_init() { 720 mm_init(); 721 } 722