Merge branch 'for-4.16/remove-immediate' into for-linus

Pull 'immediate' feature removal from Miroslav Benes.

2 files changed, 6 insertions, 55 deletions

diff --git a/kernel/livepatch/core.c b/kernel/livepatch/core.c
index 8fd8e8f126da..3a4656fb7047 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;
@@ -894,12 +889,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.
          */