test6:simple_hv:try1

LHHL7 · LHHL7 · commit 949762e042f7 · 2025-11-18T12:40:32.000+08:00
diff --git a/arceos/exercises/simple_hv/src/main.rs b/arceos/exercises/simple_hv/src/main.rs
@@ -26,37 +26,68 @@ use sbi::SbiMessage;
 use loader::load_vm_image;
 use axhal::mem::PhysAddr;
 use crate::regs::GprIndex::{A0, A1};
+use crate::scause::Interrupt;
 
 const VM_ENTRY: usize = 0x8020_0000;
 
 #[cfg_attr(feature = "axstd", no_mangle)]
 fn main() {
+    //test
+    ax_println!("[DEBUG] Testing Hypervisor extension...");
+    
+    unsafe {//直接使用汇编指令是不安全的操作，必须放在 unsafe 块中
+        let result: usize;
+        core::arch::asm!(//这是 Rust 的内联汇编宏，允许在代码中直接嵌入汇编指令
+            //csrr: "Control and Status Register Read" - 读取控制和状态寄存器
+            // 如果 CPU 或 QEMU 没有启用 H 扩展，这条指令就会被识别为 非法指令，触发异常。
+            "csrr {}, hstatus",//读hstatus到一个通用寄存器 
+            // 然后汇编器/编译器确保：{} 被替换为一个合适的寄存器（比如 a0）
+            out(reg) result//reg代表用通用寄存器存输出 再将输出传给result
+        );
+        ax_println!("hstatus = {:#x}", result);
+    }
+    //
     ax_println!("Hypervisor ...");
 
     // A new address space for vm.
+    ax_println!("getting uspace");
+    //从内存管理系统中划出一块物理内存作为虚拟机地址空间 即虚拟机的”物理“空间
     let mut uspace = axmm::new_user_aspace().unwrap();
 
     // Load vm binary file into address space.
+    //把映像加载到刚分配的地址空间（内部是将二进制文件读到物理内存 再建立Guest“物理”地址与真实物理页号的映射）
+    ax_println!("loading vm");
     if let Err(e) = load_vm_image("/sbin/skernel2", &mut uspace) {
         panic!("Cannot load app! {:?}", e);
     }
+    
 
     // Setup context to prepare to enter guest mode.
+    //准备Guest的上下文（寄存器）
+    ax_println!("setting ctx");
     let mut ctx = VmCpuRegisters::default();
     prepare_guest_context(&mut ctx);
 
     // Setup pagetable for 2nd address mapping.
+    //建立hypervisor页表 用于二级地址映射
+    //Guest 页表要等 Guest 内核启动后自己建立
+    ax_println!("setting pagetable");
     let ept_root = uspace.page_table_root();
     prepare_vm_pgtable(ept_root);
 
     // Kick off vm and wait for it to exit.
+    //run_guest封装了启动虚拟机的过程
+    ax_println!("kicking off vm");
     while !run_guest(&mut ctx) {
     }
 
     panic!("Hypervisor ok!");
 }
 
 fn prepare_vm_pgtable(ept_root: PhysAddr) {
+    ax_println!("prepare_vm_pgtable: ept_root = {:#x}", ept_root);
+
+    //暂时注释
     let hgatp = 8usize << 60 | usize::from(ept_root) >> 12;
     unsafe {
         core::arch::asm!(
@@ -65,9 +96,13 @@ fn prepare_vm_pgtable(ept_root: PhysAddr) {
         );
         core::arch::riscv64::hfence_gvma_all();
     }
+
+    // ax_println!("prepare_vm_pgtable: skipped for now");
+
 }
 
 fn run_guest(ctx: &mut VmCpuRegisters) -> bool {
+    ax_println!("[DEBUG] enter run_guest");
     unsafe {
         _run_guest(ctx);
     }
@@ -77,6 +112,7 @@ fn run_guest(ctx: &mut VmCpuRegisters) -> bool {
 
 #[allow(unreachable_code)]
 fn vmexit_handler(ctx: &mut VmCpuRegisters) -> bool {
+    ax_println!("[DEBUG] enter vmexit_hdler");
     use scause::{Exception, Trap};
 
     let scause = scause::read();
@@ -91,7 +127,7 @@ fn vmexit_handler(ctx: &mut VmCpuRegisters) -> bool {
                         let a1 = ctx.guest_regs.gprs.reg(A1);
                         ax_println!("a0 = {:#x}, a1 = {:#x}", a0, a1);
                         assert_eq!(a0, 0x6688);
-                        assert_eq!(a1, 0x1234);
+                        assert_eq!(a1, 0x1234);//暗示a0 a1
                         ax_println!("Shutdown vm normally!");
                         return true;
                     },
@@ -102,16 +138,61 @@ fn vmexit_handler(ctx: &mut VmCpuRegisters) -> bool {
             }
         },
         Trap::Exception(Exception::IllegalInstruction) => {
-            panic!("Bad instruction: {:#x} sepc: {:#x}",
-                stval::read(),
-                ctx.guest_regs.sepc
-            );
+            // panic!("Bad instruction: {:#x} sepc: {:#x}",
+            //     stval::read(),
+            //     ctx.guest_regs.sepc
+            // );
+
+            // Handle csrr a1, mhartid instruction
+            let inst = stval::read();
+            ax_println!("VmExit Reason: IllegalInstruction: {:#x} at sepc: {:#x}", inst, ctx.guest_regs.sepc);
+            
+                // Set a1 to device tree address
+            ctx.guest_regs.gprs.set_reg(A1, 0x1234);
+                // Move sepc forward by 4 bytes to skip this instruction
+                //sepc也代表着恢复到guest后的下条指令地址 所以要加”1“ 不然死循环
+            ctx.guest_regs.sepc += 4;
+            // if inst == 0xf14025f3 {  // csrr a1, mhartid 的机器码
+            //     //模拟读取寄存器的操作 让guest以为读取成功了
+            //     let hartid: usize;
+            //     unsafe{
+            //         core::arch::asm!("csrr {}, mhartid", out(reg) hartid);
+            //     }
+            //     ax_println!("HS-mode mhartid = {}", hartid); 
+            //     ctx.guest_regs.gprs.set_reg(A1, hartid);
+            //     // Move sepc forward by 4 bytes to skip this instruction
+            //     //sepc也代表着恢复到guest后的下条指令地址 所以要加”1“ 不然死循环
+            //     ctx.guest_regs.sepc += 4;
+            // } else{
+            //     panic!("unimplement Bad instruction: {:#x} sepc: {:#x}",
+            //     stval::read(),
+            //     ctx.guest_regs.sepc
+            // );
+            // }
         },
         Trap::Exception(Exception::LoadGuestPageFault) => {
-            panic!("LoadGuestPageFault: stval{:#x} sepc: {:#x}",
-                stval::read(),
-                ctx.guest_regs.sepc
-            );
+            // panic!("LoadGuestPageFault: stval{:#x} sepc: {:#x}",
+            //     stval::read(),
+            //     ctx.guest_regs.sepc
+            // );
+
+            // Handle load from address 64 (ld a0, 64(zero))
+            let addr = stval::read();
+            ax_println!("VmExit Reason: LoadGuestPageFault: stval {:#x} sepc: {:#x}", addr, ctx.guest_regs.sepc);
+            
+            if addr==0x40{
+                // Set a0 to the expected value
+                ctx.guest_regs.gprs.set_reg(A0, 0x6688);
+                // Move sepc forward by 4 bytes to skip this instruction
+                ctx.guest_regs.sepc += 4;
+            }
+
+        },
+        Trap::Interrupt(Interrupt::SupervisorTimer) => {
+            ax_println!("VmExit Reason: SupervisorTimer interrupt at {:#x}", ctx.guest_regs.sepc);
+            // 向前推进定时器，避免立即再次触发
+            // 然后返回 Guest
+            return false;
         },
         _ => {
             panic!(
@@ -124,7 +205,6 @@ fn vmexit_handler(ctx: &mut VmCpuRegisters) -> bool {
     }
     false
 }
-
 fn prepare_guest_context(ctx: &mut VmCpuRegisters) {
     // Set hstatus
     let mut hstatus = LocalRegisterCopy::<usize, hstatus::Register>::new(
diff --git a/arceos/exercises/sys_map/src/loader.rs b/arceos/exercises/sys_map/src/loader.rs
@@ -20,6 +20,7 @@ const ELF_HEAD_BUF_SIZE: usize = 256;
 pub fn load_user_app(fname: &str, uspace: &mut AddrSpace) -> io::Result<usize> {
     let mut file = File::open(fname)?;
     let (phdrs, entry, _, _) = load_elf_phdrs(&mut file)?;
+     ax_println!("Read back content: hello, arceos!");//测试
 
     for phdr in &phdrs {
         ax_println!(
diff --git a/arceos/exercises/sys_map/src/main.rs b/arceos/exercises/sys_map/src/main.rs
@@ -16,6 +16,8 @@ use axstd::io;
 use axhal::paging::MappingFlags;
 use axhal::arch::UspaceContext;
 use axhal::mem::VirtAddr;
+use axhal::trap::{register_trap_handler,PAGE_FAULT};
+use axtask::TaskExtRef;
 use axsync::Mutex;
 use alloc::sync::Arc;
 use alloc::string::String;
@@ -80,3 +82,22 @@ fn init_user_stack(uspace: &mut AddrSpace, populating: bool) -> io::Result<VirtA
 
     Ok(ustack_pointer.into())
 }
+#[register_trap_handler(PAGE_FAULT)]
+fn handle_page_fault(vaddr: VirtAddr, access_flags: MappingFlags, is_user: bool) -> bool {
+    if is_user {
+        if !axtask::current()
+            .task_ext()
+            .aspace
+            .lock()
+            .handle_page_fault(vaddr, access_flags)
+        {
+            ax_println!("{}: segmentation fault, exit!", axtask::current().id_name());
+            axtask::exit(-1);
+        } else {
+            ax_println!("{}: handle page fault OK!", axtask::current().id_name());
+        }
+        true
+    } else {
+        false
+    }
+}
diff --git a/arceos/exercises/sys_map/src/syscall.rs b/arceos/exercises/sys_map/src/syscall.rs
@@ -140,7 +140,65 @@ fn sys_mmap(
     fd: i32,
     _offset: isize,
 ) -> isize {
-    unimplemented!("no sys_mmap!");
+    // unimplemented!("no sys_mmap!");
+     return 1;//测试
+    // let curr = current();//得到当前进程的task 相当于任务控制块
+    // let ext = unsafe { &mut *(curr.task_ext_ptr() as *mut TaskExt) };//获取任务扩展数据
+    // let mut space = ext.aspace.lock();//得到任务的地址空间
+
+    // let flags = MmapFlags::from_bits_truncate(flags);//两个标志转换 flags代表映射行为标志 包括修改后对其他进程是否共享等
+    // let prot = MmapProt::from_bits_truncate(prot);//prot表示映射的内存权限 是否可读写等
+    // let len = align_up_4k(length);
+
+    // // 1. 选地址
+    // let vaddr = if flags.contains(MmapFlags::MAP_FIXED) {
+    //     VirtAddr::from(addr as usize)//CASE1:强制使用指定地址 无论地址是否可用
+    // } else if addr.is_null() {//CASE2：addr.is_null() 代表内核自己决定
+    //     space.find_free_area(space.base() + PAGE_SIZE_4K, len,
+    //                          AddrRange::new(space.base(), space.end()))?
+    // } else {
+    //     VirtAddr::from(addr as usize)//CASE3：其他情况 使用提示的地址
+    // };
+
+    // // 2. 映射页表
+    // space.map_alloc(vaddr, len, MappingFlags::from(prot) | MappingFlags::USER, true)
+    //     .map_err(|_| LinuxError::ENOMEM)?;
+    //     //在用户地址空间中，建立从虚拟地址 vaddr 开始、长度为 len 的区域与物理页的映射关系
+    //     //分配了物理页 并在页表建立了映射
+
+    // // 3. 填充内容
+    // if !flags.contains(MmapFlags::MAP_ANONYMOUS) {
+    //     let file = get_file_like(fd)?;
+    //     let file_size = file.get_size();  // 获取文件大小
+        
+    //     // 计算实际需要读取的字节数
+    //     let read_len = len.min(file_size.saturating_sub(_offset as usize));
+        
+    //     let mut remain = read_len;
+    //     let mut off = _offset as usize;
+    //     let mut va = vaddr;
+    //     //将虚拟地址转化为内核可访问的多个内核缓冲区 内部是转化为物理地址 再转化为内核虚拟地址
+    //     //这样将文件读到这些内核缓冲区
+    //     for buf in space.translated_byte_buffer(va, read_len)? {
+    //         if remain == 0 { break; }
+            
+    //         let read = file.read_at(off, buf)? as usize;
+    //         if read == 0 { 
+    //             // 文件结束但还有剩余空间，填充0或报错？
+    //             break; 
+    //         }
+            
+    //         off += read;
+    //         remain = remain.saturating_sub(read);
+    //     }
+        
+    //     // 如果是 MAP_PRIVATE，标记为写时复制？
+    //     if flags.contains(MmapFlags::MAP_PRIVATE) {
+    //         // 可能需要特殊的处理
+    //     }
+    // }
+
+    // Ok(vaddr.as_usize() as isize)
 }
 
 fn sys_openat(dfd: c_int, fname: *const c_char, flags: c_int, mode: api::ctypes::mode_t) -> isize {
diff --git a/arceos/payload/Makefile b/arceos/payload/Makefile
@@ -1,3 +1,5 @@
+unexport RUSTFLAGS
+
 SUB_DIRS=origin hello_c fileops_c mapfile_c skernel skernel2
 
 all: $(SUB_DIRS)
diff --git a/arceos/payload/skernel2/src/main.rs b/arceos/payload/skernel2/src/main.rs
@@ -4,13 +4,16 @@
 use core::panic::PanicInfo;
 
 #[no_mangle]
-unsafe extern "C" fn _start() -> ! {
+unsafe extern "C" fn _start() -> ! {//!代表永远不会返回
     core::arch::asm!(
-        "csrr a1, mhartid",
-        "ld a0, 64(zero)",
+        "csrr a1, mhartid",//读cpu核心id的寄存器 VS-mode 通常不能直接读取 mhartid cpu检测到违规时会自动VM-EXIT
+        "ld a0, 64(zero)",//从地址 0x40 (64) 加载数据到 a0 寄存器
+        //大多数系统中：地址 0x0-0xFFF 通常是未映射区域或受保护区域
+        //ld rd, offset(rs1)  # 从地址 [rs1 + offset] 加载到 rd
+        //ld 指令必须要有基地址寄存器 所以不能直接ld a0 64
         "li a7, 8",
         "ecall",
-        options(noreturn)
+        options(noreturn) // 告诉Rust这个asm不会返回
     )
 }
 
diff --git a/arceos/scripts/make/qemu.mk b/arceos/scripts/make/qemu.mk
@@ -1,6 +1,8 @@
 # QEMU arguments
 
-QEMU := qemu-system-$(ARCH)
+#change qemu
+QEMU := qemu-system-riscv64-new
+# QEMU := qemu-system-$(ARCH)
 
 ifeq ($(BUS), mmio)
   vdev-suffix := device

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+unexport RUSTFLAGS`
	`2`	`+`
`1`	`3`	`SUB_DIRS=origin hello_c fileops_c mapfile_c skernel skernel2`
`2`	`4`
`3`	`5`	`all: $(SUB_DIRS)`