Linux Stack Sizes

Question

I'm looking for a good description of stacks within the linux kernel, but I'm finding it surprisingly difficult to find anything useful.

I know that stacks are limited to 4k for most systems, and 8k for others. I'm assuming that each kernel thread / bottom half has its own stack. I've also heard that if an interrupt goes off, it uses the current thread's stack, but I can't find any documentation on any of this. What I'm looking for is how the stacks are allocated, if there's any good debugging routines for them (I'm suspecting a stack overflow for a particular problem, and I'd like to know if its possible to compile the kernel to police stack sizes, etc).

Answer 1

The reason that documentation is scarce is that it's an area that's quite architecture-dependent. The code is really the best documentation - for example, the THREAD_SIZE macro defines the (architecture-dependent) per-thread kernel stack size.

The stacks are allocated in alloc_thread_info_node(), or the architecture-specific override for that function (the struct thread_info always lives at the bottom of the stack). The stack pointer in the struct task_struct is updated in dup_task_struct(), which is called as part of cloning a thread.

The kernel does check for kernel stack overflows, by placing a canary value STACK_END_MAGIC at the end of the stack (immediately after the struct thread_info in memory). In the page fault handler, if a fault in kernel space occurs this canary is checked - see for example the x86 fault handler which prints the message Thread overran stack, or stack corrupted after the Oops message if the stack canary has been clobbered.

Of course this won't trigger on all stack overruns, only the ones that clobber the stack canary. However, you should always be able to tell from the Oops output if you've suffered a stack overrun - that's the case if the stack pointer is below &threadinfo.

Answer 2

You can determine the process stack size with the ulimit command. I get 8192 KiB on my system:

$ ulimit -s
8192

Answer 3

For processes, you can control the stack size of processes via ulimit command (-s option). For threads, the default stack size varies a lot, but you can control it via a call to pthread_attr_setstacksize() (assuming you are using pthreads).

As for the interrupt using the userland stack, I somewhat doubt it, as accessing userland memory is a kind of a hassle from the kernel, especially from an interrupt routine. But I don't know for sure.