diff --git a/src/framework/jinux-frame/src/driver/timer/hpet.rs b/src/framework/jinux-frame/src/driver/timer/hpet.rs index 4141d2c9c..0fc38bf86 100644 --- a/src/framework/jinux-frame/src/driver/timer/hpet.rs +++ b/src/framework/jinux-frame/src/driver/timer/hpet.rs @@ -8,7 +8,7 @@ use volatile::{ }; use crate::driver::{acpi::ACPI_TABLES, ioapic}; -static HPET_INSTANCE: Once = Once::new(); +static HPET_INSTANCE: Once = Once::new(); const OFFSET_ID_REGISTER: usize = 0x000; const OFFSET_CONFIGURATION_REGISTER: usize = 0x010; @@ -19,22 +19,22 @@ const HPET_FREQ: usize = 1_000_000_000_000_000; #[derive(Debug)] #[repr(C)] -struct HPETTimerRegister { +struct HpetTimerRegister { configuration_and_capabilities_register: u32, timer_compartor_value_register: u32, fsb_interrupt_route_register: u32, } -struct HPET { +struct Hpet { information_register: Volatile<&'static u32, ReadOnly>, general_configuration_register: Volatile<&'static mut u32, ReadWrite>, general_interrupt_status_register: Volatile<&'static mut u32, ReadWrite>, - timer_registers: Vec>, + timer_registers: Vec>, } -impl HPET { - fn new(base_address: usize) -> HPET { +impl Hpet { + fn new(base_address: usize) -> Hpet { let information_register_ref = unsafe { &*(phys_to_virt(base_address + OFFSET_ID_REGISTER) as *mut usize as *mut u32) }; @@ -59,7 +59,7 @@ impl HPET { for i in 0..num_comparator { let comp = Volatile::new(unsafe { &mut *(phys_to_virt(base_address + 0x100 + i as usize * 0x20) as *mut usize - as *mut HPETTimerRegister) + as *mut HpetTimerRegister) }); comparators.push(comp); } @@ -74,7 +74,7 @@ impl HPET { .lock() .enable(vector, destination_apic_id); - HPET { + Hpet { information_register, general_configuration_register, general_interrupt_status_register, @@ -110,7 +110,7 @@ pub fn init() -> Result<(), AcpiError> { let hpet_info = HpetInfo::new(&*c)?; // config IO APIC entry - let hpet = HPET::new(hpet_info.base_address); + let hpet = Hpet::new(hpet_info.base_address); HPET_INSTANCE.call_once(|| hpet); Ok(()) } diff --git a/src/framework/jinux-frame/src/driver/xapic.rs b/src/framework/jinux-frame/src/driver/xapic.rs index 966fe58ff..6ba92f3ca 100644 --- a/src/framework/jinux-frame/src/driver/xapic.rs +++ b/src/framework/jinux-frame/src/driver/xapic.rs @@ -9,14 +9,14 @@ pub(crate) const IA32_APIC_BASE_MSR_ENABLE: u64 = 0x800; const APIC_LVT_MASK_BITS: u32 = 1 << 16; -pub(crate) static XAPIC_INSTANCE: Once> = Once::new(); +pub(crate) static XAPIC_INSTANCE: Once> = Once::new(); #[derive(Debug)] -pub struct XAPIC { +pub struct Xapic { mmio_region: &'static mut [u32], } -impl XAPIC { +impl Xapic { pub fn new(address: usize) -> Self { let region: &'static mut [u32] = unsafe { &mut *(address as *mut [u32; 256]) }; Self { @@ -47,7 +47,7 @@ pub(crate) fn has_apic() -> bool { pub(crate) fn init() { super::pic::disable_temp(); - let mut apic = XAPIC::new(vm::phys_to_virt(get_apic_base_address())); + let mut apic = Xapic::new(vm::phys_to_virt(get_apic_base_address())); // enable apic set_apic_base_address(get_apic_base_address()); diff --git a/src/framework/jinux-frame/src/vm/frame.rs b/src/framework/jinux-frame/src/vm/frame.rs index f4ce28cd6..e1b774880 100644 --- a/src/framework/jinux-frame/src/vm/frame.rs +++ b/src/framework/jinux-frame/src/vm/frame.rs @@ -263,7 +263,7 @@ impl VmAllocOptions { bitflags::bitflags! { pub(crate) struct VmFrameFlags : usize{ - const NEED_DEALLOC = 1<<63; + const NEED_DEALLOC = 1 << 63; } } diff --git a/src/framework/jinux-frame/src/vm/memory_set.rs b/src/framework/jinux-frame/src/vm/memory_set.rs index 316e54ed3..4b2095d9e 100644 --- a/src/framework/jinux-frame/src/vm/memory_set.rs +++ b/src/framework/jinux-frame/src/vm/memory_set.rs @@ -1,4 +1,4 @@ -use super::page_table::{PTFlags, PageTable}; +use super::page_table::{PageTable, PageTableFlags}; use crate::{ config::PAGE_SIZE, vm::is_page_aligned, @@ -11,7 +11,7 @@ use core::fmt; use super::frame_allocator; pub struct MapArea { - pub flags: PTFlags, + pub flags: PageTableFlags, pub start_va: Vaddr, pub size: usize, pub mapper: BTreeMap, @@ -46,9 +46,16 @@ impl MapArea { } /// This function will map the vitural address to the given physical frames - pub fn new(start_va: Vaddr, size: usize, flags: PTFlags, physical_frames: VmFrameVec) -> Self { + pub fn new( + start_va: Vaddr, + size: usize, + flags: PageTableFlags, + physical_frames: VmFrameVec, + ) -> Self { assert!( - is_page_aligned(start_va) && is_page_aligned(size) && physical_frames.len() == (size / PAGE_SIZE) + is_page_aligned(start_va) + && is_page_aligned(size) + && physical_frames.len() == (size / PAGE_SIZE) ); let mut map_area = Self { @@ -193,7 +200,7 @@ impl MemorySet { let mut offset = 0usize; for (va, area) in self.areas.iter_mut() { if current_addr >= *va && current_addr < area.size + va { - if !area.flags.contains(PTFlags::WRITABLE) { + if !area.flags.contains(PageTableFlags::WRITABLE) { return Err(Error::PageFault); } let write_len = remain.min(area.size + va - current_addr); @@ -235,7 +242,7 @@ impl MemorySet { Err(Error::PageFault) } - pub fn protect(&mut self, addr: Vaddr, flags: PTFlags) { + pub fn protect(&mut self, addr: Vaddr, flags: PageTableFlags) { let va = addr; self.pt.protect(va, flags) } diff --git a/src/framework/jinux-frame/src/vm/page_table.rs b/src/framework/jinux-frame/src/vm/page_table.rs index fbf2c51f9..8f2792643 100644 --- a/src/framework/jinux-frame/src/vm/page_table.rs +++ b/src/framework/jinux-frame/src/vm/page_table.rs @@ -5,7 +5,8 @@ use super::{ }; use crate::{ config::{ENTRY_COUNT, PAGE_SIZE, PHYS_OFFSET}, - vm::VmFrame, AlignExt, + vm::VmFrame, + AlignExt, }; use alloc::{collections::BTreeMap, vec, vec::Vec}; use core::{fmt, panic}; @@ -19,13 +20,13 @@ lazy_static! { bitflags::bitflags! { /// Possible flags for a page table entry. - pub struct PTFlags: usize { + pub struct PageTableFlags: usize { /// Specifies whether the mapped frame or page table is loaded in memory. - const PRESENT = 1; + const PRESENT = 1 << 0; /// Controls whether writes to the mapped frames are allowed. const WRITABLE = 1 << 1; /// Controls whether accesses from userspace (i.e. ring 3) are permitted. - const USER = 1 << 2; + const USER = 1 << 2; /// If this bit is set, a “write-through” policy is used for the cache, else a “write-back” /// policy is used. const WRITE_THROUGH = 1 << 3; @@ -35,7 +36,7 @@ bitflags::bitflags! { /// the TLB on an address space switch. const GLOBAL = 1 << 8; /// Forbid execute codes on the page. The NXE bits in EFER msr must be set. - const NO_EXECUTE = 1 << 63; + const NO_EXECUTE = 1 << 63; } } @@ -46,20 +47,20 @@ pub struct PageTableEntry(usize); impl PageTableEntry { const PHYS_ADDR_MASK: usize = !(PAGE_SIZE - 1); - pub const fn new_page(pa: Paddr, flags: PTFlags) -> Self { + pub const fn new_page(pa: Paddr, flags: PageTableFlags) -> Self { Self((pa & Self::PHYS_ADDR_MASK) | flags.bits) } const fn pa(self) -> Paddr { self.0 as usize & Self::PHYS_ADDR_MASK } - const fn flags(self) -> PTFlags { - PTFlags::from_bits_truncate(self.0) + const fn flags(self) -> PageTableFlags { + PageTableFlags::from_bits_truncate(self.0) } const fn is_unused(self) -> bool { self.0 == 0 } const fn is_present(self) -> bool { - (self.0 & PTFlags::PRESENT.bits) != 0 + (self.0 & PageTableFlags::PRESENT.bits) != 0 } } @@ -93,7 +94,7 @@ impl PageTable { } } - pub fn map(&mut self, va: Vaddr, pa: Paddr, flags: PTFlags) { + pub fn map(&mut self, va: Vaddr, pa: Paddr, flags: PageTableFlags) { let entry = self.get_entry_or_create(va).unwrap(); if !entry.is_unused() { panic!("{:#x?} is mapped before mapping", va); @@ -109,13 +110,13 @@ impl PageTable { entry.0 = 0; } - pub fn protect(&mut self, va: Vaddr, flags: PTFlags) { + pub fn protect(&mut self, va: Vaddr, flags: PageTableFlags) { let entry = self.get_entry_or_create(va).unwrap(); if entry.is_unused() || !entry.is_present() { panic!("{:#x?} is invalid before protect", va); } // clear old mask - let clear_flags_mask = !PTFlags::all().bits; + let clear_flags_mask = !PageTableFlags::all().bits; entry.0 &= clear_flags_mask; // set new mask entry.0 |= flags.bits; @@ -203,7 +204,10 @@ fn next_table_or_create<'a>( ) -> Option<&'a mut [PageTableEntry]> { if entry.is_unused() { let pa = alloc(); - *entry = PageTableEntry::new_page(pa, PTFlags::PRESENT | PTFlags::WRITABLE | PTFlags::USER); + *entry = PageTableEntry::new_page( + pa, + PageTableFlags::PRESENT | PageTableFlags::WRITABLE | PageTableFlags::USER, + ); Some(table_of(pa)) } else { next_table(entry) @@ -242,7 +246,7 @@ pub(crate) fn init() { p4[0].0 = 0; let mut map_pte = ALL_MAPPED_PTE.lock(); for i in 0..512 { - if p4[i].flags().contains(PTFlags::PRESENT) { + if p4[i].flags().contains(PageTableFlags::PRESENT) { map_pte.insert(i, p4[i]); } } diff --git a/src/framework/jinux-frame/src/vm/space.rs b/src/framework/jinux-frame/src/vm/space.rs index 48a4bc70f..f6889d0a1 100644 --- a/src/framework/jinux-frame/src/vm/space.rs +++ b/src/framework/jinux-frame/src/vm/space.rs @@ -1,5 +1,5 @@ use crate::config::PAGE_SIZE; -use crate::vm::page_table::PTFlags; +use crate::vm::page_table::PageTableFlags; use bitflags::bitflags; use core::ops::Range; use spin::Mutex; @@ -54,7 +54,7 @@ impl VmSpace { /// /// For more information, see `VmMapOptions`. pub fn map(&self, frames: VmFrameVec, options: &VmMapOptions) -> Result { - let flags = PTFlags::from(options.perm); + let flags = PageTableFlags::from(options.perm); if options.addr.is_none() { return Err(Error::InvalidArgs); } @@ -106,7 +106,7 @@ impl VmSpace { debug_assert!(range.end % PAGE_SIZE == 0); let start_page = range.start / PAGE_SIZE; let end_page = range.end / PAGE_SIZE; - let flags = PTFlags::from(perm); + let flags = PageTableFlags::from(perm); for page_idx in start_page..end_page { let addr = page_idx * PAGE_SIZE; self.memory_set.lock().protect(addr, flags) @@ -238,15 +238,15 @@ impl TryFrom for VmPerm { } } -impl From for PTFlags { +impl From for PageTableFlags { fn from(vm_perm: VmPerm) -> Self { - let mut flags = PTFlags::PRESENT | PTFlags::USER; + let mut flags = PageTableFlags::PRESENT | PageTableFlags::USER; if vm_perm.contains(VmPerm::W) { - flags |= PTFlags::WRITABLE; + flags |= PageTableFlags::WRITABLE; } // FIXME: how to respect executable flags? if !vm_perm.contains(VmPerm::X) { - flags |= PTFlags::NO_EXECUTE; + flags |= PageTableFlags::NO_EXECUTE; } flags }