diff --git a/Marlin/M100_Free_Mem_Chk.cpp b/Marlin/M100_Free_Mem_Chk.cpp
index 01709c5d28a9a19a28080806034435ab73cb88da..de61d5bb22e56d45479f49b0d9339ba38625098f 100644
--- a/Marlin/M100_Free_Mem_Chk.cpp
+++ b/Marlin/M100_Free_Mem_Chk.cpp
@@ -26,227 +26,238 @@
* This code watches the free memory block between the bottom of the heap and the top of the stack.
* This memory block is initialized and watched via the M100 command.
*
- * M100 I Initializes the free memory block and prints vitals statistics about the area
- * M100 F Identifies how much of the free memory block remains free and unused. It also
- * detects and reports any corruption within the free memory block that may have
- * happened due to errant firmware.
- * M100 D Does a hex display of the free memory block along with a flag for any errant
- * data that does not match the expected value.
- * M100 C x Corrupts x locations within the free memory block. This is useful to check the
- * correctness of the M100 F and M100 D commands.
+ * M100 I Initializes the free memory block and prints vitals statistics about the area
+ *
+ * M100 F Identifies how much of the free memory block remains free and unused. It also
+ * detects and reports any corruption within the free memory block that may have
+ * happened due to errant firmware.
+ *
+ * M100 D Does a hex display of the free memory block along with a flag for any errant
+ * data that does not match the expected value.
+ *
+ * M100 C x Corrupts x locations within the free memory block. This is useful to check the
+ * correctness of the M100 F and M100 D commands.
*
* Initial version by Roxy-3D
*/
-#define M100_FREE_MEMORY_DUMPER // Comment out to remove Dump sub-command
-#define M100_FREE_MEMORY_CORRUPTOR // Comment out to remove Corrupt sub-command
+#define M100_FREE_MEMORY_DUMPER // Enable for the `M110 D` Dump sub-command
+#define M100_FREE_MEMORY_CORRUPTOR // Enable for the `M100 C` Corrupt sub-command
-#include "Marlin.h"
+#include "MarlinConfig.h"
#if ENABLED(M100_FREE_MEMORY_WATCHER)
+
+#define TEST_BYTE 0xE5
+
extern char* __brkval;
extern size_t __heap_start, __heap_end, __flp;
extern char __bss_end;
+#include "Marlin.h"
+#include "hex_print_routines.h"
+
//
-// Utility functions used by M100 to get its work done.
+// Utility functions
//
-#include "hex_print_routines.h"
+#define END_OF_HEAP() (__brkval ? __brkval : &__bss_end)
-char* top_of_stack();
-int how_many_E5s_are_here(char*);
-int free_memory_is_corrupted(); // int not bool!!!! it will tell us how many blocks of
- // free memory it found.
-void gcode_M100() {
- static bool m100_not_initialized = true;
- char* sp, *ptr;
- int i, j, n;
- //
- // M100 D dumps the free memory block from __brkval to the stack pointer.
- // malloc() eats memory from the start of the block and the stack grows
- // up from the bottom of the block. Solid 0xE5's indicate nothing has
- // used that memory yet. There should not be anything but 0xE5's within
- // the block of 0xE5's. If there is, that would indicate memory corruption
- // probably caused by bad pointers. Any unexpected values will be flagged in
- // the right hand column to help spotting them.
- //
- SERIAL_ECHOPAIR("\n__brkval : 0x", hex_word((uint16_t)__brkval) );
- SERIAL_ECHOPAIR("\n__bss_end : 0x", hex_word((uint16_t)&__bss_end));
- //
- // With out malloc() we need to be smart and use &__bss_end
- //
- ptr = __brkval ? __brkval : &__bss_end;
- SERIAL_ECHOPAIR("\nstart of free space : 0x", hex_word((uint16_t)ptr));
-
- sp = top_of_stack();
- SERIAL_ECHOLNPAIR("\nStack Pointer : 0x", hex_word((uint16_t)sp));
-
- #if ENABLED(M100_FREE_MEMORY_DUMPER) // Disable to remove Dump sub-command
- if (code_seen('D')) {
- //
- // We want to start and end the dump on a nice 16 byte boundry even though
- // the values we are using are not 16 byte aligned.
- //
- ptr = (char*) ((uint16_t) ptr & 0xfff0);
- sp = (char*) ((uint16_t) sp | 0x000f);
-
- n = sp - ptr;
- //
- // This is the main loop of the Dump command.
- //
- while (ptr < sp) {
- print_hex_word((uint16_t)ptr); // Print the address
- SERIAL_CHAR(':');
- for (i = 0; i < 16; i++) { // and 16 data bytes
- if (i==8)
- SERIAL_CHAR('-');
- print_hex_byte(*(ptr + i));
- SERIAL_CHAR(' ');
- }
- SERIAL_CHAR('|'); // now show where non 0xE5's are
- for (i = 0; i < 16; i++)
- SERIAL_CHAR((*(ptr + i) == (char)0xe5) ? ' ' : '?');
- SERIAL_EOL;
- ptr += 16;
- idle();
+// Location of a variable on its stack frame. Returns a value above
+// the stack (once the function returns to the caller).
+char* top_of_stack() {
+ char x;
+ return &x + 1; // x is pulled on return;
+}
+
+// Count the number of test bytes at the specified location.
+int16_t count_test_bytes(const char * const ptr) {
+ for (uint16_t i = 0; i < 32000; i++)
+ if (ptr[i] != TEST_BYTE)
+ return i - 1;
+
+ return -1;
+}
+
+// Return a count of free memory blocks.
+uint16_t free_memory_is_corrupted(char * const ptr, const uint16_t size) {
+ // Find the longest block of test bytes in the given buffer
+ uint16_t block_cnt = 0;
+ for (uint16_t i = 0; i < size; i++) {
+ if (ptr[i] == TEST_BYTE) {
+ const uint16_t j = count_test_bytes(ptr + i);
+ if (j > 8) {
+ //SERIAL_ECHOPAIR("Found ", j);
+ //SERIAL_ECHOLNPAIR(" bytes free at 0x", hex_word((uint16_t)ptr + i));
+ i += j;
+ block_cnt++;
}
- return;
}
- #endif
- //
- // M100 F requests the code to return the number of free bytes in the memory pool along with
- // other vital statistics that define the memory pool.
- //
- if (code_seen('F')) {
- int max_cnt = -1, block_cnt = 0;
- uint16_t max_addr=0;
- ptr = __brkval ? __brkval : &__bss_end;
- sp = top_of_stack();
- n = sp - ptr;
- // Scan through the range looking for the biggest block of 0xE5's we can find
- for (i = 0; i < n; i++) {
- if (*(ptr + i) == (char)0xe5) {
- j = how_many_E5s_are_here(ptr + i);
- if (j > 8) {
- SERIAL_ECHOPAIR("Found ", j);
- SERIAL_ECHOLNPAIR(" bytes free at 0x", hex_word((uint16_t)(ptr + i)));
- if (j > max_cnt) {
- max_cnt = j;
- max_addr = (uint16_t) ptr + i;
- }
- i += j;
- block_cnt++;
- }
+ }
+ //if (block_cnt > 1) {
+ // SERIAL_ECHOLNPGM("\nMemory Corruption detected in free memory area.");
+ // SERIAL_ECHOLNPAIR("\nLargest free block is ", max_cnt);
+ //}
+ return block_cnt;
+}
+
+//
+// M100 sub-commands
+//
+
+#if ENABLED(M100_FREE_MEMORY_DUMPER)
+ /**
+ * M100 D
+ * Dump the free memory block from __brkval to the stack pointer.
+ * malloc() eats memory from the start of the block and the stack grows
+ * up from the bottom of the block. Solid test bytes indicate nothing has
+ * used that memory yet. There should not be anything but test bytes within
+ * the block. If so, it may indicate memory corruption due to a bad pointer.
+ * Unexpected bytes are flagged in the right column.
+ */
+ void dump_free_memory(char *ptr, char *sp) {
+ //
+ // Start and end the dump on a nice 16 byte boundary
+ // (even though the values are not 16-byte aligned).
+ //
+ ptr = (char*)((uint16_t)ptr & 0xFFF0); // Align to 16-byte boundary
+ sp = (char*)((uint16_t)sp | 0x000F); // Align sp to the 15th byte (at or above sp)
+
+ // Dump command main loop
+ while (ptr < sp) {
+ print_hex_word((uint16_t)ptr); // Print the address
+ SERIAL_CHAR(':');
+ for (uint8_t i = 0; i < 16; i++) { // and 16 data bytes
+ if (i == 8) SERIAL_CHAR('-');
+ print_hex_byte(ptr[i]);
+ SERIAL_CHAR(' ');
}
+ SERIAL_CHAR('|'); // Point out non test bytes
+ for (uint8_t i = 0; i < 16; i++)
+ SERIAL_CHAR(ptr[i] == TEST_BYTE ? ' ' : '?');
+ SERIAL_EOL;
+ ptr += 16;
+ idle();
}
- if (block_cnt > 1) {
- SERIAL_ECHOLNPGM("\nMemory Corruption detected in free memory area.");
- SERIAL_ECHOPAIR("\nLargest free block is ", max_cnt);
- SERIAL_ECHOLNPAIR(" bytes big at 0x", hex_word(max_addr));
+ }
+#endif // M100_FREE_MEMORY_DUMPER
+
+/**
+ * M100 F
+ * Return the number of free bytes in the memory pool,
+ * with other vital statistics defining the pool.
+ */
+void free_memory_pool_report(const char * const ptr, const uint16_t size) {
+ int16_t max_cnt = -1;
+ uint16_t block_cnt = 0;
+ char *max_addr = NULL;
+ // Find the longest block of test bytes in the buffer
+ for (uint16_t i = 0; i < size; i++) {
+ char * const addr = ptr + i;
+ if (*addr == TEST_BYTE) {
+ const uint16_t j = count_test_bytes(addr);
+ if (j > 8) {
+ SERIAL_ECHOPAIR("Found ", j);
+ SERIAL_ECHOLNPAIR(" bytes free at 0x", hex_word((uint16_t)addr));
+ if (j > max_cnt) {
+ max_cnt = j;
+ max_addr = addr;
+ }
+ i += j;
+ block_cnt++;
+ }
}
- SERIAL_ECHOLNPAIR("free_memory_is_corrupted() = ", free_memory_is_corrupted());
- return;
}
- //
- // M100 C x Corrupts x locations in the free memory pool and reports the locations of the corruption.
- // This is useful to check the correctness of the M100 D and the M100 F commands.
- //
- #if ENABLED(M100_FREE_MEMORY_CORRUPTOR)
+ if (block_cnt > 1) {
+ SERIAL_ECHOLNPGM("\nMemory Corruption detected in free memory area.");
+ SERIAL_ECHOPAIR("\nLargest free block is ", max_cnt);
+ SERIAL_ECHOLNPAIR(" bytes at 0x", hex_word((uint16_t)max_addr));
+ }
+ SERIAL_ECHOLNPAIR("free_memory_is_corrupted() = ", free_memory_is_corrupted(ptr, size));
+}
+
+#if ENABLED(M100_FREE_MEMORY_CORRUPTOR)
+ /**
+ * M100 C<num>
+ * Corrupt <num> locations in the free memory pool and report the corrupt addresses.
+ * This is useful to check the correctness of the M100 D and the M100 F commands.
+ */
+ void corrupt_free_memory(char *ptr, const uint16_t size) {
if (code_seen('C')) {
- int x = code_value_int(); // x gets the # of locations to corrupt within the memory pool
- SERIAL_ECHOLNPGM("Corrupting free memory block.\n");
ptr += 8;
- sp = top_of_stack();
- n = sp - ptr - 250; // -250 just to keep us from finding interrupt activity that
- // has altered the stack.
- j = n / (x + 1);
- for (i = 1; i <= x; i++) {
- *(ptr + (i * j)) = i;
- SERIAL_ECHOPAIR("\nCorrupting address: 0x", hex_word((uint16_t)(ptr + i * j)));
- }
- SERIAL_ECHOLNPGM("\n");
- return;
- }
- #endif
- //
- // M100 I Initializes the free memory pool so it can be watched and prints vital
- // statistics that define the free memory pool.
- //
- if (m100_not_initialized || code_seen('I')) { // If no sub-command is specified, the first time
- SERIAL_ECHOLNPGM("Initializing free memory block.\n"); // this happens, it will Initialize.
- // Repeated M100 with no sub-command will not destroy the
- // state of the initialized free memory pool.
- ptr += 8;
- SERIAL_ECHOLNPGM("\n");
- n = sp - ptr - 250; // -250 just to keep us from finding interrupt activity that
- // has altered the stack.
- SERIAL_ECHO(n);
- SERIAL_ECHOLNPGM(" bytes of memory initialized.\n");
- for (i = 0; i < n; i++)
- *(ptr + i) = (char)0xe5;
- for (i = 0; i < n; i++) {
- if (*(ptr + i) != (char)0xe5) {
- SERIAL_ECHOPAIR("? address : ", hex_word(ptr+i) );
- SERIAL_ECHOPAIR("=", hex_byte(*(ptr + i)) );
- SERIAL_ECHOLNPGM("\n");
+ const uint16_t near_top = top_of_stack() - ptr - 250, // -250 to avoid interrupt activity that's altered the stack.
+ j = near_top / (size + 1);
+
+ SERIAL_ECHOLNPGM("Corrupting free memory block.\n");
+ for (uint16_t i = 1; i <= size; i++) {
+ char * const addr = ptr + i * j;
+ *addr = i;
+ SERIAL_ECHOPAIR("\nCorrupting address: 0x", hex_word((uint16_t)addr));
}
+ SERIAL_EOL;
}
- m100_not_initialized = false;
- return;
}
- return;
-}
+#endif // M100_FREE_MEMORY_CORRUPTOR
-// top_of_stack() returns the location of a variable on its stack frame. The value returned is above
-// the stack once the function returns to the caller.
+/**
+ * M100 I
+ * Init memory for the M100 tests. (Automatically applied on the first M100.)
+ */
+void init_free_memory(char *ptr, int16_t size) {
+ SERIAL_ECHOLNPGM("Initializing free memory block.\n\n");
-char* top_of_stack() {
- char x;
- return &x + 1; // x is pulled on return;
-}
+ size -= 250; // -250 to avoid interrupt activity that's altered the stack.
+ if (size < 0) return;
-// how_many_E5s_are_here() is a utility function to easily find out how many 0xE5's are
-// at the specified location. Having this logic as a function simplifies the search code.
-//
-int how_many_E5s_are_here(char* p) {
- int n;
- for (n = 0; n < 32000; n++) {
- if (*(p + n) != (char)0xe5)
- return n - 1;
+ ptr += 8;
+ memset(ptr, TEST_BYTE, size);
+
+ SERIAL_ECHO(size);
+ SERIAL_ECHOLNPGM(" bytes of memory initialized.\n");
+
+ for (uint16_t i = 0; i < size; i++) {
+ if (ptr[i] != TEST_BYTE) {
+ SERIAL_ECHOPAIR("? address : 0x", hex_word((uint16_t)ptr + i));
+ SERIAL_ECHOPAIR("=", hex_byte(ptr[i]));
+ SERIAL_EOL; SERIAL_EOL;
+ }
}
- return -1;
}
+/**
+ * M100: Free Memory Check
+ */
+void gcode_M100() {
+ SERIAL_ECHOPAIR("\n__brkval : 0x", hex_word((uint16_t)__brkval));
+ SERIAL_ECHOPAIR("\n__bss_end : 0x", hex_word((uint16_t)&__bss_end));
-int free_memory_is_corrupted() {
- char *sp, *ptr;
- int block_cnt = 0, i, j, n;
+ char *ptr = END_OF_HEAP(), *sp = top_of_stack();
- ptr = __brkval ? __brkval : &__bss_end;
- sp = top_of_stack();
+ SERIAL_ECHOPAIR("\nstart of free space : 0x", hex_word((uint16_t)ptr));
+ SERIAL_ECHOLNPAIR("\nStack Pointer : 0x", hex_word((uint16_t)sp));
- n = sp - ptr;
+ // Always init on the first invocation of M100
+ static bool m100_not_initialized = true;
+ if (m100_not_initialized || code_seen('I')) {
+ m100_not_initialized = false;
+ init_free_memory(ptr, sp - ptr);
+ }
- // Scan through the range looking for the biggest block of 0xE5's we can find
- for (i = 0; i < n; i++) {
- if (*(ptr + i) == (char)0xe5) {
- j = how_many_E5s_are_here(ptr + i);
- if (j > 8) {
-// SERIAL_ECHOPAIR("Found ", j);
-// SERIAL_ECHOLNPAIR(" bytes free at 0x", hex_word((uint16_t)(ptr + i)));
+ #if ENABLED(M100_FREE_MEMORY_DUMPER)
- i += j;
- block_cnt++;
- }
- }
- }
+ if (code_seen('D'))
+ return dump_free_memory(ptr, sp);
-// if (block_cnt > 1) {
-// SERIAL_ECHOLNPGM("\nMemory Corruption detected in free memory area.");
-// SERIAL_ECHOLNPAIR("\nLargest free block is ", max_cnt);
-// }
- return block_cnt;
- }
+ #endif
-#endif
+ if (code_seen('F'))
+ return free_memory_pool_report(ptr, sp - ptr);
+
+ #if ENABLED(M100_FREE_MEMORY_CORRUPTOR)
+
+ if (code_seen('C'))
+ return corrupt_free_memory(ptr, code_value_int());
+
+ #endif
+}
+#endif // M100_FREE_MEMORY_WATCHER
diff --git a/Marlin/hex_print_routines.cpp b/Marlin/hex_print_routines.cpp
index 9218f9f84cd264e2ee4631b7499393cb49b57623..02b07754d147eeba82e34e35f83c27717cedc096 100644
--- a/Marlin/hex_print_routines.cpp
+++ b/Marlin/hex_print_routines.cpp
@@ -43,7 +43,7 @@ char* hex_word(const uint16_t w) {
return _hex;
}
-void print_hex_nybble(const uint8_t n) { SERIAL_CHAR(hex_nybble(n)); }
+void print_hex_nybble(const uint8_t n) { SERIAL_CHAR(hex_nybble(n)); }
void print_hex_byte(const uint8_t b) { SERIAL_ECHO(hex_byte(b)); }
void print_hex_word(const uint16_t w) { SERIAL_ECHO(hex_word(w)); }
diff --git a/Marlin/hex_print_routines.h b/Marlin/hex_print_routines.h
index 5956a72ee07c80ee14c572f53065dbd3be600dd1..c5c4f759f008781da85350649cfea41b50a74cac 100644
--- a/Marlin/hex_print_routines.h
+++ b/Marlin/hex_print_routines.h
@@ -42,4 +42,4 @@ void print_hex_byte(const uint8_t b);
void print_hex_word(const uint16_t w);
#endif // AUTO_BED_LEVELING_UBL || M100_FREE_MEMORY_WATCHER
-#endif // HEX_PRINT_ROUTINES_H
\ No newline at end of file
+#endif // HEX_PRINT_ROUTINES_H