Skip to contentSkip to conversation

Fix ordering of ftrace/livepatch calls on module load and unload

PATCH Superseded Jessica Yu 7 participants 20 messages Feb 2, 2016 – Feb 8, 2016

Subsystems (3)

v2 of 5 Superseded Latest is v5 →

lore
Share & tools
lore

Jessica Yu

author
#0 lore raw

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
author
#1 lore raw

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
index 81de712..c2b340e 100644
@@ -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
index 8358f46..b05d466 100644
@@ -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
index eca592f..57a6eea 100644
@@ -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
maintainer
#2 lore raw

Re: [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() 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
index 81de712..c2b340e 100644
@@ -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
index 8358f46..b05d466 100644
@@ -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

maintainer
#3 lore raw

Re: [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() in bug_cleanup:
goto target in load_module(). Otherwise, it will stay enabled when, e.g. parse_args() fails.

Look farther down (after free_module:), it's already there.

-- Steve

maintainer
#4 lore raw

Re: [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() in bug_cleanup:
goto target in load_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

maintainer
#5 lore raw

Re: [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

author
#6 lore raw

PATCH v2 2/2 livepatch/module: remove livepatch module notifier

In reply to 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 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
index a882865..fdd5f1c 100644
@@ -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
index b05d466..71c77ed 100644
@@ -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
maintainer
#7 lore raw

Re: [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 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
index a882865..fdd5f1c 100644
@@ -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
index bc2c85c..7aa975d 100644

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
index b05d466..71c77ed 100644
@@ -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

maintainer
#8 lore raw

Re: [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 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);
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

maintainer
#9 lore raw

Re: [PATCH v2 2/2] livepatch/module: remove livepatch module notifier

In reply to Petr Mladek
Quoted 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

author
#10 lore raw

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
index b05d466..71c77ed 100644
@@ -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);
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

maintainer
#11 lore raw

Re: 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
index b05d466..71c77ed 100644
@@ -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 -0
 	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, · 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 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);
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:

(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, 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.

(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 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?

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

maintainer
#12 lore raw

Re: 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 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.

This sounds better to me.

Quoted 9 lines
Quoted 8 lines

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?

Quoted 3 lines

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.

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

#13 lore raw

Re: livepatch/module: remove livepatch module notifier

In reply to Jessica Yu
Quoted 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
index b05d466..71c77ed 100644
@@ -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);
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:

(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, 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.

Sounds good.

Quoted 5 lines

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?

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.

maintainer
#14 lore raw

Re: [PATCH v2 2/2] livepatch/module: remove livepatch module notifier

In reply to Jessica Yu

include/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
index b05d466..71c77ed 100644
@@ -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

#15 lore raw

Re: [PATCH v2 2/2] livepatch/module: remove livepatch module notifier

In reply to Jessica Yu
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 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
index a882865..fdd5f1c 100644
@@ -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
index bc2c85c..7aa975d 100644
@@ -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
maintainer
#16 lore raw

Re: [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 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
index a882865..fdd5f1c 100644
@@ -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
index bc2c85c..7aa975d 100644
@@ -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

#17 lore raw
In reply to Jessica Yu
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 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

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
maintainer Reviewed-by
#18 lore raw
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

Acked-by
#19 lore raw
Quoted 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:

on the first patch and take it through your tree.

Agreed.

Cheers,
Rusty.