Merge branch 'dev' into update_virtio

Author: lhw2002426

.gitignore

@@ -10,9 +10,9 @@ compile_commands.json
 /fw_dynamic.bin
 
 *.asm
-disk.img
+*.img
 actual.out
-qemu.log
+*.log
 rusty-tags.vi
 apps/c/redis/
 apps/c/iperf/

Cargo.lock

@@ -270,8 +270,10 @@ else ifeq ($(FS), fat32)
 	$(call make_disk_image,fat32,$(DISK_IMG))
 else ifeq ($(FS), ext4)
 	$(call make_disk_image,ext4,$(DISK_IMG))
+else ifeq ($(FS), exfat)
+	$(call make_disk_image,exfat,$(DISK_IMG))
 else
-	$(error "FS" must be one of "fat32" or "ext4")
+	$(error "FS" must be one of "fat32" or "ext4" or "exfat")
 endif
 
 clean: clean_c clean_musl

Makefile

@@ -55,6 +55,7 @@ sched_cfs = ["ruxtask/sched_cfs", "irq"]
 # File system
 fs = ["alloc", "dep:ruxfs", "ruxruntime/fs"]
 blkfs = ["ruxdriver/virtio-blk", "ruxruntime/blkfs", "ruxfs/blkfs"]
+fusefs = ["ruxruntime/fusefs"]
 myfs = ["ruxfs?/myfs"]
 9pfs = []
 fatfs = ["ruxfs?/fatfs"]
@@ -114,6 +115,8 @@ ruxdriver = { path = "../../modules/ruxdriver", optional = true }
 ruxfs = { path = "../../modules/ruxfs", optional = true }
 rux9p = { path = "../../modules/rux9p", optional = true }
 ruxnet = { path = "../../modules/ruxnet", optional = true }
+ruxfuse = { path = "../../modules/ruxfuse", optional = true }
+ruxvda = { path = "../../modules/ruxvda", optional = true }
 ruxdisplay = { path = "../../modules/ruxdisplay", optional = true }
 axsync = { path = "../../modules/axsync", optional = true }
 ruxtask = { path = "../../modules/ruxtask", optional = true }

api/ruxfeat/Cargo.toml

@@ -20,9 +20,9 @@ default = []
 smp = ["ruxfeat/smp"]
 alloc = ["dep:axalloc", "ruxfeat/alloc"]
 paging = ["alloc", "ruxfeat/paging", "ruxmm"]
-multitask = ["ruxfeat/multitask", "ruxtask/multitask", "dep:ruxfutex"]
+multitask = ["ruxfeat/multitask", "ruxfuse/multitask", "ruxtask/multitask", "dep:ruxfutex"]
 fd = ["alloc"]
-fs = ["dep:ruxfs", "ruxfeat/fs", "fd"]
+fs = ["dep:ruxfs", "ruxfeat/fs", "fd", "ruxfuse"]
 net = ["dep:ruxnet", "ruxfeat/net", "fd"]
 signal = ["ruxruntime/signal", "ruxhal/signal", "ruxtask/signal"]
 pipe = ["fd"]
@@ -50,6 +50,7 @@ ruxtask = { path = "../../modules/ruxtask", features = [
     "notest",
 ], optional = true }
 ruxfs = { path = "../../modules/ruxfs", optional = true }
+ruxfuse = { path = "../../modules/ruxfuse", optional = true }
 ruxnet = { path = "../../modules/ruxnet", optional = true }
 
 # Other crates

api/ruxos_posix_api/Cargo.toml

@@ -26,7 +26,7 @@ impl From<ctypes::timespec> for RuxTimeSpec {
 }
 
 impl From<ctypes::stat> for RuxStat {
-    #[cfg(target_arch = "aarch64")]
+    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
     fn from(cstat: ctypes::stat) -> Self {
         RuxStat {
             st_dev: cstat.st_dev,
@@ -48,7 +48,7 @@ impl From<ctypes::stat> for RuxStat {
         }
     }
 
-    #[cfg(any(target_arch = "x86_64", target_arch = "riscv64"))]
+    #[cfg(target_arch = "x86_64")]
     fn from(cstat: ctypes::stat) -> Self {
         RuxStat {
             st_dev: cstat.st_dev,
@@ -80,7 +80,7 @@ impl From<RuxTimeSpec> for ctypes::timespec {
 }
 
 impl From<RuxStat> for ctypes::stat {
-    #[cfg(target_arch = "aarch64")]
+    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
     fn from(rstat: RuxStat) -> Self {
         ctypes::stat {
             st_dev: rstat.st_dev,
@@ -102,7 +102,7 @@ impl From<RuxStat> for ctypes::stat {
         }
     }
 
-    #[cfg(any(target_arch = "x86_64", target_arch = "riscv64"))]
+    #[cfg(target_arch = "x86_64")]
     fn from(rstat: RuxStat) -> Self {
         ctypes::stat {
             st_dev: rstat.st_dev,

api/ruxos_posix_api/src/imp/fd_ops.rs

@@ -7,13 +7,14 @@
  *   See the Mulan PSL v2 for more details.
  */
 
+use alloc::string::String;
 use alloc::sync::Arc;
 use core::{
-    ffi::{c_char, c_int, c_long, c_void, CStr},
+    ffi::{c_char, c_int, c_long, c_ulong, c_void, CStr},
     str,
 };
 
-use ruxfs::{api::FileType, fops::lookup, FilePerm};
+use ruxfs::{api::FileType, fops::lookup, FilePerm, MountPoint};
 
 use axerrno::{LinuxError, LinuxResult};
 use axio::{Error, SeekFrom};
@@ -23,7 +24,7 @@ use ruxfs::{
     AbsPath, DirEntry, Directory, File, RelPath,
 };
 
-use crate::ctypes;
+use crate::{ctypes, utils::char_ptr_to_str};
 use ruxtask::fs::{add_file_like, get_file_like, get_umask};
 
 use super::stdio::{Stdin, Stdout};
@@ -256,6 +257,12 @@ pub unsafe fn sys_newfstatat(
         }
         let node = fops::lookup(&path)?;
         let st = RuxStat::from(node.get_attr()?);
+
+        // TODO: remove this initialization when fields are fully implemented
+        unsafe {
+            core::ptr::write_bytes(kst, 0, 1);
+        }
+
         unsafe {
             (*kst).st_dev = st.st_dev;
             (*kst).st_ino = st.st_ino;
@@ -278,7 +285,7 @@ pub fn sys_getcwd(buf: *mut c_char, size: usize) -> c_int {
         if buf.is_null() {
             return Err(LinuxError::EINVAL);
         }
-        let dst = unsafe { core::slice::from_raw_parts_mut(buf as *mut u8, size as _) };
+        let dst: &mut [u8] = unsafe { core::slice::from_raw_parts_mut(buf as _, size as _) };
         let cwd = fops::current_dir()?;
         let cwd = cwd.as_bytes();
         if cwd.len() < size {
@@ -547,7 +554,7 @@ pub unsafe fn sys_getdents64(fd: c_int, dirp: *mut LinuxDirent64, count: ctypes:
 
             let name = entry.name_as_bytes();
             let name_len = name.len();
-            let entry_size = DIRENT64_FIXED_SIZE + name_len + 1;
+            let entry_size = (DIRENT64_FIXED_SIZE + name_len + 1 + 7) & !7; // align to 8 bytes
 
             // buf not big enough to hold the entry
             if written + entry_size > count {
@@ -562,7 +569,7 @@ pub unsafe fn sys_getdents64(fd: c_int, dirp: *mut LinuxDirent64, count: ctypes:
                 unsafe { &mut *(buf.as_mut_ptr().add(written) as *mut LinuxDirent64) };
             // set fixed-size fields
             dirent.d_ino = 1;
-            dirent.d_off = offset as i64;
+            dirent.d_off = (offset + 1) as i64;
             dirent.d_reclen = entry_size as u16;
             dirent.d_type = entry.entry_type() as u8;
             // set file name
@@ -632,6 +639,85 @@ pub fn sys_chdir(path: *const c_char) -> c_int {
     })
 }
 
+pub const MS_NODEV: u32 = 2;
+pub const MS_NOSUID: u32 = 4;
+
+/// umount a filesystem at a specific location in the filesystem tree
+pub fn sys_umount2(target: *const c_char, flags: c_int) -> c_int {
+    info!(
+        "sys_umount2 <= target: {:?}, flags: {:#x}",
+        char_ptr_to_str(target),
+        flags
+    );
+    syscall_body!(sys_umount2, {
+        let target = char_ptr_to_str(target)?;
+        let dir = ruxtask::current()
+            .fs
+            .lock()
+            .as_mut()
+            .unwrap()
+            .root_dir
+            .clone();
+        dir.umount(&AbsPath::new(target));
+        Ok(0)
+    })
+}
+
+/// mount a filesystem at a specific location in the filesystem tree
+pub fn sys_mount(
+    source: *const c_char,
+    raw_target: *const c_char,
+    filesystemtype: *const c_char,
+    mountflags: c_ulong,
+    data: *const c_void,
+) -> c_int {
+    info!(
+        "sys_mount <= source: {:?}, target: {:?}, filesystemtype: {:?}, mountflags: {:#x}, data: {:p}",
+        char_ptr_to_str(source),
+        char_ptr_to_str(raw_target),
+        char_ptr_to_str(filesystemtype),
+        mountflags,
+        data
+    );
+    syscall_body!(sys_mount, {
+        let f1 = MS_NODEV; //ctypes::MS_NODEV;
+        let f2 = MS_NOSUID; //ctypes::MS_NOSUID;
+        info!(
+            "mount flags: {:#x}, f1: {:#}, f2: {:#}, flag: {:#}",
+            mountflags,
+            f1,
+            f2,
+            f1 | f2
+        );
+        if mountflags != (f1 | f2).into() {
+            warn!("mount flags not supported: {:#x}", mountflags);
+        }
+
+        let target = char_ptr_to_str(raw_target)?;
+        let target = String::from(target);
+        let dir = ruxtask::current()
+            .fs
+            .lock()
+            .as_mut()
+            .unwrap()
+            .root_dir
+            .clone();
+        let vfsops = ruxfuse::fuse::fusefs();
+        info!("mounting filesystem at {}", target);
+        dir.mount(MountPoint {
+            path: target,
+            fs: vfsops,
+        })?;
+        Ok(0)
+    })
+}
+
+/// perform a memory barrier operation.
+pub fn sys_membarrier(cmd: c_int, flags: c_int) -> c_int {
+    info!("sys_membarrier <= cmd: {}, flags: {}", cmd, flags);
+    syscall_body!(sys_membarrier, Ok(0))
+}
+
 /// from char_ptr get path_str
 fn char_ptr_to_path_str<'a>(ptr: *const c_char) -> LinuxResult<&'a str> {
     if ptr.is_null() {

api/ruxos_posix_api/src/imp/fs.rs

@@ -44,8 +44,8 @@ pub fn sys_mmap(
     off: ctypes::off_t,
 ) -> *mut c_void {
     debug!(
-        "sys_mmap <= start: {:p}, len: 0x{:x}, prot:0x{:x?}, flags:0x{:x?}, fd: {}",
-        start, len, prot, flags, fd
+        "sys_mmap <= start: {:p}, len: 0x{:x}, prot:0x{:x?}, flags:0x{:x?}, fd: {}, off: 0x{:x}",
+        start, len, prot, flags, fd, off
     );
     syscall_body!(sys_mmap, {
         // transform C-type into rust-type

api/ruxos_posix_api/src/imp/mmap/api.rs

@@ -44,7 +44,13 @@ impl ruxhal::trap::TrapHandler for TrapHandlerImpl {
         let mut binding_mem_map = binding_task.mm.vma_map.lock();
         let vma_map = binding_mem_map.deref_mut();
         if let Some((_, vma)) = vma_map.upper_bound(Bound::Included(&vaddr)).peek_prev() {
-            // error!("vaddr=({:#x?}, {:#x?}) {:#x?}", vma.start_addr, vma.end_addr, vaddr);
+            trace!(
+                "vaddr=({:#x?}, {:#x?}) {:#x?} {:#x?}",
+                vma.start_addr,
+                vma.end_addr,
+                vaddr,
+                cause
+            );
             let vma_end_aligned = vma.end_addr;
             // Check if page existing in the vma, go to panic if not.
             if vma_end_aligned <= vaddr {

api/ruxos_posix_api/src/imp/mmap/trap.rs

@@ -68,10 +68,10 @@ pub fn sys_setpgid(pid: pid_t, pgid: pid_t) -> c_int {
     syscall_body!(sys_setpgid, Ok(0))
 }
 
-/// set process sid (empty implementation)
+/// set process sid and create a new session (return 1000)
 ///
 /// TODO:
-pub fn sys_setsid() -> c_int {
-    warn!("sys_setsid: do nothing",);
-    syscall_body!(sys_setsid, Ok(0))
+pub fn sys_setsid() -> pid_t {
+    info!("sys_setsid: create a new session");
+    syscall_body!(sys_setsid, Ok(1000))
 }