sys_getdents: read one directory entry at a time

Unfortunately, the sys_read_entries sysdep in libc is required to read one
directory entry at a time but the Aero getdents syscall reads as much it can
into the provided in the buffer and we dont know the size of the buffer
since we dont know the size of the name aswell. We cannot also assign
an aribiray size to the name since the syscall will bail out if the size
of the buffer is too small to fit in the name. :^)

* We need a way to retrieve the chopped off name.
* We need to null terminate the string since rust strings are not null
terminated and this could possibally cause issues.

Signed-off-by: Andy-Python-Programmer <[email protected]>

Author: Andy-Python-Programmer

patches/mlibc/mlibc.patch

@@ -1,4 +1,4 @@
-From ef88dca94b8e13b78bdd0dc71df8b6062009c6f0 Mon Sep 17 00:00:00 2001
+From d92b4e7afe56d401b465f3dcdf12c60d9b414b6b Mon Sep 17 00:00:00 2001
 From: unknown <[email protected]>
 Date: Sun, 6 Jun 2021 16:37:54 +1000
 Subject: [PATCH] targets: add aero target port
@@ -15,7 +15,7 @@ Signed-off-by: Andy-Python-Programmer <[email protected]>
  sysdeps/aero/crt-x86_64/crt0.S              |   8 +
  sysdeps/aero/generic/aero.cc                | 276 ++++++++++++++++++++
  sysdeps/aero/generic/entry.cc               |  32 +++
- sysdeps/aero/generic/filesystem.cc          | 266 +++++++++++++++++++
+ sysdeps/aero/generic/filesystem.cc          | 262 +++++++++++++++++++
  sysdeps/aero/generic/signals.S              |   7 +
  sysdeps/aero/generic/signals.cc             |  43 +++
  sysdeps/aero/generic/sockets.cc             |   0
@@ -51,7 +51,7 @@ Signed-off-by: Andy-Python-Programmer <[email protected]>
  sysdeps/aero/meson.build                    |  67 +++++
  sysdeps/dripos/generic/generic.cpp          |   3 +
  sysdeps/lemon/generic/signals.S             |   7 +
- 46 files changed, 1025 insertions(+), 11 deletions(-)
+ 46 files changed, 1021 insertions(+), 11 deletions(-)
  create mode 100644 abis/aero/auxv.h
  create mode 100644 sysdeps/aero/crt-x86_64/crt0.S
  create mode 100644 sysdeps/aero/generic/aero.cc
@@ -567,10 +567,10 @@ index 0000000..265ab56
 +}
 diff --git a/sysdeps/aero/generic/filesystem.cc b/sysdeps/aero/generic/filesystem.cc
 new file mode 100644
-index 0000000..a944402
+index 0000000..421e2d6
 --- /dev/null
 +++ b/sysdeps/aero/generic/filesystem.cc
-@@ -0,0 +1,266 @@
+@@ -0,0 +1,262 @@
 +#include <aero/syscall.h>
 +
 +#include <sys/types.h>
@@ -740,8 +740,7 @@ index 0000000..a944402
 +} __attribute__((packed));
 +
 +int sys_read_entries(int handle, void *buffer, size_t max_size, size_t *bytes_read) {
-+	struct aero_dir_entry entry;
-+	auto result = syscall(SYS_GETDENTS, handle, &entry, sizeof(struct aero_dir_entry));
++	auto result = syscall(SYS_GETDENTS, handle, buffer, max_size);
 +
 +	// Check if we got an error.
 +	if (result < 0) {
@@ -755,26 +754,23 @@ index 0000000..a944402
 +		return 0;
 +	}
 +
-+	// Check if we have enough space.
-+	__ensure(max_size >= entry.reclen);
++	auto entry = (struct aero_dir_entry*)buffer;
 +
-+	struct dirent *dirent = (struct dirent *)buffer;
-+
-+	dirent->d_ino = entry.inode;
-+	dirent->d_off = entry.offset;
-+	dirent->d_reclen = entry.reclen;
-+	dirent->d_type = entry.filetyp;
++	struct dirent dirent = {
++		.d_ino = entry->inode,
++		.d_off = entry->offset,
++		.d_reclen = entry->reclen,
++		.d_type = entry->filetyp,
++	};
 +
 +	// The reclen is the size of the dirent struct, plus the size of the name.
-+	auto name_size = entry.reclen - sizeof(struct aero_dir_entry);
-+
-+	if (name_size > 255) {
-+		name_size = 255;
-+	}
++	auto name_size = entry->reclen - sizeof(struct aero_dir_entry);
++	__ensure(name_size < 255);
 +
-+	memcpy(dirent->d_name, entry.name, name_size);
-+	*bytes_read = entry.reclen;
++	memcpy(&dirent.d_name, entry->name, name_size);
++	*bytes_read = entry->reclen;
 +
++	memcpy(buffer, &dirent, sizeof(struct dirent));
 +	return 0;
 +}
 +

src/aero_kernel/src/fs/file_table.rs

@@ -125,57 +125,49 @@ impl FileHandle {
         Ok(new)
     }
 
-    pub fn get_dents(&self, mut buffer: &mut [u8]) -> super::Result<usize> {
-        let mut offset = 0x00usize;
-
-        loop {
-            let inode = self
-                .inode
-                .inode()
-                .dirent(self.inode.clone(), self.offset.load(Ordering::SeqCst))?;
-
-            if let Some(entry) = inode {
-                let reclen = core::mem::size_of::<SysDirEntry>() + entry.name().len();
-                let dir_offset = offset + reclen;
-
-                let file_type = entry.inode().metadata()?.file_type();
-                let file_type: aero_syscall::SysFileType = file_type.into();
-
-                let sysd = SysDirEntry {
-                    inode: entry.inode().metadata()?.id(),
-                    offset: dir_offset,
-                    reclen,
-                    file_type: file_type as usize,
-                    name: [], // will be filled in later
-                };
-
-                if buffer.len() < sysd.reclen {
-                    break Ok(offset);
-                }
+    pub fn get_dents(&self, buffer: &mut [u8]) -> super::Result<usize> {
+        let inode = self
+            .inode
+            .inode()
+            .dirent(self.inode.clone(), self.offset.load(Ordering::SeqCst))?;
 
-                self.offset.fetch_add(1, Ordering::SeqCst);
+        // We are allowed to chop off the name of the entry though not the header
+        // itself.
+        if buffer.len() < core::mem::size_of::<SysDirEntry>() {
+            return Err(FileSystemError::TooSmall);
+        }
 
-                unsafe {
-                    let sysd_ref = &mut *(buffer.as_mut_ptr() as *mut SysDirEntry);
+        if let Some(entry) = inode {
+            let mut reclen = core::mem::size_of::<SysDirEntry>() + entry.name().len();
 
-                    // Copy the directory entry info into the provided buffer.
-                    buffer.as_mut_ptr().copy_from(
-                        &sysd as *const _ as *const u8,
-                        core::mem::size_of::<SysDirEntry>(),
-                    );
+            if reclen > buffer.len() {
+                reclen = buffer.len();
+            }
 
-                    // Copy over the name of the inode.
-                    sysd_ref
-                        .name
-                        .as_mut_ptr()
-                        .copy_from(entry.name().as_ptr(), entry.name().len());
-                }
+            let name_size = reclen - core::mem::size_of::<SysDirEntry>();
 
-                offset += sysd.reclen;
-                buffer = &mut buffer[sysd.reclen..];
-            } else {
-                break Ok(offset);
+            let file_type = entry.inode().metadata()?.file_type();
+            let file_type: aero_syscall::SysFileType = file_type.into();
+
+            let sysd = unsafe { &mut *(buffer.as_mut_ptr() as *mut SysDirEntry) };
+
+            sysd.inode = entry.inode().metadata()?.id();
+            sysd.offset = reclen;
+            sysd.reclen = reclen;
+            sysd.file_type = file_type as usize;
+
+            unsafe {
+                // Copy over the name of the inode.
+                sysd.name
+                    .as_mut_ptr()
+                    .copy_from(entry.name().as_ptr(), name_size);
             }
+
+            self.offset.fetch_add(1, Ordering::SeqCst);
+            Ok(reclen)
+        } else {
+            // nothin to read
+            Ok(0)
         }
     }
 }

src/aero_kernel/src/fs/mod.rs

@@ -128,6 +128,7 @@ pub enum FileSystemError {
     NotDirectory,
     IsPipe,
     Interrupted,
+    TooSmall,
 }
 
 impl From<FileSystemError> for AeroSyscallError {
@@ -140,6 +141,7 @@ impl From<FileSystemError> for AeroSyscallError {
             FileSystemError::NotDirectory => AeroSyscallError::ENOTDIR,
             FileSystemError::IsPipe => AeroSyscallError::ESPIPE,
             FileSystemError::Interrupted => AeroSyscallError::EINTR,
+            FileSystemError::TooSmall => AeroSyscallError::E2BIG,
         }
     }
 }

userland/aero_shell/src/main.rs

@@ -231,7 +231,6 @@ fn list_directory(path: &str) -> Result<(), AeroSyscallError> {
     let dir_fd = sys_open(path, OpenFlags::O_DIRECTORY)?;
 
     loop {
-        let mut offset = 0;
         let mut dir_ents_buffer = [0; 1024];
 
         let size = sys_getdents(dir_fd, &mut dir_ents_buffer)?;
@@ -240,20 +239,15 @@ fn list_directory(path: &str) -> Result<(), AeroSyscallError> {
             break;
         }
 
-        while offset < size {
-            let dir_entry =
-                unsafe { &*(dir_ents_buffer.as_ptr().add(offset) as *const SysDirEntry) };
+        let dir_entry = unsafe { &*(dir_ents_buffer.as_ptr() as *const SysDirEntry) };
 
-            let name_start = offset + core::mem::size_of::<SysDirEntry>();
-            let name_end = offset + dir_entry.reclen;
+        let name_start = core::mem::size_of::<SysDirEntry>();
+        let name_end = dir_entry.reclen;
 
-            let name =
-                unsafe { core::str::from_utf8_unchecked(&dir_ents_buffer[name_start..name_end]) };
+        let name =
+            unsafe { core::str::from_utf8_unchecked(&dir_ents_buffer[name_start..name_end]) };
 
-            offset += dir_entry.reclen;
-
-            print!("{} ", name);
-        }
+        print!("{} ", name);
     }
 
     println!();