livepatch: add (un)patch callbacks

Provide livepatch modules a klp_object (un)patching notification
mechanism.  Pre and post-(un)patch callbacks allow livepatch modules to
setup or synchronize changes that would be difficult to support in only
patched-or-unpatched code contexts.

Callbacks can be registered for target module or vmlinux klp_objects,
but each implementation is klp_object specific.

  - Pre-(un)patch callbacks run before any (un)patching transition
    starts.

  - Post-(un)patch callbacks run once an object has been (un)patched and
    the klp_patch fully transitioned to its target state.

Example use cases include modification of global data and registration
of newly available services/handlers.

See Documentation/livepatch/callbacks.txt for details and
samples/livepatch/ for examples.

Signed-off-by: Joe Lawrence <joe.lawrence@redhat.com>
Acked-by: Josh Poimboeuf <jpoimboe@redhat.com>
Acked-by: Miroslav Benes <mbenes@suse.cz>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>

4 files changed, 98 insertions, 13 deletions

diff --git a/kernel/livepatch/core.c b/kernel/livepatch/core.c
index b9628e43c78f..cafb5a84417d 100644
--- a/kernel/livepatch/core.c
+++ b/kernel/livepatch/core.c
@@ -54,11 +54,6 @@ static bool klp_is_module(struct klp_object *obj)
         return obj->name;
 }
 
-static bool klp_is_object_loaded(struct klp_object *obj)
-{
-        return !obj->name || obj->mod;
-}
-
 /* sets obj->mod if object is not vmlinux and module is found */
 static void klp_find_object_module(struct klp_object *obj)
 {
@@ -285,6 +280,8 @@ static int klp_write_object_relocations(struct module *pmod,
 
 static int __klp_disable_patch(struct klp_patch *patch)
 {
+        struct klp_object *obj;
+
         if (klp_transition_patch)
                 return -EBUSY;
 
@@ -295,6 +292,10 @@ static int __klp_disable_patch(struct klp_patch *patch)
 
         klp_init_transition(patch, KLP_UNPATCHED);
 
+        klp_for_each_object(patch, obj)
+                if (patch->enabled && obj->patched)
+                        klp_pre_unpatch_callback(obj);
+
         /*
          * Enforce the order of the func->transition writes in
          * klp_init_transition() and the TIF_PATCH_PENDING writes in
@@ -388,13 +389,18 @@ static int __klp_enable_patch(struct klp_patch *patch)
                 if (!klp_is_object_loaded(obj))
                         continue;
 
-                ret = klp_patch_object(obj);
+                ret = klp_pre_patch_callback(obj);
                 if (ret) {
-                        pr_warn("failed to enable patch '%s'\n",
-                                patch->mod->name);
+                        pr_warn("pre-patch callback failed for object '%s'\n",
+                                klp_is_module(obj) ? obj->name : "vmlinux");
+                        goto err;
+                }
 
-                        klp_cancel_transition();
-                        return ret;
+                ret = klp_patch_object(obj);
+                if (ret) {
+                        pr_warn("failed to patch object '%s'\n",
+                                klp_is_module(obj) ? obj->name : "vmlinux");
+                        goto err;
                 }
         }
 
@@ -403,6 +409,11 @@ static int __klp_enable_patch(struct klp_patch *patch)
         patch->enabled = true;
 
         return 0;
+err:
+        pr_warn("failed to enable patch '%s'\n", patch->mod->name);
+
+        klp_cancel_transition();
+        return ret;
 }
 
 /**
@@ -871,13 +882,27 @@ int klp_module_coming(struct module *mod)
                         pr_notice("applying patch '%s' to loading module '%s'\n",
                                   patch->mod->name, obj->mod->name);
 
+                        ret = klp_pre_patch_callback(obj);
+                        if (ret) {
+                                pr_warn("pre-patch callback failed for object '%s'\n",
+                                        obj->name);
+                                goto err;
+                        }
+
                         ret = klp_patch_object(obj);
                         if (ret) {
                                 pr_warn("failed to apply patch '%s' to module '%s' (%d)\n",
                                         patch->mod->name, obj->mod->name, ret);
+
+                                if (patch != klp_transition_patch)
+                                        klp_post_unpatch_callback(obj);
+
                                 goto err;
                         }
 
+                        if (patch != klp_transition_patch)
+                                klp_post_patch_callback(obj);
+
                         break;
                 }
         }
@@ -927,9 +952,15 @@ void klp_module_going(struct module *mod)
                          * is in transition.
                          */
                         if (patch->enabled || patch == klp_transition_patch) {
+
+                                if (patch != klp_transition_patch)
+                                        klp_pre_unpatch_callback(obj);
+
                                 pr_notice("reverting patch '%s' on unloading module '%s'\n",
                                           patch->mod->name, obj->mod->name);
                                 klp_unpatch_object(obj);
+
+                                klp_post_unpatch_callback(obj);
                         }
 
                         klp_free_object_loaded(obj);
diff --git a/kernel/livepatch/core.h b/kernel/livepatch/core.h
index c74f24c47837..6fc907b54e71 100644
--- a/kernel/livepatch/core.h
+++ b/kernel/livepatch/core.h
@@ -1,6 +1,44 @@
 #ifndef _LIVEPATCH_CORE_H
 #define _LIVEPATCH_CORE_H
 
+#include <linux/livepatch.h>
+
 extern struct mutex klp_mutex;
 
+static inline bool klp_is_object_loaded(struct klp_object *obj)
+{
+        return !obj->name || obj->mod;
+}
+
+static inline int klp_pre_patch_callback(struct klp_object *obj)
+{
+        int ret;
+
+        ret = (obj->callbacks.pre_patch) ?
+                (*obj->callbacks.pre_patch)(obj) : 0;
+
+        obj->callbacks.post_unpatch_enabled = !ret;
+
+        return ret;
+}
+
+static inline void klp_post_patch_callback(struct klp_object *obj)
+{
+        if (obj->callbacks.post_patch)
+                (*obj->callbacks.post_patch)(obj);
+}
+
+static inline void klp_pre_unpatch_callback(struct klp_object *obj)
+{
+        if (obj->callbacks.pre_unpatch)
+                (*obj->callbacks.pre_unpatch)(obj);
+}
+
+static inline void klp_post_unpatch_callback(struct klp_object *obj)
+{
+        if (obj->callbacks.post_unpatch_enabled &&
+            obj->callbacks.post_unpatch)
+                (*obj->callbacks.post_unpatch)(obj);
+}
+
 #endif /* _LIVEPATCH_CORE_H */
diff --git a/kernel/livepatch/patch.c b/kernel/livepatch/patch.c
index 52c4e907c14b..82d584225dc6 100644
--- a/kernel/livepatch/patch.c
+++ b/kernel/livepatch/patch.c
@@ -28,6 +28,7 @@
 #include <linux/slab.h>
 #include <linux/bug.h>
 #include <linux/printk.h>
+#include "core.h"
 #include "patch.h"
 #include "transition.h"
 
diff --git a/kernel/livepatch/transition.c b/kernel/livepatch/transition.c
index b004a1fb6032..7bf55b7f3687 100644
--- a/kernel/livepatch/transition.c
+++ b/kernel/livepatch/transition.c
@@ -109,9 +109,6 @@ static void klp_complete_transition(void)
                 }
         }
 
-        if (klp_target_state == KLP_UNPATCHED && !immediate_func)
-                module_put(klp_transition_patch->mod);
-
         /* Prevent klp_ftrace_handler() from seeing KLP_UNDEFINED state */
         if (klp_target_state == KLP_PATCHED)
                 klp_synchronize_transition();
@@ -130,6 +127,24 @@ static void klp_complete_transition(void)
         }
 
 done:
+        klp_for_each_object(klp_transition_patch, obj) {
+                if (!klp_is_object_loaded(obj))
+                        continue;
+                if (klp_target_state == KLP_PATCHED)
+                        klp_post_patch_callback(obj);
+                else if (klp_target_state == KLP_UNPATCHED)
+                        klp_post_unpatch_callback(obj);
+        }
+
+        /*
+         * See complementary comment in __klp_enable_patch() for why we
+         * keep the module reference for immediate patches.
+         */
+        if (!klp_transition_patch->immediate && !immediate_func &&
+            klp_target_state == KLP_UNPATCHED) {
+                module_put(klp_transition_patch->mod);
+        }
+
         klp_target_state = KLP_UNDEFINED;
         klp_transition_patch = NULL;
 }