jump_label: Robustify jump label patching
Subsystems (3)
v3 cover jump_label: Robustify jump label patching
v3:
- Make init_kernel_text() global
- Use braces in multi-line 'for' statements
v2:
- Refine the warning so that it doesn't warn about __init entries
- (Do so by explicitly disabling __init entries)
- Drop v1 patches which removed __init tracepoints
Josh Poimboeuf (3):
jump_label: Explicitly disable jump labels in __init code
jump_label: Warn on failed jump_label patch
extable: Make init_kernel_text() global
arch/x86/kernel/unwind_orc.c | 3 +-- include/linux/jump_label.h | 3 +++ include/linux/kernel.h | 1 + init/main.c | 2 ++ kernel/extable.c | 2 +- kernel/jump_label.c | 27 ++++++++++++++++++++++----- 6 files changed, 30 insertions(+), 8 deletions(-)
Signature · 1 line
2.14.3
PATCH v3 3/3 extable: Make init_kernel_text() global
Convert init_kernel_text() to a global function and use it in a few places instead of manually comparing _sinittext and _einittext.
Note that kallsyms.h has a very similar function called is_kernel_inittext(), but its end check is inclusive. I'm not sure whether that's intentional behavior, so I didn't touch it.
--- arch/x86/kernel/unwind_orc.c | 3 +-- include/linux/kernel.h | 1 + kernel/extable.c | 2 +- kernel/jump_label.c | 4 +--- 4 files changed, 4 insertions(+), 6 deletions(-)
arch/x86/kernel/unwind_orc.c +1 -2
@@ -5,7 +5,6 @@#include <asm/unwind.h> #include <asm/orc_types.h> #include <asm/orc_lookup.h> -#include <asm/sections.h> #define orc_warn (fmt, ...) \ printk_deferred_once(KERN_WARNING pr_fmt("WARNING: " fmt), ##__VA_ARGS__)
@@ -148,7 +147,7 @@ static struct orc_entry *orc_find(unsigned long ip) }/* vmlinux .init slow lookup: */ -if (ip >= (unsigned long )_sinittext && ip < (unsigned long )_einittext) +if (init_kernel_text (ip))return __orc_find (__start_orc_unwind_ip, __start_orc_unwind, __stop_orc_unwind_ip - __start_orc_unwind_ip, ip);
include/linux/kernel.h +1 -0
@@ -472,6 +472,7 @@ extern bool parse_option_str(const char *str, const char *option);extern char *next_arg (char *args,char **param,char **val);extern int core_kernel_text (unsigned long addr); +extern int init_kernel_text (unsigned long addr);extern int core_kernel_data (unsigned long addr);extern int __kernel_text_address (unsigned long addr);extern int kernel_text_address (unsigned long addr);
kernel/extable.c +1 -1
@@ -64,7 +64,7 @@ const struct exception_table_entry *search_exception_tables(unsigned long addr)return e; } -static inline int init_kernel_text (unsigned long addr) +int init_kernel_text (unsigned long addr) {if (addr >= (unsigned long )_sinittext && addr < (unsigned long )_einittext)
kernel/jump_label.c +1 -3
@@ -16,7 +16,6 @@#include <linux/jump_label_ratelimit.h> #include <linux/bug.h> #include <linux/cpu.h> -#include <asm/sections.h> #ifdef HAVE_JUMP_LABEL
@@ -645,8 +644,7 @@ void __init jump_label_invalidate_init(void)struct jump_entry *iter;for (iter = iter_start; iter < iter_stop; iter++) { -if (iter->code >= (unsigned long )_sinittext && - iter->code < (unsigned long )_einittext) +if (init_kernel_text (iter->code)) iter->code =0 ; } }
Signature · 1 line
2.14.3
PATCH v3 2/3 jump_label: Warn on failed jump_label patch
In reply to Josh PoimboeufWhen the jump label code encounters an address which isn't recognized by kernel_text_address(), it just silently fails.
This can be dangerous because jump labels are used in a variety of places, and are generally expected to work. Convert the silent failure to a warning.
This won't warn about attempted writes to tracepoints in __init code after initmem has been freed, as those are already guarded by the entry->code check.
--- kernel/jump_label.c | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-)
kernel/jump_label.c +8 -5
@@ -367,12 +367,15 @@ static void __jump_label_update(struct static_key *key, {for (; (entry < stop) && (jump_entry_key (entry) == key); entry++) {/* -* entry->code set to 0 invalidates module init text sections -* kernel_text_address() verifies we are not in core kernel -* init code, see jump_label_invalidate_module_init(). +* An entry->code of 0 indicates an entry which has been +* disabled because it was in an init text area. */ -if (entry->code &&kernel_text_address (entry->code)) -arch_jump_label_transform (entry,jump_label_type (entry)); +if (entry->code) { +if (kernel_text_address (entry->code)) +arch_jump_label_transform (entry,jump_label_type (entry)); +else +WARN_ONCE (1 ,"can't patch jump_label at %pS" , (void *)entry->code); + } } }
Signature · 1 line
2.14.3
PATCH v3 1/3 jump_label: Explicitly disable jump labels in __init code
In reply to Josh PoimboeufAfter initmem has been freed, any jump labels in __init code are prevented from being written to by the kernel_text_address() check in __jump_label_update(). However, this check is quite broad. If kernel_text_address() were to return false for any other reason, the jump label write would fail silently with no warning.
For jump labels in module init code, entry->code is set to zero to indicate that the entry is disabled. Do the same thing for core kernel init code. This makes the behavior more consistent, and will also make it more straightforward to detect non-init jump label write failures in the next patch.
--- include/linux/jump_label.h | 3 +++ init/main.c | 2 ++ kernel/jump_label.c | 16 ++++++++++++++++ 3 files changed, 21 insertions(+)
include/linux/jump_label.h +3 -0
@@ -151,6 +151,7 @@ extern struct jump_entry __start___jump_table[];extern struct jump_entry __stop___jump_table[];extern void jump_label_init (void ); +extern void jump_label_invalidate_init (void );extern void jump_label_lock (void );extern void jump_label_unlock (void ); extern void arch_jump_label_transform(struct jump_entry *entry,
@@ -198,6 +199,8 @@ static __always_inline void jump_label_init(void) static_key_initialized = true; } +static inline void jump_label_invalidate_init (void ) {} + static __always_inline bool static_key_false(struct static_key *key) {if (unlikely (static_key_count (key) >0 ))
init/main.c +2 -0
@@ -89,6 +89,7 @@#include <linux/io.h> #include <linux/cache.h> #include <linux/rodata_test.h> +#include <linux/jump_label.h> #include <asm/io.h> #include <asm/bugs.h>
@@ -1000,6 +1001,7 @@ static int __ref kernel_init(void *unused)/* need to finish all async __init code before freeing the memory */ async_synchronize_full ();ftrace_free_init_mem (); +jump_label_invalidate_init ();free_initmem ();mark_readonly (); system_state =SYSTEM_RUNNING ;
kernel/jump_label.c +16 -0
@@ -16,6 +16,7 @@#include <linux/jump_label_ratelimit.h> #include <linux/bug.h> #include <linux/cpu.h> +#include <asm/sections.h> #ifdef HAVE_JUMP_LABEL
@@ -633,6 +634,21 @@ static void jump_label_del_module(struct module *mod) } } +/* Disable any jump label entries in __init code */ +void __init jump_label_invalidate_init (void ) +{ +struct jump_entry *iter_start = __start___jump_table; +struct jump_entry *iter_stop = __stop___jump_table; +struct jump_entry *iter; + +for (iter = iter_start; iter < iter_stop; iter++) { +if (iter->code >= (unsigned long )_sinittext && + iter->code < (unsigned long )_einittext) + iter->code =0 ; + } +} + +/* Disable any jump label entries in module init code */ static void jump_label_invalidate_module_init (struct module *mod) {struct jump_entry *iter_start = mod->jump_entries;
Signature · 1 line
2.14.3
Josh Poimboeuf
NAKRe: [PATCH v3 1/3] jump_label: Explicitly disable jump labels in __init code
Quoted 6 lines · Josh Poimboeuf
After initmem has been freed, any jump labels in
__initcode are prevented from being written to by thekernel_text_address()check in__jump_label_update(). However, this check is quite broad. Ifkernel_text_address()were to return false for any other reason, the jump label write would fail silently with no warning.
Quoted 7 lines
For jump labels in module init code,
entry->codeis set to zero to indicate that the entry is disabled. Do the same thing for core kernel init code. This makes the behavior more consistent, and will also make it more straightforward to detect non-init jump label write failures in the next patch.Signed-off-by Josh Poimboeuf <[email protected]>
NACK
0-day reports this doesn't build with CONFIG_MODULES=n:
init/main.o: In function `kernel_init':
Quoted 1 line
Quoted 1 line
main.c:(.ref.text+0x98): undefined reference to `jump_label_invalidate_init'
Signature · 1 line
Josh