ch7: more util & builtin

Author: lythesia

easy-fs/src/layout.rs

@@ -447,6 +447,7 @@ impl DiskInode {
 
 /// A directory entry
 #[repr(C)]
+#[derive(Clone)]
 pub struct DirEntry {
     name: [u8; NAME_LENGTH_LIMIT + 1], // filename len at most 27 + '\0'
     inode_number: u32,

easy-fs/src/vfs.rs

@@ -100,6 +100,40 @@ impl Inode {
         .map(f)
     }
 
+    /// Get inodes of dir entries
+    pub fn dirents(&self, cursor: u32) -> Vec<(String, Arc<Inode>)> {
+        let fs = self.fs.lock();
+        let cursor = cursor as usize;
+        self.read_disk_inode(|disk_inode| {
+            assert!(disk_inode.is_dir());
+            let file_count = (disk_inode.size as usize) / DIRENT_SZ;
+            if cursor >= file_count {
+                return Vec::new();
+            }
+            let mut v = Vec::with_capacity(file_count - cursor);
+            let mut dirent = DirEntry::new_empty();
+            for i in cursor..file_count {
+                assert_eq!(
+                    disk_inode.read_at(i * DIRENT_SZ, dirent.as_bytes_mut(), &self.block_device),
+                    DIRENT_SZ
+                );
+                let inode_id = dirent.inode_number();
+                let (block_id, block_offset) = fs.get_disk_inode_pos(inode_id);
+                v.push((
+                    String::from(dirent.name()),
+                    Arc::new(Self::new(
+                        inode_id,
+                        block_id,
+                        block_offset,
+                        self.fs.clone(),
+                        self.block_device.clone(),
+                    )),
+                ))
+            }
+            v
+        })
+    }
+
     /// Find inode under current inode(recursively) by name
     pub fn find(&self, path: &str) -> Option<Arc<Inode>> {
         let fs = self.fs.lock();
@@ -246,7 +280,6 @@ impl Inode {
 
     fn clear_locked(&self, fs: &mut EasyFileSystem) {
         self.modify_disk_inode(|disk_inode| {
-            assert!(disk_inode.is_file());
             let size = disk_inode.size;
             let data_blocks_dealloc = disk_inode.clear_size(&self.block_device);
             assert_eq!(

os/src/syscall/fs.rs

@@ -249,22 +249,25 @@ pub struct Stat {
     pub ino: u64,
     pub mode: StatMode,
     pub nlink: u32,
-    pad: [u64; 7],
+    pub size: u64, // added
+    pad: [u64; 6],
 }
 
 impl Stat {
-    pub fn new(ino: u64, mode: StatMode, nlink: u32) -> Self {
+    pub fn new(ino: u64, mode: StatMode, nlink: u32, size: u64) -> Self {
         Self {
             dev: 0,
             ino,
             mode,
             nlink,
-            pad: [0; 7],
+            size,
+            pad: [0; 6],
         }
     }
 }
 
 bitflags! {
+    #[derive(Default)]
     pub struct StatMode: u32 {
         const NULL  = 0;
         /// directory
@@ -295,8 +298,9 @@ pub fn sys_fstat(fd: usize, ptr: *mut Stat) -> isize {
     } else {
         StatMode::NULL
     };
+    let size = inode.get_size();
     let nlink = inode.nlink();
-    let stat = Stat::new(ino as u64, mode, nlink);
+    let stat = Stat::new(ino as u64, mode, nlink, size as u64);
 
     let dst_vs = mm::translated_byte_buffer(
         task_inner.get_user_token(),
@@ -339,3 +343,61 @@ pub fn sys_dup(fd: usize) -> isize {
     inner.fd_table[new_fd] = Some(file);
     new_fd as isize
 }
+
+/// The max length of inode name
+const NAME_LENGTH_LIMIT: usize = 27;
+#[repr(C, align(32))]
+#[derive(Clone, Default)]
+pub struct Dirent {
+    pub ftype: FileType,
+    pub name: [u8; NAME_LENGTH_LIMIT],
+    pub next_offset: u32,
+}
+
+bitflags! {
+    #[derive(Default)]
+    pub struct FileType: u8 {
+        const UNKNOWN = 0;
+        const DIR = 1 << 0;
+        const REG = 1 << 1;
+    }
+}
+
+pub fn sys_getdents(fd: usize, ptr: *mut Dirent, len: usize) -> isize {
+    let task = task::current_task().unwrap();
+    let inner = task.inner_exclusive_access();
+    let token = inner.get_user_token();
+
+    let file = match inner.fd_table.get(fd) {
+        Some(Some(file)) => {
+            let file_clone = file.clone();
+            match file_clone.downcast_arc::<OSInode>() {
+                Some(os_inode) if os_inode.is_dir() => os_inode.clone_inner_inode(),
+                _ => return -1,
+            }
+        }
+        _ => return -1,
+    };
+    let cursor = mm::translate_ref(token, unsafe { ptr.add(len - 1) }).next_offset;
+    let dirents = file.dirents(cursor);
+    let nread = len.min(dirents.len());
+    for i in 0..nread {
+        let ename = dirents[i].0.as_bytes();
+        let inode = &dirents[i].1;
+        let ftype = if inode.is_dir() {
+            FileType::DIR
+        } else if inode.is_file() {
+            FileType::REG
+        } else {
+            FileType::UNKNOWN
+        };
+        let mut name = [0u8; NAME_LENGTH_LIMIT];
+        name[..ename.len()].copy_from_slice(&ename[..]);
+        *mm::translated_refmut(token, unsafe { ptr.add(i) }) = Dirent {
+            ftype,
+            name,
+            next_offset: cursor + i as u32 + 1,
+        };
+    }
+    nread as isize
+}

os/src/syscall/mod.rs

@@ -15,6 +15,7 @@ const SYSCALL_CHDIR: usize = 49;
 const SYSCALL_OPENAT: usize = 56;
 const SYSCALL_CLOSE: usize = 57;
 const SYSCALL_PIPE: usize = 59;
+const SYSCALL_GETDENTS: usize = 61;
 const SYSCALL_READ: usize = 63;
 const SYSCALL_WRITE: usize = 64;
 const SYSCALL_FSTAT: usize = 80;
@@ -54,6 +55,7 @@ pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
         SYSCALL_OPENAT => sys_openat(args[0] as isize, args[1] as *const u8, args[2] as u32),
         SYSCALL_CLOSE => sys_close(args[0]),
         SYSCALL_PIPE => sys_pipe(args[0] as *mut usize),
+        SYSCALL_GETDENTS => sys_getdents(args[0], args[1] as *mut _, args[2]),
         SYSCALL_READ => sys_read(args[0], args[1] as *const u8, args[2]),
         SYSCALL_WRITE => sys_write(args[0], args[1] as *const u8, args[2]),
         SYSCALL_FSTAT => sys_fstat(args[0] as usize, args[1] as *mut Stat),
@@ -63,7 +65,7 @@ pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
         SYSCALL_SIGACTION => sys_sigaction(args[0] as i32, args[1] as *const _, args[2] as *mut _),
         SYSCALL_SIGPROCMASK => sys_sigprocmask(args[0] as u32),
         SYSCALL_SIGRETURN => sys_sigreturn(),
-        SYSCALL_GET_TIME => sys_get_time(args[0] as *mut TimeVal),
+        SYSCALL_GET_TIME => sys_get_time(args[0] as *mut _),
         SYSCALL_GETPID => sys_getpid(),
         SYSCALL_MUNMAP => sys_munmap(args[0], args[1]),
         SYSCALL_FORK => sys_fork(),

user/src/bin/echo.rs

@@ -0,0 +1,13 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+extern crate alloc;
+
+#[no_mangle]
+fn main(_argc: usize, argv: &[&str]) -> i32 {
+    let s = argv[1..].join(" ");
+    println!("{}", s);
+    0
+}

user/src/bin/ls.rs

@@ -0,0 +1,57 @@
+#![no_std]
+#![no_main]
+
+use alloc::vec;
+use user_lib::{exit, getdents, open, Dirent, FileType, OpenFlags};
+
+#[macro_use]
+extern crate user_lib;
+extern crate alloc;
+
+#[no_mangle]
+fn main(argc: usize, argv: &[&str]) -> i32 {
+    let path = if argc == 1 {
+        ".\0"
+    } else if argc == 2 {
+        argv[1]
+    } else {
+        panic!("wrong number of args!");
+    };
+    let fd = open(path, OpenFlags::RDONLY);
+    if fd == -1 {
+        println!("Error open {}", path);
+        exit(-1);
+    }
+
+    const BUF_SIZE: usize = 16;
+    let mut total = 0usize;
+    let mut entries = vec![Dirent::default(); BUF_SIZE];
+    let mut n = BUF_SIZE;
+    loop {
+        n = match getdents(fd as usize, &mut entries.as_mut_slice()[..n]) {
+            -1 => {
+                println!("Error read dir {}", path);
+                exit(-1);
+                unreachable!()
+            }
+            0 => break,
+            v => v as usize,
+        };
+        total += n;
+        for i in 0..n {
+            let entry = &entries[i];
+            let color_code = match entry.ftype {
+                FileType::DIR => 94,
+                FileType::REG => 0,
+                _ => panic!("unknown file type {}", entry.name()),
+            };
+            print_color(format_args!("{}\n", entry.name()), color_code);
+        }
+    }
+    print_color(format_args!("total {}\n", total), 90);
+    0
+}
+
+fn print_color(args: core::fmt::Arguments, color_code: u8) {
+    print!("\u{1b}[{}m{}\u{1b}[0m", color_code, args);
+}

user/src/bin/mkdir.rs

@@ -0,0 +1,19 @@
+#![no_std]
+#![no_main]
+
+use user_lib::{exit, mkdir};
+
+#[macro_use]
+extern crate user_lib;
+
+#[no_mangle]
+fn main(argc: usize, argv: &[&str]) -> i32 {
+    assert_eq!(argc, 2, "wrong number of args!");
+    let path = argv[1];
+
+    if mkdir(path) == -1 {
+        println!("Error mkdir {}", path);
+        exit(-1);
+    }
+    0
+}

user/src/bin/stat.rs

@@ -0,0 +1,30 @@
+#![no_std]
+#![no_main]
+
+use user_lib::{exit, fstat, open, OpenFlags, Stat};
+
+#[macro_use]
+extern crate user_lib;
+
+#[no_mangle]
+fn main(argc: usize, argv: &[&str]) -> i32 {
+    assert_eq!(argc, 2, "wrong number of args!");
+    let path = argv[1];
+
+    let fd = open(path, OpenFlags::RDONLY);
+    if fd == -1 {
+        println!("Error open {}", path);
+        exit(-1);
+    }
+    let mut stat = Stat::new();
+    if fstat(fd as usize, &mut stat) == -1 {
+        println!("Error unlink {}", path);
+        exit(-1);
+    }
+
+    println!("File:   {}", path);
+    println!("Size:   {}\t{:?}", stat.size, stat.mode);
+    println!("Device: {}", stat.dev);
+    println!("Inode:  {}", stat.ino);
+    0
+}

user/src/bin/unlink.rs

@@ -0,0 +1,37 @@
+#![no_std]
+#![no_main]
+
+use user_lib::{exit, fstat, open, unlink, OpenFlags, Stat, StatMode};
+
+#[macro_use]
+extern crate user_lib;
+
+#[no_mangle]
+fn main(argc: usize, argv: &[&str]) -> i32 {
+    assert_eq!(argc, 2, "wrong number of args!");
+    let path = argv[1];
+
+    let fd = open(path, OpenFlags::RDONLY);
+    if fd == -1 {
+        println!("Error open {}", path);
+        exit(-1);
+    }
+    let mut stat = Stat::new();
+    if fstat(fd as usize, &mut stat) == -1 {
+        println!("Error fstat {}", path);
+        exit(-1);
+    }
+
+    const DIRENT_SZ: usize = 32;
+    if stat.mode == StatMode::DIR && stat.size as usize > 2 * DIRENT_SZ {
+        // 2 dirent: . and ..
+        println!("Directory not empty!");
+        exit(-1);
+    }
+
+    if unlink(path) == -1 {
+        println!("Error unlink {}", path);
+        exit(-1);
+    }
+    0
+}