chore: add v2p and p2v conversion wrt. id mapping

Also renamed a few symbols to avoid confusion.

Author: shrik3

boot/startup-x86_64.s

@@ -31,8 +31,8 @@ MAX_MEM: equ 512
 [GLOBAL mb_info_addr]
 ; functions from other parts of rustubs
 ; NOTE: this are all from 64bit code, so do not use them in 32bit assembly
-[EXTERN ___BSS_PM_START__]
-[EXTERN ___BSS_PM_END__]
+[EXTERN ___BSS_START__]
+[EXTERN ___BSS_END__]
 [EXTERN KERNEL_OFFSET]
 [EXTERN _entry]
 ; =============================================================================
@@ -170,8 +170,8 @@ fill_kvma2:
 	jne    fill_kvma2
 	; done :-)
 	; clear BSS section for the rust code.
-	mov    rdi, ___BSS_PM_START__
-	mov    rax, ___BSS_PM_END__
+	mov    rdi, ___BSS_START__
+	mov    rax, ___BSS_END__
 clear_bss:
 	; clear the BSS section before going to rust code
 	; TODO speed this up by clearing 8 bytes at once. Alignment should be taken

defs/x86_64-hm-linker.ld

@@ -93,10 +93,10 @@ SECTIONS
 
 	.bss : AT(ADDR(.bss) - KERNEL_OFFSET)
 	{
-		PROVIDE (___BSS_PM_START__ = .);
+		PROVIDE (___BSS_START__ = .);
 		*(".bss")
 		*(".bss.*")
-		PROVIDE (___BSS_PM_END__ = .);
+		PROVIDE (___BSS_END__ = .);
 	}
 
 	.rodata : AT(ADDR(.rodata) - KERNEL_OFFSET)

defs/x86_64-linker.ld

@@ -71,10 +71,10 @@ SECTIONS
 
 	.bss :
 	{
-		PROVIDE (___BSS_PM_START__ = .);
+		PROVIDE (___BSS_START__ = .);
 		*(".bss")
 		*(".bss.*")
-		PROVIDE (___BSS_PM_END__ = .);
+		PROVIDE (___BSS_END__ = .);
 	}
 
 	/* global page table for 64-bit long mode */

src/arch/x86_64/interrupt/mod.rs

@@ -3,7 +3,7 @@ pub mod pit;
 use crate::io::*;
 use core::arch::asm;
 use core::slice;
-
+// TODO use P2V for extern symbol addresses
 // number of entries in IDT
 pub const IDT_CAPACITY: usize = 256;
 // size of interrupt handler wrapper routine (vector)

src/defs.rs

@@ -3,29 +3,46 @@
 extern "C" {
 	fn ___KERNEL_PM_START__();
 	fn ___KERNEL_PM_END__();
-	fn ___BSS_PM_START__();
-	fn ___BSS_PM_END__();
+	fn ___BSS_START__();
+	fn ___BSS_END__();
 }
 
+#[inline]
 pub fn pmap_kernel_start() -> u64 {
-	return ___KERNEL_PM_START__ as u64;
+	___KERNEL_PM_START__ as u64
 }
 
+#[inline]
 pub fn pmap_kernel_end() -> u64 {
-	return ___KERNEL_PM_END__ as u64;
+	___KERNEL_PM_END__ as u64
 }
-pub fn pmap_bss_start() -> u64 {
-	return ___BSS_PM_START__ as u64;
+
+#[inline]
+pub fn vmap_kernel_start() -> u64 {
+	pmap_kernel_start() + Mem::KERNEL_OFFSET
+}
+
+#[inline]
+pub fn vmap_kernel_end() -> u64 {
+	pmap_kernel_end() + Mem::KERNEL_OFFSET
+}
+
+#[inline]
+pub fn bss_start() -> u64 {
+	return ___BSS_START__ as u64;
 }
 
-pub fn pmap_bss_end() -> u64 {
-	return ___BSS_PM_END__ as u64;
+#[inline]
+pub fn bss_end() -> u64 {
+	return ___BSS_END__ as u64;
 }
 
+#[inline]
 pub fn roundup_4k(addr: u64) -> u64 {
 	return (addr + 0xfff) & !0xfff;
 }
 
+#[inline]
 pub fn rounddown_4k(addr: u64) -> u64 {
 	return addr & !0xfff;
 }
@@ -55,11 +72,30 @@ impl Mem {
 	// memory (37268) 4k pages, 37268 bits are needed, hence
 	// 4096 bytes, exactly one page!
 	pub const PHY_BM_SIZE: u64 = Mem::PHY_PAGES >> 3;
+	pub const ID_MAP_START: u64 = 0xffff_8000_0000_0000;
+	pub const ID_MAP_END: u64 = 0xffff_8010_0000_0000;
+	pub const KERNEL_OFFSET: u64 = 0xffff_8020_0000_0000;
+	// 64 GiB available memory
+	pub const MAX_PHY_MEM: u64 = 0x1000000000;
+}
+
+// convert VA <-> PA wrt. the kernel id mapping
+// from 0xffff_8000_0000_0000 ~ 0xffff_800f_ffff_ffff virtual
+// to 0x0 ~ 0xf_ffff_ffff physical (64G)
+#[allow(non_snake_case)]
+#[inline]
+pub fn V2P(va: u64) -> Option<u64> {
+	if va >= Mem::ID_MAP_END || va < Mem::ID_MAP_START {
+		return None;
+	}
+	return Some(va - Mem::ID_MAP_START);
 }
 
-// PHY_TOP			128M
-// ~				free frames
-// PMA::bitmap		+ PHY_BM_SIZE
-// ~				___KERNEL_END__
-// KERNEL IMAGE
-// KERNEL START		1 M
+#[allow(non_snake_case)]
+#[inline]
+pub fn P2V(pa: u64) -> Option<u64> {
+	if pa >= Mem::MAX_PHY_MEM {
+		return None;
+	}
+	return Some(pa + Mem::ID_MAP_START);
+}

src/lib.rs

@@ -14,6 +14,7 @@ use arch::x86_64::interrupt;
 use arch::x86_64::interrupt::pic_8259;
 use arch::x86_64::interrupt::pic_8259::PicDeviceInt;
 use core::panic::PanicInfo;
+use defs::*;
 use machine::cgascr::CGAScreen;
 use machine::multiboot;
 
@@ -33,7 +34,7 @@ pub extern "C" fn _entry() -> ! {
 	let mbi = multiboot::get_mb_info().expect("bad multiboot info flags");
 	let mem = unsafe { mbi.get_mem() }.unwrap();
 	println!(
-		"available memory: lower {:#X} KiB, upper:{:#X} KiB",
+		"[init] available memory: lower {:#X} KiB, upper:{:#X} KiB",
 		mem.lower(),
 		mem.upper()
 	);
@@ -43,14 +44,14 @@ pub extern "C" fn _entry() -> ! {
 	interrupt::interrupt_enable();
 
 	println!(
-		"kernel: {:#X} - {:#X}",
-		defs::pmap_kernel_start(),
-		defs::pmap_kernel_end()
+		"[init] kernel mapped @ {:#X} - {:#X}",
+		vmap_kernel_start(),
+		vmap_kernel_end(),
 	);
 	println!(
-		"   BSS: {:#X} - {:#X}",
-		defs::pmap_bss_start(),
-		defs::pmap_bss_end()
+		"[init] BSS mapped    @ {:#X} - {:#X}",
+		bss_start(),
+		bss_end()
 	);
 
 	// io::print_welcome();

src/mm/mod.rs

@@ -41,12 +41,12 @@ pub fn init() {
 	}
 
 	println!(
-		"pma init: kernel mapped at {:#X} - {:#X}",
+		"[init] pma: kernel loaded at phy: {:#X} - {:#X}",
 		pmap_kernel_start(),
 		pmap_kernel_end()
 	);
 	println!(
-		"pma init: {:#X}KiB free memory, {:#X} pages",
+		"[init] pma: {:#X} KiB free memory, {:#X} frames inserted",
 		inserted * 0x4,
 		inserted,
 	);