vexos: finish bringing modules up to date

Author: tropicaaal

library/std/Cargo.toml

@@ -62,7 +62,7 @@ path = "../windows_targets"
 rand = { version = "0.9.0", default-features = false, features = ["alloc"] }
 rand_xorshift = "0.4.0"
 
-[target.'cfg(any(all(target_family = "wasm", target_os = "unknown"), target_os = "xous", all(target_vendor = "fortanix", target_env = "sgx")))'.dependencies]
+[target.'cfg(any(all(target_family = "wasm", target_os = "unknown"), target_os = "xous", target_os = "vexos", all(target_vendor = "fortanix", target_env = "sgx")))'.dependencies]
 dlmalloc = { version = "0.2.10", features = ['rustc-dep-of-std'] }
 
 [target.x86_64-fortanix-unknown-sgx.dependencies]

library/std/src/sys/alloc/vexos.rs

@@ -53,7 +53,6 @@ mod lock {
             if LOCKED.swap(1, Acquire) == 0 {
                 return DropLock;
             }
-            crate::os::xous::ffi::do_yield();
         }
     }
 

library/std/src/sys/fs/vexos.rs

@@ -1,10 +1,11 @@
 use crate::ffi::{CString, OsString};
 use crate::fmt;
+use crate::fs::TryLockError;
 use crate::hash::Hash;
 use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, SeekFrom};
 use crate::path::{Path, PathBuf};
 use crate::sys::time::SystemTime;
-use crate::sys::unsupported;
+use crate::sys::{unsupported, unsupported_err};
 
 #[derive(Debug)]
 struct FileDesc(*mut vex_sdk::FIL);
@@ -19,12 +20,8 @@ pub struct FileAttr {
     is_dir: bool,
 }
 
-#[derive(Debug)]
-pub struct ReadDir {
-    entries: Vec<DirEntry>,
-}
+pub struct ReadDir(!);
 
-#[derive(Debug)]
 pub struct DirEntry {
     path: PathBuf,
 }
@@ -39,18 +36,18 @@ pub struct OpenOptions {
 }
 
 #[derive(Copy, Clone, Debug, Default)]
-pub struct FileTimes(());
+pub struct FileTimes {}
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct FilePermissions;
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct FilePermissions {}
 
-#[derive(Clone, Debug, Copy, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
 pub struct FileType {
     is_dir: bool,
 }
 
 #[derive(Debug)]
-pub struct DirBuilder(());
+pub struct DirBuilder {}
 
 impl FileAttr {
     /// Creates a FileAttr by getting data from an opened file.
@@ -79,9 +76,8 @@ impl FileAttr {
             let mut opts = OpenOptions::new();
             opts.read(true);
             let file = File::open(path, &opts)?;
-            let fd = file.fd.0;
 
-            Self::from_fd(fd)
+            Self::from_fd(file.fd.0)
         }
     }
 
@@ -90,7 +86,7 @@ impl FileAttr {
     }
 
     pub fn perm(&self) -> FilePermissions {
-        FilePermissions
+        FilePermissions {}
     }
 
     pub fn file_type(&self) -> FileType {
@@ -135,15 +131,22 @@ impl FileType {
     }
 
     pub fn is_symlink(&self) -> bool {
+        // No symlinks in vexos; entries are either files or directories.
         false
     }
 }
 
+impl fmt::Debug for ReadDir {
+    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0
+    }
+}
+
 impl Iterator for ReadDir {
     type Item = io::Result<DirEntry>;
 
     fn next(&mut self) -> Option<io::Result<DirEntry>> {
-        self.entries.pop().map(Ok)
+        self.0
     }
 }
 
@@ -191,6 +194,7 @@ impl OpenOptions {
 }
 
 impl File {
+    // TODO
     pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> {
         // Mount sdcard volume as FAT filesystem
         map_fresult(unsafe { vex_sdk::vexFileMountSD() })?;
@@ -265,12 +269,12 @@ impl File {
         unsupported()
     }
 
-    pub fn try_lock(&self) -> io::Result<bool> {
-        unsupported()
+    pub fn try_lock(&self) -> Result<(), TryLockError> {
+        Err(TryLockError::Error(unsupported_err()))
     }
 
-    pub fn try_lock_shared(&self) -> io::Result<bool> {
-        unsupported()
+    pub fn try_lock_shared(&self) -> Result<(), TryLockError> {
+        Err(TryLockError::Error(unsupported_err()))
     }
 
     pub fn unlock(&self) -> io::Result<()> {
@@ -333,13 +337,17 @@ impl File {
         Ok(())
     }
 
-    fn tell(&self) -> io::Result<u64> {
+    pub fn tell(&self) -> io::Result<u64> {
         let position = unsafe { vex_sdk::vexFileTell(self.fd.0) };
         position.try_into().map_err(|_| {
             io::Error::new(io::ErrorKind::InvalidData, "Failed to get current location in file")
         })
     }
 
+    pub fn size(&self) -> Option<io::Result<u64>> {
+        None
+    }
+
     pub fn seek(&self, pos: SeekFrom) -> io::Result<u64> {
         const SEEK_SET: i32 = 0;
         const SEEK_CUR: i32 = 1;
@@ -412,7 +420,7 @@ impl File {
 
 impl DirBuilder {
     pub fn new() -> DirBuilder {
-        DirBuilder(())
+        DirBuilder {}
     }
 
     pub fn mkdir(&self, _p: &Path) -> io::Result<()> {

library/std/src/sys/pal/vexos/mod.rs

@@ -21,9 +21,9 @@ global_asm!(
 );
 
 #[cfg(not(test))]
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn _start() -> ! {
-    extern "C" {
+    unsafe extern "C" {
         static mut __bss_start: u8;
         static mut __bss_end: u8;
 
@@ -40,6 +40,7 @@ pub unsafe extern "C" fn _start() -> ! {
 
     main();
 
+    cleanup();
     abort_internal()
 }
 
@@ -49,7 +50,22 @@ pub unsafe fn init(_argc: isize, _argv: *const *const u8, _sigpipe: u8) {}
 
 // SAFETY: must be called only once during runtime cleanup.
 // NOTE: this is not guaranteed to run, for example when the program aborts.
-pub unsafe fn cleanup() {}
+pub unsafe fn cleanup() {
+    let exit_time = Instant::now();
+    const FLUSH_TIMEOUT: Duration = Duration::from_millis(15);
+    const STDIO_CHANNEL: u32 = 1;
+
+    // Force the serial buffer to flush
+    while exit_time.elapsed() < FLUSH_TIMEOUT {
+        vex_sdk::vexTasksRun();
+
+        // If the buffer has been fully flushed, exit the loop
+        if vex_sdk::vexSerialWriteFree(STDIO_CHANNEL) == (crate::sys::stdio::STDOUT_BUF_SIZE as i32)
+        {
+            break;
+        }
+    }
+}
 
 pub fn unsupported<T>() -> crate::io::Result<T> {
     Err(unsupported_err())
@@ -68,21 +84,7 @@ pub fn decode_error_kind(_code: i32) -> crate::io::ErrorKind {
 }
 
 pub fn abort_internal() -> ! {
-    let exit_time = Instant::now();
-    const FLUSH_TIMEOUT: Duration = Duration::from_millis(15);
-
     unsafe {
-        // Force the serial buffer to flush
-        while exit_time.elapsed() < FLUSH_TIMEOUT {
-            vex_sdk::vexTasksRun();
-
-            // If the buffer has been fully flushed, exit the loop
-            if vex_sdk::vexSerialWriteFree(stdio::STDIO_CHANNEL) == (stdio::STDOUT_BUF_SIZE as i32)
-            {
-                break;
-            }
-        }
-
         vex_sdk::vexSystemExitRequest();
 
         loop {

library/std/src/sys/pal/vexos/thread.rs

@@ -4,13 +4,17 @@ use crate::io;
 use crate::num::NonZero;
 use crate::time::{Duration, Instant};
 
-pub struct Thread(!);
-
 pub const DEFAULT_MIN_STACK_SIZE: usize = 64 * 1024;
 
+pub struct Thread(!);
+
 impl Thread {
     // unsafe: see thread::Builder::spawn_unchecked for safety requirements
-    pub unsafe fn new(_stack: usize, _p: Box<dyn FnOnce()>) -> io::Result<Thread> {
+    pub unsafe fn new(
+        _stack: usize,
+        _name: Option<&str>,
+        _p: Box<dyn FnOnce()>,
+    ) -> io::Result<Thread> {
         unsupported()
     }
 
@@ -34,11 +38,23 @@ impl Thread {
         }
     }
 
+    pub fn sleep_until(deadline: Instant) {
+        let now = Instant::now();
+
+        if let Some(delay) = deadline.checked_duration_since(now) {
+            Self::sleep(delay);
+        }
+    }
+
     pub fn join(self) {
         self.0
     }
 }
 
+pub(crate) fn current_os_id() -> Option<u64> {
+    None
+}
+
 pub fn available_parallelism() -> io::Result<NonZero<usize>> {
     unsupported()
 }

library/std/src/sys/pal/vexos/time.rs

@@ -32,15 +32,22 @@ impl SystemTime {
         panic!("system time not implemented on this platform")
     }
 
-    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+        // FIXME: ok_or_else with const closures
+        match self.0.checked_sub(other.0) {
+            Some(duration) => Ok(duration),
+            None => Err(other.0 - self.0),
+        }
     }
 
-    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_add(*other)?))
     }
 
-    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_sub(*other)?))
     }
 }

library/std/src/sys/thread_local/mod.rs

@@ -99,6 +99,7 @@ pub(crate) mod guard {
             target_os = "uefi",
             target_os = "zkvm",
             target_os = "trusty",
+            target_os = "vexos",
         ) => {
             pub(crate) fn enable() {
                 // FIXME: Right now there is no concept of "thread exit" on