Support block read/write on a disk image.

Also switches to clap for args.

Author: thejpster

.gitignore

@@ -12,3 +12,7 @@ Cargo.lock
 # Shared libraries from OS build
 *.dylib
 *.so
+
+# Our uncompressed disk image
+disk.img
+

Cargo.toml

@@ -14,3 +14,5 @@ libloading = "0.7"
 pix-engine = "0.5.4"
 env_logger = "0.9"
 log = "0.4"
+clap = { version="4.2", features=["derive"] }
+

disk.img.gz

@@ -27,8 +27,10 @@
 // Imports
 // ===========================================================================
 
+use std::io::prelude::*;
 use std::sync::atomic::{AtomicU32, AtomicU8, Ordering};
 
+use clap::Parser;
 use common::video::RGBColour;
 use log::{debug, info};
 use pix_engine::prelude::*;
@@ -60,10 +62,33 @@ struct Framebuffer<const N: usize> {
 	contents: std::cell::UnsafeCell<[u8; N]>,
 }
 
+/// A Desktop GUI version of a Neotron BIOS
+#[derive(Parser)]
+#[command(author, version, about)]
+struct Args {
+	/// Path to the OS library
+	#[arg(long)]
+	os: std::path::PathBuf,
+	/// Path to a file to use as a disk image
+	#[arg(long)]
+	disk: Option<std::path::PathBuf>,
+}
+
+/// All our emulated hardware
+struct Hardware {
+	/// When we booted up
+	boot_time: std::time::Instant,
+	/// Our disk image
+	disk_file: Option<std::fs::File>,
+}
+
 // ===========================================================================
 // Global Variables
 // ===========================================================================
 
+/// We only have 'normal' sectored emulated disks
+const BLOCK_SIZE: usize = 512;
+
 /// The VRAM we share in a very hazardous way with the OS.
 ///
 /// Big enough for 640x480 @ 256 colour.
@@ -74,7 +99,7 @@ static FRAMEBUFFER: Framebuffer<{ 640 * 480 }> = Framebuffer::new();
 const SCALE_FACTOR: f32 = 2.0;
 
 /// When we booted up
-static BOOT_TIME: std::sync::Mutex<Option<std::time::Instant>> = std::sync::Mutex::new(None);
+static HARDWARE: std::sync::Mutex<Option<Hardware>> = std::sync::Mutex::new(None);
 
 /// The functions we export to the OS
 static BIOS_API: common::Api = common::Api {
@@ -667,10 +692,20 @@ static EV_QUEUE: std::sync::Mutex<Option<std::sync::mpsc::Receiver<AppEvent>>> =
 fn main() {
 	env_logger::init();
 
+	let args = Args::parse();
+
 	// Let's go!
 	info!("Netron Desktop BIOS");
 
-	*BOOT_TIME.lock().unwrap() = Some(std::time::Instant::now());
+	{
+		let mut hw = HARDWARE.lock().unwrap();
+		*hw = Some(Hardware {
+			boot_time: std::time::Instant::now(),
+			disk_file: args
+				.disk
+				.map(|path| std::fs::File::open(path).expect("open disk file")),
+		});
+	}
 
 	let white_on_black = common::video::Attr::new(
 		common::video::TextForegroundColour::WHITE,
@@ -685,14 +720,9 @@ fn main() {
 	}
 
 	// Process args
-	let mut lib = None;
-	for arg in std::env::args() {
-		if let Some(os_path) = arg.strip_prefix("--os=") {
-			info!("Loading OS from {:?}", os_path);
-			lib = unsafe { Some(libloading::Library::new(os_path).expect("library to load")) };
-			println!("Loaded!");
-		}
-	}
+	info!("Loading OS from {}", args.os.display());
+	let lib = unsafe { libloading::Library::new(args.os).expect("library to load") };
+	println!("Loaded!");
 
 	// Make a window
 	let mut engine = PixEngine::builder()
@@ -713,7 +743,6 @@ fn main() {
 	EV_QUEUE.lock().unwrap().replace(receiver);
 
 	// Run the OS
-	let lib = lib.unwrap();
 	std::thread::spawn(move || unsafe {
 		// Wait for Started message
 		let queue = EV_QUEUE.lock().unwrap();
@@ -1311,7 +1340,9 @@ extern "C" fn bus_exchange(_buffer: common::ApiBuffer) -> common::Result<()> {
 }
 
 extern "C" fn time_ticks_get() -> common::Ticks {
-	let boot_time = BOOT_TIME.lock().unwrap().unwrap();
+	let mut hw_guard = HARDWARE.lock().unwrap();
+	let hw = hw_guard.as_mut().unwrap();
+	let boot_time = hw.boot_time;
 	let difference = boot_time.elapsed();
 	debug!("time_ticks_get() -> {}", difference.as_millis());
 	common::Ticks(difference.as_millis() as u64)
@@ -1330,7 +1361,25 @@ extern "C" fn bus_interrupt_status() -> u32 {
 
 extern "C" fn block_dev_get_info(dev_id: u8) -> common::Option<common::block_dev::DeviceInfo> {
 	debug!("block_dev_get_info(dev_id: {})", dev_id);
-	common::Option::None
+	let mut hw_guard = HARDWARE.lock().unwrap();
+	let hw = hw_guard.as_mut().unwrap();
+	if dev_id == 0 {
+		match &mut hw.disk_file {
+			Some(file) => common::Option::Some(common::block_dev::DeviceInfo {
+				name: common::ApiString::new("File0"),
+				device_type: common::block_dev::DeviceType::HardDiskDrive,
+				block_size: BLOCK_SIZE as u32,
+				num_blocks: file.metadata().unwrap().len() / (BLOCK_SIZE as u64),
+				ejectable: false,
+				removable: false,
+				media_present: true,
+				read_only: false,
+			}),
+			None => common::Option::None,
+		}
+	} else {
+		common::Option::None
+	}
 }
 
 extern "C" fn block_dev_eject(dev_id: u8) -> common::Result<()> {
@@ -1348,20 +1397,66 @@ extern "C" fn block_write(
 		"block_write(dev_id: {}, block_id: {}, num_blocks: {}, buffer_len: {})",
 		dev_id, block_idx.0, num_blocks, buffer.data_len
 	);
-	common::Result::Ok(())
+	let mut hw_guard = HARDWARE.lock().unwrap();
+	let hw = hw_guard.as_mut().unwrap();
+	if dev_id == 0 {
+		match &mut hw.disk_file {
+			Some(file) => {
+				if file
+					.seek(std::io::SeekFrom::Start(block_idx.0 * BLOCK_SIZE as u64))
+					.is_err()
+				{
+					return common::Result::Err(common::Error::BlockOutOfBounds);
+				}
+				let buffer_slice = &buffer.as_slice()[0..usize::from(num_blocks) * BLOCK_SIZE];
+				if let Err(e) = file.write_all(buffer_slice) {
+					log::warn!("Failed to write to disk image: {:?}", e);
+					return common::Result::Err(common::Error::DeviceError(0));
+				}
+				common::Result::Ok(())
+			}
+			None => common::Result::Err(common::Error::DeviceError(0)),
+		}
+	} else {
+		common::Result::Err(common::Error::InvalidDevice)
+	}
 }
 
 extern "C" fn block_read(
 	dev_id: u8,
 	block_idx: common::block_dev::BlockIdx,
 	num_blocks: u8,
-	buffer: common::ApiBuffer,
+	mut buffer: common::ApiBuffer,
 ) -> common::Result<()> {
 	debug!(
 		"block_read(dev_id: {}, block_id: {}, num_blocks: {}, buffer_len: {})",
 		dev_id, block_idx.0, num_blocks, buffer.data_len
 	);
-	common::Result::Ok(())
+	let mut hw_guard = HARDWARE.lock().unwrap();
+	let hw = hw_guard.as_mut().unwrap();
+	if dev_id == 0 {
+		match &mut hw.disk_file {
+			Some(file) => {
+				if file
+					.seek(std::io::SeekFrom::Start(block_idx.0 * BLOCK_SIZE as u64))
+					.is_err()
+				{
+					return common::Result::Err(common::Error::BlockOutOfBounds);
+				}
+				if let Some(buffer_slice) = buffer.as_mut_slice() {
+					let buffer_slice = &mut buffer_slice[0..usize::from(num_blocks) * BLOCK_SIZE];
+					if let Err(e) = file.read_exact(buffer_slice) {
+						log::warn!("Failed to read from disk image: {:?}", e);
+						return common::Result::Err(common::Error::DeviceError(0));
+					}
+				}
+				common::Result::Ok(())
+			}
+			None => common::Result::Err(common::Error::DeviceError(0)),
+		}
+	} else {
+		common::Result::Err(common::Error::InvalidDevice)
+	}
 }
 
 extern "C" fn block_verify(
@@ -1374,7 +1469,34 @@ extern "C" fn block_verify(
 		"block_read(dev_id: {}, block_id: {}, num_blocks: {}, buffer_len: {})",
 		dev_id, block_idx.0, num_blocks, buffer.data_len
 	);
-	common::Result::Ok(())
+	let mut hw_guard = HARDWARE.lock().unwrap();
+	let hw = hw_guard.as_mut().unwrap();
+	if dev_id == 0 {
+		match &mut hw.disk_file {
+			Some(file) => {
+				if file
+					.seek(std::io::SeekFrom::Start(block_idx.0 * BLOCK_SIZE as u64))
+					.is_err()
+				{
+					return common::Result::Err(common::Error::BlockOutOfBounds);
+				}
+				let buffer_slice = &buffer.as_slice()[0..usize::from(num_blocks) * BLOCK_SIZE];
+				let mut read_buffer = vec![0u8; buffer_slice.len()];
+				if let Err(e) = file.read_exact(&mut read_buffer) {
+					log::warn!("Failed to write to disk image: {:?}", e);
+					return common::Result::Err(common::Error::DeviceError(0));
+				}
+				if read_buffer.as_slice() == buffer_slice {
+					common::Result::Ok(())
+				} else {
+					common::Result::Err(common::Error::DeviceError(1))
+				}
+			}
+			None => common::Result::Err(common::Error::DeviceError(0)),
+		}
+	} else {
+		common::Result::Err(common::Error::InvalidDevice)
+	}
 }
 
 extern "C" fn power_idle() {
@@ -1534,7 +1656,7 @@ impl AppState for MyApp {
 
 impl<const N: usize> Framebuffer<N> {
 	/// Create a new blank Framebuffer.
-	/// 
+	///
 	/// Everything is zero initialised.
 	const fn new() -> Framebuffer<N> {
 		Framebuffer {
@@ -1543,9 +1665,9 @@ impl<const N: usize> Framebuffer<N> {
 	}
 
 	/// Set a byte in the framebuffer.
-	/// 
+	///
 	/// Panics if you try and write out of bounds.
-	/// 
+	///
 	/// Uses volatile writes.
 	fn write_at(&self, offset: usize, value: u8) {
 		if offset > std::mem::size_of_val(&self.contents) {
@@ -1559,9 +1681,9 @@ impl<const N: usize> Framebuffer<N> {
 	}
 
 	/// Get a byte from the framebuffer.
-	/// 
+	///
 	/// Panics if you try and read out of bounds.
-	/// 
+	///
 	/// Uses volatile reads.
 	fn get_at(&self, offset: usize) -> u8 {
 		if offset > std::mem::size_of_val(&self.contents) {