Merge pull request #67 from Neotron-Compute/stack-paint

Increase core0 stack to 8K and paint/measure stack usage.

Author: thejpster

.cargo/config.toml

@@ -2,8 +2,7 @@
 # This will make a UF2 and copy it to the RP2040's Mass Storage Device bootloader
 # runner = "elf2uf2-rs -d"
 # This will flash over SWD with any compatible probe it finds. You need 0.3.1 or higher for RP2040 support.
-runner = "probe-run --chip RP2040 --measure-stack"
-
+runner = "probe-run --chip RP2040"
 rustflags = [
   # This is needed if your flash or ram addresses are not aligned to 0x10000 in memory.x
   # See https://github.com/rust-embedded/cortex-m-quickstart/pull/95
@@ -17,4 +16,4 @@ rustflags = [
 ]
 
 [build]
-target = "thumbv6m-none-eabi"        # Cortex-M0 and Cortex-M0+
+target = "thumbv6m-none-eabi" # Cortex-M0 and Cortex-M0+

Cargo.toml

@@ -77,3 +77,6 @@ lto = true
 # good choice for performance on the RP2040, where code executes from external
 # SPI Flash and has to be buffered in a small on-chip cache memory.
 opt-level = "s"
+
+[features]
+check-stack = []

memory.x

@@ -25,37 +25,15 @@ MEMORY {
     /*
      * This is the bottom of the four striped banks of SRAM in the RP2040.
      */
-    RAM_OS : ORIGIN = 0x20000000, LENGTH = 0x3A000
+    RAM_OS : ORIGIN = 0x20000000, LENGTH = 232K
     /*
-     * This is the top of the four striped banks of SRAM in the RP2040.
+     * This is the top of the four striped banks of SRAM in the RP2040, plus SRAM_BANK4 and SRAM_BANK5.
      *
-     * We give ourselves six 4K pages [0x3A_000, 0x40_000]
+     * We give ourselves eight 4K pages [0x3A_000..0x41_FFF]
      */
-    RAM : ORIGIN = 0x2003A000, LENGTH = 24K
-    /*
-     * This is the fifth bank, a 4KB block. We use this for Core 0 Stack.
-     */
-    RAM_CORE0_STACK : ORIGIN = 0x20040000, LENGTH = 4K
-    /*
-     * This is the sixth bank, a 4KB block. We use this for Core 1 Stack.
-     */
-    RAM_CORE1_STACK : ORIGIN = 0x20041000, LENGTH = 4K
+    RAM : ORIGIN = 0x2003A000, LENGTH = 32K
 }
 
-/*
- * This is where the call stack for Core 0 will be located. The stack is of
- * the full descending type. You may want to use this variable to locate the
- * call stack and static variables in different memory regions. Below is
- * shown the default value
- */
-_stack_start = ORIGIN(RAM_CORE0_STACK) + LENGTH(RAM_CORE0_STACK);
-
-/*
- * This is where the call stack for Core 1 will be located.
- */
-_core1_stack_bottom = ORIGIN(RAM_CORE1_STACK);
-_core1_stack_len = LENGTH(RAM_CORE1_STACK);
-
 /*
  * Export some symbols to tell the BIOS where it might find the OS.
  */

src/main.rs

@@ -249,6 +249,9 @@ pub static OS_IMAGE: [u8; include_bytes!("thumbv6m-none-eabi-flash1002-libneotro
 /// is currently active (low).
 static INTERRUPT_PENDING: AtomicBool = AtomicBool::new(false);
 
+/// Stack for Core 1
+static mut CORE1_STACK: [usize; 256] = [0; 256];
+
 /// The table of API calls we provide the OS
 static API_CALLS: common::Api = common::Api {
 	api_version_get,
@@ -311,6 +314,12 @@ extern "C" {
 	static mut _ram_os_len: u32;
 }
 
+/// What we paint Core 0's stack with
+const CORE0_STACK_PAINT_WORD: usize = 0xBBBB_BBBB;
+
+/// What we paint Core 1's stack with
+const CORE1_STACK_PAINT_WORD: usize = 0xCCCC_CCCC;
+
 // -----------------------------------------------------------------------------
 // Functions
 // -----------------------------------------------------------------------------
@@ -333,6 +342,30 @@ fn main() -> ! {
 	// Reset the spinlocks.
 	pp.SIO.spinlock[31].reset();
 
+	{
+		// Paint the stack
+		extern "C" {
+			static mut __sheap: usize;
+			static mut _stack_start: usize;
+		}
+		let stack_len = unsafe {
+			(&_stack_start as *const usize as usize) - (&__sheap as *const usize as usize)
+		};
+		// But not the top 64 words, because we're using the stack right now!
+		let stack = unsafe {
+			core::slice::from_raw_parts_mut(
+				&mut __sheap as *mut usize,
+				(stack_len / core::mem::size_of::<usize>()) - 256,
+			)
+		};
+		info!("Painting {:?}", stack.as_ptr_range());
+		for b in stack.iter_mut() {
+			*b = CORE0_STACK_PAINT_WORD;
+		}
+	}
+
+	check_stacks();
+
 	// Needed by the clock setup
 	let mut watchdog = hal::watchdog::Watchdog::new(pp.WATCHDOG);
 
@@ -1897,6 +1930,7 @@ extern "C" fn bus_interrupt_status() -> u32 {
 /// media is indicated with a boolean field in the
 /// `block_dev::DeviceInfo` structure.
 pub extern "C" fn block_dev_get_info(device: u8) -> common::Option<common::block_dev::DeviceInfo> {
+	check_stacks();
 	match device {
 		0 => {
 			let mut lock = HARDWARE.lock();
@@ -1970,6 +2004,7 @@ pub extern "C" fn block_read(
 	data: common::ApiBuffer,
 ) -> common::Result<()> {
 	use embedded_sdmmc::BlockDevice;
+	check_stacks();
 	if data.data_len != usize::from(num_blocks) * 512 {
 		return common::Result::Err(common::Error::UnsupportedConfiguration(0));
 	}
@@ -2087,6 +2122,53 @@ fn IO_IRQ_BANK0() {
 	cortex_m::asm::sev();
 }
 
+/// Measure how much stack space remains unused.
+#[cfg(feature = "check-stack")]
+fn check_stacks() {
+	extern "C" {
+		static mut __sheap: usize;
+		static mut _stack_start: usize;
+	}
+	let stack_len =
+		unsafe { (&_stack_start as *const usize as usize) - (&__sheap as *const usize as usize) };
+	check_stack(
+		unsafe { &__sheap as *const usize },
+		stack_len,
+		CORE0_STACK_PAINT_WORD,
+	);
+	check_stack(
+		unsafe { CORE1_STACK.as_ptr() },
+		unsafe { CORE1_STACK.len() * core::mem::size_of::<usize>() },
+		CORE1_STACK_PAINT_WORD,
+	);
+}
+
+/// Dummy stack checker that does nothing
+#[cfg(not(feature = "check-stack"))]
+fn check_stacks() {}
+
+/// Check an individual stack to see how much has been used
+#[cfg(feature = "check-stack")]
+fn check_stack(start: *const usize, stack_len_bytes: usize, check_word: usize) {
+	let mut p: *const usize = start;
+	let mut free_bytes = 0;
+	loop {
+		let value = unsafe { p.read_volatile() };
+		if value != check_word {
+			break;
+		}
+		// Safety: We must hit a used stack value somewhere!
+		p = unsafe { p.offset(1) };
+		free_bytes += core::mem::size_of::<usize>();
+	}
+	defmt::debug!(
+		"Stack free at 0x{:08x}: {} bytes used of {} bytes",
+		start,
+		stack_len_bytes - free_bytes,
+		stack_len_bytes
+	);
+}
+
 /// Called when the CPU Hard Faults.
 ///
 /// This probably means something panicked, and the Rust code was compiled to

src/vga/mod.rs

@@ -1027,29 +1027,30 @@ pub fn init(
 	// cannot be reconfigured at a later time, but they do keep on running
 	// as-is.
 
-	let core1_stack: &'static mut [usize] = unsafe {
-		extern "C" {
-			static mut _core1_stack_bottom: usize;
-			static mut _core1_stack_len: usize;
+	unsafe {
+		for b in super::CORE1_STACK.iter_mut() {
+			*b = super::CORE1_STACK_PAINT_WORD;
 		}
-		core::slice::from_raw_parts_mut(
-			&mut _core1_stack_bottom as *mut _,
-			&mut _core1_stack_len as *const _ as usize / 4,
-		)
-	};
+	}
 
 	debug!(
 		"Core 1 stack: {:08x}, {} bytes",
-		core1_stack.as_ptr(),
-		core1_stack.len()
+		unsafe { super::CORE1_STACK.as_ptr() },
+		unsafe { super::CORE1_STACK.len() * core::mem::size_of::<usize>() }
 	);
 
 	// No-one else is looking at this right now.
 	unsafe {
 		TEXT_COLOUR_LOOKUP.init(&VIDEO_PALETTE);
 	}
 
-	multicore_launch_core1_with_stack(core1_main, core1_stack, ppb, fifo, psm);
+	multicore_launch_core1_with_stack(
+		core1_main,
+		unsafe { &mut super::CORE1_STACK },
+		ppb,
+		fifo,
+		psm,
+	);
 
 	debug!("Core 1 running");
 }