arch/arm64/include/asm/stacktrace/common.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * Common arm64 stack unwinder code.
   4  *
   5  * To implement a new arm64 stack unwinder:
   6  *     1) Include this header
   7  *
   8  *     2) Call into unwind_next_common() from your top level unwind
   9  *        function, passing it the validation and translation callbacks
  10  *        (though the later can be NULL if no translation is required).
  11  *
  12  * See: arch/arm64/kernel/stacktrace.c for the reference implementation.
  13  *
  14  * Copyright (C) 2012 ARM Ltd.
  15  */
  16 #ifndef __ASM_STACKTRACE_COMMON_H
  17 #define __ASM_STACKTRACE_COMMON_H
  18
  19 #include <linux/bitmap.h>
  20 #include <linux/bitops.h>
  21 #include <linux/kprobes.h>
  22 #include <linux/types.h>
  23
  24 enum stack_type {
  25         STACK_TYPE_UNKNOWN,
  26         STACK_TYPE_TASK,
  27         STACK_TYPE_IRQ,
  28         STACK_TYPE_OVERFLOW,
  29         STACK_TYPE_SDEI_NORMAL,
  30         STACK_TYPE_SDEI_CRITICAL,
  31         STACK_TYPE_HYP,
  32         __NR_STACK_TYPES
  33 };
  34
  35 struct stack_info {
  36         unsigned long low;
  37         unsigned long high;
  38         enum stack_type type;
  39 };
  40
  41 /*
  42  * A snapshot of a frame record or fp/lr register values, along with some
  43  * accounting information necessary for robust unwinding.
  44  *
  45  * @fp:          The fp value in the frame record (or the real fp)
  46  * @pc:          The lr value in the frame record (or the real lr)
  47  *
  48  * @stacks_done: Stacks which have been entirely unwound, for which it is no
  49  *               longer valid to unwind to.
  50  *
  51  * @prev_fp:     The fp that pointed to this frame record, or a synthetic value
  52  *               of 0. This is used to ensure that within a stack, each
  53  *               subsequent frame record is at an increasing address.
  54  * @prev_type:   The type of stack this frame record was on, or a synthetic
  55  *               value of STACK_TYPE_UNKNOWN. This is used to detect a
  56  *               transition from one stack to another.
  57  *
  58  * @kr_cur:      When KRETPROBES is selected, holds the kretprobe instance
  59  *               associated with the most recently encountered replacement lr
  60  *               value.
  61  *
  62  * @task:        The task being unwound.
  63  */
  64 struct unwind_state {
  65         unsigned long fp;
  66         unsigned long pc;
  67         DECLARE_BITMAP(stacks_done, __NR_STACK_TYPES);
  68         unsigned long prev_fp;
  69         enum stack_type prev_type;
  70 #ifdef CONFIG_KRETPROBES
  71         struct llist_node *kr_cur;
  72 #endif
  73         struct task_struct *task;
  74 };
  75
  76 static inline bool on_stack(unsigned long sp, unsigned long size,
  77                             unsigned long low, unsigned long high,
  78                             enum stack_type type, struct stack_info *info)
  79 {
  80         if (!low)
  81                 return false;
  82
  83         if (sp < low || sp + size < sp || sp + size > high)
  84                 return false;
  85
  86         if (info) {
  87                 info->low = low;
  88                 info->high = high;
  89                 info->type = type;
  90         }
  91         return true;
  92 }
  93
  94 static inline void unwind_init_common(struct unwind_state *state,
  95                                       struct task_struct *task)
  96 {
  97         state->task = task;
  98 #ifdef CONFIG_KRETPROBES
  99         state->kr_cur = NULL;
 100 #endif
 101
 102         /*
 103          * Prime the first unwind.
 104          *
 105          * In unwind_next() we'll check that the FP points to a valid stack,
 106          * which can't be STACK_TYPE_UNKNOWN, and the first unwind will be
 107          * treated as a transition to whichever stack that happens to be. The
 108          * prev_fp value won't be used, but we set it to 0 such that it is
 109          * definitely not an accessible stack address.
 110          */
 111         bitmap_zero(state->stacks_done, __NR_STACK_TYPES);
 112         state->prev_fp = 0;
 113         state->prev_type = STACK_TYPE_UNKNOWN;
 114 }
 115
 116 /*
 117  * stack_trace_translate_fp_fn() - Translates a non-kernel frame pointer to
 118  * a kernel address.
 119  *
 120  * @fp:   the frame pointer to be updated to its kernel address.
 121  * @type: the stack type associated with frame pointer @fp
 122  *
 123  * Returns true and success and @fp is updated to the corresponding
 124  * kernel virtual address; otherwise returns false.
 125  */
 126 typedef bool (*stack_trace_translate_fp_fn)(unsigned long *fp,
 127                                             enum stack_type type);
 128
 129 /*
 130  * on_accessible_stack_fn() - Check whether a stack range is on any
 131  * of the possible stacks.
 132  *
 133  * @tsk:  task whose stack is being unwound
 134  * @sp:   stack address being checked
 135  * @size: size of the stack range being checked
 136  * @info: stack unwinding context
 137  */
 138 typedef bool (*on_accessible_stack_fn)(const struct task_struct *tsk,
 139                                        unsigned long sp, unsigned long size,
 140                                        struct stack_info *info);
 141
 142 static inline int unwind_next_common(struct unwind_state *state,
 143                                      struct stack_info *info,
 144                                      on_accessible_stack_fn accessible,
 145                                      stack_trace_translate_fp_fn translate_fp)
 146 {
 147         unsigned long fp = state->fp, kern_fp = fp;
 148         struct task_struct *tsk = state->task;
 149
 150         if (fp & 0x7)
 151                 return -EINVAL;
 152
 153         if (!accessible(tsk, fp, 16, info))
 154                 return -EINVAL;
 155
 156         if (test_bit(info->type, state->stacks_done))
 157                 return -EINVAL;
 158
 159         /*
 160          * If fp is not from the current address space perform the necessary
 161          * translation before dereferencing it to get the next fp.
 162          */
 163         if (translate_fp && !translate_fp(&kern_fp, info->type))
 164                 return -EINVAL;
 165
 166         /*
 167          * As stacks grow downward, any valid record on the same stack must be
 168          * at a strictly higher address than the prior record.
 169          *
 170          * Stacks can nest in several valid orders, e.g.
 171          *
 172          * TASK -> IRQ -> OVERFLOW -> SDEI_NORMAL
 173          * TASK -> SDEI_NORMAL -> SDEI_CRITICAL -> OVERFLOW
 174          * HYP -> OVERFLOW
 175          *
 176          * ... but the nesting itself is strict. Once we transition from one
 177          * stack to another, it's never valid to unwind back to that first
 178          * stack.
 179          */
 180         if (info->type == state->prev_type) {
 181                 if (fp <= state->prev_fp)
 182                         return -EINVAL;
 183         } else {
 184                 __set_bit(state->prev_type, state->stacks_done);
 185         }
 186
 187         /*
 188          * Record this frame record's values and location. The prev_fp and
 189          * prev_type are only meaningful to the next unwind_next() invocation.
 190          */
 191         state->fp = READ_ONCE(*(unsigned long *)(kern_fp));
 192         state->pc = READ_ONCE(*(unsigned long *)(kern_fp + 8));
 193         state->prev_fp = fp;
 194         state->prev_type = info->type;
 195
 196         return 0;
 197 }
 198
 199 #endif  /* __ASM_STACKTRACE_COMMON_H */