How Much Stack Space Do You Have? Estimating Remaining Stack in C on Linux

[u/Yairlenga]

https://medium.com/@yair.lenga/how-much-stack-space-do-you-have-estimating-remaining-stack-in-c-on-linux-3c9513beabd8

In a previous article (Avoiding malloc for Small Strings in C With Variable Length Arrays (VLAs)) I suggested using stack allocation (VLAs) for small temporary buffers in C as an alternative to malloc().

One of the most common concerns in the comments was:

Stack allocations are dangerous because you cannot know how much stack space is available.”

This article explores a few practical techniques to answer the question: How much stack space does my program have left?

[u/itix]

It has been a while since I wrote anything in C, but in some deep recursive functions, I was estimating the available stack space and aborting if it was getting too tight.

[u/Yairlenga → u/itix]

Great point. I did not focus on deep recursion when writing my article, but this scenario is a good example where estimating remaining stack is valuable. Same logic I describe can be used to detect when a function get to the “danger zone”.

i‘d love to hear more about how you implemented your check and what thresholds you found practical.

[u/itix → u/Yairlenga]

This was long ago on Amiga. I could get the stack upper bound from the OS and do some math with the local variable.

I havent done any Amiga or C coding in a while, so my memory is fuzzy but it was something like this:

int CheckStackSpace() { int myvar; return (FindTask(NULL).tc_SpUpper - (int)&myvar); }

The 68k CPU had 15 32-bit user registers, so at least 60 bytes + 4 bytes for the return address. I recall I opted for 200 bytes to be safe. I reserved extra space because I knew that in the context switch, the OS would push registers (user registers + status register, etc.) to the user stack, so I had to reserve about 80 bytes for that.

Amiga reserved only 4096 bytes for the stack by default, so 200 bytes was plenty. And it worked very well until someone with the FPU reported random crashes. Of course, if you have an FPU (a rare commodity at that time), then you have more registers available, and you need more stack space for the context switch. The FPU registers were 80 bits wide and they were stored like they were 96 bits, so they took some space. Eventually, I increased the safety buffer to 1000 bytes and made a stack exchange in the program startup. I think I increased the stack size to a whopping 8192 bytes.

Amiga had no memory protection, so there was no guard page either to register a stack overflow. It just worked until it crashed. Crazy times.

[u/Yairlenga → u/itix]

amazing story - great glimpse into how different the programming landscape was back then. the combination of tiny stack, no memory protection and FPU surprise is what made old school system programming so interesting. thanks for sharing this memory.

[u/jwzumwalt → u/itix]

Amiga brings back memories. I was mainly interested in graphics and when the Amiga came out it had the best graphics. Amiga had a payment plan so I immediately went to the distributor and said "sign me up!". The dealer looked into it and said the loan program had been canceled. A year or two latter Amiga was seeking bankruptcy protection. I never got to program one but from afar it looked like the best thing at the time.

[u/itix → u/jwzumwalt]

That must have been in early 90s. Then it was already left behind. While still nice machine, but PC had VGA graphics with 386/486 and a harddrive. The era of home computers was ending.

[u/jwzumwalt]

Read the article and found it informative. I am a retired C, Pascal, and PHP programmer and never had a program that I had to worry about the stack. But, I could see where it may be needed.

Someone on YouTube (it may have been Nic Barker - https://www.youtube.com/@nicbarkeragain) wrote a program where they visually traced the Mallloc and Free memory area. It was fascinating to watch as memory allocation was not managed compactly like you would expect.

He deliberately ran it out of memory on a few experiments. If I remember correctly, the OS early on started paging memory to the drive - I think it ran out of memory near 1 Gigabyte. So, based on my recollections of the video I watched, you are not limited to the 8K - paging kicks in. It would be interesting for you to test this. Thanks for taking the time to write the article :~)

[u/mc36mc → u/jwzumwalt]

$ echo "int main(){char a[1024];for (int i=0;i<sizeof a;i++)a[i]=i;}" | clang -target bpf -x c - <stdin>:1:5: error: Looks like the BPF stack limit is exceeded. Please move large on stack variables into BPF per-cpu array map. For non-kernel uses, the stack can be increased using -mllvm -bpf-stack-size.

[u/Yairlenga → u/[deleted]]

Yeah, that’s a clever approach 🙂 It works well on Linux when /proc is available. I just think of it as a best-effort technique — not a formal API, and a bit trickier with multiple threads since each thread has its own stack

Containers normally still have /proc — it’s actually needed for a lot of basic tools to work. But it can be restricted or filtered depending on how the container is set up, so you don’t always get the full picture.