pass usertests

os/src/mm/mod.rs

@@ -18,8 +18,7 @@ pub use memory_set::{dump_test, from_global_test, remap_test};
 pub use memory_set::{kernel_token, MapPermission, MemorySet, KERNEL_SPACE};
 use page_table::PTEFlags;
 pub use page_table::{
-    current_satp, translated_byte_buffer, translated_ref, translated_refmut, translated_str,
-    PageTable, PageTableEntry, UserBuffer, UserBufferIterator,
+    current_satp, translated_byte_buffer, PageTable, PageTableEntry, UserBuffer, UserBufferIterator,
 };
 
 use self::frame_allocator::frame_allocator_test;

os/src/mm/page_table.rs

@@ -317,44 +317,6 @@ pub fn translated_byte_buffer(token: usize, ptr: *const u8, len: usize) -> Vec<&
     v
 }
 
-/// Translate a pointer to a mutable u8 Vec end with `\0` through page table to a `String`
-pub fn translated_str(token: usize, ptr: *const u8) -> String {
-    let page_table = PageTable::from_token(token);
-    //page_table.dump();
-    let mut string = String::new();
-    let mut va = ptr as usize;
-    loop {
-        let ch: u8 = *(page_table
-            .translate_va(VirtAddr::from(va))
-            .unwrap()
-            .get_mut());
-        if ch == 0 {
-            break;
-        }
-        string.push(ch as char);
-        va += 1;
-    }
-    string
-}
-
-#[allow(unused)]
-///Translate a generic through page table and return a reference
-pub fn translated_ref<T>(token: usize, ptr: *const T) -> &'static T {
-    let page_table = PageTable::from_token(token);
-    page_table
-        .translate_va(VirtAddr::from(ptr as usize))
-        .unwrap()
-        .get_ref()
-}
-///Translate a generic through page table and return a mutable reference
-pub fn translated_refmut<T>(token: usize, ptr: *mut T) -> &'static mut T {
-    let page_table = PageTable::from_token(token);
-    let va = ptr as usize;
-    page_table
-        .translate_va(VirtAddr::from(va))
-        .unwrap()
-        .get_mut()
-}
 ///Array of u8 slice that user communicate with os
 pub struct UserBuffer {
     ///U8 vec

os/src/syscall/fs.rs

 //! File and filesystem-related syscalls
 use crate::fs::{open_file, OpenFlags};
-use crate::mm::{translated_byte_buffer, translated_str, UserBuffer};
+use crate::mm::{translated_byte_buffer, UserBuffer};
 use crate::task::{current_task, current_user_token};
+use crate::utils::c_str_to_string;
 
 pub fn sys_write(fd: usize, buf: *const u8, len: usize) -> isize {
     let token = current_user_token();
@@ -45,8 +46,9 @@ pub fn sys_read(fd: usize, buf: *const u8, len: usize) -> isize {
 
 pub fn sys_open(path: *const u8, flags: u32) -> isize {
     let task = current_task().unwrap();
-    let token = current_user_token();
-    let path = translated_str(token, path);
+    //let token = current_user_token();
+    //let path = translated_str(token, path);
+    let path = c_str_to_string(path);
     if let Some(inode) = open_file(path.as_str(), OpenFlags::from_bits(flags).unwrap()) {
         let mut inner = task.inner_exclusive_access();
         let fd = inner.alloc_fd();

os/src/syscall/process.rs

 use crate::fs::{open_file, OpenFlags};
-use crate::mm::{translated_refmut, translated_str};
 use crate::task::schedule::spawn_thread;
 use crate::task::{current_task, current_user_token, exit_current, yield_task};
 use crate::timer::get_time_ms;