1 use crate::arch::mm::LockedFrameAllocator;
2 use crate::arch::mm::PageMapper;
3 use crate::arch::MMArch;
4 use crate::mm::page::PageFlags;
5 use crate::mm::{PageTableKind, PhysAddr, VirtAddr};
6 use crate::smp::core::smp_get_processor_id;
7 use crate::smp::cpu::AtomicProcessorId;
8 use crate::smp::cpu::ProcessorId;
9 use core::sync::atomic::{compiler_fence, AtomicUsize, Ordering};
10 use system_error::SystemError;
11 use x86::msr;
12 
13 /// Check if MTRR is supported
check_ept_features() -> Result<(), SystemError>14 pub fn check_ept_features() -> Result<(), SystemError> {
15     const MTRR_ENABLE_BIT: u64 = 1 << 11;
16     let ia32_mtrr_def_type = unsafe { msr::rdmsr(msr::IA32_MTRR_DEF_TYPE) };
17     if (ia32_mtrr_def_type & MTRR_ENABLE_BIT) == 0 {
18         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
19     }
20     Ok(())
21 }
22 
23 // pub fn ept_build_mtrr_map() -> Result<(), SystemError> {
24 // let ia32_mtrr_cap = unsafe { msr::rdmsr(msr::IA32_MTRRCAP) };
25 // Ok(())
26 // }
27 
28 /// 标志当前没有处理器持有内核映射器的锁
29 /// 之所以需要这个标志，是因为AtomicUsize::new(0)会把0当作一个处理器的id
30 const EPT_MAPPER_NO_PROCESSOR: ProcessorId = ProcessorId::INVALID;
31 /// 当前持有内核映射器锁的处理器
32 static EPT_MAPPER_LOCK_OWNER: AtomicProcessorId = AtomicProcessorId::new(EPT_MAPPER_NO_PROCESSOR);
33 /// 内核映射器的锁计数器
34 static EPT_MAPPER_LOCK_COUNT: AtomicUsize = AtomicUsize::new(0);
35 
36 pub struct EptMapper {
37     /// EPT页表映射器
38     mapper: PageMapper,
39     /// 标记当前映射器是否为只读
40     readonly: bool,
41     // EPT页表根地址
42     // root_hpa: PhysAddr,
43 }
44 
45 impl EptMapper {
lock_cpu(cpuid: ProcessorId, mapper: PageMapper) -> Self46     fn lock_cpu(cpuid: ProcessorId, mapper: PageMapper) -> Self {
47         loop {
48             match EPT_MAPPER_LOCK_OWNER.compare_exchange_weak(
49                 EPT_MAPPER_NO_PROCESSOR,
50                 cpuid,
51                 Ordering::Acquire,
52                 Ordering::Relaxed,
53             ) {
54                 Ok(_) => break,
55                 // 当前处理器已经持有了锁
56                 Err(id) if id == cpuid => break,
57                 // either CAS failed, or some other hardware thread holds the lock
58                 Err(_) => core::hint::spin_loop(),
59             }
60         }
61 
62         let prev_count = EPT_MAPPER_LOCK_COUNT.fetch_add(1, Ordering::Relaxed);
63         compiler_fence(Ordering::Acquire);
64 
65         // 本地核心已经持有过锁，因此标记当前加锁获得的映射器为只读
66         let readonly = prev_count > 0;
67 
68         return Self { mapper, readonly };
69     }
70 
71     /// @brief 锁定内核映射器, 并返回一个内核映射器对象
72     #[inline(always)]
lock() -> Self73     pub fn lock() -> Self {
74         let cpuid = smp_get_processor_id();
75         let mapper = unsafe { PageMapper::current(PageTableKind::EPT, LockedFrameAllocator) };
76         return Self::lock_cpu(cpuid, mapper);
77     }
78 
79     /// 映射guest physical addr(gpa)到指定的host physical addr(hpa)。
80     ///
81     /// ## 参数
82     ///
83     /// - `gpa`: 要映射的guest physical addr
84     /// - `hpa`: 要映射的host physical addr
85     /// - `flags`: 页面标志
86     ///
87     /// ## 返回
88     ///
89     /// - 成功：返回Ok(())
90     /// - 失败： 如果当前映射器为只读，则返回EAGAIN_OR_EWOULDBLOCK
walk( &mut self, gpa: u64, hpa: u64, flags: PageFlags<MMArch>, ) -> Result<(), SystemError>91     pub unsafe fn walk(
92         &mut self,
93         gpa: u64,
94         hpa: u64,
95         flags: PageFlags<MMArch>,
96     ) -> Result<(), SystemError> {
97         if self.readonly {
98             return Err(SystemError::EAGAIN_OR_EWOULDBLOCK);
99         }
100         self.mapper
101             .map_phys(
102                 VirtAddr::new(gpa as usize),
103                 PhysAddr::new(hpa as usize),
104                 flags,
105             )
106             .unwrap()
107             .flush();
108         return Ok(());
109     }
110 
111     // fn get_ept_index(addr: u64, level: usize) -> u64 {
112     //     let pt64_level_shift = PAGE_SHIFT + (level - 1) * PT64_LEVEL_BITS;
113     //     (addr >> pt64_level_shift) & ((1 << PT64_LEVEL_BITS) - 1)
114     // }
115 }
116