WIP: Add Valgrind "max address space" option.

projectgus · projectgus · commit 02e3968ccb8e · 2024-03-27T18:35:05.000+11:00
This option prevents the Python heap from reusing freed memory addresses
for new allocations (obviously only viable for some workloads!)

Advantage is that valgrind will be able to catch any use-after-free, that
might have been missed if the freed memory address was reallocated for
another use.

This work was funded through GitHub Sponsors.

Signed-off-by: Angus Gratton &lt;angus@redyak.com.au&gt;
diff --git a/py/gc.c b/py/gc.c
@@ -643,9 +643,11 @@ void gc_collect_end(void) {
     #if MICROPY_GC_SPLIT_HEAP
     MP_STATE_MEM(gc_last_free_area) = &MP_STATE_MEM(area);
     #endif
+    #if !MICROPY_DEBUG_VALGRIND_MAX_ADDRSPACE
     for (mp_state_mem_area_t *area = &MP_STATE_MEM(area); area != NULL; area = NEXT_AREA(area)) {
         area->gc_last_free_atb_index = 0;
     }
+    #endif
     MP_STATE_THREAD(gc_lock_depth)--;
     GC_EXIT();
 }
@@ -832,6 +834,9 @@ void *gc_alloc(size_t n_bytes, unsigned int alloc_flags) {
         #endif
         area->gc_last_free_atb_index = (i + 1) / BLOCKS_PER_ATB;
     }
+    #if MICROPY_DEBUG_VALGRIND_MAX_ADDRSPACE
+    area->gc_last_free_atb_index = (i + 1) / BLOCKS_PER_ATB;
+    #endif
 
     area->gc_last_used_block = MAX(area->gc_last_used_block, end_block);
 
@@ -960,10 +965,12 @@ void gc_free(void *ptr) {
     }
     #endif
 
+    #if !MICROPY_DEBUG_VALGRIND_MAX_ADDRSPACE
     // set the last_free pointer to this block if it's earlier in the heap
     if (block / BLOCKS_PER_ATB < area->gc_last_free_atb_index) {
         area->gc_last_free_atb_index = block / BLOCKS_PER_ATB;
     }
+    #endif
 
     // free head and all of its tail blocks
     do {
@@ -1127,10 +1134,12 @@ void *gc_realloc(void *ptr_in, size_t n_bytes, bool allow_move) {
         }
         #endif
 
+        #if !MICROPY_DEBUG_VALGRIND_MAX_ADDRSPACE
         // set the last_free pointer to end of this block if it's earlier in the heap
         if ((block + new_blocks) / BLOCKS_PER_ATB < area->gc_last_free_atb_index) {
             area->gc_last_free_atb_index = (block + new_blocks) / BLOCKS_PER_ATB;
         }
+        #endif
 
         VALGRIND_MP_RESIZE_BLOCK(ptr, n_blocks, n_bytes);
 
diff --git a/py/mpconfig.h b/py/mpconfig.h
@@ -540,6 +540,12 @@
 #define MICROPY_DEBUG_VALGRIND (0)
 #endif
 
+// Whether valgrind should always use new memory addresses for allocations,
+// making it easier to find use-after-free bugs.
+#ifndef MICROPY_DEBUG_VALGRIND_MAX_ADDRSPACE
+#define MICROPY_DEBUG_VALGRIND_MAX_ADDRSPACE (MICROPY_DEBUG_VALGRIND)
+#endif
+
 /*****************************************************************************/
 /* Optimisations                                                             */
 

Original file line number	Diff line number	Diff line change
`@@ -643,9 +643,11 @@ void gc_collect_end(void) {`
`643`	`643`	`#if MICROPY_GC_SPLIT_HEAP`
`644`	`644`	`MP_STATE_MEM(gc_last_free_area) = &MP_STATE_MEM(area);`
`645`	`645`	`#endif`
	`646`	`+ #if !MICROPY_DEBUG_VALGRIND_MAX_ADDRSPACE`
`646`	`647`	`for (mp_state_mem_area_t *area = &MP_STATE_MEM(area); area != NULL; area = NEXT_AREA(area)) {`
`647`	`648`	`area->gc_last_free_atb_index = 0;`
`648`	`649`	`}`
	`650`	`+ #endif`
`649`	`651`	`MP_STATE_THREAD(gc_lock_depth)--;`
`650`	`652`	`GC_EXIT();`
`651`	`653`	`}`
`@@ -832,6 +834,9 @@ void *gc_alloc(size_t n_bytes, unsigned int alloc_flags) {`
`832`	`834`	`#endif`
`833`	`835`	`area->gc_last_free_atb_index = (i + 1) / BLOCKS_PER_ATB;`
`834`	`836`	`}`
	`837`	`+ #if MICROPY_DEBUG_VALGRIND_MAX_ADDRSPACE`
	`838`	`+ area->gc_last_free_atb_index = (i + 1) / BLOCKS_PER_ATB;`
	`839`	`+ #endif`
`835`	`840`
`836`	`841`	`area->gc_last_used_block = MAX(area->gc_last_used_block, end_block);`
`837`	`842`
`@@ -960,10 +965,12 @@ void gc_free(void *ptr) {`
`960`	`965`	`}`
`961`	`966`	`#endif`
`962`	`967`
	`968`	`+ #if !MICROPY_DEBUG_VALGRIND_MAX_ADDRSPACE`
`963`	`969`	`// set the last_free pointer to this block if it's earlier in the heap`
`964`	`970`	`if (block / BLOCKS_PER_ATB < area->gc_last_free_atb_index) {`
`965`	`971`	`area->gc_last_free_atb_index = block / BLOCKS_PER_ATB;`
`966`	`972`	`}`
	`973`	`+ #endif`
`967`	`974`
`968`	`975`	`// free head and all of its tail blocks`
`969`	`976`	`do {`
`@@ -1127,10 +1134,12 @@ void gc_realloc(void ptr_in, size_t n_bytes, bool allow_move) {`
`1127`	`1134`	`}`
`1128`	`1135`	`#endif`
`1129`	`1136`
	`1137`	`+ #if !MICROPY_DEBUG_VALGRIND_MAX_ADDRSPACE`
`1130`	`1138`	`// set the last_free pointer to end of this block if it's earlier in the heap`
`1131`	`1139`	`if ((block + new_blocks) / BLOCKS_PER_ATB < area->gc_last_free_atb_index) {`
`1132`	`1140`	`area->gc_last_free_atb_index = (block + new_blocks) / BLOCKS_PER_ATB;`
`1133`	`1141`	`}`
	`1142`	`+ #endif`
`1134`	`1143`
`1135`	`1144`	`VALGRIND_MP_RESIZE_BLOCK(ptr, n_blocks, n_bytes);`
`1136`	`1145`