Merge branches 'for-4.12/upstream' and 'for-4.12/klp-hybrid-consistency-model' into for-linus

7 files changed, 1043 insertions, 274 deletions

diff --git a/kernel/livepatch/Makefile b/kernel/livepatch/Makefile
index e8780c0901d9..2b8bdb1925da 100644
--- a/kernel/livepatch/Makefile
+++ b/kernel/livepatch/Makefile
@@ -1,3 +1,3 @@
 obj-$(CONFIG_LIVEPATCH) += livepatch.o
 
-livepatch-objs := core.o
+livepatch-objs := core.o patch.o transition.o
diff --git a/kernel/livepatch/core.c b/kernel/livepatch/core.c
index 8739e9e0bdb8..b9628e43c78f 100644
--- a/kernel/livepatch/core.c
+++ b/kernel/livepatch/core.c
@@ -24,61 +24,31 @@
 #include <linux/kernel.h>
 #include <linux/mutex.h>
 #include <linux/slab.h>
-#include <linux/ftrace.h>
 #include <linux/list.h>
 #include <linux/kallsyms.h>
 #include <linux/livepatch.h>
 #include <linux/elf.h>
 #include <linux/moduleloader.h>
+#include <linux/completion.h>
 #include <asm/cacheflush.h>
-
-/**
- * struct klp_ops - structure for tracking registered ftrace ops structs
- *
- * A single ftrace_ops is shared between all enabled replacement functions
- * (klp_func structs) which have the same old_addr.  This allows the switch
- * between function versions to happen instantaneously by updating the klp_ops
- * struct's func_stack list.  The winner is the klp_func at the top of the
- * func_stack (front of the list).
- *
- * @node:       node for the global klp_ops list
- * @func_stack: list head for the stack of klp_func's (active func is on top)
- * @fops:       registered ftrace ops struct
- */
-struct klp_ops {
-        struct list_head node;
-        struct list_head func_stack;
-        struct ftrace_ops fops;
-};
+#include "core.h"
+#include "patch.h"
+#include "transition.h"
 
 /*
- * The klp_mutex protects the global lists and state transitions of any
- * structure reachable from them.  References to any structure must be obtained
- * under mutex protection (except in klp_ftrace_handler(), which uses RCU to
- * ensure it gets consistent data).
+ * klp_mutex is a coarse lock which serializes access to klp data.  All
+ * accesses to klp-related variables and structures must have mutex protection,
+ * except within the following functions which carefully avoid the need for it:
+ *
+ * - klp_ftrace_handler()
+ * - klp_update_patch_state()
  */
-static DEFINE_MUTEX(klp_mutex);
+DEFINE_MUTEX(klp_mutex);
 
 static LIST_HEAD(klp_patches);
-static LIST_HEAD(klp_ops);
 
 static struct kobject *klp_root_kobj;
 
-static struct klp_ops *klp_find_ops(unsigned long old_addr)
-{
-        struct klp_ops *ops;
-        struct klp_func *func;
-
-        list_for_each_entry(ops, &klp_ops, node) {
-                func = list_first_entry(&ops->func_stack, struct klp_func,
-                                        stack_node);
-                if (func->old_addr == old_addr)
-                        return ops;
-        }
-
-        return NULL;
-}
-
 static bool klp_is_module(struct klp_object *obj)
 {
         return obj->name;
@@ -117,7 +87,6 @@ static void klp_find_object_module(struct klp_object *obj)
         mutex_unlock(&module_mutex);
 }
 
-/* klp_mutex must be held by caller */
 static bool klp_is_patch_registered(struct klp_patch *patch)
 {
         struct klp_patch *mypatch;
@@ -314,191 +283,30 @@ static int klp_write_object_relocations(struct module *pmod,
         return ret;
 }
 
-static void notrace klp_ftrace_handler(unsigned long ip,
-                                       unsigned long parent_ip,
-                                       struct ftrace_ops *fops,
-                                       struct pt_regs *regs)
-{
-        struct klp_ops *ops;
-        struct klp_func *func;
-
-        ops = container_of(fops, struct klp_ops, fops);
-
-        rcu_read_lock();
-        func = list_first_or_null_rcu(&ops->func_stack, struct klp_func,
-                                      stack_node);
-        if (WARN_ON_ONCE(!func))
-                goto unlock;
-
-        klp_arch_set_pc(regs, (unsigned long)func->new_func);
-unlock:
-        rcu_read_unlock();
-}
-
-/*
- * Convert a function address into the appropriate ftrace location.
- *
- * Usually this is just the address of the function, but on some architectures
- * it's more complicated so allow them to provide a custom behaviour.
- */
-#ifndef klp_get_ftrace_location
-static unsigned long klp_get_ftrace_location(unsigned long faddr)
-{
-        return faddr;
-}
-#endif
-
-static void klp_disable_func(struct klp_func *func)
-{
-        struct klp_ops *ops;
-
-        if (WARN_ON(func->state != KLP_ENABLED))
-                return;
-        if (WARN_ON(!func->old_addr))
-                return;
-
-        ops = klp_find_ops(func->old_addr);
-        if (WARN_ON(!ops))
-                return;
-
-        if (list_is_singular(&ops->func_stack)) {
-                unsigned long ftrace_loc;
-
-                ftrace_loc = klp_get_ftrace_location(func->old_addr);
-                if (WARN_ON(!ftrace_loc))
-                        return;
-
-                WARN_ON(unregister_ftrace_function(&ops->fops));
-                WARN_ON(ftrace_set_filter_ip(&ops->fops, ftrace_loc, 1, 0));
-
-                list_del_rcu(&func->stack_node);
-                list_del(&ops->node);
-                kfree(ops);
-        } else {
-                list_del_rcu(&func->stack_node);
-        }
-
-        func->state = KLP_DISABLED;
-}
-
-static int klp_enable_func(struct klp_func *func)
-{
-        struct klp_ops *ops;
-        int ret;
-
-        if (WARN_ON(!func->old_addr))
-                return -EINVAL;
-
-        if (WARN_ON(func->state != KLP_DISABLED))
-                return -EINVAL;
-
-        ops = klp_find_ops(func->old_addr);
-        if (!ops) {
-                unsigned long ftrace_loc;
-
-                ftrace_loc = klp_get_ftrace_location(func->old_addr);
-                if (!ftrace_loc) {
-                        pr_err("failed to find location for function '%s'\n",
-                                func->old_name);
-                        return -EINVAL;
-                }
-
-                ops = kzalloc(sizeof(*ops), GFP_KERNEL);
-                if (!ops)
-                        return -ENOMEM;
-
-                ops->fops.func = klp_ftrace_handler;
-                ops->fops.flags = FTRACE_OPS_FL_SAVE_REGS |
-                                  FTRACE_OPS_FL_DYNAMIC |
-                                  FTRACE_OPS_FL_IPMODIFY;
-
-                list_add(&ops->node, &klp_ops);