0 +l4( (  fB- ̉_I|+?// SPDX-License-Identifier: GPL-2.0-only /* * Copyright 2011-2017 by the PaX Team * Modified by Alexander Popov * * Note: the choice of the license means that the compilation process is * NOT 'eligible' as defined by gcc's library exception to the GPL v3, * but for the kernel it doesn't matter since it doesn't link against * any of the gcc libraries * * This gcc plugin is needed for tracking the lowest border of the kernel stack. * It instruments the kernel code inserting stackleak_track_stack() calls: * - after alloca(); * - for the functions with a stack frame size greater than or equal * to the "track-min-size" plugin parameter. * * This plugin is ported from grsecurity/PaX. For more information see: * https://grsecurity.net/ * https://pax.grsecurity.net/ * * Debugging: * - use fprintf() to stderr, debug_generic_expr(), debug_gimple_stmt(), * print_rtl_single() and debug_rtx(); * - add "-fdump-tree-all -fdump-rtl-all" to the plugin CFLAGS in * Makefile.gcc-plugins to see the verbose dumps of the gcc passes; * - use gcc -E to understand the preprocessing shenanigans; * - use gcc with enabled CFG/GIMPLE/SSA verification (--enable-checking). */ #include "gcc-common.h" __visible int plugin_is_GPL_compatible; static int track_frame_size = -1; static bool build_for_x86 = false; static const char track_function[] = "stackleak_track_stack"; static bool disable = false; static bool verbose = false; /* * Mark these global variables (roots) for gcc garbage collector since * they point to the garbage-collected memory. */ static GTY(()) tree track_function_decl; static struct plugin_info stackleak_plugin_info = { .version = "201707101337", .help = "track-min-size=nn\ttrack stack for functions with a stack frame size >= nn bytes\n" "arch=target_arch\tspecify target build arch\n" "disable\t\tdo not activate the plugin\n" "verbose\t\tprint info about the instrumentation\n" }; static void add_stack_tracking_gcall(gimple_stmt_iterator *gsi, bool after) { gimple stmt; gcall *gimple_call; cgraph_node_ptr node; basic_block bb; /* Insert calling stackleak_track_stack() */ stmt = gimple_build_call(track_function_decl, 0); gimple_call = as_a_gcall(stmt); if (after) gsi_insert_after(gsi, gimple_call, GSI_CONTINUE_LINKING); else gsi_insert_before(gsi, gimple_call, GSI_SAME_STMT); /* Update the cgraph */ bb = gimple_bb(gimple_call); node = cgraph_get_create_node(track_function_decl); gcc_assert(node); cgraph_create_edge(cgraph_get_node(current_function_decl), node, gimple_call, bb->count, compute_call_stmt_bb_frequency(current_function_decl, bb)); } static bool is_alloca(gimple stmt) { if (gimple_call_builtin_p(stmt, BUILT_IN_ALLOCA)) return true; if (gimple_call_builtin_p(stmt, BUILT_IN_ALLOCA_WITH_ALIGN)) return true; return false; } static tree get_current_stack_pointer_decl(void) { varpool_node_ptr node; FOR_EACH_VARIABLE(node) { tree var = NODE_DECL(node); tree name = DECL_NAME(var); if (DECL_NAME_LENGTH(var) != sizeof("current_stack_pointer") - 1) continue; if (strcmp(IDENTIFIER_POINTER(name), "current_stack_pointer")) continue; return var; } if (verbose) { fprintf(stderr, "stackleak: missing current_stack_pointer in %s()\n", DECL_NAME_POINTER(current_function_decl)); } return NULL_TREE; } static void add_stack_tracking_gasm(gimple_stmt_iterator *gsi, bool after) { gasm *asm_call = NULL; tree sp_decl, input; vec *inputs = NULL; /* 'no_caller_saved_registers' is currently supported only for x86 */ gcc_assert(build_for_x86); /* * Insert calling stackleak_track_stack() in asm: * asm volatile("call stackleak_track_stack" * :: "r" (current_stack_pointer)) * Use ASM_CALL_CONSTRAINT trick from arch/x86/include/asm/asm.h. * This constraint is taken into account during gcc shrink-wrapping * optimization. It is needed to be sure that stackleak_track_stack() * call is in