Fix ordering of ftrace/livepatch calls on module load and unload
Subsystems (3)
v2 cover Fix ordering of ftrace/livepatch calls on module load and unload
As explained here [1], livepatch modules are failing to initialize properly because the ftrace coming module notifier (which calls ftrace_module_enable()) runs *after* the livepatch module notifier (which enables the patch(es)). Thus livepatch attempts to apply patches to modules before ftrace_module_enable() is even called for the corresponding module(s). As a result, patch modules break. Ftrace code must run before livepatch on module load, and the reverse is true on module unload.
For ftrace and livepatch, order of initialization (plus exit/cleanup code) is important for loading and unloading modules, and using module notifiers to perform this work is not ideal since it is not always clear what gets called when. In this patchset, dependence on the module notifier call chain is removed in favor of hard coding the corresponding function calls in the module loader. This promotes better code visibility and ensures that ftrace and livepatch code get called in the correct order on patch module load and unload.
Tested the changes with a test livepatch module that patches 9p and nilfs2, and verified that the issue described in [1] is fixed.
Patches are based on linux-next.
v1 can be found here -
http://lkml.kernel.org/g/[email protected]
v2:
- Instead of splitting the ftrace and livepatch notifiers into coming + going notifiers and adjusting their priorities, remove ftrace and livepatch notifiers completely and hard-code the necessary function calls in the module loader.
[1] http://lkml.kernel.org/g/[email protected]
Jessica Yu (2):
ftrace/module: remove ftrace module notifier livepatch/module: remove livepatch module notifier
include/linux/ftrace.h | 6 +- include/linux/livepatch.h | 9 +++ kernel/livepatch/core.c | 144 ++++++++++++++++++++++------------------------ kernel/module.c | 12 ++++ kernel/trace/ftrace.c | 36 +----------- 5 files changed, 95 insertions(+), 112 deletions(-)
Signature · 1 line
2.4.3
PATCH v2 1/2 ftrace/module: remove ftrace module notifier
Remove the ftrace module notifier in favor of directly calling ftrace_module_enable() and ftrace_release_mod() in the module loader. Hard-coding the function calls directly in the module loader removes dependence on the module notifier call chain and provides better visibility and control over what gets called when, which is important to kernel utilities such as livepatch.
--- include/linux/ftrace.h | 6 ++++-- kernel/module.c | 4 ++++ kernel/trace/ftrace.c | 36 +----------------------------------- 3 files changed, 9 insertions(+), 37 deletions(-)
include/linux/ftrace.h +4 -2
@@ -603,6 +603,7 @@ extern int ftrace_arch_read_dyn_info(char *buf, int size);extern int skip_trace (unsigned long ip);extern void ftrace_module_init (struct module *mod); +extern void ftrace_module_enable (struct module *mod);extern void ftrace_release_mod (struct module *mod);extern void ftrace_disable_daemon (void );
@@ -612,8 +613,9 @@ static inline int skip_trace(unsigned long ip) { return 0; }static inline int ftrace_force_update (void ) {return 0 ; }static inline void ftrace_disable_daemon (void ) { }static inline void ftrace_enable_daemon (void ) { } -static inline void ftrace_release_mod (struct module *mod) {} -static inline void ftrace_module_init (struct module *mod) {} +static inline void ftrace_module_init (struct module *mod) { } +static inline void ftrace_module_enable (struct module *mod) { } +static inline void ftrace_release_mod (struct module *mod) { }static inline __init int register_ftrace_command (struct ftrace_func_command *cmd) {return -EINVAL ;
kernel/module.c +4 -0
@@ -981,6 +981,8 @@ SYSCALL_DEFINE2(delete_module, const char __user *, name_user, mod->exit ();blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_GOING , mod); +ftrace_release_mod (mod); +async_synchronize_full ();/* Store the name of the last unloaded module for diagnostic purposes */
@@ -3295,6 +3297,7 @@ fail:module_put (mod);blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_GOING , mod); +ftrace_release_mod (mod);free_module (mod);wake_up_all (&module_wq);return ret;
@@ -3371,6 +3374,7 @@ static int complete_formation(struct module *mod, struct load_info *info) mod->state =MODULE_STATE_COMING ;mutex_unlock (&module_mutex); +ftrace_module_enable (mod);blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_COMING , mod);return 0 ;
kernel/trace/ftrace.c +1 -35
@@ -4961,7 +4961,7 @@ void ftrace_release_mod(struct module *mod)mutex_unlock (&ftrace_lock); } -static void ftrace_module_enable (struct module *mod) +void ftrace_module_enable (struct module *mod) {struct dyn_ftrace *rec;struct ftrace_page *pg;
@@ -5038,38 +5038,8 @@ void ftrace_module_init(struct module *mod)ftrace_process_locs (mod, mod->ftrace_callsites, mod->ftrace_callsites + mod->num_ftrace_callsites); } - -static int ftrace_module_notify (struct notifier_block *self, -unsigned long val,void *data) -{ -struct module *mod = data; - -switch (val) { -case MODULE_STATE_COMING : -ftrace_module_enable (mod); -break ; -case MODULE_STATE_GOING : -ftrace_release_mod (mod); -break ; -default : -break ; - } - -return 0 ; -} -#else -static int ftrace_module_notify (struct notifier_block *self, -unsigned long val,void *data) -{ -return 0 ; -}#endif /* CONFIG_MODULES */ -struct notifier_block ftrace_module_nb = { - .notifier_call = ftrace_module_notify, - .priority =INT_MIN ,/* Run after anything that can remove kprobes */ -}; -void __init ftrace_init (void ) {extern unsigned long __start_mcount_loc[];
@@ -5098,10 +5068,6 @@ void __init ftrace_init(void) __start_mcount_loc, __stop_mcount_loc); - ret =register_module_notifier (&ftrace_module_nb); -if (ret) -pr_warning ("Failed to register trace ftrace module exit notifier\n" ); -set_ftrace_early_filters ();return ;
Signature · 1 line
2.4.3
Petr Mladek
maintainerRe: [PATCH v2 1/2] ftrace/module: remove ftrace module notifier
Quoted 60 lines · Jessica Yu
Remove the ftrace module notifier in favor of directly calling
ftrace_module_enable()andftrace_release_mod()in the module loader. Hard-coding the function calls directly in the module loader removes dependence on the module notifier call chain and provides better visibility and control over what gets called when, which is important to kernel utilities such as livepatch.Signed-off-by Jessica Yu <[email protected]>--- include/linux/ftrace.h | 6 ++++-- kernel/module.c | 4 ++++ kernel/trace/ftrace.c | 36 +----------------------------------- 3 files changed, 9 insertions(+), 37 deletions(-)include/linux/ftrace.h +4
-2@@ -603,6 +603,7 @@ extern int ftrace_arch_read_dyn_info(char *buf, int size);extern int skip_trace (unsigned long ip);extern void ftrace_module_init (struct module *mod); +extern void ftrace_module_enable (struct module *mod);extern void ftrace_release_mod (struct module *mod);extern void ftrace_disable_daemon (void );@@ -612,8 +613,9 @@ static inline int skip_trace(unsigned long ip) { return 0; }static inline int ftrace_force_update (void ) {return 0 ; }static inline void ftrace_disable_daemon (void ) { }static inline void ftrace_enable_daemon (void ) { } -static inline void ftrace_release_mod (struct module *mod) {} -static inline void ftrace_module_init (struct module *mod) {} +static inline void ftrace_module_init (struct module *mod) { } +static inline void ftrace_module_enable (struct module *mod) { } +static inline void ftrace_release_mod (struct module *mod) { }static inline __init int register_ftrace_command (struct ftrace_func_command *cmd) {return -EINVAL ;kernel/module.c +3
-0@@ -981,6 +981,8 @@ SYSCALL_DEFINE2(delete_module, const char __user *, name_user, mod->exit ();blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_GOING , mod); +ftrace_release_mod (mod); +async_synchronize_full ();/* Store the name of the last unloaded module for diagnostic purposes */ @@ -3295,6 +3297,7 @@ fail:module_put (mod);blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_GOING , mod); +ftrace_release_mod (mod);free_module (mod);wake_up_all (&module_wq);return ret;
kernel/module.c static int complete_formation(struct module *mod, struct load_info *info) · line 3380
Quoted 7 lines
kernel/module.c +1
-0@@ -3371,6 +3374,7 @@ static int complete_formation(struct module *mod, struct load_info *info) mod->state =MODULE_STATE_COMING ;mutex_unlock (&module_mutex); +ftrace_module_enable (mod);blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_COMING , mod);return 0 ;
Also we need to call ftrace_release_mod() in bug_cleanup:
goto target in load_module(). Otherwise, it will stay enabled when, e.g. parse_args() fails.
Best Regards,
Petr
Steven Rostedt
maintainerRe: [PATCH v2 1/2] ftrace/module: remove ftrace module notifier
Quoted 8 lines · On Thu, 4 Feb 2016 14:27:51 +0100 Petr Mladek <[email protected]> wrote:
kernel/module.c static int complete_formation(struct module *mod, struct load_info *info) · line 3380
Quoted 4 lines
kernel/module.c +1
-0+ftrace_module_enable (mod);blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_COMING , mod);return 0 ;Also we need to call
ftrace_release_mod()inbug_cleanup:
goto target inload_module(). Otherwise, it will stay enabled when, e.g.parse_args()fails.
Look farther down (after free_module:), it's already there.
-- Steve
Petr Mladek
maintainerRe: [PATCH v2 1/2] ftrace/module: remove ftrace module notifier
Quoted 13 lines · Steven Rostedt
Quoted 8 lines · On Thu, 4 Feb 2016 14:27:51 +0100 Petr Mladek <[email protected]> wrote:
kernel/module.c static int complete_formation(struct module *mod, struct load_info *info) · line 3380
Quoted 4 lines
kernel/module.c +1
-0+ftrace_module_enable (mod);blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_COMING , mod);return 0 ;Also we need to call
ftrace_release_mod()inbug_cleanup:
goto target inload_module(). Otherwise, it will stay enabled when, e.g.parse_args()fails.
Quoted 1 line
Look farther down (after
free_module:), it's already there.
Ah, I see. ftrace_release_mod() is called there on an unexpected location. Error paths typically do actions in the reverse order in compare with the normal paths :-)
Thanks for the pointer,
Petr
Steven Rostedt
maintainerRe: [PATCH v2 1/2] ftrace/module: remove ftrace module notifier
Quoted 3 lines · On Thu, 4 Feb 2016 16:21:20 +0100 Petr Mladek <[email protected]> wrote:
Ah, I see.
ftrace_release_mod()is called there on an unexpected location. Error paths typically do actions in the reverse order in compare with the normal paths :-)
And that's why there's a comment above it describing why it's not in the normal "reverse" location.
-- Steve
PATCH v2 2/2 livepatch/module: remove livepatch module notifier
In reply to Jessica YuRemove the livepatch module notifier in favor of directly enabling and disabling patches to modules in the module loader. Hard-coding the function calls ensures that ftrace_module_enable() is run before klp_module_enable() during module load, and that klp_module_disable() is run before ftrace_release_mod() during module unload. This way, ftrace and livepatch code is run in the correct order during the module load/unload sequence without dependence on the module notifier call chain.
This fixes a notifier ordering issue in which the ftrace module notifier (and hence ftrace_module_enable()) for coming modules was being called after klp_module_notify(), which caused livepatch modules to initialize incorrectly.
--- include/linux/livepatch.h | 9 +++ kernel/livepatch/core.c | 144 ++++++++++++++++++++++------------------------ kernel/module.c | 8 +++ 3 files changed, 86 insertions(+), 75 deletions(-)
include/linux/livepatch.h +9 -0
@@ -134,6 +134,15 @@ int klp_unregister_patch(struct klp_patch *);int klp_enable_patch (struct klp_patch *);int klp_disable_patch (struct klp_patch *); +/* Called from the module loader during module coming/going states */ +extern int klp_module_enable (struct module *mod); +extern void klp_module_disable (struct module *mod); + +#else /* !CONFIG_LIVEPATCH */ + +static inline int klp_module_enable (struct module *mod) {return 0 ; } +static inline void klp_module_disable (struct module *mod) { } +#endif /* CONFIG_LIVEPATCH */ #endif /* _LINUX_LIVEPATCH_H_ */
kernel/livepatch/core.c +69 -75
200 lines not on this page · raw message
kernel/module.c +8 -0
@@ -53,6 +53,7 @@#include <asm/sections.h> #include <linux/tracepoint.h> #include <linux/ftrace.h> +#include <linux/livepatch.h> #include <linux/async.h> #include <linux/percpu.h> #include <linux/kmemleak.h>
@@ -981,6 +982,7 @@ SYSCALL_DEFINE2(delete_module, const char __user *, name_user, mod->exit ();blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_GOING , mod); +klp_module_disable (mod);ftrace_release_mod (mod);async_synchronize_full ();
@@ -3297,6 +3299,7 @@ fail:module_put (mod);blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_GOING , mod); +klp_module_disable (mod);ftrace_release_mod (mod);free_module (mod);wake_up_all (&module_wq);
@@ -3375,6 +3378,10 @@ static int complete_formation(struct module *mod, struct load_info *info)mutex_unlock (&module_mutex);ftrace_module_enable (mod); + err =klp_module_enable (mod); +if (err) + goto out; +blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_COMING , mod);return 0 ;
@@ -3531,6 +3538,7 @@ static int load_module(struct load_info *info, const char __user *uargs,blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_GOING , mod); +klp_module_disable (mod);/* we can't deallocate the module until we clear memory protection */ module_disable_ro (mod);
Signature · 1 line
2.4.3
Petr Mladek
maintainerRe: [PATCH v2 2/2] livepatch/module: remove livepatch module notifier
Quoted 45 lines · Jessica Yu
Remove the livepatch module notifier in favor of directly enabling and disabling patches to modules in the module loader. Hard-coding the function calls ensures that
ftrace_module_enable()is run beforeklp_module_enable()during module load, and thatklp_module_disable()is run beforeftrace_release_mod()during module unload. This way, ftrace and livepatch code is run in the correct order during the module load/unload sequence without dependence on the module notifier call chain.This fixes a notifier ordering issue in which the ftrace module notifier (and hence
ftrace_module_enable()) for coming modules was being called afterklp_module_notify(), which caused livepatch modules to initialize incorrectly.Signed-off-by Jessica Yu <[email protected]>--- include/linux/livepatch.h | 9 +++ kernel/livepatch/core.c | 144 ++++++++++++++++++++++------------------------ kernel/module.c | 8 +++ 3 files changed, 86 insertions(+), 75 deletions(-)include/linux/livepatch.h +9
-0@@ -134,6 +134,15 @@ int klp_unregister_patch(struct klp_patch *);int klp_enable_patch (struct klp_patch *);int klp_disable_patch (struct klp_patch *); +/* Called from the module loader during module coming/going states */ +extern int klp_module_enable (struct module *mod); +extern void klp_module_disable (struct module *mod); + +#else /* !CONFIG_LIVEPATCH */ + +static inline int klp_module_enable (struct module *mod) {return 0 ; } +static inline void klp_module_disable (struct module *mod) { } +#endif /* CONFIG_LIVEPATCH */ #endif /* _LINUX_LIVEPATCH_H_ */ kernel/livepatch/core.c +0
-0
kernel/livepatch/core.c static void klp_find_object_module(struct klp_object *obj) · line 106
Quoted 5 lines
kernel/livepatch/core.c +1
-1@@ -103,7 +103,7 @@ static void klp_find_object_module(struct klp_object *obj)*/ mod =find_module (obj->name);/* -* Do not mess work of the module coming and going notifiers. +* Do not mess work of the klp module coming and going handlers.
This is a bit confusing because you removed all functions called *coming* and *going*. I would say something like:
* Do not mess work of klp_module_enable() and klp_module_disable().
Quoted 18 lines
kernel/livepatch/core.c +4
-4* Note that the patch might still be needed before the going handler * is called. Module functions can be called even in the GOING state * until mod->exit() finishes. This is especially important for @@ -866,103 +866,107 @@ int klp_register_patch(struct klp_patch *patch) }EXPORT_SYMBOL_GPL (klp_register_patch); -static int klp_module_notify_coming (struct klp_patch *patch, -struct klp_object *obj) +/* Called when module state is MODULE_STATE_COMING */ +int klp_module_enable (struct module *mod) { -struct module *pmod = patch->mod; -struct module *mod = obj->mod;int ret; +struct klp_patch *patch; +struct klp_object *obj;
kernel/livepatch/core.c int klp_register_patch(struct klp_patch *patch) · line 877
Quoted 10 lines
kernel/livepatch/core.c +1
-8- ret =klp_init_object_loaded (patch, obj); -if (ret) { -pr_warn ("failed to initialize patch '%s' for module '%s' (%d)\n" , - pmod->name, mod->name, ret); -return ret; - } - -if (patch->state ==KLP_DISABLED ) +if (mod->state !=MODULE_STATE_COMING )return 0 ;
The function is not longer called from another state. I would replace this by:
if (WARN_ON(mod->state != MODULE_STATE_COMING)) return -EINVAL;
Quoted 60 lines
kernel/livepatch/core.c +35
-19-pr_notice ("applying patch '%s' to loading module '%s'\n" , - pmod->name, mod->name); +mutex_lock (&klp_mutex); +/* +* Each module has to know that the coming handler has +* been called. We never know what module will get +* patched by a new patch. +*/ + mod->klp_alive = true; - ret =klp_enable_object (obj); -if (ret) -pr_warn ("failed to apply patch '%s' to module '%s' (%d)\n" , - pmod->name, mod->name, ret); -return ret; -} +list_for_each_entry (patch, &klp_patches, list) { +klp_for_each_object (patch, obj) { +if (!klp_is_module (obj) ||strcmp (obj->name, mod->name)) +continue ; -static void klp_module_notify_going (struct klp_patch *patch, -struct klp_object *obj) -{ -struct module *pmod = patch->mod; -struct module *mod = obj->mod; + obj->mod = mod; -if (patch->state ==KLP_DISABLED ) - goto disabled; + ret =klp_init_object_loaded (patch, obj); +if (ret) { +pr_warn ("failed to initialize patch '%s' for module '%s' (%d)\n" , + patch->mod->name, obj->mod->name, ret); + goto err; + } + +if (patch->state ==KLP_DISABLED ) +break ; -pr_notice ("reverting patch '%s' on unloading module '%s'\n" , - pmod->name, mod->name); +pr_notice ("applying patch '%s' to loading module '%s'\n" , + patch->mod->name, obj->mod->name); -klp_disable_object (obj); + ret =klp_enable_object (obj); +if (ret) { +pr_warn ("failed to apply patch '%s' to module '%s' (%d)\n" , + patch->mod->name, obj->mod->name, ret); + goto err; + } + +break ; + } + } + +mutex_unlock (&klp_mutex); -disabled:
kernel/livepatch/core.c int klp_register_patch(struct klp_patch *patch) · line 928
Quoted 10 lines
kernel/livepatch/core.c +9
-1-klp_free_object_loaded (obj); +return 0 ; + +err: +/* +* If a patch is unsuccessfully applied, return +* error to the module loader. +*/ + obj->mod =NULL ; +pr_warn ("patch '%s' is in an inconsistent state!\n" , patch->mod->name);
This message is not correct. The module will not get loaded when the patch is not applied.
Instead, we need to revert all the operations that has already been done for this module. Note that the module stayed loaded before, so we did not need to release any memory or revert any ftrace call registration but we need to do so now!
Quoted 127 lines
kernel/livepatch/core.c +19
-42+mutex_unlock (&klp_mutex); + +return ret; } -static int klp_module_notify (struct notifier_block *nb,unsigned long action, -void *data) +/* Called when module state is MODULE_STATE_GOING */ +void klp_module_disable (struct module *mod) { -int ret; -struct module *mod = data;struct klp_patch *patch;struct klp_object *obj; -if (action !=MODULE_STATE_COMING && action !=MODULE_STATE_GOING ) -return 0 ; +if (mod->state !=MODULE_STATE_GOING ) +return ;mutex_lock (&klp_mutex); -/* -* Each module has to know that the notifier has been called. -* We never know what module will get patched by a new patch. +* Each module has to know that the going handler +* has been called. We never know what module will +* get patched by a new patch. */ -if (action ==MODULE_STATE_COMING ) - mod->klp_alive = true; -else /* MODULE_STATE_GOING */ - mod->klp_alive = false; + mod->klp_alive = false;list_for_each_entry (patch, &klp_patches, list) {klp_for_each_object (patch, obj) {if (!klp_is_module (obj) ||strcmp (obj->name, mod->name))continue ; -if (action ==MODULE_STATE_COMING ) { - obj->mod = mod; - ret =klp_module_notify_coming (patch, obj); -if (ret) { - obj->mod =NULL ; -pr_warn ("patch '%s' is in an inconsistent state!\n" , - patch->mod->name); - } - }else /* MODULE_STATE_GOING */ -klp_module_notify_going (patch, obj); +if (patch->state !=KLP_DISABLED ) { +pr_notice ("reverting patch '%s' on unloading module '%s'\n" , + patch->mod->name, obj->mod->name); +klp_disable_object (obj); + } +klp_free_object_loaded (obj);break ; } }mutex_unlock (&klp_mutex); - -return 0 ; } -static struct notifier_block klp_module_nb = { - .notifier_call = klp_module_notify, - .priority =INT_MIN +1 ,/* called late but before ftrace notifier */ -}; -static int __init klp_init (void ) {int ret;@@ -973,21 +977,11 @@ static int __init klp_init(void)return -EINVAL ; } - ret =register_module_notifier (&klp_module_nb); -if (ret) -return ret; - klp_root_kobj =kobject_create_and_add ("livepatch" , kernel_kobj); -if (!klp_root_kobj) { - ret = -ENOMEM ; - goto unregister; - } +if (!klp_root_kobj) +return -ENOMEM ;return 0 ; - -unregister: -unregister_module_notifier (&klp_module_nb); -return ret; }module_init (klp_init);kernel/module.c +3
-0@@ -53,6 +53,7 @@#include <asm/sections.h> #include <linux/tracepoint.h> #include <linux/ftrace.h> +#include <linux/livepatch.h> #include <linux/async.h> #include <linux/percpu.h> #include <linux/kmemleak.h> @@ -981,6 +982,7 @@ SYSCALL_DEFINE2(delete_module, const char __user *, name_user, mod->exit ();blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_GOING , mod); +klp_module_disable (mod);ftrace_release_mod (mod);async_synchronize_full ();@@ -3297,6 +3299,7 @@ fail:module_put (mod);blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_GOING , mod); +klp_module_disable (mod);ftrace_release_mod (mod);free_module (mod);wake_up_all (&module_wq);
kernel/module.c static int complete_formation(struct module *mod, struct load_info *info) · line 3383
Quoted 6 lines
kernel/module.c +3
-0@@ -3375,6 +3378,10 @@ static int complete_formation(struct module *mod, struct load_info *info)mutex_unlock (&module_mutex);ftrace_module_enable (mod); + err =klp_module_enable (mod); +if (err) + goto out;
If you go out here, you need to revert some some operations that are normally done in the bug_cleanup: goto target in load_module(). In particular, you need to do:
/* module_bug_cleanup needs module_mutex protection */ mutex_lock(&module_mutex); module_bug_cleanup(mod); mutex_unlock(&module_mutex); ftrace_release_mod(mod); /* we can't deallocate the module until we clear memory protection */ module_disable_ro(mod); module_disable_nx(mod);
IMHO, it would make sense to somehow split the complete_formation() function and avoid a code duplication in the error paths.
Best Regards,
Petr
Steven Rostedt
maintainerRe: [PATCH v2 2/2] livepatch/module: remove livepatch module notifier
Quoted 24 lines · On Thu, 4 Feb 2016 15:39:35 +0100 Petr Mladek <[email protected]> wrote:
kernel/module.c static int complete_formation(struct module *mod, struct load_info *info) · line 3383
Quoted 7 lines
kernel/module.c +3
-0@@ -3375,6 +3378,10 @@ static int complete_formation(struct module *mod, struct load_info *info)mutex_unlock (&module_mutex);ftrace_module_enable (mod); + err =klp_module_enable (mod); +if (err) + goto out;If you go out here, you need to revert some some operations that are normally done in the
bug_cleanup: goto target inload_module(). In particular, you need to do:/* module_bug_cleanup needs module_mutex protection */ mutex_lock(&module_mutex); module_bug_cleanup(mod); mutex_unlock(&module_mutex); ftrace_release_mod(mod); /* we can't deallocate the module until we clear memory protection */ module_disable_ro(mod); module_disable_nx(mod);
Quoted 2 lines
IMHO, it would make sense to somehow split the
complete_formation()function and avoid a code duplication in the error paths.
If complete_formation() fails, load_module will do a goto ddebug_cleanup, which will eventually call ftrace_release_mod(). No need to do it here.
-- Steve
Miroslav Benes
maintainerRe: [PATCH v2 2/2] livepatch/module: remove livepatch module notifier
In reply to Petr MladekQuoted 34 lines · Petr Mladek
Quoted 33 lines · Jessica Yu
kernel/livepatch/core.c +23
-5-if (patch->state ==KLP_DISABLED ) - goto disabled; + ret =klp_init_object_loaded (patch, obj); +if (ret) { +pr_warn ("failed to initialize patch '%s' for module '%s' (%d)\n" , + patch->mod->name, obj->mod->name, ret); + goto err; + } + +if (patch->state ==KLP_DISABLED ) +break ; -pr_notice ("reverting patch '%s' on unloading module '%s'\n" , - pmod->name, mod->name); +pr_notice ("applying patch '%s' to loading module '%s'\n" , + patch->mod->name, obj->mod->name); -klp_disable_object (obj); + ret =klp_enable_object (obj); +if (ret) { +pr_warn ("failed to apply patch '%s' to module '%s' (%d)\n" , + patch->mod->name, obj->mod->name, ret); + goto err; + } + +break ; + } + } + +mutex_unlock (&klp_mutex);
Quoted 14 lines
kernel/livepatch/core.c int klp_register_patch(struct klp_patch *patch) · line 928
Quoted 11 lines
kernel/livepatch/core.c +9
-2-disabled: -klp_free_object_loaded (obj); +return 0 ; + +err: +/* +* If a patch is unsuccessfully applied, return +* error to the module loader. +*/ + obj->mod =NULL ; +pr_warn ("patch '%s' is in an inconsistent state!\n" , patch->mod->name);This message is not correct. The module will not get loaded when the patch is not applied.
Yes, because we are in a better situation with this patch. We actually return an error and refuse to load the module. Message should take that into account.
Quoted 4 lines
Instead, we need to revert all the operations that has already been done for this module. Note that the module stayed loaded before, so we did not need to release any memory or revert any ftrace call registration but we need to do so now!
Actually, I think the code is correct. If klp_init_object_loaded() there is no problem because we only write relocations there (which are written to the module being loaded) and resolve symbols via kallsyms. Nothing to revert there and it could be done again.
If klp_enable_object() fails, all the relevant error handling was already done there. See the call to klp_disable_object() if klp_enable_function() fails there.
Miroslav
Re: livepatch/module: remove livepatch module notifier
In reply to Petr Mladek+++ Petr Mladek [04/02/16 15:39 +0100]:
Quoted 1 line · Jessica Yu
[ snipped since email is getting long ]
Quoted 52 lines
Quoted 29 lines
kernel/module.c +3
-0@@ -53,6 +53,7 @@#include <asm/sections.h> #include <linux/tracepoint.h> #include <linux/ftrace.h> +#include <linux/livepatch.h> #include <linux/async.h> #include <linux/percpu.h> #include <linux/kmemleak.h> @@ -981,6 +982,7 @@ SYSCALL_DEFINE2(delete_module, const char __user *, name_user, mod->exit ();blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_GOING , mod); +klp_module_disable (mod);ftrace_release_mod (mod);async_synchronize_full ();@@ -3297,6 +3299,7 @@ fail:module_put (mod);blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_GOING , mod); +klp_module_disable (mod);ftrace_release_mod (mod);free_module (mod);wake_up_all (&module_wq);kernel/module.c static int complete_formation(struct module *mod, struct load_info *info) · line 3383
Quoted 6 lines
kernel/module.c +3
-0@@ -3375,6 +3378,10 @@ static int complete_formation(struct module *mod, struct load_info *info)mutex_unlock (&module_mutex);ftrace_module_enable (mod); + err =klp_module_enable (mod); +if (err) + goto out;If you go out here, you need to revert some some operations that are normally done in the
bug_cleanup: goto target inload_module(). In particular, you need to do:/* module_bug_cleanup needs module_mutex protection */ mutex_lock(&module_mutex); module_bug_cleanup(mod); mutex_unlock(&module_mutex); ftrace_release_mod(mod); /* we can't deallocate the module until we clear memory protection */ module_disable_ro(mod); module_disable_nx(mod);
Quoted 2 lines
IMHO, it would make sense to somehow split the
complete_formation()function and avoid a code duplication in the error paths.
Argh, thank you for catching that. I think we could split up complete_formation() into two functions in order to make the error handling work.
We could probably take out the coming notifier calls, ftrace_module_enable(), and klp_module_enable() out of complete_formation(), and put them in another function, maybe called prepare_coming_module(), that would be called right after complete_formation(). It might look something like this:
@@ -3614,6 +3621,9 @@ static int load_module(struct load_info *info, const char __user *uargs,
err = complete_formation(mod, info);
if (err)
goto ddebug_cleanup;+ err = prepare_coming_module(mod); // calls ftrace_module_enable(), klp_module_enable(), then coming notifiers
+ if (err) // means that klp_module_enable failed
+ goto bug_cleanup;
/* Module is ready to execute: parsing args may do that. */
after_dashes = parse_args(mod->name, mod->args, mod->kp, mod->num_kp,
@@ -3621,7 +3631,7 @@ static int load_module(struct load_info *info, const char __user *uargs,
unknown_module_param_cb);
if (IS_ERR(after_dashes)) {
err = PTR_ERR(after_dashes);
- goto bug_cleanup;
+ goto coming_cleanup;
} else if (after_dashes) {
pr_warn("%s: parameters '%s' after `--' ignored\n",
mod->name, after_dashes);Now for the error conditions. If complete_formation() fails, goto ddebug_cleanup. If prepare_coming_module() fails (at that point, module_enable_{ro,nx} and module_bug_finalize() have already finished), goto bug_cleanup. Everything else that fails afterwards (meaning klp_module_enable, ftrace_module_enable, and the coming notifiers have finished) goto coming_cleanup. ftrace_release_mod() gets called in the goto free_module label so we don't have to call it in coming_module.
@@ -3649,16 +3659,16 @@ static int load_module(struct load_info *info, const char __user *uargs,
+ coming_cleanup:
+ blocking_notifier_call_chain(&module_notify_list,
+ MODULE_STATE_GOING, mod);
+ klp_module_disable(mod);
bug_cleanup:
/* module_bug_cleanup needs module_mutex protection */
mutex_lock(&module_mutex);
module_bug_cleanup(mod);
mutex_unlock(&module_mutex);- blocking_notifier_call_chain(&module_notify_list,
- MODULE_STATE_GOING, mod);
- klp_module_disable(mod);
-
/* we can't deallocate the module until we clear memory protection */
module_disable_ro(mod);
module_disable_nx(mod);Does all this look ok? Also, one last thing, I noticed that module->state isn't set to MODULE_STATE_GOING anywhere before the going notifier chain is called in the bug_cleanup label (I think it is still COMING at that point), so the klp_module_disable call right afterwards would have bailed out because of that. To be consistent, shouldn't it be set before the going notifiers are called?
Thanks,
Jessica
Miroslav Benes
maintainerRe: livepatch/module: remove livepatch module notifier
Quoted 119 lines · Jessica Yu
+++ Petr Mladek [04/02/16 15:39 +0100]:
Quoted 1 line · Jessica Yu
[ snipped since email is getting long ]
Quoted 54 lines
Quoted 30 lines
kernel/module.c +2
-0@@ -53,6 +53,7 @@#include <asm/sections.h> #include <linux/tracepoint.h> #include <linux/ftrace.h> +#include <linux/livepatch.h> #include <linux/async.h> #include <linux/percpu.h> #include <linux/kmemleak.h> @@ -981,6 +982,7 @@ SYSCALL_DEFINE2(delete_module, const char __user *, name_user, mod->exit ();blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_GOING , mod); +klp_module_disable (mod);ftrace_release_mod (mod);kernel/module.c +1
-0async_synchronize_full ();@@ -3297,6 +3299,7 @@ fail:module_put (mod);blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_GOING , mod); +klp_module_disable (mod);ftrace_release_mod (mod);free_module (mod);wake_up_all (&module_wq);kernel/module.c static int complete_formation(struct module *mod, · line 3384
Quoted 7 lines
kernel/module.c +3
-0@@ -3375,6 +3378,10 @@ static int complete_formation(struct module *mod, struct load_info *info) mutex_unlock(&module_mutex);ftrace_module_enable (mod); + err =klp_module_enable (mod); +if (err) + goto out;If you go out here, you need to revert some some operations that are normally done in the
bug_cleanup: goto target inload_module(). In particular, you need to do:/* module_bug_cleanup needs module_mutex protection */ mutex_lock(&module_mutex); module_bug_cleanup(mod); mutex_unlock(&module_mutex); ftrace_release_mod(mod); /* we can't deallocate the module until we clear memory protection */ module_disable_ro(mod); module_disable_nx(mod);Quoted 2 lines
IMHO, it would make sense to somehow split the
complete_formation()function and avoid a code duplication in the error paths.Argh, thank you for catching that. I think we could split up
complete_formation()
into two functions in order to make the error handling work.
We could probably take out the coming notifier calls,ftrace_module_enable(), andklp_module_enable()out ofcomplete_formation(), and put them in another function, maybe calledprepare_coming_module(), that would be called right aftercomplete_formation(). It might look something like this:(quoted diff) +1
-0@@ -3614,6 +3621,9 @@ static int load_module(struct load_info *info, const char __user *uargs, err = complete_formation(mod, info); if (err) goto ddebug_cleanup; + err = prepare_coming_module(mod); // calls ftrace_module_enable(),
klp_module_enable(), then coming notifiers(quoted diff) +3
-1+ if (err) // means that klp_module_enable failed + goto bug_cleanup; /* Module is ready to execute: parsing args may do that. */ after_dashes = parse_args(mod->name, mod->args, mod->kp, mod->num_kp,@@ -3621,7 +3631,7 @@ static int load_module(struct load_info *info, const char __user *uargs, unknown_module_param_cb); if (IS_ERR(after_dashes)) { err = PTR_ERR(after_dashes); - goto bug_cleanup; + goto coming_cleanup; } else if (after_dashes) { pr_warn("%s: parameters '%s' after `--' ignored\n",mod->name, after_dashes);Now for the error conditions. If
complete_formation()fails, gotoddebug_cleanup. Ifprepare_coming_module()fails (at that point, module_enable_{ro,nx} andmodule_bug_finalize()have already finished), gotobug_cleanup. Everything else that fails afterwards (meaningklp_module_enable,ftrace_module_enable, and the coming notifiers have finished) gotocoming_cleanup.ftrace_release_mod()gets called in the gotofree_modulelabel so we don't have to call it incoming_module.(quoted diff) +4
-4@@ -3649,16 +3659,16 @@ static int load_module(struct load_info *info, const char __user *uargs, + coming_cleanup: + blocking_notifier_call_chain(&module_notify_list, + MODULE_STATE_GOING, mod); + klp_module_disable(mod); bug_cleanup: /* module_bug_cleanup needs module_mutex protection */ mutex_lock(&module_mutex); module_bug_cleanup(mod); mutex_unlock(&module_mutex); - blocking_notifier_call_chain(&module_notify_list, - MODULE_STATE_GOING, mod); - klp_module_disable(mod); - /* we can't deallocate the module until we clear memory protection */ module_disable_ro(mod); module_disable_nx(mod);
Quoted 1 line
Does all this look ok?
Hm, there is an another option. We can cover the needed error handling in complete_formation(). So for the first error there (verify_export_symbols() fails) we need to only release module_mutex. For our second error we need more. We would call module_bug_cleanup() under module_mutex, module_disable_{ro,nx} and going notifiers. Is this correct? It would be hidden in complete_formation() this way and cleaner in my opinion. There is some code duplication though.
Quoted 8 lines
Also, one last thing, I noticed that
module->state
isn't
set toMODULE_STATE_GOINGanywhere before the going notifier chain is called in
thebug_cleanuplabel (I think it is still COMING at that point), so theklp_module_disablecall right afterwards would have bailed out because of that.
To be consistent, shouldn't it be set before the going notifiers are called?
This could break something or introduce a race somewhere. Git grep says there are several checks for MODULE_STATE_GOING through out the kernel which need to be checked.
Regards,
Miroslav
Petr Mladek
maintainerRe: livepatch/module: remove livepatch module notifier
Quoted 7 lines · Miroslav Benes
Quoted 5 lines · Jessica Yu
Argh, thank you for catching that. I think we could split up
complete_formation()
into two functions in order to make the error handling work.Does all this look ok?
Quoted 7 lines
Hm, there is an another option. We can cover the needed error handling in
complete_formation(). So for the first error there (verify_export_symbols()fails) we need to only releasemodule_mutex. For our second error we need more. We would callmodule_bug_cleanup()undermodule_mutex, module_disable_{ro,nx} and going notifiers. Is this correct? It would be hidden incomplete_formation()this way and cleaner in my opinion. There is some code duplication though.
This sounds better to me.
Quoted 9 lines
Quoted 8 lines
Also, one last thing, I noticed that
module->state
isn't
set toMODULE_STATE_GOINGanywhere before the going notifier chain is called in
thebug_cleanuplabel (I think it is still COMING at that point), so theklp_module_disablecall right afterwards would have bailed out because of that.
To be consistent, shouldn't it be set before the going notifiers are called?
Quoted 3 lines
This could break something or introduce a race somewhere. Git grep says there are several checks for
MODULE_STATE_GOINGthrough out the kernel which need to be checked.
I think that we could relax the condition in the klp_module_going/disable() function and allow to call it also in MODULE_STATE_COMMING_STATE. It would deserve a comment.
Best Regards,
Petr
Re: livepatch/module: remove livepatch module notifier
In reply to Jessica YuQuoted 86 lines · Jessica Yu
+++ Petr Mladek [04/02/16 15:39 +0100]:
Quoted 1 line · Jessica Yu
[ snipped since email is getting long ]
Quoted 52 lines
Quoted 29 lines
kernel/module.c +3
-0@@ -53,6 +53,7 @@#include <asm/sections.h> #include <linux/tracepoint.h> #include <linux/ftrace.h> +#include <linux/livepatch.h> #include <linux/async.h> #include <linux/percpu.h> #include <linux/kmemleak.h> @@ -981,6 +982,7 @@ SYSCALL_DEFINE2(delete_module, const char __user *, name_user, mod->exit ();blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_GOING , mod); +klp_module_disable (mod);ftrace_release_mod (mod);async_synchronize_full ();@@ -3297,6 +3299,7 @@ fail:module_put (mod);blocking_notifier_call_chain (&module_notify_list,MODULE_STATE_GOING , mod); +klp_module_disable (mod);ftrace_release_mod (mod);free_module (mod);wake_up_all (&module_wq);kernel/module.c static int complete_formation(struct module *mod, struct load_info *info) · line 3383
Quoted 6 lines
kernel/module.c +3
-0@@ -3375,6 +3378,10 @@ static int complete_formation(struct module *mod, struct load_info *info)mutex_unlock (&module_mutex);ftrace_module_enable (mod); + err =klp_module_enable (mod); +if (err) + goto out;If you go out here, you need to revert some some operations that are normally done in the
bug_cleanup: goto target inload_module(). In particular, you need to do:/* module_bug_cleanup needs module_mutex protection */ mutex_lock(&module_mutex); module_bug_cleanup(mod); mutex_unlock(&module_mutex); ftrace_release_mod(mod); /* we can't deallocate the module until we clear memory protection */ module_disable_ro(mod); module_disable_nx(mod);Quoted 2 lines
IMHO, it would make sense to somehow split the
complete_formation()function and avoid a code duplication in the error paths.Argh, thank you for catching that. I think we could split up
complete_formation()into two functions in order to make the error handling work.We could probably take out the coming notifier calls,
ftrace_module_enable(), andklp_module_enable()out ofcomplete_formation(), and put them in another function, maybe calledprepare_coming_module(), that would be called right aftercomplete_formation(). It might look something like this:(quoted diff) +4
-1@@ -3614,6 +3621,9 @@ static int load_module(struct load_info *info, const char __user *uargs, err = complete_formation(mod, info); if (err) goto ddebug_cleanup; + err = prepare_coming_module(mod); // calls ftrace_module_enable(), klp_module_enable(), then coming notifiers + if (err) // means that klp_module_enable failed + goto bug_cleanup; /* Module is ready to execute: parsing args may do that. */ after_dashes = parse_args(mod->name, mod->args, mod->kp, mod->num_kp,@@ -3621,7 +3631,7 @@ static int load_module(struct load_info *info, const char __user *uargs, unknown_module_param_cb); if (IS_ERR(after_dashes)) { err = PTR_ERR(after_dashes); - goto bug_cleanup; + goto coming_cleanup; } else if (after_dashes) { pr_warn("%s: parameters '%s' after `--' ignored\n", mod->name, after_dashes);
Quoted 7 lines
Now for the error conditions. If
complete_formation()fails, gotoddebug_cleanup. Ifprepare_coming_module()fails (at that point, module_enable_{ro,nx} andmodule_bug_finalize()have already finished), gotobug_cleanup. Everything else that fails afterwards (meaningklp_module_enable,ftrace_module_enable, and the coming notifiers have finished) gotocoming_cleanup.ftrace_release_mod()gets called in the gotofree_modulelabel so we don't have to call it incoming_module.
Sounds good.
Quoted 5 lines
Also, one last thing, I noticed that
module->stateisn't
set toMODULE_STATE_GOINGanywhere before the going notifier chain is called in thebug_cleanuplabel (I think it is still COMING at that point), so theklp_module_disablecall right afterwards would have bailed out because of that. To be consistent, shouldn't it be set before the going notifiers are called?
Good spotting. You could argue that there's a difference between the notifier argument (what we're doing) and the module state (how far it got), but we do set 'mod->state = MODULE_STATE_GOING;' in the initcall fail case, so this should be the same.
Patch welcome :)
Thanks,
Rusty.
Miroslav Benes
maintainerRe: [PATCH v2 2/2] livepatch/module: remove livepatch module notifier
In reply to Jessica Yuinclude/linux/livepatch.h int klp_unregister_patch(struct klp_patch *); · line 139
Quoted 3 lines · Jessica Yu
include/linux/livepatch.h +3
-0+/* Called from the module loader during module coming/going states */ +extern int klp_module_enable (struct module *mod); +extern void klp_module_disable (struct module *mod);
We do not use 'extern' keyword in header files. It is redundant. Unfortunately, the situation differs among header files and it is hard to be consistent.
kernel/livepatch/core.c int klp_register_patch(struct klp_patch *patch) · line 885
Quoted 6 lines
kernel/livepatch/core.c +6
-0+/* +* Each module has to know that the coming handler has +* been called. We never know what module will get +* patched by a new patch. +*/ + mod->klp_alive = true;
This comment should fixed too.
Note: we still need klp_alive, because the race is still there even without notifiers.
kernel/livepatch/core.c int klp_register_patch(struct klp_patch *patch) · line 941
Quoted 11 lines
kernel/livepatch/core.c +3
-4+void klp_module_disable (struct module *mod) { -int ret; -struct module *mod = data;struct klp_patch *patch;struct klp_object *obj; -if (action !=MODULE_STATE_COMING && action !=MODULE_STATE_GOING ) -return 0 ; +if (mod->state !=MODULE_STATE_GOING ) +return ;
This is similar to what Petr proposed. We must be in MODULE_STATE_GOING here. We could WARN here and return.
kernel/module.c static int complete_formation(struct module *mod, struct load_info *info) · line 3384
Quoted 12 lines
kernel/module.c +4
-0@@ -3375,6 +3378,10 @@ static int complete_formation(struct module *mod, struct load_info *info)mutex_unlock (&module_mutex);ftrace_module_enable (mod); + err =klp_module_enable (mod); +if (err) + goto out; +
if (err)
return err;
module_mutex is already unlocked so no need to jump to out.
Apart from these minor things and Petr's remarks it looks ok.
Thanks for fixing this.
Miroslav
Re: [PATCH v2 2/2] livepatch/module: remove livepatch module notifier
In reply to Jessica YuQuoted 54 lines · Jessica Yu
Remove the livepatch module notifier in favor of directly enabling and disabling patches to modules in the module loader. Hard-coding the function calls ensures that
ftrace_module_enable()is run beforeklp_module_enable()during module load, and thatklp_module_disable()is run beforeftrace_release_mod()during module unload. This way, ftrace and livepatch code is run in the correct order during the module load/unload sequence without dependence on the module notifier call chain.This fixes a notifier ordering issue in which the ftrace module notifier (and hence
ftrace_module_enable()) for coming modules was being called afterklp_module_notify(), which caused livepatch modules to initialize incorrectly.Signed-off-by Jessica Yu <[email protected]>--- include/linux/livepatch.h | 9 +++ kernel/livepatch/core.c | 144 ++++++++++++++++++++++------------------------ kernel/module.c | 8 +++ 3 files changed, 86 insertions(+), 75 deletions(-)include/linux/livepatch.h +9
-0@@ -134,6 +134,15 @@ int klp_unregister_patch(struct klp_patch *);int klp_enable_patch (struct klp_patch *);int klp_disable_patch (struct klp_patch *); +/* Called from the module loader during module coming/going states */ +extern int klp_module_enable (struct module *mod); +extern void klp_module_disable (struct module *mod); + +#else /* !CONFIG_LIVEPATCH */ + +static inline int klp_module_enable (struct module *mod) {return 0 ; } +static inline void klp_module_disable (struct module *mod) { } +#endif /* CONFIG_LIVEPATCH */ #endif /* _LINUX_LIVEPATCH_H_ */ kernel/livepatch/core.c +1
-1@@ -103,7 +103,7 @@ static void klp_find_object_module(struct klp_object *obj)*/ mod =find_module (obj->name);/* -* Do not mess work of the module coming and going notifiers. +* Do not mess work of the klp module coming and going handlers. * Note that the patch might still be needed before the going handler * is called. Module functions can be called even in the GOING state * until mod->exit() finishes. This is especially important for
kernel/livepatch/core.c int klp_register_patch(struct klp_patch *patch) · line 870
Quoted 7 lines
kernel/livepatch/core.c +2
-2@@ -866,103 +866,107 @@ int klp_register_patch(struct klp_patch *patch) }EXPORT_SYMBOL_GPL (klp_register_patch); -static int klp_module_notify_coming (struct klp_patch *patch, -struct klp_object *obj) +/* Called when module state is MODULE_STATE_COMING */ +int klp_module_enable (struct module *mod)
I think this function name was originally my idea. But now I'm thinking it could cause some confusion with the similarly named klp_enable_object().
How about naming it klp_module_coming()? That more accurately describes its purpose IMO and it would also make the comment above it no longer necessary.
And similarly we could rename klp_module_disable() -> klp_module_going().
Signature · 1 line
Josh
Miroslav Benes
maintainerRe: [PATCH v2 2/2] livepatch/module: remove livepatch module notifier
Quoted 67 lines · Josh Poimboeuf
Quoted 54 lines · Jessica Yu
Remove the livepatch module notifier in favor of directly enabling and disabling patches to modules in the module loader. Hard-coding the function calls ensures that
ftrace_module_enable()is run beforeklp_module_enable()during module load, and thatklp_module_disable()is run beforeftrace_release_mod()during module unload. This way, ftrace and livepatch code is run in the correct order during the module load/unload sequence without dependence on the module notifier call chain.This fixes a notifier ordering issue in which the ftrace module notifier (and hence
ftrace_module_enable()) for coming modules was being called afterklp_module_notify(), which caused livepatch modules to initialize incorrectly.Signed-off-by Jessica Yu <[email protected]>--- include/linux/livepatch.h | 9 +++ kernel/livepatch/core.c | 144 ++++++++++++++++++++++------------------------ kernel/module.c | 8 +++ 3 files changed, 86 insertions(+), 75 deletions(-)include/linux/livepatch.h +9
-0@@ -134,6 +134,15 @@ int klp_unregister_patch(struct klp_patch *);int klp_enable_patch (struct klp_patch *);int klp_disable_patch (struct klp_patch *); +/* Called from the module loader during module coming/going states */ +extern int klp_module_enable (struct module *mod); +extern void klp_module_disable (struct module *mod); + +#else /* !CONFIG_LIVEPATCH */ + +static inline int klp_module_enable (struct module *mod) {return 0 ; } +static inline void klp_module_disable (struct module *mod) { } +#endif /* CONFIG_LIVEPATCH */ #endif /* _LINUX_LIVEPATCH_H_ */ kernel/livepatch/core.c +1
-1@@ -103,7 +103,7 @@ static void klp_find_object_module(struct klp_object *obj)*/ mod =find_module (obj->name);/* -* Do not mess work of the module coming and going notifiers. +* Do not mess work of the klp module coming and going handlers. * Note that the patch might still be needed before the going handler * is called. Module functions can be called even in the GOING state * until mod->exit() finishes. This is especially important for kernel/livepatch/core.c int klp_register_patch(struct klp_patch *patch) · line 870
Quoted 7 lines
kernel/livepatch/core.c +2
-2@@ -866,103 +866,107 @@ int klp_register_patch(struct klp_patch *patch) }EXPORT_SYMBOL_GPL (klp_register_patch); -static int klp_module_notify_coming (struct klp_patch *patch, -struct klp_object *obj) +/* Called when module state is MODULE_STATE_COMING */ +int klp_module_enable (struct module *mod)I think this function name was originally my idea. But now I'm thinking it could cause some confusion with the similarly named
klp_enable_object().
Quoted 6 lines
How about naming it
klp_module_coming()? That more accurately describes its purpose IMO and it would also make the comment above it no longer necessary.And similarly we could rename
klp_module_disable()->klp_module_going().
I agree. klp_module_{coming,going} is better.
Miroslav
Quoted 37 lines · Jessica Yu
As explained here [1], livepatch modules are failing to initialize properly because the ftrace coming module notifier (which calls
ftrace_module_enable()) runs *after* the livepatch module notifier (which enables the patch(es)). Thus livepatch attempts to apply patches to modules beforeftrace_module_enable()is even called for the corresponding module(s). As a result, patch modules break. Ftrace code must run before livepatch on module load, and the reverse is true on module unload.For ftrace and livepatch, order of initialization (plus exit/cleanup code) is important for loading and unloading modules, and using module notifiers to perform this work is not ideal since it is not always clear what gets called when. In this patchset, dependence on the module notifier call chain is removed in favor of hard coding the corresponding function calls in the module loader. This promotes better code visibility and ensures that ftrace and livepatch code get called in the correct order on patch module load and unload.
Tested the changes with a test livepatch module that patches 9p and nilfs2, and verified that the issue described in [1] is fixed.
Patches are based on linux-next.
v1 can be found here -
http://lkml.kernel.org/g/[email protected]v2:
- Instead of splitting the ftrace and livepatch notifiers into coming + going notifiers and adjusting their priorities, remove ftrace and livepatch notifiers completely and hard-code the necessary function calls in the module loader.[1] http://lkml.kernel.org/g/[email protected]
Jessica Yu (2):
ftrace/module: remove ftrace module notifier livepatch/module: remove livepatch module notifier
Quoted 5 lines
include/linux/ftrace.h | 6 +- include/linux/livepatch.h | 9 +++ kernel/livepatch/core.c | 144 ++++++++++++++++++++++------------------------ kernel/module.c | 12 ++++ kernel/trace/ftrace.c | 36 +-----------
Steven, Rusty, what is your word on this please?
These two patches should be merged together, and I'd like to have the module patching issue Jessica discovered fixed for 4.5 still. IOW, if you Ack the parts relevant to you (ftrace and module), I'd be willing to take it to Linus through my tree.
Thanks,
Signature · 2 lines
Jiri Kosina SUSE Labs
Quoted 2 lines · On Thu, 4 Feb 2016 11:43:57 +0100 (CET) Jiri Kosina <[email protected]> wrote:
Steven, Rusty, what is your word on this please?
I'm fine with the first patch, but you still need an Ack from Rusty on both. Unfortunately, Rusty is more part-time on kernel development these days. Hopefully he's still paying attention.
Quoted 5 lines
These two patches should be merged together, and I'd like to have the module patching issue Jessica discovered fixed for 4.5 still. IOW, if you Ack the parts relevant to you (ftrace and module), I'd be willing to take it to Linus through my tree.
If you get Rusty's acks, you can add my:
on the first patch and take it through your tree.
-- Steve
Rusty Russell
Acked-byQuoted 10 lines · Steven Rostedt
Quoted 4 lines
These two patches should be merged together, and I'd like to have the module patching issue Jessica discovered fixed for 4.5 still. IOW, if you Ack the parts relevant to you (ftrace and module), I'd be willing to take it to Linus through my tree.
If you get Rusty's acks, you can add my:
Reviewed-by Steven Rostedt <[email protected]>on the first patch and take it through your tree.
Agreed.
Cheers,
Rusty.