Memory Leak & Stack Overflow Detection

#include 
#include "Std_Types.h"

/* Method 1: Stack canary pattern — fill stack with known pattern at init */
#define STACK_CANARY  0xDEADBEEFu
#define STACK_SIZE    512u   /* 512 × 4 bytes = 2 kB */

static uint32_t s_task_stack[STACK_SIZE];

void Stack_Init(void)
{
    /* Fill entire stack with canary pattern before first use */
    for (uint32_t i = 0u; i < STACK_SIZE; i++) {
        s_task_stack[i] = STACK_CANARY;
    }
}

/* Check watermark: find deepest stack usage */
uint32_t Stack_GetHighWaterMark(void)
{
    uint32_t i = 0u;
    while ((i < STACK_SIZE) && (s_task_stack[i] == STACK_CANARY)) {
        i++;
    }
    /* Words 0..i-1 were never touched; watermark at word i */
    return (STACK_SIZE - i) * sizeof(uint32_t);  /* bytes used */
}

/* Method 2: MPU guard region — hardware triggers fault on first write past stack */
/* Place MPU region with no-access at bottom of stack (lowest addresses) */
/* When stack overflows into guard region: MemManage fault → ProtectionHook */

/* Method 3: FreeRTOS stack overflow hook */
void vApplicationStackOverflowHook(TaskHandle_t task, char *task_name)
{
    (void)task;
    /* Log task name; trigger safe state; never return */
    Dem_ReportErrorStatus(DEM_TASK_STACK_OVERFLOW, DEM_EVENT_STATUS_FAILED);
    for (;;) {}  /* halt or trigger watchdog reset */
}

/* Leak detection wrapper: track all allocations */
/* Use only in DEBUG builds — never production (ASIL: no heap) */
#include 
#include 
#include 

#if defined(BUILD_DEBUG)

#define MAX_TRACKED_ALLOCS  64u

typedef struct {
    void    *ptr;
    size_t   size;
    const char *file;
    int      line;
} AllocRecord_t;

static AllocRecord_t s_allocs[MAX_TRACKED_ALLOCS];
static uint32_t      s_alloc_count = 0u;
static uint32_t      s_total_bytes = 0u;

void *tracked_malloc(size_t size, const char *file, int line)
{
    void *ptr = malloc(size);
    if (ptr != NULL) {
        for (uint32_t i = 0u; i < MAX_TRACKED_ALLOCS; i++) {
            if (s_allocs[i].ptr == NULL) {
                s_allocs[i] = (AllocRecord_t){ptr, size, file, line};
                s_alloc_count++;
                s_total_bytes += (uint32_t)size;
                break;
            }
        }
    }
    return ptr;
}

void tracked_free(void *ptr)
{
    for (uint32_t i = 0u; i < MAX_TRACKED_ALLOCS; i++) {
        if (s_allocs[i].ptr == ptr) {
            s_total_bytes -= (uint32_t)s_allocs[i].size;
            s_allocs[i] = (AllocRecord_t){0};
            s_alloc_count--;
            break;
        }
    }
    free(ptr);
}

void print_leak_report(void) {
    printf("=== Memory Leak Report ===
");
    printf("Active allocations: %u  Total bytes: %u
", s_alloc_count, s_total_bytes);
    for (uint32_t i = 0u; i < MAX_TRACKED_ALLOCS; i++) {
        if (s_allocs[i].ptr != NULL) {
            printf("  LEAK: %u bytes at %p (%s:%d)
",
                   (unsigned)s_allocs[i].size, s_allocs[i].ptr,
                   s_allocs[i].file, s_allocs[i].line);
        }
    }
}
#define malloc(s)  tracked_malloc((s), __FILE__, __LINE__)
#define free(p)    tracked_free(p)
#endif /* BUILD_DEBUG */