1 files changed, 33 insertions, 10 deletions

diff --git a/kernel/livepatch/core.c b/kernel/livepatch/core.c
index ff7f47d026ac..3f9f1d6b4c2e 100644
--- a/kernel/livepatch/core.c
+++ b/kernel/livepatch/core.c
@@ -89,16 +89,28 @@ static bool klp_is_object_loaded(struct klp_object *obj)
 /* sets obj->mod if object is not vmlinux and module is found */
 static void klp_find_object_module(struct klp_object *obj)
 {
+        struct module *mod;
+
         if (!klp_is_module(obj))
                 return;
 
         mutex_lock(&module_mutex);
         /*
-         * We don't need to take a reference on the module here because we have
-         * the klp_mutex, which is also taken by the module notifier.  This
-         * prevents any module from unloading until we release the klp_mutex.
+         * We do not want to block removal of patched modules and therefore
+         * we do not take a reference here. The patches are removed by
+         * a going module handler instead.
+         */
+        mod = find_module(obj->name);
+        /*
+         * Do not mess work of the module coming and going notifiers.
+         * 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
+         * patches that modify semantic of the functions.
          */
-        obj->mod = find_module(obj->name);
+        if (mod && mod->klp_alive)
+                obj->mod = mod;
+
         mutex_unlock(&module_mutex);
 }
 
@@ -248,11 +260,12 @@ static int klp_find_external_symbol(struct module *pmod, const char *name,
         /* first, check if it's an exported symbol */
         preempt_disable();
         sym = find_symbol(name, NULL, NULL, true, true);
-        preempt_enable();
         if (sym) {
                 *addr = sym->value;
+                preempt_enable();
                 return 0;
         }
+        preempt_enable();
 
         /* otherwise check if it's in another .o within the patch module */
         return klp_find_object_symbol(pmod->name, name, addr);
@@ -314,12 +327,12 @@ static void notrace klp_ftrace_handler(unsigned long ip,
         rcu_read_lock();
         func = list_first_or_null_rcu(&ops->func_stack, struct klp_func,
                                       stack_node);
-        rcu_read_unlock();
-
         if (WARN_ON_ONCE(!func))
-                return;
+                goto unlock;
 
         klp_arch_set_pc(regs, (unsigned long)func->new_func);
+unlock:
+        rcu_read_unlock();
 }
 
 static int klp_disable_func(struct klp_func *func)
@@ -731,7 +744,7 @@ static int klp_init_func(struct klp_object *obj, struct klp_func *func)
         func->state = KLP_DISABLED;
 
         return kobject_init_and_add(&func->kobj, &klp_ktype_func,
-                                    obj->kobj, func->old_name);
+                                    obj->kobj, "%s", func->old_name);
 }
 
 /* parts of the initialization that is done only when the object is loaded */
@@ -766,6 +779,7 @@ static int klp_init_object(struct klp_patch *patch, struct klp_object *obj)
                 return -EINVAL;
 
         obj->state = KLP_DISABLED;
+        obj->mod = NULL;
 
         klp_find_object_module(obj);
 
@@ -807,7 +821,7 @@ static int klp_init_patch(struct klp_patch *patch)
         patch->state = KLP_DISABLED;
 
         ret = kobject_init_and_add(&patch->kobj, &klp_ktype_patch,
-                                   klp_root_kobj, patch->mod->name);
+                                   klp_root_kobj, "%s", patch->mod->name);
         if (ret)
                 goto unlock;
 
@@ -960,6 +974,15 @@ static int klp_module_notify(struct notifier_block *nb, unsigned long action,
 
         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.
+         */
+        if (action == MODULE_STATE_COMING)
+                mod->klp_alive = true;
+        else /* MODULE_STATE_GOING */
+                mod->klp_alive = false;
+
         list_for_each_entry(patch, &klp_patches, list) {
                 for (obj = patch->objs; obj->funcs; obj++) {
                         if (!klp_is_module(obj) || strcmp(obj->name, mod->name))