c code to paint an embedded stack with a pattern say (0xABABABAB) just after main begins?

user_13989572 0
Viewed 115

I am working on dynamic memory analysis using stack painting/foot print analysis method.

dynamic-stack-depth-determination-using-footprint-analysis

basically the idea is to fill the entire amount of memory allocated to the stack area with a dedicated fill value, for example 0xABABABAB, before the application starts executing. Whenever the execution stops, the stack memory can be searched upwards from the end of the stack until a value that is not 0xABABABABis found, which is assumed to be how far the stack has been used. If the dedicated value cannot be found, the stack has consumed all stack space and most likely has overflowed.

I want a c code to fill the stack from top to bottom with a pattern.

void FillSystemStack()
{
    extern char __stack_start,_Stack_bottom;


}

NOTE

  • I am using STM32F407VG board emulated with QEMU on eclipse.
  • stack is growing from higher address to lower address
  • start of the stack is 0x20020000
  • bottom of the stack is Ox2001fc00
stm32 stack-overflow embedded stack
3 Answers

You shouldn't completely fill the stack after main() begins, because the stack is in use once main() begins. Completely filling the stack would overwrite the bit of stack that has already been used and could lead to undefined behavior. I suppose you could fill a portion of the stack soon after main() begins as long as you're careful not to overwrite the portion that has been used already.

But a better plan is to fill the stack with a pattern before main() is called. Review the startup code for your tool chain. The startup code initializes variable values and sets the stack pointer before calling main(). The startup code may be in assembly depending on your tool chain. The code that initializes variables is probably a simple loop that copies bytes or words from the appropriate ROM to RAM sections. You can probably use this code as an example to write a new loop that will fill the stack memory range with a pattern.

user_14012130

This is a Cortex M so it gets the stack pointer set out of reset. Meaning it's pretty much instantly ready to go for C code. If your reset vector is written in C and performs stacking/C function calls, it will be too late to fill the stack at a very early stage. Meaning you shouldn't do it from application C code.

The normal way to do the trick you describe is through an in-circuit debugger. Download the program, hit reset, fill the stack with the help of the debugger. There will be some convenient debugger command available to do that. Execute the program, try to use as much of it as possible, observe the stack in the memory map of your debugger.

user_5845180

With the insights from @kkrambo answer, I tried to paint the stack just after the start of main by taking care that I do not overwrite the portion that has been used already.My stack paint and stack count functions are given below:

StackPaint

uint32_t sp;
#define STACK_CANARY 0xc5
#define WaterMark 0xc9
void StackPaint(void)
{

    char *p = &__StackLimit; // __StackLimit macro defined in linker script
    
    sp=__get_MSP();
    PRINTF("stack pointer %08x \r\n\n",sp); 

    while((uint32_t)p < sp)
    {
        if(p==&__StackTop){ // __StackTop macro defined in linker script
            *p = WaterMark;
            p++;
        }
        *p = STACK_CANARY;
        p++;

    }

}

StackCount

uint16_t StackCount(void)
{
    PRINTF("In the check address function in main file \r\n\n");
    const char *p = &__StackLimit;
    uint16_t       c = 0;

    while(*p == WaterMark || (*p == STACK_CANARY && p <= &__StackTop))
    {
        p++;
        c++;
                
    }
        
    PRINTF("stack used:%d bytes \n",1024-c);
    PRINTF("remaining stack :%d bytes\n",c);
         
    return c;
}
user_139895720
Related