Merge branch 'for-5.1/fake-signal' into for-linus

Ability to send fake signal to blocking tasks automatically, instead of
requiring manual intervention, from Miroslav Benes

3 files changed, 51 insertions, 74 deletions

diff --git a/kernel/livepatch/core.c b/kernel/livepatch/core.c
index adca5cf07f7e..fe1993399823 100644
--- a/kernel/livepatch/core.c
+++ b/kernel/livepatch/core.c
@@ -313,7 +313,6 @@ static int klp_write_object_relocations(struct module *pmod,
  * /sys/kernel/livepatch/<patch>
  * /sys/kernel/livepatch/<patch>/enabled
  * /sys/kernel/livepatch/<patch>/transition
- * /sys/kernel/livepatch/<patch>/signal
  * /sys/kernel/livepatch/<patch>/force
  * /sys/kernel/livepatch/<patch>/<object>
  * /sys/kernel/livepatch/<patch>/<object>/<function,sympos>
@@ -382,35 +381,6 @@ static ssize_t transition_show(struct kobject *kobj,
                         patch == klp_transition_patch);
 }
 
-static ssize_t signal_store(struct kobject *kobj, struct kobj_attribute *attr,
-                            const char *buf, size_t count)
-{
-        struct klp_patch *patch;
-        int ret;
-        bool val;
-
-        ret = kstrtobool(buf, &val);
-        if (ret)
-                return ret;
-
-        if (!val)
-                return count;
-
-        mutex_lock(&klp_mutex);
-
-        patch = container_of(kobj, struct klp_patch, kobj);
-        if (patch != klp_transition_patch) {
-                mutex_unlock(&klp_mutex);
-                return -EINVAL;
-        }
-
-        klp_send_signals();
-
-        mutex_unlock(&klp_mutex);
-
-        return count;
-}
-
 static ssize_t force_store(struct kobject *kobj, struct kobj_attribute *attr,
                            const char *buf, size_t count)
 {
@@ -442,12 +412,10 @@ static ssize_t force_store(struct kobject *kobj, struct kobj_attribute *attr,
 
 static struct kobj_attribute enabled_kobj_attr = __ATTR_RW(enabled);
 static struct kobj_attribute transition_kobj_attr = __ATTR_RO(transition);
-static struct kobj_attribute signal_kobj_attr = __ATTR_WO(signal);
 static struct kobj_attribute force_kobj_attr = __ATTR_WO(force);
 static struct attribute *klp_patch_attrs[] = {
         &enabled_kobj_attr.attr,
         &transition_kobj_attr.attr,
-        &signal_kobj_attr.attr,
         &force_kobj_attr.attr,
         NULL
 };
diff --git a/kernel/livepatch/transition.c b/kernel/livepatch/transition.c
index 300273819674..183b2086ba03 100644
--- a/kernel/livepatch/transition.c
+++ b/kernel/livepatch/transition.c
@@ -29,10 +29,14 @@
 #define MAX_STACK_ENTRIES  100
 #define STACK_ERR_BUF_SIZE 128
 
+#define SIGNALS_TIMEOUT 15
+
 struct klp_patch *klp_transition_patch;
 
 static int klp_target_state = KLP_UNDEFINED;
 
+static unsigned int klp_signals_cnt;
+
 /*
  * This work can be performed periodically to finish patching or unpatching any
  * "straggler" tasks which failed to transition in the first attempt.
@@ -344,6 +348,47 @@ done:
 }
 
 /*
+ * Sends a fake signal to all non-kthread tasks with TIF_PATCH_PENDING set.
+ * Kthreads with TIF_PATCH_PENDING set are woken up.
+ */
+static void klp_send_signals(void)
+{
+        struct task_struct *g, *task;
+
+        if (klp_signals_cnt == SIGNALS_TIMEOUT)
+                pr_notice("signaling remaining tasks\n");
+
+        read_lock(&tasklist_lock);
+        for_each_process_thread(g, task) {
+                if (!klp_patch_pending(task))
+                        continue;
+
+                /*
+                 * There is a small race here. We could see TIF_PATCH_PENDING
+                 * set and decide to wake up a kthread or send a fake signal.
+                 * Meanwhile the task could migrate itself and the action
+                 * would be meaningless. It is not serious though.
+                 */
+                if (task->flags & PF_KTHREAD) {
+                        /*
+                         * Wake up a kthread which sleeps interruptedly and
+                         * still has not been migrated.
+                         */
+                        wake_up_state(task, TASK_INTERRUPTIBLE);
+                } else {
+                        /*
+                         * Send fake signal to all non-kthread tasks which are
+                         * still not migrated.
+                         */
+                        spin_lock_irq(&task->sighand->siglock);
+                        signal_wake_up(task, 0);
+                        spin_unlock_irq(&task->sighand->siglock);
+                }
+        }
+        read_unlock(&tasklist_lock);
+}
+
+/*
  * Try to switch all remaining tasks to the target patch state by walking the
  * stacks of sleeping tasks and looking for any to-be-patched or
  * to-be-unpatched functions.  If such functions are found, the task can't be
@@ -393,6 +438,10 @@ void klp_try_complete_transition(void)
         put_online_cpus();
 
         if (!complete) {
+                if (klp_signals_cnt && !(klp_signals_cnt % SIGNALS_TIMEOUT))
+                        klp_send_signals();
+                klp_signals_cnt++;
+
                 /*
                  * Some tasks weren't able to be switched over.  Try again
                  * later and/or wait for other methods like kernel exit
@@ -454,6 +503,8 @@ void klp_start_transition(void)
                 if (task->patch_state != klp_target_state)
                         set_tsk_thread_flag(task, TIF_PATCH_PENDING);
         }
+
+        klp_signals_cnt = 0;
 }
 
 /*
@@ -577,47 +628,6 @@ void klp_copy_process(struct task_struct *child)
 }
 
 /*
- * Sends a fake signal to all non-kthread tasks with TIF_PATCH_PENDING set.
- * Kthreads with TIF_PATCH_PENDING set are woken up. Only admin can request this
- * action currently.
- */
-void klp_send_signals(void)
-{
-        struct task_struct *g, *task;
-
-        pr_notice("signaling remaining tasks\n");
-
-        read_lock(&tasklist_lock);
-        for_each_process_thread(g, task) {
-                if (!klp_patch_pending(task))
-                        continue;
-
-                /*
-                 * There is a small race here. We could see TIF_PATCH_PENDING
-                 * set and decide to wake up a kthread or send a fake signal.
-                 * Meanwhile the task could migrate itself and the action
-                 * would be meaningless. It is not serious though.
-                 */
-                if (task->flags & PF_KTHREAD) {
-                        /*
-                         * Wake up a kthread which sleeps interruptedly and
-                         * still has not been migrated.
-                         */
-                        wake_up_state(task, TASK_INTERRUPTIBLE);
-                } else {
-                        /*
-                         * Send fake signal to all non-kthread tasks which are
-                         * still not migrated.
-                         */
-                        spin_lock_irq(&task->sighand->siglock);
-                        signal_wake_up(task, 0);
-                        spin_unlock_irq(&task->sighand->siglock);
-                }
-        }
-        read_unlock(&tasklist_lock);
-}
-
-/*
  * Drop TIF_PATCH_PENDING of all tasks on admin's request. This forces an
  * existing transition to finish.
  *
diff --git a/kernel/livepatch/transition.h b/kernel/livepatch/transition.h
index f9d0bc016067..322db16233de 100644
--- a/kernel/livepatch/transition.h
+++ b/kernel/livepatch/transition.h
@@ -11,7 +11,6 @@ void klp_cancel_transition(void);
 void klp_start_transition(void);
 void klp_try_complete_transition(void);
 void klp_reverse_transition(void);
-void klp_send_signals(void);
 void klp_force_transition(void);
 
 #endif /* _LIVEPATCH_TRANSITION_H */