livepatch: separate enabled and patched states

Once we have a consistency model, patches and their objects will be
enabled and disabled at different times.  For example, when a patch is
disabled, its loaded objects' funcs can remain registered with ftrace
indefinitely until the unpatching operation is complete and they're no
longer in use.

It's less confusing if we give them different names: patches can be
enabled or disabled; objects (and their funcs) can be patched or
unpatched:

- Enabled means that a patch is logically enabled (but not necessarily
  fully applied).

- Patched means that an object's funcs are registered with ftrace and
  added to the klp_ops func stack.

Also, since these states are binary, represent them with booleans
instead of ints.

Signed-off-by: Josh Poimboeuf <jpoimboe@redhat.com>
Acked-by: Miroslav Benes <mbenes@suse.cz>
Reviewed-by: Petr Mladek <pmladek@suse.com>
Reviewed-by: Kamalesh Babulal <kamalesh@linux.vnet.ibm.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>

1 files changed, 36 insertions, 36 deletions

diff --git a/kernel/livepatch/core.c b/kernel/livepatch/core.c
index 217b39d71176..2dbd355cee07 100644
--- a/kernel/livepatch/core.c
+++ b/kernel/livepatch/core.c
@@ -348,11 +348,11 @@ static unsigned long klp_get_ftrace_location(unsigned long faddr)
 }
 #endif
 
-static void klp_disable_func(struct klp_func *func)
+static void klp_unpatch_func(struct klp_func *func)
 {
         struct klp_ops *ops;
 
-        if (WARN_ON(func->state != KLP_ENABLED))
+        if (WARN_ON(!func->patched))
                 return;
         if (WARN_ON(!func->old_addr))
                 return;
@@ -378,10 +378,10 @@ static void klp_disable_func(struct klp_func *func)
                 list_del_rcu(&func->stack_node);
         }
 
-        func->state = KLP_DISABLED;
+        func->patched = false;
 }
 
-static int klp_enable_func(struct klp_func *func)
+static int klp_patch_func(struct klp_func *func)
 {
         struct klp_ops *ops;
         int ret;
@@ -389,7 +389,7 @@ static int klp_enable_func(struct klp_func *func)
         if (WARN_ON(!func->old_addr))
                 return -EINVAL;
 
-        if (WARN_ON(func->state != KLP_DISABLED))
+        if (WARN_ON(func->patched))
                 return -EINVAL;
 
         ops = klp_find_ops(func->old_addr);
@@ -437,7 +437,7 @@ static int klp_enable_func(struct klp_func *func)
                 list_add_rcu(&func->stack_node, &ops->func_stack);
         }
 
-        func->state = KLP_ENABLED;
+        func->patched = true;
 
         return 0;
 
@@ -448,36 +448,36 @@ err:
         return ret;
 }
 
-static void klp_disable_object(struct klp_object *obj)
+static void klp_unpatch_object(struct klp_object *obj)
 {
         struct klp_func *func;
 
         klp_for_each_func(obj, func)
-                if (func->state == KLP_ENABLED)
-                        klp_disable_func(func);
+                if (func->patched)
+                        klp_unpatch_func(func);
 
-        obj->state = KLP_DISABLED;
+        obj->patched = false;
 }
 
-static int klp_enable_object(struct klp_object *obj)
+static int klp_patch_object(struct klp_object *obj)
 {
         struct klp_func *func;
         int ret;
 
-        if (WARN_ON(obj->state != KLP_DISABLED))
+        if (WARN_ON(obj->patched))
                 return -EINVAL;
 
         if (WARN_ON(!klp_is_object_loaded(obj)))
                 return -EINVAL;
 
         klp_for_each_func(obj, func) {
-                ret = klp_enable_func(func);
+                ret = klp_patch_func(func);
                 if (ret) {
-                        klp_disable_object(obj);
+                        klp_unpatch_object(obj);
                         return ret;
                 }
         }
-        obj->state = KLP_ENABLED;
+        obj->patched = true;
 
         return 0;
 }
@@ -488,17 +488,17 @@ static int __klp_disable_patch(struct klp_patch *patch)
 
         /* enforce stacking: only the last enabled patch can be disabled */
         if (!list_is_last(&patch->list, &klp_patches) &&
-            list_next_entry(patch, list)->state == KLP_ENABLED)
+            list_next_entry(patch, list)->enabled)
                 return -EBUSY;
 
         pr_notice("disabling patch '%s'\n", patch->mod->name);
 
         klp_for_each_object(patch, obj) {
-                if (obj->state == KLP_ENABLED)
-                        klp_disable_object(obj);
+                if (obj->patched)
+                        klp_unpatch_object(obj);
         }
 
-        patch->state = KLP_DISABLED;
+        patch->enabled = false;
 
         return 0;
 }
@@ -522,7 +522,7 @@ int klp_disable_patch(struct klp_patch *patch)
                 goto err;
         }
 
-        if (patch->state == KLP_DISABLED) {
+        if (!patch->enabled) {
                 ret = -EINVAL;
                 goto err;
         }
@@ -540,12 +540,12 @@ static int __klp_enable_patch(struct klp_patch *patch)
         struct klp_object *obj;
         int ret;
 
-        if (WARN_ON(patch->state != KLP_DISABLED))
+        if (WARN_ON(patch->enabled))
                 return -EINVAL;
 
         /* enforce stacking: only the first disabled patch can be enabled */
         if (patch->list.prev != &klp_patches &&
-            list_prev_entry(patch, list)->state == KLP_DISABLED)
+            !list_prev_entry(patch, list)->enabled)
                 return -EBUSY;
 
         pr_notice("enabling patch '%s'\n", patch->mod->name);
@@ -554,12 +554,12 @@ static int __klp_enable_patch(struct klp_patch *patch)
                 if (!klp_is_object_loaded(obj))
                         continue;
 
-                ret = klp_enable_object(obj);
+                ret = klp_patch_object(obj);
                 if (ret)
                         goto unregister;
         }
 
-        patch->state = KLP_ENABLED;
+        patch->enabled = true;
 
         return 0;
 
@@ -617,20 +617,20 @@ static ssize_t enabled_store(struct kobject *kobj, struct kobj_attribute *attr,
         if (ret)
                 return -EINVAL;
 
-        if (val != KLP_DISABLED && val != KLP_ENABLED)
+        if (val > 1)
                 return -EINVAL;
 
         patch = container_of(kobj, struct klp_patch, kobj);
 
         mutex_lock(&klp_mutex);
 
-        if (val == patch->state) {
+        if (patch->enabled == val) {
                 /* already in requested state */
                 ret = -EINVAL;
                 goto err;
         }
 
-        if (val == KLP_ENABLED) {
+        if (val) {
                 ret = __klp_enable_patch(patch);
                 if (ret)
                         goto err;
@@ -655,7 +655,7 @@ static ssize_t enabled_show(struct kobject *kobj,
         struct klp_patch *patch;
 
         patch = container_of(kobj, struct klp_patch, kobj);
-        return snprintf(buf, PAGE_SIZE-1, "%d\n", patch->state);
+        return snprintf(buf, PAGE_SIZE-1, "%d\n", patch->enabled);
 }
 
 static struct kobj_attribute enabled_kobj_attr = __ATTR_RW(enabled);
@@ -749,7 +749,7 @@ static int klp_init_func(struct klp_object *obj, struct klp_func *func)
                 return -EINVAL;
 
         INIT_LIST_HEAD(&func->stack_node);
-        func->state = KLP_DISABLED;
+        func->patched = false;
 
         /* The format for the sysfs directory is <function,sympos> where sympos
          * is the nth occurrence of this symbol in kallsyms for the patched
@@ -804,7 +804,7 @@ static int klp_init_object(struct klp_patch *patch, struct klp_object *obj)
         if (!obj->funcs)
                 return -EINVAL;
 
-        obj->state = KLP_DISABLED;
+        obj->patched = false;
         obj->mod = NULL;
 
         klp_find_object_module(obj);
@@ -845,7 +845,7 @@ static int klp_init_patch(struct klp_patch *patch)
 
         mutex_lock(&klp_mutex);
 
-        patch->state = KLP_DISABLED;
+        patch->enabled = false;
 
         ret = kobject_init_and_add(&patch->kobj, &klp_ktype_patch,
                                    klp_root_kobj, "%s", patch->mod->name);
@@ -891,7 +891,7 @@ int klp_unregister_patch(struct klp_patch *patch)
                 goto out;
         }
 
-        if (patch->state == KLP_ENABLED) {
+        if (patch->enabled) {
                 ret = -EBUSY;
                 goto out;
         }
@@ -978,13 +978,13 @@ int klp_module_coming(struct module *mod)
                                 goto err;
                         }
 
-                        if (patch->state == KLP_DISABLED)
+                        if (!patch->enabled)
                                 break;
 
                         pr_notice("applying patch '%s' to loading module '%s'\n",
                                   patch->mod->name, obj->mod->name);
 
-                        ret = klp_enable_object(obj);
+                        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);
@@ -1035,10 +1035,10 @@ void klp_module_going(struct module *mod)
                         if (!klp_is_module(obj) || strcmp(obj->name, mod->name))
                                 continue;
 
-                        if (patch->state != KLP_DISABLED) {
+                        if (patch->enabled) {
                                 pr_notice("reverting patch '%s' on unloading module '%s'\n",
                                           patch->mod->name, obj->mod->name);
-                                klp_disable_object(obj);
+                                klp_unpatch_object(obj);
                         }
 
                         klp_free_object_loaded(obj);