[v3,00/10] ARM: add support for IRQ stacks

Message

Ard Biesheuvel Oct. 17, 2021, 1:17 p.m. UTC

Compared to user space, the kernel's task stacks are tiny and
inflexible, as we don't grow them dynamically using demand paging. This
is the reason we tend to obsess about functions with disproportionately
large stack frames, given that it is hard to predict statically how
calls to those functions may combine at runtime, and exhaust the stack
and crash the kernel.

This becomes even less predictable when taking interrupt handling into
account, as their handlers are normally executed on the stack of the
task that was interrupted, regardless of how deep its call stack was at
the time of the interruption. To decouple these, and reduce the risk of
hitting a pathological worst case where IRQ handling and the task below
it happen to exhaust the available stack space when combined, we can
switch to a different stack when taking interrupts, similar to how this
is done already on some other architectures. This series implements this
approach for ARM.

Note that a good chunk of the changes below are related to supporting
non-contiguous call stacks, which is also relevant in the context of
vmap'ed stacks, which use a separate overflow stack to handle stack
overflows. The changes preserve all functionality related to walking the
call stack and dumping exception stacks and register contents.

Changes since v2:
- improve Clang support, by emitting code that is compatible with its
  frame pointer unwinder if that is the unwinder being used;
- add acks from Arnd and Linus (thanks!)

Changes since v1:
- drop the first bugfix patch, which has been queued as a fix in the
  meantime;
- preserve/restore FP in the irq_handler entry code;
- add missing include to arch/arm/kernel/irq.c to silence warnings about
  missing prototypes.

Patch #1 removes some code that I spotted that is no longer used.

Patch #2 introduces a pair of macros that will be used later in the
series to emit the optimal indirect call sequence for older and newer
cores.

Patch #3 tweaks the IRQ asm entry point to generate better code for v7
CPUs.

Patch #4 updates the unwind info based unwinder so it can deal with call
stacks that are non-contiguous.

Patch #5 exports dump_mem() to other compilation units so the ARM
unwinder can cal it directly. This is needed by the next patch.

Patch #6 refactors the ARM unwinder to dump the exception stack from a
context where it can figure out if it lives on the current stack or on
the task stack.

Patch #7 fixes an issue in the Clang frame pointer unwinder, which may
get into an endless recursive fault if any of the stack frames have a
bogus value for the link register.

Patch #8 implements the actual IRQ stacks support, by allocating one for
each CPU, and adding the code to switch to it in the IRQ entry path. It
also contains some related changes to allow the frame pointer based
unwinder to deal with the new situation.

Patch #9 modifies call_with_stack() so both the frame pointer unwinder
as well as the ARM unwinder know how to deal with it.

Patch #10 adds the IRQ stack switching for softIRQ handling initiated
from task context.

The patches are based on my arm32-ti-in-task-v5 branch [0], which is a
prerequisite for these changes, given that we can no longer rely on
thread_info being accessible by masking the stack pointer when we are
jumping between stacks. A pull request is outstanding for those changes.

[0] https://git.kernel.org/pub/scm/linux/kernel/git/ardb/linux.git/log/?h=arm32-ti-in-task-v5

Cc: Russell King <[e-mail]>
Cc: Arnd Bergmann <[e-mail]>
Cc: Kees Cook <[e-mail]>
Cc: Keith Packard <[e-mail]>
Cc: Linus Walleij <[e-mail]>
Cc: Nick Desaulniers <[e-mail]>
Cc: Nicolas Pitre <[e-mail]>

Ard Biesheuvel (10):
  ARM: remove some dead code
  ARM: assembler: introduce bl_r and bl_m macros
  ARM: optimize indirect call to handle_arch_irq for v7 cores
  ARM: unwind: support unwinding across multiple stacks
  ARM: export dump_mem() to other objects
  ARM: unwind: dump exception stack from calling frame
  ARM: backtrace-clang: avoid crash on bogus frame pointer
  ARM: implement IRQ stacks
  ARM: call_with_stack: add unwind support
  ARM: run softirqs on the per-CPU IRQ stack

 arch/arm/Kconfig                         |  6 ++
 arch/arm/include/asm/assembler.h         | 41 +++++++++++++
 arch/arm/include/asm/entry-macro-multi.S | 24 --------
 arch/arm/include/asm/smp.h               |  5 --
 arch/arm/include/asm/stacktrace.h        | 13 +++++
 arch/arm/kernel/entry-armv.S             | 60 +++++++++++++++++---
 arch/arm/kernel/irq.c                    | 37 ++++++++++++
 arch/arm/kernel/smp.c                    |  5 --
 arch/arm/kernel/traps.c                  | 25 ++++++--
 arch/arm/kernel/unwind.c                 | 33 +++++++----
 arch/arm/lib/backtrace-clang.S           | 14 ++++-
 arch/arm/lib/backtrace.S                 |  8 +++
 arch/arm/lib/call_with_stack.S           | 33 ++++++++---
 13 files changed, 236 insertions(+), 68 deletions(-)