| 1 |
|
| 2 | #ifndef _LINUX_OBJTOOL_H
|
| 3 | #define _LINUX_OBJTOOL_H
|
| 4 |
|
| 5 | #include <linux/objtool_types.h>
|
| 6 |
|
| 7 | #ifdef CONFIG_OBJTOOL
|
| 8 |
|
| 9 | #include <asm/asm.h>
|
| 10 |
|
| 11 | #ifndef __ASSEMBLY__
|
| 12 |
|
| 13 | #define UNWIND_HINT(type, sp_reg, sp_offset, signal) \
|
| 14 | "987: \n\t" \
|
| 15 | ".pushsection .discard.unwind_hints\n\t" \
|
| 16 | \
|
| 17 | ".long 987b - .\n\t" \
|
| 18 | ".short " __stringify(sp_offset) "\n\t" \
|
| 19 | ".byte " __stringify(sp_reg) "\n\t" \
|
| 20 | ".byte " __stringify(type) "\n\t" \
|
| 21 | ".byte " __stringify(signal) "\n\t" \
|
| 22 | ".balign 4 \n\t" \
|
| 23 | ".popsection\n\t"
|
| 24 |
|
| 25 | |
| 26 | * This macro marks the given function's stack frame as "non-standard", which
|
| 27 | * tells objtool to ignore the function when doing stack metadata validation.
|
| 28 | * It should only be used in special cases where you're 100% sure it won't
|
| 29 | * affect the reliability of frame pointers and kernel stack traces.
|
| 30 | *
|
| 31 | * For more information, see tools/objtool/Documentation/objtool.txt.
|
| 32 |
|
| 33 | #define STACK_FRAME_NON_STANDARD(func) \
|
| 34 | static void __used __section(".discard.func_stack_frame_non_standard") \
|
| 35 | *__func_stack_frame_non_standard_##func = func
|
| 36 |
|
| 37 | |
| 38 | * STACK_FRAME_NON_STANDARD_FP() is a frame-pointer-specific function ignore
|
| 39 | * for the case where a function is intentionally missing frame pointer setup,
|
| 40 | * but otherwise needs objtool/ORC coverage when frame pointers are disabled.
|
| 41 |
|
| 42 | #ifdef CONFIG_FRAME_POINTER
|
| 43 | #define STACK_FRAME_NON_STANDARD_FP(func) STACK_FRAME_NON_STANDARD(func)
|
| 44 | #else
|
| 45 | #define STACK_FRAME_NON_STANDARD_FP(func)
|
| 46 | #endif
|
| 47 |
|
| 48 | #define ASM_REACHABLE \
|
| 49 | "998:\n\t" \
|
| 50 | ".pushsection .discard.reachable\n\t" \
|
| 51 | ".long 998b\n\t" \
|
| 52 | ".popsection\n\t"
|
| 53 |
|
| 54 | #define __ASM_BREF(label) label ## b
|
| 55 |
|
| 56 | #define __ASM_ANNOTATE(label, type) \
|
| 57 | ".pushsection .discard.annotate_insn,\"M\",@progbits,8\n\t" \
|
| 58 | ".long " __stringify(label) " - .\n\t" \
|
| 59 | ".long " __stringify(type) "\n\t" \
|
| 60 | ".popsection\n\t"
|
| 61 |
|
| 62 | #define ASM_ANNOTATE(type) \
|
| 63 | "911:\n\t" \
|
| 64 | __ASM_ANNOTATE(911b, type)
|
| 65 |
|
| 66 | #else
|
| 67 |
|
| 68 | |
| 69 | * In asm, there are two kinds of code: normal C-type callable functions and
|
| 70 | * the rest. The normal callable functions can be called by other code, and
|
| 71 | * don't do anything unusual with the stack. Such normal callable functions
|
| 72 | * are annotated with the ENTRY/ENDPROC macros. Most asm code falls in this
|
| 73 | * category. In this case, no special debugging annotations are needed because
|
| 74 | * objtool can automatically generate the ORC data for the ORC unwinder to read
|
| 75 | * at runtime.
|
| 76 | *
|
| 77 | * Anything which doesn't fall into the above category, such as syscall and
|
| 78 | * interrupt handlers, tends to not be called directly by other functions, and
|
| 79 | * often does unusual non-C-function-type things with the stack pointer. Such
|
| 80 | * code needs to be annotated such that objtool can understand it. The
|
| 81 | * following CFI hint macros are for this type of code.
|
| 82 | *
|
| 83 | * These macros provide hints to objtool about the state of the stack at each
|
| 84 | * instruction. Objtool starts from the hints and follows the code flow,
|
| 85 | * making automatic CFI adjustments when it sees pushes and pops, filling out
|
| 86 | * the debuginfo as necessary. It will also warn if it sees any
|
| 87 | * inconsistencies.
|
| 88 |
|
| 89 | .macro UNWIND_HINT type:req sp_reg=0 sp_offset=0 signal=0
|
| 90 | .Lhere_\@:
|
| 91 | .pushsection .discard.unwind_hints
|
| 92 |
|
| 93 | .long .Lhere_\@ - .
|
| 94 | .short \sp_offset
|
| 95 | .byte \sp_reg
|
| 96 | .byte \type
|
| 97 | .byte \signal
|
| 98 | .balign 4
|
| 99 | .popsection
|
| 100 | .endm
|
| 101 |
|
| 102 | .macro STACK_FRAME_NON_STANDARD func:req
|
| 103 | .pushsection .discard.func_stack_frame_non_standard, "aw"
|
| 104 | .long \func - .
|
| 105 | .popsection
|
| 106 | .endm
|
| 107 |
|
| 108 | .macro STACK_FRAME_NON_STANDARD_FP func:req
|
| 109 | #ifdef CONFIG_FRAME_POINTER
|
| 110 | STACK_FRAME_NON_STANDARD \func
|
| 111 | #endif
|
| 112 | .endm
|
| 113 |
|
| 114 | .macro ANNOTATE type:req
|
| 115 | .Lhere_\@:
|
| 116 | .pushsection .discard.annotate_insn,"M",@progbits,8
|
| 117 | .long .Lhere_\@ - .
|
| 118 | .long \type
|
| 119 | .popsection
|
| 120 | .endm
|
| 121 |
|
| 122 | #endif
|
| 123 |
|
| 124 | #else
|
| 125 |
|
| 126 | #ifndef __ASSEMBLY__
|
| 127 |
|
| 128 | #define UNWIND_HINT(type, sp_reg, sp_offset, signal) "\n\t"
|
| 129 | #define STACK_FRAME_NON_STANDARD(func)
|
| 130 | #define STACK_FRAME_NON_STANDARD_FP(func)
|
| 131 | #define __ASM_ANNOTATE(label, type)
|
| 132 | #define ASM_ANNOTATE(type)
|
| 133 | #else
|
| 134 | .macro UNWIND_HINT type:req sp_reg=0 sp_offset=0 signal=0
|
| 135 | .endm
|
| 136 | .macro STACK_FRAME_NON_STANDARD func:req
|
| 137 | .endm
|
| 138 | .macro ANNOTATE type:req
|
| 139 | .endm
|
| 140 | #endif
|
| 141 |
|
| 142 | #endif
|
| 143 |
|
| 144 | #ifndef __ASSEMBLY__
|
| 145 | |
| 146 | * Annotate away the various 'relocation to !ENDBR` complaints; knowing that
|
| 147 | * these relocations will never be used for indirect calls.
|
| 148 |
|
| 149 | #define ANNOTATE_NOENDBR ASM_ANNOTATE(ANNOTYPE_NOENDBR)
|
| 150 | |
| 151 | * This should be used immediately before an indirect jump/call. It tells
|
| 152 | * objtool the subsequent indirect jump/call is vouched safe for retpoline
|
| 153 | * builds.
|
| 154 |
|
| 155 | #define ANNOTATE_RETPOLINE_SAFE ASM_ANNOTATE(ANNOTYPE_RETPOLINE_SAFE)
|
| 156 | |
| 157 | * See linux/instrumentation.h
|
| 158 |
|
| 159 | #define ANNOTATE_INSTR_BEGIN(label) __ASM_ANNOTATE(label, ANNOTYPE_INSTR_BEGIN)
|
| 160 | #define ANNOTATE_INSTR_END(label) __ASM_ANNOTATE(label, ANNOTYPE_INSTR_END)
|
| 161 | |
| 162 | * objtool annotation to ignore the alternatives and only consider the original
|
| 163 | * instruction(s).
|
| 164 |
|
| 165 | #define ANNOTATE_IGNORE_ALTERNATIVE ASM_ANNOTATE(ANNOTYPE_IGNORE_ALTS)
|
| 166 | |
| 167 | * This macro indicates that the following intra-function call is valid.
|
| 168 | * Any non-annotated intra-function call will cause objtool to issue a warning.
|
| 169 |
|
| 170 | #define ANNOTATE_INTRA_FUNCTION_CALL ASM_ANNOTATE(ANNOTYPE_INTRA_FUNCTION_CALL)
|
| 171 | |
| 172 | * Use objtool to validate the entry requirement that all code paths do
|
| 173 | * VALIDATE_UNRET_END before RET.
|
| 174 | *
|
| 175 | * NOTE: The macro must be used at the beginning of a global symbol, otherwise
|
| 176 | * it will be ignored.
|
| 177 |
|
| 178 | #define ANNOTATE_UNRET_BEGIN ASM_ANNOTATE(ANNOTYPE_UNRET_BEGIN)
|
| 179 | |
| 180 | * This should be used to refer to an instruction that is considered
|
| 181 | * terminating, like a noreturn CALL or UD2 when we know they are not -- eg
|
| 182 | * WARN using UD2.
|
| 183 |
|
| 184 | #define ANNOTATE_REACHABLE(label) __ASM_ANNOTATE(label, ANNOTYPE_REACHABLE)
|
| 185 |
|
| 186 | #else
|
| 187 | #define ANNOTATE_NOENDBR ANNOTATE type=ANNOTYPE_NOENDBR
|
| 188 | #define ANNOTATE_RETPOLINE_SAFE ANNOTATE type=ANNOTYPE_RETPOLINE_SAFE
|
| 189 |
|
| 190 |
|
| 191 | #define ANNOTATE_IGNORE_ALTERNATIVE ANNOTATE type=ANNOTYPE_IGNORE_ALTS
|
| 192 | #define ANNOTATE_INTRA_FUNCTION_CALL ANNOTATE type=ANNOTYPE_INTRA_FUNCTION_CALL
|
| 193 | #define ANNOTATE_UNRET_BEGIN ANNOTATE type=ANNOTYPE_UNRET_BEGIN
|
| 194 | #define ANNOTATE_REACHABLE ANNOTATE type=ANNOTYPE_REACHABLE
|
| 195 | #endif
|
| 196 |
|
| 197 | #if defined(CONFIG_NOINSTR_VALIDATION) && \
|
| 198 | (defined(CONFIG_MITIGATION_UNRET_ENTRY) || defined(CONFIG_MITIGATION_SRSO))
|
| 199 | #define VALIDATE_UNRET_BEGIN ANNOTATE_UNRET_BEGIN
|
| 200 | #else
|
| 201 | #define VALIDATE_UNRET_BEGIN
|
| 202 | #endif
|
| 203 |
|
| 204 | #endif
|