fix some errors with more errors generated

kernel/src/syscall/invocation/decode/arch/aarch64.rs

@@ -33,13 +33,11 @@ use sel4_cspace::interface::{cap_t, cte_insert, cte_t, CapTag};
 
 use sel4_vspace::{
     asid_map_t, asid_pool_t, asid_t, clean_by_va_pou, doFlush, find_vspace_for_asid,
-    get_asid_pool_by_index, makeUser3rdLevel, make_user_1st_level, make_user_2nd_level,
-    pptr_to_paddr, set_asid_pool_by_index, vm_attributes_t, vptr_t, PDE, PGDE, PTE, PUDE,
+    get_asid_pool_by_index, pptr_to_paddr, set_asid_pool_by_index, vm_attributes_t, vptr_t, PTE,
 };
 
 use crate::syscall::invocation::invoke_mmu_op::{
-    invoke_huge_page_map, invoke_large_page_map, invoke_page_get_address, invoke_page_table_unmap,
-    invoke_page_unmap, invoke_small_page_map,
+    invoke_page_get_address, invoke_page_map, invoke_page_table_unmap, invoke_page_unmap,
 };
 use crate::{
     config::maxIRQ,
@@ -118,8 +116,8 @@ fn decode_page_table_invocation(
         return exception_t::EXCEPTION_SYSCALL_ERROR;
     }
 
-    let vspace_root = vspace_root_cap.get_pgd_base_ptr();
-    let asid = vspace_root_cap.get_pgd_mapped_asid();
+    let vspace_root = vspace_root_cap.get_vs_base_ptr();
+    let asid = vspace_root_cap.get_vs_mapped_asid();
 
     if unlikely(vaddr > USER_TOP) {
         global_ops!(current_syscall_error._type = seL4_InvalidArgument);
@@ -374,7 +372,7 @@ fn decode_asid_pool(label: MessageLabel, cte: &mut cte_t) -> exception_t {
     let vspace_cap_slot = global_ops!(current_extra_caps.excaprefs[0]);
     let vspace_cap = convert_to_mut_type_ref::<cap_t>(vspace_cap_slot);
 
-    if unlikely(!vspace_cap.is_vtable_root() || vspace_cap.get_pgd_is_mapped() == 1) {
+    if unlikely(!vspace_cap.is_vtable_root() || vspace_cap.get_vs_is_mapped() == 1) {
         log::debug!("is not a valid vtable root");
         global_ops!(current_syscall_error._type = seL4_InvalidCapability);
         global_ops!(current_syscall_error.invalidArgumentNumber = 1);
@@ -418,7 +416,7 @@ fn decode_asid_pool(label: MessageLabel, cte: &mut cte_t) -> exception_t {
 
     get_currenct_thread().set_state(ThreadState::ThreadStateRestart);
     vspace_cap.set_pgd_mapped_asid(asid);
-    vspace_cap.set_pgd_is_mapped(1);
+    vspace_cap.set_vs_is_mapped(1);
     let asid_map = asid_map_t::new_vspace(vspace_cap.get_pgd_base_ptr());
     pool[asid & MASK!(asidLowBits)] = asid_map;
     exception_t::EXCEPTION_NONE
@@ -444,8 +442,8 @@ fn decode_frame_map(length: usize, frame_slot: &mut cte_t, buffer: &seL4_IPCBuff
         global_ops!(current_syscall_error.invalidCapNumber = 1);
         return exception_t::EXCEPTION_SYSCALL_ERROR;
     }
-    let vspace_root = vspace_root_cap.get_pgd_base_ptr();
-    let asid = vspace_root_cap.get_pgd_mapped_asid();
+    let vspace_root = vspace_root_cap.get_vs_base_ptr();
+    let asid = vspace_root_cap.get_vs_mapped_asid();
     let find_ret = find_vspace_for_asid(asid);
     if unlikely(find_ret.status != exception_t::EXCEPTION_NONE) {
         global_ops!(current_syscall_error._type = seL4_FailedLookup);
@@ -498,9 +496,10 @@ fn decode_frame_map(length: usize, frame_slot: &mut cte_t, buffer: &seL4_IPCBuff
             return exception_t::EXCEPTION_SYSCALL_ERROR;
         }
         set_thread_state(get_currenct_thread(), ThreadState::ThreadStateRestart);
-        // TODO: unimplement
+        // TODO:unimplement
         return invoke_page_map();
     }
+    exception_t::EXCEPTION_SYSCALL_ERROR
     // match frame_size {
     //     ARM_Small_Page => {
     //         let lu_ret = vspace_root.lookup_pt_slot(vaddr);

kernel/src/syscall/invocation/invoke_mmu_op.rs

@@ -138,14 +138,14 @@ pub fn invoke_page_map(
     exception_t::EXCEPTION_NONE
 }
 #[cfg(target_arch = "aarch64")]
-pub fn invoke_page_map(
-    _frame_cap: &mut cap_t,
+pub fn invoke_page_map(// _frame_cap: &mut cap_t,
 
-    asid: usize,
-    pt_slot: &mut PTE,
-    frame_slot: &mut cte_t,
-) {
+    // asid: usize,
+    // pt_slot: &mut PTE,
+    // frame_slot: &mut cte_t,
+) -> exception_t {
     // TODO:unimplement
+    exception_t::EXCEPTION_NONE
 }
 // #[cfg(target_arch = "aarch64")]
 // pub fn invoke_huge_page_map(

sel4_vspace/src/arch/aarch64/interface.rs

@@ -2,7 +2,8 @@ use core::intrinsics::unlikely;
 use core::ops::{Deref, DerefMut};
 
 use super::pte::pte_tag_t;
-use super::{kpptr_to_paddr, machine::*};
+use super::{kpptr_to_paddr, machine::*, UPT_LEVELS};
+use crate::arch::VAddr;
 use crate::{
     ap_from_vm_rights, asid_t, find_map_for_asid, find_vspace_for_asid, paddr_to_pptr, pptr_t,
     pptr_to_paddr, vm_attributes_t, vptr_t, PTE,
@@ -251,25 +252,25 @@ pub fn set_vm_root_for_flush_with_thread_root(
 // }
 
 /// TODO: Make pt as usize of
-pub fn page_table_mapped(asid: asid_t, vaddr: vptr_t, pt: &PTE) -> Option<*mut PDE> {
-    match find_map_for_asid(asid) {
-        Some(asid_map) => {
-            let lookup_ret = PGDE::new_from_pte(asid_map.get_vspace_root()).lookup_pd_slot(vaddr);
-            if lookup_ret.status != exception_t::EXCEPTION_NONE {
-                return None;
-            }
+// pub fn page_table_mapped(asid: asid_t, vaddr: vptr_t, pt: &PTE) -> Option<*mut PDE> {
+//     match find_map_for_asid(asid) {
+//         Some(asid_map) => {
+//             let lookup_ret = PGDE::new_from_pte(asid_map.get_vspace_root()).lookup_pd_slot(vaddr);
+//             if lookup_ret.status != exception_t::EXCEPTION_NONE {
+//                 return None;
+//             }
 
-            let slot = unsafe { &mut (*lookup_ret.pdSlot) };
+//             let slot = unsafe { &mut (*lookup_ret.pdSlot) };
 
-            if !slot.get_present() || slot.get_base_address() != pptr_to_paddr(pt.0) {
-                return None;
-            }
+//             if !slot.get_present() || slot.get_base_address() != pptr_to_paddr(pt.0) {
+//                 return None;
+//             }
 
-            return Some(slot);
-        }
-        None => None,
-    }
-}
+//             return Some(slot);
+//         }
+//         None => None,
+//     }
+// }
 
 #[inline]
 pub fn invalidate_tlb_by_asid(asid: asid_t) {
@@ -306,16 +307,30 @@ pub fn invalidate_tlb_by_asid_va(asid: asid_t, vaddr: vptr_t) {
 // }
 
 pub fn unmap_page_table(asid: asid_t, vaddr: vptr_t, pt: &PTE) {
-    //TODO:unimplement
-    match page_table_mapped(asid, vaddr, pt) {
-        Some(slot) => {
-            let slot = unsafe { &mut (*slot) };
-            slot.invalidate();
-            clean_by_va_pou(slot.get_ptr(), pptr_to_paddr(slot.get_ptr()));
-            invalidate_tlb_by_asid(asid);
+    let find_ret = find_vspace_for_asid(asid);
+    if find_ret.status != exception_t::EXCEPTION_NONE {
+        return;
+    }
+    let mut ptSlot: *mut PTE = core::ptr::null_mut::<PTE>();
+    let mut pte = find_ret.vspace_root.unwrap();
+    let mut level: usize = 0;
+    while level < UPT_LEVELS - 1 && pte as usize != pt as *const PTE as usize {
+        level = level + 1;
+        ptSlot = unsafe { pte.add(VAddr(vaddr).GET_UPT_INDEX(level)) };
+        if ptr_to_mut(ptSlot).get_type() != (pte_tag_t::pte_table) as usize {
+            return;
         }
-        None => {}
+        pte = paddr_to_pptr(ptr_to_mut(ptSlot).next_level_paddr()) as *mut PTE;
+    }
+    if pte as usize != pt as *const PTE as usize {
+        return;
     }
+    assert!(ptSlot.is_null());
+    unsafe {
+        *(ptSlot) = PTE(0);
+        ptr_to_mut(pte).update(*(ptSlot));
+    }
+    invalidate_tlb_by_asid(asid);
 }
 
 /// Unmap a page table

sel4_vspace/src/arch/aarch64/pte.rs

@@ -1,8 +1,11 @@
 use crate::{arch::aarch64::machine::clean_by_va_pou, vm_attributes_t, PTE};
 
 use super::utils::paddr_to_pptr;
+use super::{seL4_VSpaceIndexBits, UPT_LEVELS};
 use crate::arch::aarch64::get_current_lookup_fault;
 use crate::{lookupPTSlot_ret_t, vptr_t, GET_PT_INDEX};
+use sel4_common::utils::ptr_to_mut;
+use sel4_common::MASK;
 use sel4_common::{
     arch::vm_rights_t,
     fault::lookup_fault_t,
@@ -228,35 +231,23 @@ impl PTE {
         PTE(val)
     }
     ///用于记录某个虚拟地址`vptr`对应的pte表项在内存中的位置
-    pub fn lookup_pt_slot(&self, vptr: vptr_t) -> lookupPTSlot_ret_t {
-        // TODO:unimplement
-        let pdSlot = self.lookup_pd_slot(vptr);
-        if pdSlot.status != exception_t::EXCEPTION_NONE {
-            let ret = lookupPTSlot_ret_t {
-                status: pdSlot.status,
-                ptSlot: 0 as *mut PTE,
-            };
-            return ret;
-        }
-        unsafe {
-            if (*pdSlot.pdSlot).get_present() == false {
-                *get_current_lookup_fault() =
-                    lookup_fault_t::new_missing_cap(seL4_PageBits + PT_INDEX_BITS);
+    pub fn lookup_pt_slot(&mut self, vptr: vptr_t) -> lookupPTSlot_ret_t {
+        let mut pt = self as *mut PTE;
+        let mut level: usize = UPT_LEVELS - 1;
+        let ptBitsLeft = PT_INDEX_BITS * level + seL4_PageBits;
+        let mut ret = lookupPTSlot_ret_t {
+            ptSlot: unsafe { pt.add((vptr >> ptBitsLeft) & MASK!(seL4_VSpaceIndexBits)) },
+            ptBitsLeft: ptBitsLeft,
+        };
 
-                let ret = lookupPTSlot_ret_t {
-                    status: exception_t::EXCEPTION_LOOKUP_FAULT,
-                    ptSlot: 0 as *mut PTE,
-                };
-                return ret;
-            }
+        while ptr_to_mut(ret.ptSlot).get_type() == (pte_tag_t::pte_table) as usize && level > 0 {
+            level = level - 1;
+            ret.ptBitsLeft = ret.ptBitsLeft - PT_INDEX_BITS;
+            let paddr = ptr_to_mut(ret.ptSlot).next_level_paddr();
+            pt = paddr_to_pptr(paddr) as *mut PTE;
+            ret.ptSlot = unsafe { pt.add((vptr >> ptBitsLeft) & MASK!(PT_INDEX_BITS)) };
         }
-        let ptIndex = GET_PT_INDEX(vptr);
-        let pt = unsafe { paddr_to_pptr((*pdSlot.pdSlot).get_base_address()) as *mut PTE };
 
-        let ret = lookupPTSlot_ret_t {
-            status: exception_t::EXCEPTION_NONE,
-            ptSlot: unsafe { pt.add(ptIndex) },
-        };
         ret
     }
 }

sel4_vspace/src/asid.rs

@@ -4,6 +4,5 @@ use crate::asid_t;
 
 #[no_mangle]
 pub fn findVSpaceForASID(_asid: asid_t) -> findVSpaceForASID_ret {
-    // TODO:unimplement
     panic!("should not be invoked!")
 }