[library stdio]: Stdin Read implementition and a few more Error related changes

Author: safiworks

library/std/src/sys/pal/safaos/alloc.rs

@@ -22,7 +22,7 @@ impl Block {
         assert!(size <= isize::MAX as usize);
 
         let ptr = get_data_break() as *mut Block;
-        syscalls::syssbrk(size as isize).ok()?;
+        syscalls::sbrk(size as isize).ok()?;
         unsafe {
             *ptr = Self { free: true, data_len: size - size_of::<Block>(), ..Default::default() };
             Some(&mut *ptr)
@@ -50,7 +50,8 @@ struct SystemAllocator {
 }
 
 fn get_data_break() -> *mut u8 {
-    syscalls::syssbrk(0).unwrap()
+    // Should never fail
+    unsafe { syscalls::sbrk(0).unwrap_unchecked() }
 }
 
 impl SystemAllocator {
@@ -71,6 +72,7 @@ impl SystemAllocator {
         None
     }
 
+    #[inline]
     pub fn allocate(&mut self, size: usize) -> Option<NonNull<[u8]>> {
         if let Some(block) = self.find_block(size) {
             unsafe {
@@ -91,6 +93,7 @@ impl SystemAllocator {
         }
     }
 
+    #[inline]
     pub fn deallocate(&mut self, block_data: NonNull<u8>) {
         unsafe {
             let block_ptr = Block::block_from_data_ptr(block_data);
@@ -101,10 +104,11 @@ impl SystemAllocator {
 
 #[unstable(feature = "allocator_api", issue = "32838")]
 unsafe impl Allocator for Mutex<SystemAllocator> {
+    #[inline]
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, core::alloc::AllocError> {
         self.lock().unwrap().allocate(layout.size()).ok_or(core::alloc::AllocError)
     }
-
+    #[inline]
     unsafe fn deallocate(&self, ptr: NonNull<u8>, _: Layout) {
         self.lock().unwrap().deallocate(ptr)
     }
@@ -114,13 +118,14 @@ static GLOBAL_SYSTEM_ALLOCATOR: Mutex<SystemAllocator> = Mutex::new(SystemAlloca
 
 #[stable(feature = "alloc_system_type", since = "1.28.0")]
 unsafe impl GlobalAlloc for System {
+    #[inline]
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
         match GLOBAL_SYSTEM_ALLOCATOR.allocate(layout) {
             Ok(data) => data.as_ptr() as *mut u8,
             Err(core::alloc::AllocError) => ptr::null_mut(),
         }
     }
-
+    #[inline]
     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
         unsafe { GLOBAL_SYSTEM_ALLOCATOR.deallocate(NonNull::new_unchecked(ptr), layout) }
     }

library/std/src/sys/pal/safaos/stdio.rs

@@ -1,60 +1,72 @@
 use super::syscalls;
 use crate::io;
+
+#[stable(feature = "stdio", since = "1.0.0")]
+impl From<syscalls::ErrorStatus> for io::Error {
+    fn from(err: syscalls::ErrorStatus) -> io::Error {
+        let kind = err.into_io_error_kind();
+        let error = err.as_str();
+
+        io::Error::new(kind, error)
+    }
+}
+
 pub struct Stdin;
 pub struct Stdout;
 pub struct Stderr;
 
 impl Stdin {
+    pub const FD: usize = 0;
     pub const fn new() -> Stdin {
         Stdin
     }
 }
 
 impl io::Read for Stdin {
-    fn read(&mut self, _buf: &mut [u8]) -> io::Result<usize> {
-        Ok(0)
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        Ok(syscalls::read(Self::FD, -1, buf)?)
     }
 }
 
 impl Stdout {
+    const FD: usize = 1;
     pub const fn new() -> Stdout {
         Stdout
     }
 }
 
 impl io::Write for Stdout {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let mut dest_wrote = 0;
-        syscalls::syswrite(1, -1, buf.as_ptr(), buf.len(), &mut dest_wrote);
-        Ok(dest_wrote)
+        Ok(syscalls::write(Self::FD, -1, buf)?)
     }
 
     fn flush(&mut self) -> io::Result<()> {
-        syscalls::syssync(1);
-        Ok(())
+        Ok(syscalls::sync(1)?)
     }
 }
 
 impl Stderr {
+    // TODO: please add a seprate stderr fd
+    const FD: usize = Stdout::FD;
     pub const fn new() -> Stderr {
         Stderr
     }
 }
 
 impl io::Write for Stderr {
+    #[inline]
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let mut dest_wrote = 0;
-        syscalls::syswrite(2, -1, buf.as_ptr(), buf.len(), &mut dest_wrote);
-        Ok(dest_wrote)
+        let wrote = syscalls::write(Self::FD, -1, buf)?;
+        self.flush()?;
+        Ok(wrote)
     }
-
+    #[inline]
     fn flush(&mut self) -> io::Result<()> {
-        syscalls::syssync(2);
-        Ok(())
+        Ok(syscalls::sync(Self::FD)?)
     }
 }
 
-pub const STDIN_BUF_SIZE: usize = 0;
+pub const STDIN_BUF_SIZE: usize = 1024;
 
 pub fn is_ebadf(_err: &io::Error) -> bool {
     true