livepatch: Remove immediate feature

Immediate flag has been used to disable per-task consistency and patch
all tasks immediately. It could be useful if the patch doesn't change any
function or data semantics.

However, it causes problems on its own. The consistency problem is
currently broken with respect to immediate patches.

func            a
patches         1i
                2i
                3

When the patch 3 is applied, only 2i function is checked (by stack
checking facility). There might be a task sleeping in 1i though. Such
task is migrated to 3, because we do not check 1i in
klp_check_stack_func() at all.

Coming atomic replace feature would be easier to implement and more
reliable without immediate.

Thus, remove immediate feature completely and save us from the problems.

Note that force feature has the similar problem. However it is
considered as a last resort. If used, administrator should not apply any
new live patches and should plan for reboot into an updated kernel.

The architectures would now need to provide HAVE_RELIABLE_STACKTRACE to
fully support livepatch.

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

2 files changed, 6 insertions, 55 deletions

diff --git a/kernel/livepatch/core.c b/kernel/livepatch/core.c
index 1c3c9b27c916..41be6061b92f 100644
--- a/kernel/livepatch/core.c
+++ b/kernel/livepatch/core.c
@@ -366,11 +366,6 @@ static int __klp_enable_patch(struct klp_patch *patch)
         /*
          * A reference is taken on the patch module to prevent it from being
          * unloaded.
-         *
-         * Note: For immediate (no consistency model) patches we don't allow
-         * patch modules to unload since there is no safe/sane method to
-         * determine if a thread is still running in the patched code contained
-         * in the patch module once the ftrace registration is successful.
          */
         if (!try_module_get(patch->mod))
                 return -ENODEV;
@@ -890,12 +885,7 @@ int klp_register_patch(struct klp_patch *patch)
         if (!klp_initialized())
                 return -ENODEV;
 
-        /*
-         * Architectures without reliable stack traces have to set
-         * patch->immediate because there's currently no way to patch kthreads
-         * with the consistency model.
-         */
-        if (!klp_have_reliable_stack() && !patch->immediate) {
+        if (!klp_have_reliable_stack()) {
                 pr_err("This architecture doesn't have support for the livepatch consistency model.\n");
                 return -ENOSYS;
         }
diff --git a/kernel/livepatch/transition.c b/kernel/livepatch/transition.c
index be5bfa533ee8..7c6631e693bc 100644
--- a/kernel/livepatch/transition.c
+++ b/kernel/livepatch/transition.c
@@ -82,7 +82,6 @@ static void klp_complete_transition(void)
         struct klp_func *func;
         struct task_struct *g, *task;
         unsigned int cpu;
-        bool immediate_func = false;
 
         pr_debug("'%s': completing %s transition\n",
                  klp_transition_patch->mod->name,
@@ -104,16 +103,9 @@ static void klp_complete_transition(void)
                 klp_synchronize_transition();
         }
 
-        if (klp_transition_patch->immediate)
-                goto done;
-
-        klp_for_each_object(klp_transition_patch, obj) {
-                klp_for_each_func(obj, func) {
+        klp_for_each_object(klp_transition_patch, obj)
+                klp_for_each_func(obj, func)
                         func->transition = false;
-                        if (func->immediate)
-                                immediate_func = true;
-                }
-        }
 
         /* Prevent klp_ftrace_handler() from seeing KLP_UNDEFINED state */
         if (klp_target_state == KLP_PATCHED)
@@ -132,7 +124,6 @@ static void klp_complete_transition(void)
                 task->patch_state = KLP_UNDEFINED;
         }
 
-done:
         klp_for_each_object(klp_transition_patch, obj) {
                 if (!klp_is_object_loaded(obj))
                         continue;
@@ -146,16 +137,11 @@ done:
                   klp_target_state == KLP_PATCHED ? "patching" : "unpatching");
 
         /*
-         * See complementary comment in __klp_enable_patch() for why we
-         * keep the module reference for immediate patches.
-         *
-         * klp_forced or immediate_func set implies unbounded increase of
-         * module's ref count if the module is disabled/enabled in a loop.
+         * klp_forced set implies unbounded increase of module's ref count if
+         * the module is disabled/enabled in a loop.
          */
-        if (!klp_forced && !klp_transition_patch->immediate &&
-                !immediate_func && klp_target_state == KLP_UNPATCHED) {
+        if (!klp_forced && klp_target_state == KLP_UNPATCHED)
                 module_put(klp_transition_patch->mod);
-        }
 
         klp_target_state = KLP_UNDEFINED;
         klp_transition_patch = NULL;
@@ -223,9 +209,6 @@ static int klp_check_stack_func(struct klp_func *func,
         struct klp_ops *ops;
         int i;
 
-        if (func->immediate)
-                return 0;
-
         for (i = 0; i < trace->nr_entries; i++) {
                 address = trace->entries[i];
 
@@ -388,13 +371,6 @@ void klp_try_complete_transition(void)
         WARN_ON_ONCE(klp_target_state == KLP_UNDEFINED);
 
         /*
-         * If the patch can be applied or reverted immediately, skip the
-         * per-task transitions.
-         */
-        if (klp_transition_patch->immediate)
-                goto success;
-
-        /*
          * Try to switch the tasks to the target patch state by walking their
          * stacks and looking for any to-be-patched or to-be-unpatched
          * functions.  If such functions are found on a stack, or if the stack
@@ -437,7 +413,6 @@ void klp_try_complete_transition(void)
                 return;
         }
 
-success:
         /* we're done, now cleanup the data structures */
         klp_complete_transition();
 }
@@ -458,13 +433,6 @@ void klp_start_transition(void)
                   klp_target_state == KLP_PATCHED ? "patching" : "unpatching");
 
         /*
-         * If the patch can be applied or reverted immediately, skip the
-         * per-task transitions.
-         */
-        if (klp_transition_patch->immediate)
-                return;
-
-        /*
          * Mark all normal tasks as needing a patch state update.  They'll
          * switch either in klp_try_complete_transition() or as they exit the
          * kernel.
@@ -514,13 +482,6 @@ void klp_init_transition(struct klp_patch *patch, int state)
                  klp_target_state == KLP_PATCHED ? "patching" : "unpatching");
 
         /*
-         * If the patch can be applied or reverted immediately, skip the
-         * per-task transitions.
-         */
-        if (patch->immediate)
-                return;
-
-        /*
          * Initialize all tasks to the initial patch state to prepare them for
          * switching to the target state.
          */