1 use alloc::sync::Arc; 2 use system_error::SystemError; 3 4 use crate::{arch::MMArch, include::bindings::bindings::PAGE_OFFSET}; 5 6 use core::{ 7 cmp, 8 fmt::Debug, 9 intrinsics::unlikely, 10 ops::{Add, AddAssign, Sub, SubAssign}, 11 ptr, 12 sync::atomic::{AtomicBool, Ordering}, 13 }; 14 15 use self::{ 16 allocator::page_frame::{VirtPageFrame, VirtPageFrameIter}, 17 memblock::MemoryAreaAttr, 18 page::round_up_to_page_size, 19 ucontext::{AddressSpace, UserMapper}, 20 }; 21 22 pub mod allocator; 23 pub mod c_adapter; 24 pub mod early_ioremap; 25 pub mod kernel_mapper; 26 pub mod memblock; 27 pub mod mmio_buddy; 28 pub mod no_init; 29 pub mod page; 30 pub mod percpu; 31 pub mod syscall; 32 pub mod ucontext; 33 34 /// 内核INIT进程的用户地址空间结构体(仅在process_init中初始化) 35 static mut __INITIAL_PROCESS_ADDRESS_SPACE: Option<Arc<AddressSpace>> = None; 36 37 /// 获取内核INIT进程的用户地址空间结构体 38 #[allow(non_snake_case)] 39 #[inline(always)] 40 pub fn INITIAL_PROCESS_ADDRESS_SPACE() -> Arc<AddressSpace> { 41 unsafe { 42 return __INITIAL_PROCESS_ADDRESS_SPACE 43 .as_ref() 44 .expect("INITIAL_PROCESS_ADDRESS_SPACE is null") 45 .clone(); 46 } 47 } 48 49 /// 设置内核INIT进程的用户地址空间结构体全局变量 50 #[allow(non_snake_case)] 51 pub unsafe fn set_INITIAL_PROCESS_ADDRESS_SPACE(address_space: Arc<AddressSpace>) { 52 static INITIALIZED: AtomicBool = AtomicBool::new(false); 53 if INITIALIZED 54 .compare_exchange(false, true, Ordering::SeqCst, Ordering::Acquire) 55 .is_err() 56 { 57 panic!("INITIAL_PROCESS_ADDRESS_SPACE is already initialized"); 58 } 59 __INITIAL_PROCESS_ADDRESS_SPACE = Some(address_space); 60 } 61 62 /// @brief 将内核空间的虚拟地址转换为物理地址 63 #[inline(always)] 64 pub fn virt_2_phys(addr: usize) -> usize { 65 addr - PAGE_OFFSET as usize 66 } 67 68 /// @brief 将物理地址转换为内核空间的虚拟地址 69 #[inline(always)] 70 pub fn phys_2_virt(addr: usize) -> usize { 71 addr + PAGE_OFFSET as usize 72 } 73 74 #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, Hash)] 75 pub enum PageTableKind { 76 /// 用户可访问的页表 77 User, 78 /// 内核页表 79 Kernel, 80 /// x86内存虚拟化中使用的EPT 81 #[cfg(target_arch = "x86_64")] 82 EPT, 83 } 84 85 /// 物理内存地址 86 #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd, Hash)] 87 #[repr(transparent)] 88 pub struct PhysAddr(usize); 89 90 impl PhysAddr { 91 /// 最大物理地址 92 pub const MAX: Self = PhysAddr(usize::MAX); 93 94 #[inline(always)] 95 pub const fn new(address: usize) -> Self { 96 Self(address) 97 } 98 99 /// @brief 获取物理地址的值 100 #[inline(always)] 101 pub const fn data(&self) -> usize { 102 self.0 103 } 104 105 /// @brief 将物理地址加上一个偏移量 106 #[inline(always)] 107 pub fn add(self, offset: usize) -> Self { 108 Self(self.0 + offset) 109 } 110 111 /// @brief 判断物理地址是否按照指定要求对齐 112 #[inline(always)] 113 pub fn check_aligned(&self, align: usize) -> bool { 114 return self.0 & (align - 1) == 0; 115 } 116 117 #[inline(always)] 118 pub fn is_null(&self) -> bool { 119 return self.0 == 0; 120 } 121 } 122 123 impl Debug for PhysAddr { 124 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 125 write!(f, "PhysAddr({:#x})", self.0) 126 } 127 } 128 129 impl core::ops::Add<usize> for PhysAddr { 130 type Output = Self; 131 132 #[inline(always)] 133 fn add(self, rhs: usize) -> Self::Output { 134 return Self(self.0 + rhs); 135 } 136 } 137 138 impl core::ops::AddAssign<usize> for PhysAddr { 139 #[inline(always)] 140 fn add_assign(&mut self, rhs: usize) { 141 self.0 += rhs; 142 } 143 } 144 145 impl core::ops::Add<PhysAddr> for PhysAddr { 146 type Output = Self; 147 148 #[inline(always)] 149 fn add(self, rhs: PhysAddr) -> Self::Output { 150 return Self(self.0 + rhs.0); 151 } 152 } 153 154 impl core::ops::AddAssign<PhysAddr> for PhysAddr { 155 #[inline(always)] 156 fn add_assign(&mut self, rhs: PhysAddr) { 157 self.0 += rhs.0; 158 } 159 } 160 161 impl core::ops::BitOrAssign<usize> for PhysAddr { 162 #[inline(always)] 163 fn bitor_assign(&mut self, rhs: usize) { 164 self.0 |= rhs; 165 } 166 } 167 168 impl core::ops::BitOrAssign<PhysAddr> for PhysAddr { 169 #[inline(always)] 170 fn bitor_assign(&mut self, rhs: PhysAddr) { 171 self.0 |= rhs.0; 172 } 173 } 174 175 impl core::ops::Sub<usize> for PhysAddr { 176 type Output = Self; 177 178 #[inline(always)] 179 fn sub(self, rhs: usize) -> Self::Output { 180 return Self(self.0 - rhs); 181 } 182 } 183 184 impl core::ops::SubAssign<usize> for PhysAddr { 185 #[inline(always)] 186 fn sub_assign(&mut self, rhs: usize) { 187 self.0 -= rhs; 188 } 189 } 190 191 impl core::ops::Sub<PhysAddr> for PhysAddr { 192 type Output = usize; 193 194 #[inline(always)] 195 fn sub(self, rhs: PhysAddr) -> Self::Output { 196 return self.0 - rhs.0; 197 } 198 } 199 200 impl core::ops::SubAssign<PhysAddr> for PhysAddr { 201 #[inline(always)] 202 fn sub_assign(&mut self, rhs: PhysAddr) { 203 self.0 -= rhs.0; 204 } 205 } 206 207 /// 虚拟内存地址 208 #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd, Hash)] 209 #[repr(transparent)] 210 pub struct VirtAddr(usize); 211 212 impl VirtAddr { 213 #[inline(always)] 214 pub const fn new(address: usize) -> Self { 215 return Self(address); 216 } 217 218 /// @brief 获取虚拟地址的值 219 #[inline(always)] 220 pub const fn data(&self) -> usize { 221 return self.0; 222 } 223 224 /// @brief 判断虚拟地址的类型 225 #[inline(always)] 226 pub fn kind(&self) -> PageTableKind { 227 if self.check_user() { 228 return PageTableKind::User; 229 } else { 230 return PageTableKind::Kernel; 231 } 232 } 233 234 /// @brief 判断虚拟地址是否按照指定要求对齐 235 #[inline(always)] 236 pub fn check_aligned(&self, align: usize) -> bool { 237 return self.0 & (align - 1) == 0; 238 } 239 240 /// @brief 判断虚拟地址是否在用户空间 241 #[inline(always)] 242 pub fn check_user(&self) -> bool { 243 if self < &MMArch::USER_END_VADDR { 244 return true; 245 } else { 246 return false; 247 } 248 } 249 250 #[inline(always)] 251 pub fn as_ptr<T>(self) -> *mut T { 252 return self.0 as *mut T; 253 } 254 255 #[inline(always)] 256 pub fn is_null(&self) -> bool { 257 return self.0 == 0; 258 } 259 } 260 261 impl Add<VirtAddr> for VirtAddr { 262 type Output = Self; 263 264 #[inline(always)] 265 fn add(self, rhs: VirtAddr) -> Self::Output { 266 return Self(self.0 + rhs.0); 267 } 268 } 269 270 impl Add<usize> for VirtAddr { 271 type Output = Self; 272 273 #[inline(always)] 274 fn add(self, rhs: usize) -> Self::Output { 275 return Self(self.0 + rhs); 276 } 277 } 278 279 impl Sub<VirtAddr> for VirtAddr { 280 type Output = usize; 281 282 #[inline(always)] 283 fn sub(self, rhs: VirtAddr) -> Self::Output { 284 return self.0 - rhs.0; 285 } 286 } 287 288 impl Sub<usize> for VirtAddr { 289 type Output = Self; 290 291 #[inline(always)] 292 fn sub(self, rhs: usize) -> Self::Output { 293 return Self(self.0 - rhs); 294 } 295 } 296 297 impl AddAssign<usize> for VirtAddr { 298 #[inline(always)] 299 fn add_assign(&mut self, rhs: usize) { 300 self.0 += rhs; 301 } 302 } 303 304 impl AddAssign<VirtAddr> for VirtAddr { 305 #[inline(always)] 306 fn add_assign(&mut self, rhs: VirtAddr) { 307 self.0 += rhs.0; 308 } 309 } 310 311 impl SubAssign<usize> for VirtAddr { 312 #[inline(always)] 313 fn sub_assign(&mut self, rhs: usize) { 314 self.0 -= rhs; 315 } 316 } 317 318 impl SubAssign<VirtAddr> for VirtAddr { 319 #[inline(always)] 320 fn sub_assign(&mut self, rhs: VirtAddr) { 321 self.0 -= rhs.0; 322 } 323 } 324 325 impl Debug for VirtAddr { 326 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 327 write!(f, "VirtAddr({:#x})", self.0) 328 } 329 } 330 331 /// @brief 物理内存区域 332 #[derive(Clone, Copy, Debug)] 333 pub struct PhysMemoryArea { 334 /// 物理基地址 335 pub base: PhysAddr, 336 /// 该区域的物理内存大小 337 pub size: usize, 338 339 pub flags: MemoryAreaAttr, 340 } 341 342 impl PhysMemoryArea { 343 pub const DEFAULT: Self = Self { 344 base: PhysAddr::new(0), 345 size: 0, 346 flags: MemoryAreaAttr::empty(), 347 }; 348 349 pub fn new(base: PhysAddr, size: usize, flags: MemoryAreaAttr) -> Self { 350 Self { base, size, flags } 351 } 352 353 /// 返回向上页面对齐的区域起始物理地址 354 pub fn area_base_aligned(&self) -> PhysAddr { 355 return PhysAddr::new( 356 (self.base.data() + (MMArch::PAGE_SIZE - 1)) & !(MMArch::PAGE_SIZE - 1), 357 ); 358 } 359 360 /// 返回向下页面对齐的区域截止物理地址 361 pub fn area_end_aligned(&self) -> PhysAddr { 362 return PhysAddr::new((self.base.data() + self.size) & !(MMArch::PAGE_SIZE - 1)); 363 } 364 } 365 366 impl Default for PhysMemoryArea { 367 fn default() -> Self { 368 return Self::DEFAULT; 369 } 370 } 371 372 pub trait MemoryManagementArch: Clone + Copy + Debug { 373 /// 页面大小的shift(假如页面4K,那么这个值就是12,因为2^12=4096) 374 const PAGE_SHIFT: usize; 375 /// 每个页表的页表项数目。(以2^n次幂来表示)假如有512个页表项,那么这个值就是9 376 const PAGE_ENTRY_SHIFT: usize; 377 /// 页表层级数量 378 const PAGE_LEVELS: usize; 379 380 /// 页表项的有效位的index(假如页表项的第0-51位有效,那么这个值就是52) 381 const ENTRY_ADDRESS_SHIFT: usize; 382 /// 页面的页表项的默认值 383 const ENTRY_FLAG_DEFAULT_PAGE: usize; 384 /// 页表的页表项的默认值 385 const ENTRY_FLAG_DEFAULT_TABLE: usize; 386 /// 页表项的present位被置位之后的值 387 const ENTRY_FLAG_PRESENT: usize; 388 /// 页表项为read only时的值 389 const ENTRY_FLAG_READONLY: usize; 390 /// 页表项为可读写状态的值 391 const ENTRY_FLAG_READWRITE: usize; 392 /// 页面项标记页面为user page的值 393 const ENTRY_FLAG_USER: usize; 394 /// 页面项标记页面为write through的值 395 const ENTRY_FLAG_WRITE_THROUGH: usize; 396 /// 页面项标记页面为cache disable的值 397 const ENTRY_FLAG_CACHE_DISABLE: usize; 398 /// 标记当前页面不可执行的标志位(Execute disable)(也就是说,不能从这段内存里面获取处理器指令) 399 const ENTRY_FLAG_NO_EXEC: usize; 400 /// 标记当前页面可执行的标志位(Execute enable) 401 const ENTRY_FLAG_EXEC: usize; 402 /// 当该位为1时,标明这是一个脏页 403 const ENTRY_FLAG_DIRTY: usize; 404 /// 当该位为1时,代表这个页面被处理器访问过 405 const ENTRY_FLAG_ACCESSED: usize; 406 407 /// 虚拟地址与物理地址的偏移量 408 const PHYS_OFFSET: usize; 409 410 /// 每个页面的大小 411 const PAGE_SIZE: usize = 1 << Self::PAGE_SHIFT; 412 /// 通过这个mask,获取地址的页内偏移量 413 const PAGE_OFFSET_MASK: usize = Self::PAGE_SIZE - 1; 414 /// 通过这个mask,获取页的首地址 415 const PAGE_MASK: usize = !(Self::PAGE_OFFSET_MASK); 416 /// 页表项的地址、数据部分的shift。 417 /// 打个比方,如果这个值为52,那么意味着页表项的[0, 52)位,用于表示地址以及其他的标志位 418 const PAGE_ADDRESS_SHIFT: usize = Self::PAGE_LEVELS * Self::PAGE_ENTRY_SHIFT + Self::PAGE_SHIFT; 419 /// 最大的虚拟地址(对于不同的架构,由于上述PAGE_ADDRESS_SHIFT可能包括了reserved bits, 事实上能表示的虚拟地址应该比这个值要小) 420 const PAGE_ADDRESS_SIZE: usize = 1 << Self::PAGE_ADDRESS_SHIFT; 421 /// 页表项的值与这个常量进行与运算,得到的结果是所填写的物理地址 422 const PAGE_ADDRESS_MASK: usize = Self::PAGE_ADDRESS_SIZE - Self::PAGE_SIZE; 423 /// 每个页表项的大小 424 const PAGE_ENTRY_SIZE: usize = 1 << (Self::PAGE_SHIFT - Self::PAGE_ENTRY_SHIFT); 425 /// 每个页表的页表项数目 426 const PAGE_ENTRY_NUM: usize = 1 << Self::PAGE_ENTRY_SHIFT; 427 /// 该字段用于根据虚拟地址,获取该虚拟地址在对应的页表中是第几个页表项 428 const PAGE_ENTRY_MASK: usize = Self::PAGE_ENTRY_NUM - 1; 429 430 const PAGE_NEGATIVE_MASK: usize = !((Self::PAGE_ADDRESS_SIZE) - 1); 431 432 const ENTRY_ADDRESS_SIZE: usize = 1 << Self::ENTRY_ADDRESS_SHIFT; 433 /// 该mask用于获取页表项中地址字段 434 const ENTRY_ADDRESS_MASK: usize = Self::ENTRY_ADDRESS_SIZE - Self::PAGE_SIZE; 435 /// 这个mask用于获取页表项中的flags 436 const ENTRY_FLAGS_MASK: usize = !Self::ENTRY_ADDRESS_MASK; 437 438 /// 用户空间的最高地址 439 const USER_END_VADDR: VirtAddr; 440 /// 用户堆的起始地址 441 const USER_BRK_START: VirtAddr; 442 /// 用户栈起始地址(向下生长,不包含该值) 443 const USER_STACK_START: VirtAddr; 444 445 /// 内核的固定映射区的起始地址 446 const FIXMAP_START_VADDR: VirtAddr; 447 /// 内核的固定映射区的大小 448 const FIXMAP_SIZE: usize; 449 /// 内核的固定映射区的结束地址 450 const FIXMAP_END_VADDR: VirtAddr = 451 VirtAddr::new(Self::FIXMAP_START_VADDR.data() + Self::FIXMAP_SIZE); 452 453 /// @brief 用于初始化内存管理模块与架构相关的信息。 454 /// 该函数应调用其他模块的接口,把可用内存区域添加到memblock,提供给BumpAllocator使用 455 unsafe fn init(); 456 457 /// @brief 读取指定虚拟地址的值,并假设它是类型T的指针 458 #[inline(always)] 459 unsafe fn read<T>(address: VirtAddr) -> T { 460 return ptr::read(address.data() as *const T); 461 } 462 463 /// @brief 将value写入到指定的虚拟地址 464 #[inline(always)] 465 unsafe fn write<T>(address: VirtAddr, value: T) { 466 ptr::write(address.data() as *mut T, value); 467 } 468 469 #[inline(always)] 470 unsafe fn write_bytes(address: VirtAddr, value: u8, count: usize) { 471 ptr::write_bytes(address.data() as *mut u8, value, count); 472 } 473 474 /// @brief 刷新TLB中,关于指定虚拟地址的条目 475 unsafe fn invalidate_page(address: VirtAddr); 476 477 /// @brief 刷新TLB中,所有的条目 478 unsafe fn invalidate_all(); 479 480 /// @brief 获取顶级页表的物理地址 481 unsafe fn table(table_kind: PageTableKind) -> PhysAddr; 482 483 /// @brief 设置顶级页表的物理地址到处理器中 484 unsafe fn set_table(table_kind: PageTableKind, table: PhysAddr); 485 486 /// @brief 将物理地址转换为虚拟地址. 487 /// 488 /// @param phys 物理地址 489 /// 490 /// @return 转换后的虚拟地址。如果转换失败,返回None 491 #[inline(always)] 492 unsafe fn phys_2_virt(phys: PhysAddr) -> Option<VirtAddr> { 493 if let Some(vaddr) = phys.data().checked_add(Self::PHYS_OFFSET) { 494 return Some(VirtAddr::new(vaddr)); 495 } else { 496 return None; 497 } 498 } 499 500 /// 将虚拟地址转换为物理地址 501 /// 502 /// ## 参数 503 /// 504 /// - `virt` 虚拟地址 505 /// 506 /// ## 返回值 507 /// 508 /// 转换后的物理地址。如果转换失败,返回None 509 #[inline(always)] 510 unsafe fn virt_2_phys(virt: VirtAddr) -> Option<PhysAddr> { 511 if let Some(paddr) = virt.data().checked_sub(Self::PHYS_OFFSET) { 512 return Some(PhysAddr::new(paddr)); 513 } else { 514 return None; 515 } 516 } 517 518 /// @brief 判断指定的虚拟地址是否正确(符合规范) 519 fn virt_is_valid(virt: VirtAddr) -> bool; 520 521 /// 获取内存管理初始化时,创建的第一个内核页表的地址 522 fn initial_page_table() -> PhysAddr; 523 524 /// 初始化新的usermapper,为用户进程创建页表 525 fn setup_new_usermapper() -> Result<UserMapper, SystemError>; 526 527 /// 创建页表项 528 /// 529 /// 这是一个低阶api,用于根据物理地址以及指定好的pageflags,创建页表项 530 /// 531 /// ## 参数 532 /// 533 /// - `paddr` 物理地址 534 /// - `page_flags` 页表项的flags 535 /// 536 /// ## 返回值 537 /// 538 /// 页表项的值 539 fn make_entry(paddr: PhysAddr, page_flags: usize) -> usize; 540 } 541 542 /// @brief 虚拟地址范围 543 /// 该结构体用于表示一个虚拟地址范围,包括起始地址与大小 544 /// 545 /// 请注意与VMA进行区分,该结构体被VMA所包含 546 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] 547 pub struct VirtRegion { 548 start: VirtAddr, 549 size: usize, 550 } 551 552 #[allow(dead_code)] 553 impl VirtRegion { 554 /// # 创建一个新的虚拟地址范围 555 pub fn new(start: VirtAddr, size: usize) -> Self { 556 VirtRegion { start, size } 557 } 558 559 /// 获取虚拟地址范围的起始地址 560 #[inline(always)] 561 pub fn start(&self) -> VirtAddr { 562 self.start 563 } 564 565 /// 获取虚拟地址范围的截止地址(不包括返回的地址) 566 #[inline(always)] 567 pub fn end(&self) -> VirtAddr { 568 return self.start().add(self.size); 569 } 570 571 /// # Create a new VirtRegion from a range [start, end) 572 /// 573 /// If end <= start, return None 574 pub fn between(start: VirtAddr, end: VirtAddr) -> Option<Self> { 575 if unlikely(end.data() <= start.data()) { 576 return None; 577 } 578 let size = end.data() - start.data(); 579 return Some(VirtRegion::new(start, size)); 580 } 581 582 /// # 取两个虚拟地址范围的交集 583 /// 584 /// 如果两个虚拟地址范围没有交集,返回None 585 pub fn intersect(&self, other: &VirtRegion) -> Option<VirtRegion> { 586 let start = self.start.max(other.start); 587 let end = self.end().min(other.end()); 588 return VirtRegion::between(start, end); 589 } 590 591 /// 设置虚拟地址范围的起始地址 592 #[inline(always)] 593 pub fn set_start(&mut self, start: VirtAddr) { 594 self.start = start; 595 } 596 597 #[inline(always)] 598 pub fn size(&self) -> usize { 599 self.size 600 } 601 602 /// 设置虚拟地址范围的大小 603 #[inline(always)] 604 pub fn set_size(&mut self, size: usize) { 605 self.size = size; 606 } 607 608 /// 判断虚拟地址范围是否为空 609 #[inline(always)] 610 pub fn is_empty(&self) -> bool { 611 self.size == 0 612 } 613 614 /// 将虚拟地址区域的大小向上对齐到页大小 615 #[inline(always)] 616 pub fn round_up_size_to_page(self) -> Self { 617 return VirtRegion::new(self.start, round_up_to_page_size(self.size)); 618 } 619 620 /// 判断两个虚拟地址范围是否由于具有交集而导致冲突 621 #[inline(always)] 622 pub fn collide(&self, other: &VirtRegion) -> bool { 623 return self.intersect(other).is_some(); 624 } 625 626 pub fn iter_pages(&self) -> VirtPageFrameIter { 627 return VirtPageFrame::iter_range( 628 VirtPageFrame::new(self.start), 629 VirtPageFrame::new(self.end()), 630 ); 631 } 632 633 /// 获取[self.start(), region.start())的虚拟地址范围 634 /// 635 /// 如果self.start() >= region.start(),返回None 636 pub fn before(self, region: &VirtRegion) -> Option<Self> { 637 return Self::between(self.start(), region.start()); 638 } 639 640 /// 获取[region.end(),self.end())的虚拟地址范围 641 /// 642 /// 如果 self.end() >= region.end() ,返回None 643 pub fn after(self, region: &VirtRegion) -> Option<Self> { 644 // if self.end() > region.end() none 645 return Self::between(region.end(), self.end()); 646 } 647 648 /// 把当前虚拟地址范围内的某个虚拟地址,转换为另一个虚拟地址范围内的虚拟地址 649 /// 650 /// 如果vaddr不在当前虚拟地址范围内,返回None 651 /// 652 /// 如果vaddr在当前虚拟地址范围内,返回vaddr在new_base中的虚拟地址 653 pub fn rebase(self, vaddr: VirtAddr, new_base: &VirtRegion) -> Option<VirtAddr> { 654 if !self.contains(vaddr) { 655 return None; 656 } 657 let offset = vaddr.data() - self.start().data(); 658 let new_start = new_base.start().data() + offset; 659 return Some(VirtAddr::new(new_start)); 660 } 661 662 /// 判断虚拟地址范围是否包含指定的虚拟地址 663 pub fn contains(&self, addr: VirtAddr) -> bool { 664 return self.start() <= addr && addr < self.end(); 665 } 666 667 /// 创建当前虚拟地址范围的页面迭代器 668 pub fn pages(&self) -> VirtPageFrameIter { 669 return VirtPageFrame::iter_range( 670 VirtPageFrame::new(self.start()), 671 VirtPageFrame::new(self.end()), 672 ); 673 } 674 } 675 676 impl PartialOrd for VirtRegion { 677 fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> { 678 return self.start.partial_cmp(&other.start); 679 } 680 } 681 682 impl Ord for VirtRegion { 683 fn cmp(&self, other: &Self) -> cmp::Ordering { 684 return self.start.cmp(&other.start); 685 } 686 } 687 688 /// ## 判断虚拟地址是否超出了用户空间 689 /// 690 /// 如果虚拟地址超出了用户空间,返回Err(SystemError::EFAULT). 691 /// 如果end < start,返回Err(SystemError::EOVERFLOW) 692 /// 693 /// 否则返回Ok(()) 694 pub fn verify_area(addr: VirtAddr, size: usize) -> Result<(), SystemError> { 695 let end = addr.add(size); 696 if unlikely(end.data() < addr.data()) { 697 return Err(SystemError::EOVERFLOW); 698 } 699 700 if !addr.check_user() || !end.check_user() { 701 return Err(SystemError::EFAULT); 702 } 703 704 return Ok(()); 705 } 706