Merge dev into main

api/ruxos_posix_api/build.rs

@@ -133,6 +133,7 @@ typedef struct {{
             "MS_.+",
             "MREMAP_.+",
             "GRND_.*",
+            "S_IF.+",
         ];
 
         #[derive(Debug)]

api/ruxos_posix_api/src/imp/fd_ops.rs

@@ -239,8 +239,11 @@ pub fn sys_fcntl(fd: c_int, cmd: c_int, arg: usize) -> c_int {
             }
             ctypes::F_SETFL => {
                 // Set the file status flags to the value specified by `arg`
-                get_file_like(fd)?
-                    .set_flags(OpenFlags::from_bits_truncate(arg as _).status_flags())?;
+                let f = get_file_like(fd)?;
+                let old_access_flags = f.flags() & OpenFlags::O_ACCMODE;
+                f.set_flags(
+                    old_access_flags | OpenFlags::from_bits_truncate(arg as _).status_flags(),
+                )?;
                 Ok(0)
             }
             ctypes::F_GETFL => {

api/ruxos_posix_api/src/imp/fs.rs

@@ -13,6 +13,8 @@ use core::{
     str,
 };
 
+use ruxfs::api::FileType;
+
 use axerrno::{LinuxError, LinuxResult};
 use axio::{Error, SeekFrom};
 use ruxfdtable::{FileLike, OpenFlags, RuxStat};
@@ -423,6 +425,35 @@ pub fn sys_unlinkat(fd: c_int, pathname: *const c_char, flags: c_int) -> c_int {
     })
 }
 
+/// Creates a new, empty file at the provided path.
+pub fn sys_mknodat(
+    fd: c_int,
+    pathname: *const c_char,
+    mode: ctypes::mode_t,
+    _dev: ctypes::dev_t,
+) -> c_int {
+    // TODO: implement permissions mode
+    syscall_body!(sys_mknodat, {
+        let path = parse_path_at(fd, pathname)?;
+        debug!(
+            "sys_mknodat <= fd: {}, pathname: {:?}, mode: {:x?}, dev: {:x?}",
+            fd, path, mode, _dev
+        );
+        let file_type = match mode & ctypes::S_IFMT {
+            ctypes::S_IFREG => FileType::File,
+            ctypes::S_IFIFO => FileType::Fifo,
+            _ => todo!(),
+        };
+
+        match file_type {
+            FileType::File => fops::create_file(&path)?,
+            FileType::Fifo => fops::create_fifo(&path)?,
+            _ => todo!(),
+        }
+        Ok(0)
+    })
+}
+
 /// Creates a new, empty directory at the provided path.
 pub fn sys_mkdir(pathname: *const c_char, mode: ctypes::mode_t) -> c_int {
     // TODO: implement mode

api/ruxos_posix_api/src/imp/io_mpx/epoll.rs

@@ -160,6 +160,10 @@ impl FileLike for EpollInstance {
     fn set_flags(&self, _flags: ruxfs::OpenFlags) -> LinuxResult {
         Ok(())
     }
+
+    fn flags(&self) -> OpenFlags {
+        OpenFlags::O_RDWR
+    }
 }
 
 /// Creates a new epoll instance.

api/ruxos_posix_api/src/imp/net.rs

@@ -316,6 +316,19 @@ impl FileLike for Socket {
         }
         Ok(())
     }
+
+    fn flags(&self) -> OpenFlags {
+        let nonblock = match self {
+            Socket::Udp(udpsocket) => udpsocket.lock().is_nonblocking(),
+            Socket::Tcp(tcpsocket) => tcpsocket.lock().is_nonblocking(),
+            Socket::Unix(unixsocket) => unixsocket.lock().is_nonblocking(),
+        };
+        if nonblock {
+            OpenFlags::O_NONBLOCK | OpenFlags::O_RDWR
+        } else {
+            OpenFlags::O_RDWR
+        }
+    }
 }
 
 impl From<SocketAddrV4> for ctypes::sockaddr_in {

api/ruxos_posix_api/src/imp/pipe.rs

@@ -7,215 +7,39 @@
  *   See the Mulan PSL v2 for more details.
  */
 
-use alloc::sync::{Arc, Weak};
 use core::ffi::c_int;
-use ringbuffer::RingBuffer;
-use ruxfs::AbsPath;
+use ruxfs::fifo;
 
-use axerrno::{LinuxError, LinuxResult};
-use axio::PollState;
-use axsync::Mutex;
-use ruxfdtable::{FileLike, OpenFlags, RuxStat};
+use axerrno::LinuxError;
+use ruxfdtable::OpenFlags;
 
-use crate::{ctypes, sys_fcntl};
-use ruxtask::fs::{add_file_like, close_file_like};
-
-pub struct Pipe {
-    readable: bool,
-    buffer: Arc<Mutex<RingBuffer>>,
-    // to find the write end when the read end is closed
-    _write_end_closed: Option<Weak<Mutex<RingBuffer>>>,
-}
-
-impl Pipe {
-    pub fn new() -> (Pipe, Pipe) {
-        let buffer = Arc::new(Mutex::new(RingBuffer::new(ruxconfig::PIPE_BUFFER_SIZE)));
-        let read_end = Pipe {
-            readable: true,
-            buffer: buffer.clone(),
-            _write_end_closed: None,
-        };
-        let write_end = Pipe {
-            readable: false,
-            buffer: buffer.clone(),
-            _write_end_closed: Some(Arc::downgrade(&buffer)),
-        };
-        (read_end, write_end)
-    }
-
-    pub const fn readable(&self) -> bool {
-        self.readable
-    }
-
-    pub const fn writable(&self) -> bool {
-        !self.readable
-    }
-
-    pub fn write_end_close(&self) -> bool {
-        let write_end_count = Arc::weak_count(&self.buffer);
-        write_end_count == 0
-    }
-}
-
-impl FileLike for Pipe {
-    fn path(&self) -> AbsPath {
-        AbsPath::new("/dev/pipe")
-    }
-
-    fn read(&self, buf: &mut [u8]) -> LinuxResult<usize> {
-        if !self.readable() {
-            return Err(LinuxError::EPERM);
-        }
-        let mut read_size = 0usize;
-        let max_len = buf.len();
-        let mut ring_buffer = self.buffer.lock();
-        // First, check if there is data in the read end.
-        // This loop is only runs when the write end is open
-        // and there is no data available
-        loop {
-            let loop_read = ring_buffer.available_read();
-            // If there is no data
-            if loop_read == 0 {
-                if self.write_end_close() {
-                    // write end is closed, read 0 bytes.
-                    return Ok(0);
-                } else {
-                    // write end is open
-                    drop(ring_buffer);
-                    // Data not ready, wait for write end
-                    crate::sys_sched_yield(); // TODO: use synconize primitive
-                    ring_buffer = self.buffer.lock();
-                }
-            } else {
-                break;
-            }
-        }
-        // read data
-        let loop_read = ring_buffer.available_read();
-        for _ in 0..loop_read {
-            if read_size == max_len {
-                return Ok(read_size);
-            }
-            debug_assert!(!ring_buffer.is_empty());
-            buf[read_size] = ring_buffer.dequeue().unwrap();
-            read_size += 1;
-        }
-        Ok(read_size)
-    }
-
-    fn write(&self, buf: &[u8]) -> LinuxResult<usize> {
-        if !self.writable() {
-            return Err(LinuxError::EPERM);
-        }
-        let mut write_size = 0usize;
-        let max_len = buf.len();
-        loop {
-            let mut ring_buffer = self.buffer.lock();
-            let loop_write = ring_buffer.available_write();
-            if loop_write == 0 {
-                drop(ring_buffer);
-                // Buffer is full, wait for read end to consume
-                crate::sys_sched_yield(); // TODO: use synconize primitive
-                continue;
-            }
-            for _ in 0..loop_write {
-                if write_size == max_len {
-                    return Ok(write_size);
-                }
-                debug_assert!(!ring_buffer.is_full());
-                ring_buffer.enqueue(buf[write_size]);
-                write_size += 1;
-            }
-        }
-    }
-
-    fn flush(&self) -> LinuxResult {
-        Ok(())
-    }
-
-    fn stat(&self) -> LinuxResult<RuxStat> {
-        let st_mode = 0o10000 | 0o600u32; // S_IFIFO | rw-------
-        Ok(RuxStat::from(ctypes::stat {
-            st_ino: 1,
-            st_nlink: 1,
-            st_mode,
-            st_uid: 1000,
-            st_gid: 1000,
-            st_blksize: 4096,
-            ..Default::default()
-        }))
-    }
-
-    fn into_any(self: Arc<Self>) -> Arc<dyn core::any::Any + Send + Sync> {
-        self
-    }
-
-    fn poll(&self) -> LinuxResult<PollState> {
-        let buf = self.buffer.lock();
-        Ok(PollState {
-            readable: self.readable() && buf.available_read() > 0,
-            writable: self.writable() && buf.available_write() > 0,
-            pollhup: self.write_end_close(),
-        })
-    }
-
-    fn set_flags(&self, _flags: OpenFlags) -> LinuxResult {
-        Ok(())
-    }
-}
+use ruxtask::fs::add_file_like;
 
 /// Create a pipe
 ///
 /// Return 0 if succeed
 pub fn sys_pipe(fds: &mut [c_int]) -> c_int {
-    debug!("sys_pipe <= {:#x}", fds.as_ptr() as usize);
-    syscall_body!(sys_pipe, {
-        if fds.len() != 2 {
-            return Err(LinuxError::EFAULT);
-        }
-
-        let (read_end, write_end) = Pipe::new();
-        let read_fd = add_file_like(Arc::new(read_end), OpenFlags::empty())?;
-        let write_fd =
-            add_file_like(Arc::new(write_end), OpenFlags::empty()).inspect_err(|_| {
-                close_file_like(read_fd).ok();
-            })?;
-
-        fds[0] = read_fd as c_int;
-        fds[1] = write_fd as c_int;
-
-        debug!("[sys_pipe] create pipe with read fd {read_fd} and write fd {write_fd}");
-        Ok(0)
-    })
+    sys_pipe2(fds, 0)
 }
 
 /// `pipe2` syscall, used by AARCH64
 ///
 /// Return 0 on success
 pub fn sys_pipe2(fds: &mut [c_int], flag: c_int) -> c_int {
-    debug!(
-        "sys_pipe2 <= fds: {:#x}, flag: {}",
-        fds.as_ptr() as usize,
-        flag
-    );
-    let ret = sys_pipe(fds);
-    if ret < 0 {
-        return ret;
-    }
     syscall_body!(sys_pipe2, {
-        if (flag as u32 & !(ctypes::O_CLOEXEC | ctypes::O_NONBLOCK)) != 0 {
-            return Err(LinuxError::EINVAL);
-        }
-
-        if (flag as u32 & ctypes::O_CLOEXEC) != 0 {
-            sys_fcntl(fds[0], ctypes::F_SETFD as _, ctypes::FD_CLOEXEC as _);
-            sys_fcntl(fds[1], ctypes::F_SETFD as _, ctypes::FD_CLOEXEC as _);
-        }
-
-        if (flag as u32 & ctypes::O_NONBLOCK) != 0 {
-            sys_fcntl(fds[0], ctypes::F_SETFL as _, ctypes::O_NONBLOCK as _);
-            sys_fcntl(fds[1], ctypes::F_SETFL as _, ctypes::O_NONBLOCK as _);
-        }
+        let flags = OpenFlags::from_bits(flag).ok_or(LinuxError::EINVAL)?;
+        debug!(
+            "sys_pipe2 <= fds: {:#x}, flag: {:?}",
+            fds.as_ptr() as usize,
+            flags
+        );
+        let (reader, writer) = fifo::new_pipe_pair(flags);
+        fds[0] = add_file_like(reader, flags)?;
+        fds[1] = add_file_like(writer, flags)?;
+        debug!(
+            "[sys_pipe] create pipe with read fd {} and write fd {}",
+            fds[0], fds[1]
+        );
         Ok(0)
     })
 }

api/ruxos_posix_api/src/imp/stdio.rs

@@ -129,7 +129,7 @@ impl ruxfdtable::FileLike for Stdin {
     }
 
     fn flags(&self) -> OpenFlags {
-        let mut flags = OpenFlags::empty();
+        let mut flags = OpenFlags::O_RDONLY;
         if self.nonblocking.load(Ordering::Acquire) {
             flags |= OpenFlags::O_NONBLOCK;
         }
@@ -184,4 +184,8 @@ impl ruxfdtable::FileLike for Stdout {
     fn set_flags(&self, _flags: OpenFlags) -> LinuxResult {
         Ok(())
     }
+
+    fn flags(&self) -> OpenFlags {
+        OpenFlags::O_WRONLY
+    }
 }