archive/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2025-08-15 14:11:42 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

stackleak: Rename stackleak_track_stack to __sanitizer_cov_stack_depth

Browse source 
The Clang stack depth tracking implementation has a fixed name for
the stack depth tracking callback, "__sanitizer_cov_stack_depth", so
rename the GCC plugin function to match since the plugin has no external
dependencies on naming.

Link: https://lore.kernel.org/r/20250717232519.2984886-2-kees@kernel.org
Signed-off-by: Kees Cook <kees@kernel.org>
This commit is contained in:
Kees Cook 2025-07-17 16:25:07 -07:00
parent 57fbad15c2
commit 9ea1e8d28a
5 changed files with 32 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

2
include/linux/kstack_erase.h
View file

@ -80,7 +80,7 @@ static inline void stackleak_task_init(struct task_struct *t)
asmlinkage void noinstr stackleak_erase(void); asmlinkage void noinstr stackleak_erase(void);
asmlinkage void noinstr stackleak_erase_on_task_stack(void); asmlinkage void noinstr stackleak_erase_on_task_stack(void);
asmlinkage void noinstr stackleak_erase_off_task_stack(void); asmlinkage void noinstr stackleak_erase_off_task_stack(void);
void __no_caller_saved_registers noinstr stackleak_track_stack(void); void __no_caller_saved_registers noinstr __sanitizer_cov_stack_depth(void);
#else /* !CONFIG_KSTACK_ERASE */ #else /* !CONFIG_KSTACK_ERASE */
static inline void stackleak_task_init(struct task_struct *t) { } static inline void stackleak_task_init(struct task_struct *t) { }

4
kernel/kstack_erase.c
View file

@ -156,7 +156,7 @@ asmlinkage void noinstr stackleak_erase_off_task_stack(void)
__stackleak_erase(false); __stackleak_erase(false);
} }
void __used __no_caller_saved_registers noinstr stackleak_track_stack(void) void __used __no_caller_saved_registers noinstr __sanitizer_cov_stack_depth(void)
{ {
unsigned long sp = current_stack_pointer; unsigned long sp = current_stack_pointer;
@ -174,4 +174,4 @@ void __used __no_caller_saved_registers noinstr stackleak_track_stack(void)
current->lowest_stack = sp; current->lowest_stack = sp;
} }
} }
EXPORT_SYMBOL(stackleak_track_stack); EXPORT_SYMBOL(__sanitizer_cov_stack_depth);

52
scripts/gcc-plugins/stackleak_plugin.c
View file

@ -9,7 +9,7 @@
* any of the gcc libraries * any of the gcc libraries
* *
* This gcc plugin is needed for tracking the lowest border of the kernel stack. * This gcc plugin is needed for tracking the lowest border of the kernel stack.
* It instruments the kernel code inserting stackleak_track_stack() calls: * It instruments the kernel code inserting __sanitizer_cov_stack_depth() calls:
* - after alloca(); * - after alloca();
* - for the functions with a stack frame size greater than or equal * - for the functions with a stack frame size greater than or equal
* to the "track-min-size" plugin parameter. * to the "track-min-size" plugin parameter.
@ -33,7 +33,7 @@ __visible int plugin_is_GPL_compatible;
static int track_frame_size = -1; static int track_frame_size = -1;
static bool build_for_x86 = false; static bool build_for_x86 = false;
static const char track_function[] = "stackleak_track_stack"; static const char track_function[] = "__sanitizer_cov_stack_depth";
static bool disable = false; static bool disable = false;
static bool verbose = false; static bool verbose = false;
@ -58,7 +58,7 @@ static void add_stack_tracking_gcall(gimple_stmt_iterator *gsi, bool after)
cgraph_node_ptr node; cgraph_node_ptr node;
basic_block bb; basic_block bb;
/* Insert calling stackleak_track_stack() */ /* Insert calling __sanitizer_cov_stack_depth() */
stmt = gimple_build_call(track_function_decl, 0); stmt = gimple_build_call(track_function_decl, 0);
gimple_call = as_a_gcall(stmt); gimple_call = as_a_gcall(stmt);
if (after) if (after)
@ -120,12 +120,12 @@ static void add_stack_tracking_gasm(gimple_stmt_iterator *gsi, bool after)
gcc_assert(build_for_x86); gcc_assert(build_for_x86);
/* /*
* Insert calling stackleak_track_stack() in asm: * Insert calling __sanitizer_cov_stack_depth() in asm:
* asm volatile("call stackleak_track_stack" * asm volatile("call __sanitizer_cov_stack_depth"
* :: "r" (current_stack_pointer)) * :: "r" (current_stack_pointer))
* Use ASM_CALL_CONSTRAINT trick from arch/x86/include/asm/asm.h. * Use ASM_CALL_CONSTRAINT trick from arch/x86/include/asm/asm.h.
* This constraint is taken into account during gcc shrink-wrapping * This constraint is taken into account during gcc shrink-wrapping
* optimization. It is needed to be sure that stackleak_track_stack() * optimization. It is needed to be sure that __sanitizer_cov_stack_depth()
* call is inserted after the prologue of the containing function, * call is inserted after the prologue of the containing function,
* when the stack frame is prepared. * when the stack frame is prepared.
*/ */
@ -137,7 +137,7 @@ static void add_stack_tracking_gasm(gimple_stmt_iterator *gsi, bool after)
input = build_tree_list(NULL_TREE, build_const_char_string(2, "r")); input = build_tree_list(NULL_TREE, build_const_char_string(2, "r"));
input = chainon(NULL_TREE, build_tree_list(input, sp_decl)); input = chainon(NULL_TREE, build_tree_list(input, sp_decl));
vec_safe_push(inputs, input); vec_safe_push(inputs, input);
asm_call = gimple_build_asm_vec("call stackleak_track_stack", asm_call = gimple_build_asm_vec("call __sanitizer_cov_stack_depth",
inputs, NULL, NULL, NULL); inputs, NULL, NULL, NULL);
gimple_asm_set_volatile(asm_call, true); gimple_asm_set_volatile(asm_call, true);
if (after) if (after)
@ -151,11 +151,11 @@ static void add_stack_tracking(gimple_stmt_iterator *gsi, bool after)
{ {
/* /*
* The 'no_caller_saved_registers' attribute is used for * The 'no_caller_saved_registers' attribute is used for
* stackleak_track_stack(). If the compiler supports this attribute for * __sanitizer_cov_stack_depth(). If the compiler supports this attribute for
* the target arch, we can add calling stackleak_track_stack() in asm. * the target arch, we can add calling __sanitizer_cov_stack_depth() in asm.
* That improves performance: we avoid useless operations with the * That improves performance: we avoid useless operations with the
* caller-saved registers in the functions from which we will remove * caller-saved registers in the functions from which we will remove
* stackleak_track_stack() call during the stackleak_cleanup pass. * __sanitizer_cov_stack_depth() call during the stackleak_cleanup pass.
*/ */
if (lookup_attribute_spec(get_identifier("no_caller_saved_registers"))) if (lookup_attribute_spec(get_identifier("no_caller_saved_registers")))
add_stack_tracking_gasm(gsi, after); add_stack_tracking_gasm(gsi, after);
@ -165,7 +165,7 @@ static void add_stack_tracking(gimple_stmt_iterator *gsi, bool after)
/* /*
* Work with the GIMPLE representation of the code. Insert the * Work with the GIMPLE representation of the code. Insert the
* stackleak_track_stack() call after alloca() and into the beginning * __sanitizer_cov_stack_depth() call after alloca() and into the beginning
* of the function if it is not instrumented. * of the function if it is not instrumented.
*/ */
static unsigned int stackleak_instrument_execute(void) static unsigned int stackleak_instrument_execute(void)
@ -205,7 +205,7 @@ static unsigned int stackleak_instrument_execute(void)
DECL_NAME_POINTER(current_function_decl)); DECL_NAME_POINTER(current_function_decl));
} }
/* Insert stackleak_track_stack() call after alloca() */ /* Insert __sanitizer_cov_stack_depth() call after alloca() */
add_stack_tracking(&gsi, true); add_stack_tracking(&gsi, true);
if (bb == entry_bb) if (bb == entry_bb)
prologue_instrumented = true; prologue_instrumented = true;
@ -241,7 +241,7 @@ static unsigned int stackleak_instrument_execute(void)
return 0; return 0;
} }
/* Insert stackleak_track_stack() call at the function beginning */ /* Insert __sanitizer_cov_stack_depth() call at the function beginning */
bb = entry_bb; bb = entry_bb;
if (!single_pred_p(bb)) { if (!single_pred_p(bb)) {
/* gcc_assert(bb_loop_depth(bb) || /* gcc_assert(bb_loop_depth(bb) ||
@ -270,15 +270,15 @@ static void remove_stack_tracking_gcall(void)
rtx_insn *insn, *next; rtx_insn *insn, *next;
/* /*
* Find stackleak_track_stack() calls. Loop through the chain of insns, * Find __sanitizer_cov_stack_depth() calls. Loop through the chain of insns,
* which is an RTL representation of the code for a function. * which is an RTL representation of the code for a function.
* *
* The example of a matching insn: * The example of a matching insn:
* (call_insn 8 4 10 2 (call (mem (symbol_ref ("stackleak_track_stack") * (call_insn 8 4 10 2 (call (mem (symbol_ref ("__sanitizer_cov_stack_depth")
* [flags 0x41] <function_decl 0x7f7cd3302a80 stackleak_track_stack>) * [flags 0x41] <function_decl 0x7f7cd3302a80 __sanitizer_cov_stack_depth>)
* [0 stackleak_track_stack S1 A8]) (0)) 675 {*call} (expr_list * [0 __sanitizer_cov_stack_depth S1 A8]) (0)) 675 {*call} (expr_list
* (symbol_ref ("stackleak_track_stack") [flags 0x41] <function_decl * (symbol_ref ("__sanitizer_cov_stack_depth") [flags 0x41] <function_decl
* 0x7f7cd3302a80 stackleak_track_stack>) (expr_list (0) (nil))) (nil)) * 0x7f7cd3302a80 __sanitizer_cov_stack_depth>) (expr_list (0) (nil))) (nil))
*/ */
for (insn = get_insns(); insn; insn = next) { for (insn = get_insns(); insn; insn = next) {
rtx body; rtx body;
@ -318,7 +318,7 @@ static void remove_stack_tracking_gcall(void)
if (SYMBOL_REF_DECL(body) != track_function_decl) if (SYMBOL_REF_DECL(body) != track_function_decl)
continue; continue;
/* Delete the stackleak_track_stack() call */ /* Delete the __sanitizer_cov_stack_depth() call */
delete_insn_and_edges(insn); delete_insn_and_edges(insn);
#if BUILDING_GCC_VERSION < 8000 #if BUILDING_GCC_VERSION < 8000
if (GET_CODE(next) == NOTE && if (GET_CODE(next) == NOTE &&
@ -340,12 +340,12 @@ static bool remove_stack_tracking_gasm(void)
gcc_assert(build_for_x86); gcc_assert(build_for_x86);
/* /*
* Find stackleak_track_stack() asm calls. Loop through the chain of * Find __sanitizer_cov_stack_depth() asm calls. Loop through the chain of
* insns, which is an RTL representation of the code for a function. * insns, which is an RTL representation of the code for a function.
* *
* The example of a matching insn: * The example of a matching insn:
* (insn 11 5 12 2 (parallel [ (asm_operands/v * (insn 11 5 12 2 (parallel [ (asm_operands/v
* ("call stackleak_track_stack") ("") 0 * ("call __sanitizer_cov_stack_depth") ("") 0
* [ (reg/v:DI 7 sp [ current_stack_pointer ]) ] * [ (reg/v:DI 7 sp [ current_stack_pointer ]) ]
* [ (asm_input:DI ("r")) ] []) * [ (asm_input:DI ("r")) ] [])
* (clobber (reg:CC 17 flags)) ]) -1 (nil)) * (clobber (reg:CC 17 flags)) ]) -1 (nil))
@ -375,7 +375,7 @@ static bool remove_stack_tracking_gasm(void)
continue; continue;
if (strcmp(ASM_OPERANDS_TEMPLATE(body), if (strcmp(ASM_OPERANDS_TEMPLATE(body),
"call stackleak_track_stack")) { "call __sanitizer_cov_stack_depth")) {
continue; continue;
} }
@ -389,7 +389,7 @@ static bool remove_stack_tracking_gasm(void)
/* /*
* Work with the RTL representation of the code. * Work with the RTL representation of the code.
* Remove the unneeded stackleak_track_stack() calls from the functions * Remove the unneeded __sanitizer_cov_stack_depth() calls from the functions
* which don't call alloca() and don't have a large enough stack frame size. * which don't call alloca() and don't have a large enough stack frame size.
*/ */
static unsigned int stackleak_cleanup_execute(void) static unsigned int stackleak_cleanup_execute(void)
@ -474,13 +474,13 @@ static bool stackleak_gate(void)
return track_frame_size >= 0; return track_frame_size >= 0;
} }
/* Build the function declaration for stackleak_track_stack() */ /* Build the function declaration for __sanitizer_cov_stack_depth() */
static void stackleak_start_unit(void *gcc_data __unused, static void stackleak_start_unit(void *gcc_data __unused,
void *user_data __unused) void *user_data __unused)
{ {
tree fntype; tree fntype;
/* void stackleak_track_stack(void) */ /* void __sanitizer_cov_stack_depth(void) */
fntype = build_function_type_list(void_type_node, NULL_TREE); fntype = build_function_type_list(void_type_node, NULL_TREE);
track_function_decl = build_fn_decl(track_function, fntype); track_function_decl = build_fn_decl(track_function, fntype);
DECL_ASSEMBLER_NAME(track_function_decl); /* for LTO */ DECL_ASSEMBLER_NAME(track_function_decl); /* for LTO */

4
security/Kconfig.hardening
View file

@ -129,8 +129,8 @@ config KSTACK_ERASE_TRACK_MIN_SIZE
help help
The KSTACK_ERASE option instruments the kernel code for tracking The KSTACK_ERASE option instruments the kernel code for tracking
the lowest border of the kernel stack (and for some other purposes). the lowest border of the kernel stack (and for some other purposes).
It inserts the stackleak_track_stack() call for the functions with It inserts the __sanitizer_cov_stack_depth() call for the functions
a stack frame size greater than or equal to this parameter. with a stack frame size greater than or equal to this parameter.
If unsure, leave the default value 100. If unsure, leave the default value 100.
config KSTACK_ERASE_METRICS config KSTACK_ERASE_METRICS

2
tools/objtool/check.c
View file

@ -1193,7 +1193,7 @@ static const char *uaccess_safe_builtin[] = {
"__ubsan_handle_shift_out_of_bounds", "__ubsan_handle_shift_out_of_bounds",
"__ubsan_handle_load_invalid_value", "__ubsan_handle_load_invalid_value",
/* KSTACK_ERASE */ /* KSTACK_ERASE */
"stackleak_track_stack", "__sanitizer_cov_stack_depth",
/* TRACE_BRANCH_PROFILING */ /* TRACE_BRANCH_PROFILING */
"ftrace_likely_update", "ftrace_likely_update",
/* STACKPROTECTOR */ /* STACKPROTECTOR */