phys_addr: add as_hhdm_virt to minimize the phys to hhdm virt

translation code repetetion

Signed-off-by: Andy-Python-Programmer <andypythonappdeveloper@gmail.com>

Author: Andy-Python-Programmer

src/aero_kernel/src/acpi/mod.rs

@@ -98,7 +98,8 @@ impl aml::Handler for AmlHandler {
         log::trace!("AML: Reading byte from {:#x}", address);
 
         unsafe {
-            (crate::PHYSICAL_MEMORY_OFFSET + address)
+            PhysAddr::new(address as u64)
+                .as_hhdm_virt()
                 .as_ptr::<u8>()
                 .read_volatile()
         }
@@ -221,7 +222,7 @@ impl aml::Handler for AmlHandler {
 
 /// Initialize the ACPI tables.
 pub fn init(rsdp_address: PhysAddr) -> Result<(), aml::AmlError> {
-    let rsdp_address = unsafe { crate::PHYSICAL_MEMORY_OFFSET + rsdp_address.as_u64() };
+    let rsdp_address = rsdp_address.as_hhdm_virt();
     let acpi_table = AcpiTable::new(rsdp_address);
 
     macro init_table($sig:path => $ty:ty) {
@@ -262,7 +263,7 @@ pub fn init(rsdp_address: PhysAddr) -> Result<(), aml::AmlError> {
         // The DSDT table is put inside the FADT table, instead of listing it in another ACPI table. So
         // we need to extract the DSDT table from the FADT table.
         let _dsdt_stream = unsafe {
-            let addr = crate::PHYSICAL_MEMORY_OFFSET + fadt.dsdt as u64;
+            let addr = PhysAddr::new(fadt.dsdt as u64).as_hhdm_virt();
             let sdt = Sdt::from_address(addr);
 
             core::slice::from_raw_parts(sdt.data_address() as *mut u8, sdt.data_len())

src/aero_kernel/src/acpi/rsdp.rs

@@ -20,7 +20,7 @@
 use core::marker::PhantomData;
 
 use super::sdt::Sdt;
-use crate::mem::paging::VirtAddr;
+use crate::mem::paging::{PhysAddr, VirtAddr};
 
 pub(super) fn validate_rsdt_checksum<T: RsdtHeader>(header: &'static T) -> bool {
     if header.signature() == b"RSD PTR " {
@@ -124,9 +124,10 @@ impl Rsdt<u32> {
         let header_data_address = self.header.data_address() as *const u32;
 
         for i in 0..self.entries_count() {
-            let item_addr_phys = unsafe { *(header_data_address.add(i)) } as u64;
-            let item_addr_virt = unsafe { crate::PHYSICAL_MEMORY_OFFSET + item_addr_phys };
-
+            let item_addr_virt = unsafe {
+                let ptr = header_data_address.add(i);
+                PhysAddr::new(*ptr as u64).as_hhdm_virt()
+            };
             let item = unsafe { Sdt::from_address(item_addr_virt) };
 
             if item.signature == signature.as_bytes() {
@@ -159,8 +160,10 @@ impl Rsdt<u64> {
         let header_data_address = self.header.data_address() as *const u64;
 
         for i in 0..self.entries_count() {
-            let item_addr_phys = unsafe { *(header_data_address.add(i)) };
-            let item_addr_virt = unsafe { crate::PHYSICAL_MEMORY_OFFSET + item_addr_phys };
+            let item_addr_virt = unsafe {
+                let ptr = header_data_address.add(i);
+                PhysAddr::new(*ptr).as_hhdm_virt()
+            };
 
             let item = unsafe { Sdt::from_address(item_addr_virt) };
 
@@ -187,15 +190,15 @@ pub(super) fn find_rsdt_address(rsdp_address: VirtAddr) -> RsdtAddress {
         let valid = validate_rsdt_checksum(v20);
         assert!(valid, "rsdp: failed to validate RSDP v20 checksum");
 
-        let xsdt_address = unsafe { crate::PHYSICAL_MEMORY_OFFSET + v20.xsdt_address };
+        let xsdt_address = PhysAddr::new(v20.xsdt_address).as_hhdm_virt();
         return RsdtAddress::Xsdt(xsdt_address);
     } else {
         let v10 = unsafe { &*(rsdp_address.as_ptr() as *const Rsdp10) };
         let valid = validate_rsdt_checksum(v10);
 
         assert!(valid, "rsdp: failed to validate RSDP v10 checksum");
 
-        let rsdt_address = unsafe { crate::PHYSICAL_MEMORY_OFFSET + v10.rsdt_address as u64 };
+        let rsdt_address = PhysAddr::new(v10.rsdt_address as u64).as_hhdm_virt();
         return RsdtAddress::Rsdt(rsdt_address);
     }
 }

src/aero_kernel/src/apic.rs

@@ -438,7 +438,7 @@ pub fn mark_bsp_ready(value: bool) {
 /// Read from the `io_apic_id` I/O APIC as described by the MADT.
 pub unsafe fn io_apic_read(io_apic_id: usize, register: u32) -> u32 {
     let io_apic = madt::IO_APICS.read()[io_apic_id];
-    let addr = crate::PHYSICAL_MEMORY_OFFSET + io_apic.io_apic_address as usize;
+    let addr = PhysAddr::new(io_apic.io_apic_address as u64).as_hhdm_virt();
     let ptr: *mut u32 = addr.as_mut_ptr();
 
     ptr::write_volatile(ptr, register);
@@ -448,7 +448,7 @@ pub unsafe fn io_apic_read(io_apic_id: usize, register: u32) -> u32 {
 /// Write from the `io_apic_id` I/O APIC as described by the MADT.
 pub unsafe fn io_apic_write(io_apic_id: usize, register: u32, data: u32) {
     let io_apic = madt::IO_APICS.read()[io_apic_id];
-    let addr = crate::PHYSICAL_MEMORY_OFFSET + io_apic.io_apic_address as usize;
+    let addr = PhysAddr::new(io_apic.io_apic_address as u64).as_hhdm_virt();
     let ptr: *mut u32 = addr.as_mut_ptr();
 
     ptr::write_volatile(ptr, register);

src/aero_kernel/src/arch/x86_64/mod.rs

@@ -128,17 +128,15 @@ extern "C" fn x86_64_aero_main(boot_info: &'static StivaleStruct) -> ! {
     }
 
     crate::UNWIND_INFO.call_once(move || unsafe {
-        let addr = (kernel_info as *const StivaleKernelFileV2Tag) as u64;
-        let new_addr = crate::PHYSICAL_MEMORY_OFFSET + addr;
-
-        &*new_addr.as_mut_ptr::<StivaleKernelFileV2Tag>()
+        &*(PhysAddr::new((kernel_info as *const StivaleKernelFileV2Tag) as u64)
+            .as_hhdm_virt()
+            .as_mut_ptr::<StivaleKernelFileV2Tag>())
     });
 
     crate::time::EPOCH_TAG.call_once(move || unsafe {
-        let addr = (epoch as *const StivaleEpochTag) as u64;
-        let new_addr = crate::PHYSICAL_MEMORY_OFFSET + addr;
-
-        &*new_addr.as_mut_ptr::<StivaleEpochTag>()
+        &*(PhysAddr::new((epoch as *const StivaleEpochTag) as u64)
+            .as_hhdm_virt()
+            .as_mut_ptr::<StivaleEpochTag>())
     });
 
     crate::INITRD_MODULE.call_once(move || {
@@ -160,7 +158,7 @@ extern "C" fn x86_64_aero_main(boot_info: &'static StivaleStruct) -> ! {
 
     // Parse the kernel command line.
     let command_line: &'static _ = boot_info.command_line().map_or("", |cmd| unsafe {
-        let cmdline = crate::PHYSICAL_MEMORY_OFFSET + cmd.command_line;
+        let cmdline = PhysAddr::new(cmd.command_line).as_hhdm_virt();
 
         // SAFETY: The bootloader has provided a pointer that points to a valid C
         // string with a NULL terminator of size less than `usize::MAX`, whose content

src/aero_kernel/src/arch/x86_64/task.rs

@@ -195,10 +195,12 @@ impl ArchTask {
 
         let switch_stack = unsafe {
             let frame: PhysFrame = FRAME_ALLOCATOR.allocate_frame().unwrap();
-            let phys = frame.start_address();
-            let virt = crate::PHYSICAL_MEMORY_OFFSET + phys.as_u64();
 
-            virt.as_mut_ptr::<u8>().add(Size4KiB::SIZE as usize)
+            frame
+                .start_address()
+                .as_hhdm_virt()
+                .as_mut_ptr::<u8>()
+                .add(Size4KiB::SIZE as usize)
         };
 
         let mut old_stack_ptr = self.context_switch_rsp.as_u64();

src/aero_kernel/src/drivers/block/ahci.rs

@@ -261,8 +261,7 @@ impl DmaRequest {
         for buffer in self.buffer.iter() {
             let count = core::cmp::min(remaning, 0x2000);
 
-            let buffer_address = unsafe { crate::PHYSICAL_MEMORY_OFFSET + buffer.start.as_u64() };
-            let buffer_pointer = buffer_address.as_ptr();
+            let buffer_pointer = buffer.start.as_hhdm_virt().as_ptr();
             let buffer = unsafe { core::slice::from_raw_parts::<u8>(buffer_pointer, count) };
 
             // Copy the data from the buffer into the given buffer with the
@@ -552,7 +551,7 @@ impl HbaPort {
     fn cmd_header_at(&mut self, index: usize) -> &mut HbaCmdHeader {
         // Since the CLB holds the physical address, we make the address mapped
         // before reading it.
-        let clb_mapped = unsafe { crate::PHYSICAL_MEMORY_OFFSET + self.clb.get().as_u64() };
+        let clb_mapped = self.clb.get().as_hhdm_virt();
         // Get the address of the command header at `index`.
         let clb_addr = clb_mapped + core::mem::size_of::<HbaCmdHeader>() * index;
 

src/aero_kernel/src/drivers/block/ide/channel.rs

@@ -34,8 +34,7 @@ struct PrdTable<'a> {
 
 impl<'a> PrdTable<'a> {
     pub fn new(addr: PhysAddr, entries: usize) -> PrdTable<'a> {
-        let mapped_addr = unsafe { crate::PHYSICAL_MEMORY_OFFSET + addr.as_u64() };
-        let ptr = mapped_addr.as_mut_ptr::<PrdEntry>();
+        let ptr = addr.as_hhdm_virt().as_mut_ptr::<PrdEntry>();
         let entries = unsafe { core::slice::from_raw_parts_mut(ptr, entries) };
 
         PrdTable::<'a> { data: entries }

src/aero_kernel/src/fs/initramfs.rs

@@ -20,6 +20,7 @@
 use alloc::sync::Arc;
 
 use crate::fs::{FileSystemError, Path};
+use crate::mem::paging::PhysAddr;
 
 use super::cache::DirCacheItem;
 use super::ramfs::RamFs;
@@ -49,7 +50,7 @@ pub(super) fn init() -> Result<()> {
 
     let initrd_module = crate::INITRD_MODULE.get().unwrap();
     let initrd = unsafe {
-        let base = crate::PHYSICAL_MEMORY_OFFSET + initrd_module.start;
+        let base = PhysAddr::new(initrd_module.start).as_hhdm_virt();
         let length = initrd_module.end - initrd_module.start;
 
         core::slice::from_raw_parts(base.as_ptr(), length as usize)

src/aero_kernel/src/mem/alloc.rs

@@ -59,8 +59,7 @@ impl Slab {
                 .allocate_frame()
                 .expect("slab_init: failed to allocate frame");
 
-            self.first_free = frame.start_address().as_u64() as usize;
-            self.first_free += crate::PHYSICAL_MEMORY_OFFSET.as_u64() as usize;
+            self.first_free = frame.start_address().as_hhdm_virt().as_u64() as usize;
         }
 
         let hdr_size = core::mem::size_of::<SlabHeader>() as u64;

src/aero_kernel/src/mem/mod.rs

@@ -28,7 +28,6 @@ use ::alloc::boxed::Box;
 use crate::mem::paging::*;
 
 use self::paging::{active_level_4_table, FRAME_ALLOCATOR};
-use crate::PHYSICAL_MEMORY_OFFSET;
 
 /// Structure representing a *virtual* address space. The address space
 /// contains a reference of the page table allocated for this address space.
@@ -45,9 +44,9 @@ impl AddressSpace {
                 .ok_or(MapToError::FrameAllocationFailed)?;
 
             let phys_addr = frame.start_address();
-            phys_addr.as_vm_frame().unwrap().inc_ref_count();
+            let virt_addr = phys_addr.as_hhdm_virt();
 
-            let virt_addr = PHYSICAL_MEMORY_OFFSET + phys_addr.as_u64();
+            phys_addr.as_vm_frame().unwrap().inc_ref_count();
 
             let page_table: *mut PageTable = virt_addr.as_mut_ptr();
             let page_table = &mut *page_table;
@@ -107,19 +106,13 @@ impl AddressSpace {
     /// Returns a mutable reference to the page table allocated for this
     /// address space.
     pub fn page_table(&mut self) -> &'static mut PageTable {
-        unsafe {
-            let phys_addr = self.cr3.start_address();
-            let virt_addr = PHYSICAL_MEMORY_OFFSET + phys_addr.as_u64();
-            let page_table_ptr: *mut PageTable = virt_addr.as_mut_ptr();
-
-            &mut *page_table_ptr
-        }
+        unsafe { &mut *(self.cr3.start_address().as_hhdm_virt().as_mut_ptr()) }
     }
 
     /// Returns a mutable refernce to the mapper pointing to the page table
     /// allocated for this address space.
     pub fn offset_page_table(&mut self) -> OffsetPageTable {
-        unsafe { OffsetPageTable::new(self.page_table(), PHYSICAL_MEMORY_OFFSET) }
+        unsafe { OffsetPageTable::new(self.page_table(), crate::PHYSICAL_MEMORY_OFFSET) }
     }
 }