vexos: block on stdout writes with size>2048

Author: tropicaaal

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

@@ -194,7 +194,6 @@ 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() })?;

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

@@ -7,6 +7,7 @@ pub mod time;
 
 use crate::arch::global_asm;
 use crate::ptr::{self, addr_of_mut};
+use crate::sys::stdio;
 use crate::time::{Duration, Instant};
 
 global_asm!(
@@ -53,15 +54,13 @@ pub unsafe fn init(_argc: isize, _argv: *const *const u8, _sigpipe: u8) {}
 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)
-        {
+        if vex_sdk::vexSerialWriteFree(stdio::STDIO_CHANNEL) == (stdio::STDOUT_BUF_SIZE as i32) {
             break;
         }
     }

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

@@ -4,7 +4,7 @@ pub struct Stdin;
 pub struct Stdout;
 pub type Stderr = Stdout;
 
-const STDIO_CHANNEL: u32 = 1;
+pub const STDIO_CHANNEL: u32 = 1;
 
 impl Stdin {
     pub const fn new() -> Stdin {
@@ -14,7 +14,7 @@ impl Stdin {
 
 impl io::Read for Stdin {
     fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
-        let mut written = 0;
+        let mut count = 0;
 
         while let Some((out_byte, new_buf)) = buf.split_first_mut() {
             buf = new_buf;
@@ -25,10 +25,10 @@ impl io::Read for Stdin {
             }
 
             *out_byte = byte as u8;
-            written += 1;
+            count += 1;
         }
 
-        Ok(written)
+        Ok(count)
     }
 }
 
@@ -40,20 +40,48 @@ impl Stdout {
 
 impl io::Write for Stdout {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let written =
-            unsafe { vex_sdk::vexSerialWriteBuffer(STDIO_CHANNEL, buf.as_ptr(), buf.len() as u32) };
-
-        if written < 0 {
-            return Err(io::Error::new(
-                io::ErrorKind::Uncategorized,
-                "Internal write error occurred.",
-            ));
+        let mut written = 0;
+
+        // HACK: VEXos holds an internal ringbuffer for serial writes that is flushed to USB1
+        // roughly every millisecond by `vexTasksRun`. For writes larger than 2048 bytes, we
+        // must block until that buffer is flushed to USB1 before writing the rest of `buf`.
+        //
+        // This is fairly nonstandard for a `write` implementation, but it avoids a guaranteed
+        // recursive panic when using macros such as `print!` to write large amounts of data
+        // (buf.len() > 2048) to stdout at once.
+        for chunk in buf.chunks(STDOUT_BUF_SIZE) {
+            if unsafe { vex_sdk::vexSerialWriteFree(STDIO_CHANNEL) as usize } < chunk.len() {
+                self.flush().unwrap();
+            }
+
+            let count = unsafe {
+                vex_sdk::vexSerialWriteBuffer(STDIO_CHANNEL, chunk.as_ptr(), chunk.len() as u32)
+            };
+            if count < 0 {
+                return Err(io::Error::new(
+                    io::ErrorKind::Uncategorized,
+                    "Internal write error occurred.",
+                ));
+            }
+
+            written += count;
+
+            // This is a sanity check to ensure that we don't end up with non-contiguous
+            // buffer writes. e.g. a chunk gets only partially written, but we continue
+            // attempting to write the remaining chunks.
+            //
+            // In practice, this should never really occur since the previous flush ensures
+            // enough space in FIFO to write the entire chunk to vexSerialWriteBuffer.
+            if count != chunk.len() {
+                break;
+            }
         }
 
         Ok(written as usize)
     }
 
     fn flush(&mut self) -> io::Result<()> {
+        // This may block for up to a millisecond.
         unsafe {
             while (vex_sdk::vexSerialWriteFree(STDIO_CHANNEL) as usize) != STDOUT_BUF_SIZE {
                 vex_sdk::vexTasksRun();