Use latest API crate.

Author: thejpster

Cargo.lock

@@ -1,7 +1,10 @@
 [package]
 name = "neotron-os"
 version = "0.3.3"
-authors = ["Jonathan 'theJPster' Pallant <[email protected]>", "The Neotron Developers"]
+authors = [
+    "Jonathan 'theJPster' Pallant <[email protected]>",
+    "The Neotron Developers"
+]
 edition = "2018"
 description = "The Neotron Operating System"
 license = "GPL-3.0-or-later"
@@ -46,3 +49,4 @@ serde = { version = "1.0", default-features = false }
 menu = "0.3"
 chrono = { version = "0.4", default-features = false }
 embedded-sdmmc = { version = "0.5", default-features = false }
+neotron-api = { path = "../neotron-api" }

Cargo.toml

@@ -131,6 +131,25 @@ impl Api {
 /// Represents the serial port we can use as a text input/output device.
 struct SerialConsole(u8);
 
+impl SerialConsole {
+    fn write_bstr(&mut self, data: &[u8]) -> core::fmt::Result {
+        let api = API.get();
+        let is_panic = IS_PANIC.load(Ordering::SeqCst);
+        let res = (api.serial_write)(
+            // Which port
+            self.0,
+            // Data
+            bios::ApiByteSlice::new(data),
+            // No timeout
+            bios::Option::None,
+        );
+        if !is_panic {
+            res.unwrap();
+        }
+        Ok(())
+    }
+}
+
 impl core::fmt::Write for SerialConsole {
     fn write_str(&mut self, data: &str) -> core::fmt::Result {
         let api = API.get();

src/lib.rs

@@ -3,7 +3,29 @@
 use crate::{print, println};
 
 #[allow(unused)]
-static CALLBACK_TABLE: Api = Api { print: print_fn };
+static CALLBACK_TABLE: neotron_api::Api = neotron_api::Api {
+    open: api_open,
+    close: api_close,
+    write: api_write,
+    read: api_read,
+    seek_set: api_seek_set,
+    seek_cur: api_seek_cur,
+    seek_end: api_seek_end,
+    rename: api_rename,
+    ioctl: api_ioctl,
+    opendir: api_opendir,
+    closedir: api_closedir,
+    readdir: api_readdir,
+    stat: api_stat,
+    fstat: api_fstat,
+    deletefile: api_deletefile,
+    deletedir: api_deletedir,
+    chdir: api_chdir,
+    dchdir: api_dchdir,
+    pwd: api_pwd,
+    malloc: api_malloc,
+    free: api_free,
+};
 
 /// Ways in which loading a program can fail.
 #[derive(Debug)]
@@ -12,6 +34,8 @@ pub enum Error {
     ProgramTooLarge,
     /// A filesystem error occurred
     Filesystem(embedded_sdmmc::Error<neotron_common_bios::Error>),
+    /// Start Address didn't look right
+    BadAddress(u32),
 }
 
 impl From<embedded_sdmmc::Error<neotron_common_bios::Error>> for Error {
@@ -20,13 +44,6 @@ impl From<embedded_sdmmc::Error<neotron_common_bios::Error>> for Error {
     }
 }
 
-#[allow(unused)]
-#[repr(C)]
-/// The API we give to applications.
-pub struct Api {
-    pub print: extern "C" fn(data: *const u8, len: usize),
-}
-
 /// Represents the Transient Program Area.
 ///
 /// This is a piece of memory that can be used for loading and executing programs.
@@ -139,10 +156,31 @@ impl TransientProgramArea {
     /// of view of this API. You wanted to run a program, and the program was
     /// run.
     pub fn execute(&mut self) -> Result<i32, Error> {
+        // Read start-ptr as a 32-bit value
         let application_ram = self.as_slice_u32();
-        let start_ptr = application_ram[0] as *const ();
+        let start_addr = application_ram[0];
+        // But now we want RAM as u8 values, as start_ptr will be an odd number
+        // because it's a Thumb2 address and that's a u16 aligned value, plus 1
+        // to indicate Thumb2 mode.
+        let application_ram = self.as_slice_u8();
+        print!("Start address 0x{:08x}:", start_addr);
+        // Does this start pointer look OK?
+        if (start_addr & 1) != 1 {
+            println!("not thumb2 func");
+            return Err(Error::BadAddress(start_addr));
+        }
+        if !application_ram
+            .as_ptr_range()
+            .contains(&(start_addr as *const u8))
+        {
+            println!("out of bounds");
+            return Err(Error::BadAddress(start_addr));
+        }
+        println!("OK!");
+        drop(application_ram);
         let result = unsafe {
-            let code: extern "C" fn(*const Api) -> i32 = ::core::mem::transmute(start_ptr);
+            let code: extern "C" fn(*const neotron_api::Api) -> i32 =
+                ::core::mem::transmute(start_addr);
             code(&CALLBACK_TABLE)
         };
         Ok(result)
@@ -160,6 +198,183 @@ extern "C" fn print_fn(data: *const u8, len: usize) {
     }
 }
 
+/// Open a file, given a path as UTF-8 string.
+///
+/// If the file does not exist, or is already open, it returns an error.
+///
+/// Path may be relative to current directory, or it may be an absolute
+/// path.
+extern "C" fn api_open(
+    _path: neotron_api::FfiString,
+    _flags: neotron_api::file::Flags,
+) -> neotron_api::Result<neotron_api::file::Handle> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Close a previously opened file.
+extern "C" fn api_close(_fd: neotron_api::file::Handle) -> neotron_api::Result<()> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Write to an open file handle, blocking until everything is written.
+///
+/// Some files do not support writing and will produce an error.
+extern "C" fn api_write(
+    fd: neotron_api::file::Handle,
+    buffer: neotron_api::FfiByteSlice,
+) -> neotron_api::Result<()> {
+    if fd == neotron_api::file::Handle::new_stdout() {
+        if let Some(ref mut console) = unsafe { &mut crate::VGA_CONSOLE } {
+            console.write_bstr(buffer.as_slice());
+        }
+        if let Some(ref mut console) = unsafe { &mut crate::SERIAL_CONSOLE } {
+            if let Err(_e) = console.write_bstr(buffer.as_slice()) {
+                return neotron_api::Result::Err(neotron_api::Error::DeviceSpecific);
+            }
+        }
+        neotron_api::Result::Ok(())
+    } else {
+        neotron_api::Result::Err(neotron_api::Error::BadHandle)
+    }
+}
+
+/// Read from an open file, returning how much was actually read.
+///
+/// If you hit the end of the file, you might get less data than you asked for.
+extern "C" fn api_read(
+    _fd: neotron_api::file::Handle,
+    _buffer: neotron_api::FfiBuffer,
+) -> neotron_api::Result<usize> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Move the file offset (for the given file handle) to the given position.
+///
+/// Some files do not support seeking and will produce an error.
+extern "C" fn api_seek_set(
+    _fd: neotron_api::file::Handle,
+    _position: u64,
+) -> neotron_api::Result<()> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Move the file offset (for the given file handle) relative to the current position
+///
+/// Some files do not support seeking and will produce an error.
+extern "C" fn api_seek_cur(
+    _fd: neotron_api::file::Handle,
+    _offset: i64,
+) -> neotron_api::Result<u64> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Move the file offset (for the given file handle) to the end of the file
+///
+/// Some files do not support seeking and will produce an error.
+extern "C" fn api_seek_end(_fd: neotron_api::file::Handle) -> neotron_api::Result<u64> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Rename a file
+extern "C" fn api_rename(
+    _old_path: neotron_api::FfiString,
+    _new_path: neotron_api::FfiString,
+) -> neotron_api::Result<()> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Perform a special I/O control operation.
+extern "C" fn api_ioctl(
+    _fd: neotron_api::file::Handle,
+    _command: u64,
+    _value: u64,
+) -> neotron_api::Result<u64> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Open a directory, given a path as a UTF-8 string.
+extern "C" fn api_opendir(
+    _path: neotron_api::FfiString,
+) -> neotron_api::Result<neotron_api::dir::Handle> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Close a previously opened directory.
+extern "C" fn api_closedir(_dir: neotron_api::dir::Handle) -> neotron_api::Result<()> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Read from an open directory
+extern "C" fn api_readdir(
+    _dir: neotron_api::dir::Handle,
+) -> neotron_api::Result<neotron_api::dir::Entry> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Get information about a file
+extern "C" fn api_stat(
+    _path: neotron_api::FfiString,
+) -> neotron_api::Result<neotron_api::file::Stat> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Get information about an open file
+extern "C" fn api_fstat(
+    _fd: neotron_api::file::Handle,
+) -> neotron_api::Result<neotron_api::file::Stat> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Delete a file.
+///
+/// If the file is currently open this will give an error.
+extern "C" fn api_deletefile(_path: neotron_api::FfiString) -> neotron_api::Result<()> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Delete a directory
+///
+/// If the directory has anything in it, this will give an error.
+extern "C" fn api_deletedir(_path: neotron_api::FfiString) -> neotron_api::Result<()> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Change the current directory
+///
+/// Relative file paths are taken to be relative to the current directory.
+///
+/// Unlike on MS-DOS, there is only one current directory for the whole
+/// system, not one per drive.
+extern "C" fn api_chdir(_path: neotron_api::FfiString) -> neotron_api::Result<()> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Change the current directory to the open directory
+///
+/// Relative file paths are taken to be relative to the current directory.
+///
+/// Unlike on MS-DOS, there is only one current directory for the whole
+/// system, not one per drive.
+extern "C" fn api_dchdir(_dir: neotron_api::dir::Handle) -> neotron_api::Result<()> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Obtain the current working directory.
+extern "C" fn api_pwd(_path: neotron_api::FfiBuffer) -> neotron_api::Result<usize> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Allocate some memory
+extern "C" fn api_malloc(
+    _size: usize,
+    _alignment: usize,
+) -> neotron_api::Result<*mut core::ffi::c_void> {
+    neotron_api::Result::Err(neotron_api::Error::Unimplemented)
+}
+
+/// Free some previously allocated memory
+extern "C" fn api_free(_ptr: *mut core::ffi::c_void, _size: usize, _alignment: usize) {}
+
 // ===========================================================================
 // End of file
 // ===========================================================================