Remove the shim kernel crate

kernel/src/syscall/getdents64.rs

@@ -0,0 +1,274 @@
+// SPDX-License-Identifier: MPL-2.0
+
+use core::marker::PhantomData;
+
+use super::SyscallReturn;
+use crate::{
+    fs::{
+        file_table::FileDesc,
+        inode_handle::InodeHandle,
+        utils::{DirentVisitor, InodeType},
+    },
+    prelude::*,
+};
+
+pub fn sys_getdents(
+    fd: FileDesc,
+    buf_addr: Vaddr,
+    buf_len: usize,
+    ctx: &Context,
+) -> Result<SyscallReturn> {
+    debug!(
+        "fd = {}, buf_addr = 0x{:x}, buf_len = 0x{:x}",
+        fd, buf_addr, buf_len
+    );
+
+    let file = {
+        let file_table = ctx.process.file_table().lock();
+        file_table.get_file(fd)?.clone()
+    };
+    let inode_handle = file
+        .downcast_ref::<InodeHandle>()
+        .ok_or(Error::with_message(Errno::EBADF, "not inode"))?;
+    if inode_handle.dentry().type_() != InodeType::Dir {
+        return_errno!(Errno::ENOTDIR);
+    }
+    let mut buffer = vec![0u8; buf_len];
+    let mut reader = DirentBufferReader::<Dirent>::new(&mut buffer); // Use the non-64-bit reader
+    let _ = inode_handle.readdir(&mut reader)?;
+    let read_len = reader.read_len();
+    ctx.get_user_space()
+        .write_bytes(buf_addr, &mut VmReader::from(&buffer[..read_len]))?;
+    Ok(SyscallReturn::Return(read_len as _))
+}
+
+pub fn sys_getdents64(
+    fd: FileDesc,
+    buf_addr: Vaddr,
+    buf_len: usize,
+    ctx: &Context,
+) -> Result<SyscallReturn> {
+    debug!(
+        "fd = {}, buf_addr = 0x{:x}, buf_len = 0x{:x}",
+        fd, buf_addr, buf_len
+    );
+
+    let file = {
+        let file_table = ctx.process.file_table().lock();
+        file_table.get_file(fd)?.clone()
+    };
+    let inode_handle = file
+        .downcast_ref::<InodeHandle>()
+        .ok_or(Error::with_message(Errno::EBADF, "not inode"))?;
+    if inode_handle.dentry().type_() != InodeType::Dir {
+        return_errno!(Errno::ENOTDIR);
+    }
+    let mut buffer = vec![0u8; buf_len];
+    let mut reader = DirentBufferReader::<Dirent64>::new(&mut buffer);
+    let _ = inode_handle.readdir(&mut reader)?;
+    let read_len = reader.read_len();
+    ctx.get_user_space()
+        .write_bytes(buf_addr, &mut VmReader::from(&buffer[..read_len]))?;
+    Ok(SyscallReturn::Return(read_len as _))
+}
+
+/// The DirentSerializer can decide how to serialize the data.
+trait DirentSerializer {
+    /// Create a DirentSerializer.
+    fn new(ino: u64, offset: u64, type_: InodeType, name: CString) -> Self;
+    /// Get the length of a directory entry.
+    fn len(&self) -> usize;
+    /// Try to serialize a directory entry into buffer.
+    fn serialize(&self, buf: &mut [u8]) -> Result<()>;
+}
+
+/// The Buffered DirentReader to visit the dir entry.
+/// The DirentSerializer T decides how to serialize the data.
+struct DirentBufferReader<'a, T: DirentSerializer> {
+    buffer: &'a mut [u8],
+    read_len: usize,
+    phantom: PhantomData<T>,
+}
+
+impl<'a, T: DirentSerializer> DirentBufferReader<'a, T> {
+    pub fn new(buffer: &'a mut [u8]) -> Self {
+        Self {
+            buffer,
+            read_len: 0,
+            phantom: PhantomData,
+        }
+    }
+
+    pub fn read_len(&self) -> usize {
+        self.read_len
+    }
+}
+
+impl<'a, T: DirentSerializer> DirentVisitor for DirentBufferReader<'a, T> {
+    fn visit(&mut self, name: &str, ino: u64, type_: InodeType, offset: usize) -> Result<()> {
+        let dirent_serializer = T::new(ino, offset as u64, type_, CString::new(name)?);
+        if self.read_len >= self.buffer.len() {
+            return_errno_with_message!(Errno::EINVAL, "buffer is too small");
+        }
+        dirent_serializer.serialize(&mut self.buffer[self.read_len..])?;
+        self.read_len += dirent_serializer.len();
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+struct Dirent {
+    inner: DirentInner,
+    name: CString,
+}
+
+#[repr(packed)]
+#[derive(Debug, Clone, Copy)]
+struct DirentInner {
+    d_ino: u64,
+    d_off: u64,
+    d_reclen: u16,
+}
+
+impl DirentSerializer for Dirent {
+    fn new(ino: u64, offset: u64, _type_: InodeType, name: CString) -> Self {
+        let d_reclen = {
+            let len =
+                core::mem::size_of::<Dirent64Inner>() + name.as_c_str().to_bytes_with_nul().len();
+            align_up(len, 8) as u16
+        };
+        Self {
+            inner: DirentInner {
+                d_ino: ino,
+                d_off: offset,
+                d_reclen,
+            },
+            name,
+        }
+    }
+
+    fn len(&self) -> usize {
+        self.inner.d_reclen as usize
+    }
+
+    fn serialize(&self, buf: &mut [u8]) -> Result<()> {
+        // Ensure buffer is large enough for the directory entry
+        if self.len() > buf.len() {
+            return_errno_with_message!(Errno::EINVAL, "buffer is too small");
+        }
+
+        let d_ino = self.inner.d_ino;
+        let d_off = self.inner.d_off;
+        let d_reclen = self.inner.d_reclen;
+        let items: [&[u8]; 4] = [
+            d_ino.as_bytes(),
+            d_off.as_bytes(),
+            d_reclen.as_bytes(),
+            self.name.as_c_str().to_bytes_with_nul(),
+        ];
+        let mut offset = 0;
+        for item in items {
+            buf[offset..offset + item.len()].copy_from_slice(item);
+            offset += item.len();
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+struct Dirent64 {
+    inner: Dirent64Inner,
+    name: CString,
+}
+
+#[repr(packed)]
+#[derive(Debug, Clone, Copy)]
+struct Dirent64Inner {
+    d_ino: u64,
+    d_off: u64,
+    d_reclen: u16,
+    d_type: u8,
+}
+
+impl DirentSerializer for Dirent64 {
+    fn new(ino: u64, offset: u64, type_: InodeType, name: CString) -> Self {
+        let d_reclen = {
+            let len =
+                core::mem::size_of::<Dirent64Inner>() + name.as_c_str().to_bytes_with_nul().len();
+            align_up(len, 8) as u16
+        };
+        let d_type = DirentType::from(type_) as u8;
+        Self {
+            inner: Dirent64Inner {
+                d_ino: ino,
+                d_off: offset,
+                d_reclen,
+                d_type,
+            },
+            name,
+        }
+    }
+
+    fn len(&self) -> usize {
+        self.inner.d_reclen as usize
+    }
+
+    fn serialize(&self, buf: &mut [u8]) -> Result<()> {
+        if self.len() > buf.len() {
+            return_errno_with_message!(Errno::EINVAL, "buffer is too small");
+        }
+
+        let d_ino = self.inner.d_ino;
+        let d_off = self.inner.d_off;
+        let d_reclen = self.inner.d_reclen;
+        let d_type = self.inner.d_type;
+        let items: [&[u8]; 5] = [
+            d_ino.as_bytes(),
+            d_off.as_bytes(),
+            d_reclen.as_bytes(),
+            d_type.as_bytes(),
+            self.name.as_c_str().to_bytes_with_nul(),
+        ];
+        let mut offset = 0;
+        for item in items {
+            buf[offset..offset + item.len()].copy_from_slice(item);
+            offset += item.len();
+        }
+        Ok(())
+    }
+}
+
+#[allow(non_camel_case_types)]
+#[repr(u8)]
+#[derive(Debug, Clone, Copy)]
+enum DirentType {
+    #[allow(dead_code)]
+    DT_UNKNOWN = 0,
+    DT_FIFO = 1,
+    DT_CHR = 2,
+    DT_DIR = 4,
+    DT_BLK = 6,
+    DT_REG = 8,
+    DT_LNK = 10,
+    DT_SOCK = 12,
+    #[allow(dead_code)]
+    DT_WHT = 14,
+}
+
+impl From<InodeType> for DirentType {
+    fn from(type_: InodeType) -> Self {
+        match type_ {
+            InodeType::File => DirentType::DT_REG,
+            InodeType::Dir => DirentType::DT_DIR,
+            InodeType::SymLink => DirentType::DT_LNK,
+            InodeType::CharDevice => DirentType::DT_CHR,
+            InodeType::BlockDevice => DirentType::DT_BLK,
+            InodeType::Socket => DirentType::DT_SOCK,
+            InodeType::NamedPipe => DirentType::DT_FIFO,
+        }
+    }
+}
+
+fn align_up(size: usize, align: usize) -> usize {
+    (size + align - 1) & !(align - 1)
+}