WIP add stack overflow check in yield

Author: salkinium

examples/avr/fiber/main.cpp

@@ -68,10 +68,10 @@ main()
 	MODM_LOG_INFO << "Starting fiber modm::yield benchmark..." << modm::endl;
 	MODM_LOG_INFO.flush();
 
-	fiber1.watermark_stack();
-	fiber2.watermark_stack();
-	fiber3.watermark_stack();
-	fiber4.watermark_stack();
+	fiber1.stack_watermark();
+	fiber2.stack_watermark();
+	fiber3.stack_watermark();
+	fiber4.stack_watermark();
 
 	const modm::PreciseTimestamp start = modm::PreciseClock::now();
 	modm::fiber::Scheduler::run();

examples/generic/fiber/main.cpp

@@ -90,8 +90,8 @@ main()
 	MODM_LOG_INFO << "Starting fiber modm::yield benchmark..." << modm::endl;
 	MODM_LOG_INFO.flush();
 
-	fiber_y1.watermark_stack();
-	fiber_y2.watermark_stack();
+	fiber_y1.stack_watermark();
+	fiber_y2.stack_watermark();
 	// fiber_y1, fiber_y2 were autostarted
 	{
 		modm::atomic::Lock l;
@@ -103,10 +103,10 @@ main()
 	MODM_LOG_INFO.flush();
 
 	// the rest is manually started
-	fiber1.start(); fiber1.watermark_stack();
-	fiber2.start(); fiber2.watermark_stack();
-	fiber3.start(); fiber3.watermark_stack();
-	fiber4.start(); fiber4.watermark_stack();
+	fiber1.start(); fiber1.stack_watermark();
+	fiber2.start(); fiber2.stack_watermark();
+	fiber3.start(); fiber3.stack_watermark();
+	fiber4.start(); fiber4.stack_watermark();
 	const modm::PreciseTimestamp start = modm::PreciseClock::now();
 	modm::fiber::Scheduler::run();
 	const auto diff = (modm::PreciseClock::now() - start);
@@ -125,8 +125,8 @@ main()
 	MODM_LOG_INFO << "F3 stack usage = " << fiber3.stack_usage() << modm::endl;
 	MODM_LOG_INFO << "F4 stack usage = " << fiber4.stack_usage() << modm::endl;
 
-	fiber_ping.watermark_stack();
-	fiber_pong.watermark_stack();
+	fiber_ping.stack_watermark();
+	fiber_pong.stack_watermark();
 	fiber_ping.start();
 	modm::fiber::Scheduler::run();
 

examples/generic/fiber_overflow/main.cpp

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2024, Niklas Hauser
+ *
+ * This file is part of the modm project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+// ----------------------------------------------------------------------------
+
+#include <modm/board.hpp>
+#include <modm/processing.hpp>
+
+using namespace Board;
+using namespace std::chrono_literals;
+
+
+bool overflow{false};
+
+modm::Fiber<> bad_fiber([]
+{
+	while(1)
+	{
+#ifdef __AVR__
+		if (overflow) asm volatile ("push r1");
+#else
+		if (overflow) asm volatile ("push {r0-r7}");
+#endif
+		modm::this_fiber::yield();
+	}
+});
+
+modm::Fiber<> blinky([]
+{
+	while(1)
+	{
+		Board::Leds::toggle();
+		modm::this_fiber::sleep_for(0.5s);
+		char c;
+		modm::log::info.get(c);
+		if (c == 'o') overflow = true;
+	}
+});
+
+int
+main()
+{
+	Board::initialize();
+	Board::Leds::setOutput();
+	MODM_LOG_INFO << "\nReboot!\nSend 'o' to overflow the stack!" << modm::endl;
+	modm::delay(1s);
+
+	modm::fiber::Scheduler::run();
+
+	return 0;
+}

examples/generic/fiber_overflow/project.xml

@@ -0,0 +1,14 @@
+<library>
+  <!-- <extends>modm:nucleo-u575zi-q</extends> -->
+  <!-- <extends>modm:nucleo-g071rb</extends> -->
+  <!-- <extends>modm:nucleo-l476rg</extends> -->
+  <extends>modm:mega-2560-pro</extends>
+  <!-- <extends>modm:arduino-uno</extends> -->
+  <options>
+    <option name="modm:build:build.path">../../../build/generic/fiber_overflow</option>
+  </options>
+  <modules>
+    <module>modm:build:scons</module>
+    <module>modm:processing:fiber</module>
+  </modules>
+</library>

examples/nucleo_g071rb/amnb_fiber/main.cpp

@@ -152,13 +152,13 @@ main()
 	USART4->CR3 = USART_CR3_HDSEL;
 	USART4->CR1 |= USART_CR1_UE;
 
-	fiberNode1t.watermark_stack();
-	fiberNode1r.watermark_stack();
-	fiberNode2t.watermark_stack();
-	fiberNode2r.watermark_stack();
-	fiberNode3t.watermark_stack();
-	fiberNode3r.watermark_stack();
-	thread.watermark_stack();
+	fiberNode1t.stack_watermark();
+	fiberNode1r.stack_watermark();
+	fiberNode2t.stack_watermark();
+	fiberNode2r.stack_watermark();
+	fiberNode3t.stack_watermark();
+	fiberNode3r.stack_watermark();
+	thread.stack_watermark();
 
 	modm::fiber::Scheduler::run();
 

examples/nucleo_u575zi-q/fiber_overflow/main.cpp

@@ -20,3 +20,33 @@ modm::log::Logger modm::log::debug(loggerDevice);
 modm::log::Logger modm::log::info(loggerDevice);
 modm::log::Logger modm::log::warning(loggerDevice);
 modm::log::Logger modm::log::error(loggerDevice);
+
+#include <modm/architecture/interface/accessor.hpp>
+
+modm_extern_c void
+modm_abandon(const modm::AssertionInfo &info)
+{
+	MODM_LOG_ERROR << IFSS("Assertion '") << modm::accessor::asFlash(info.name) << IFSS("'");
+	if (info.context != uintptr_t(-1)) {
+		MODM_LOG_ERROR << IFSS(" @ ") << (void *) info.context <<
+						 IFSS(" (") << (uint32_t) info.context << IFSS(")");
+	}
+	#if MODM_ASSERTION_INFO_HAS_DESCRIPTION
+	MODM_LOG_ERROR << IFSS(" failed!\n  ") << modm::accessor::asFlash(info.description) << IFSS("\nAbandoning...\n");
+	#else
+	MODM_LOG_ERROR << IFSS(" failed!\nAbandoning...\n");
+	#endif
+
+	Board::Leds::setOutput();
+	for(int times=10; times>=0; times--)
+	{
+		Board::Leds::write(1);
+		modm::delay_ms(20);
+		Board::Leds::write(0);
+		modm::delay_ms(180);
+	}
+	// Do not flush here otherwise you may deadlock due to waiting on the UART
+	// interrupt which may never be executed when abandoning in a higher
+	// priority Interrupt!!!
+	// MODM_LOG_ERROR << modm::flush;
+}

examples/nucleo_u575zi-q/fiber_overflow/project.xml

@@ -16,6 +16,7 @@
 #include <modm/debug/logger.hpp>
 %% elif core.startswith("avr")
 #include <avr/pgmspace.h>
+#include <avr/wdt.h>
 %% else
 #include <modm/platform/device.hpp>
 %% endif
@@ -77,6 +78,7 @@ modm_assert_report(_modm_assertion_info *cinfo)
 %% if core.startswith("cortex-m")
 		NVIC_SystemReset();
 %% elif core.startswith("avr")
+		wdt_enable(WDTO_30MS);
 		while(1) ;
 %% else
 		abort();

src/modm/board/mega_2560_pro/board_serial.cpp

@@ -64,43 +64,39 @@ modm_context_reset(modm_context_t *ctx);
  * Switches control from the main context to the fiber context. This initializes
  * the hardware and then jumps from the caller context into the `to` fiber.
  */
-void
+uintptr_t
 modm_context_start(modm_context_t *to);
 
 /**
  * Pushes the context onto the `from->sp` and pops the context from the `to->sp`
  * to jump from one fiber to the next.
  */
 void
-modm_context_jump(modm_context_t *from, modm_context_t *to) asm("modm_context_jump");
+modm_context_jump(modm_context_t *from, modm_context_t *to);
 
 /**
  * Switches control from the fiber context back to the main context.
  * Control flow then continues in the main context by returning from the
  * `modm_context_start()` function.
  */
 void modm_noreturn
-modm_context_end();
+modm_context_end(uintptr_t retval);
 
 /**
  * Zeros the register file and watermarks the rest of the stack.
  * You may call this function before or after `modm_context_reset()`, however,
  * *NOT* while the fiber is running!
  */
 void
-modm_context_watermark(modm_context_t *ctx);
+modm_context_stack_watermark(modm_context_t *ctx);
 
 /**
  * Returns the stack usage by searching from the bottom of the stack for the
  * watermark level. You may call this function at any point after calling
- * `modm_context_watermark()`.
+ * `modm_context_stack_watermark()`.
  */
 size_t
 modm_context_stack_usage(const modm_context_t *ctx);
-
-/// A cheap way to check if the last word of the stack was written.
-bool
-modm_context_stack_overflow(const modm_context_t *ctx);
 /// @}
 
 #ifdef __cplusplus