/* * core.c - Kernel Live Patching Core * * Copyright (C) 2014 Seth Jennings <sjenning@redhat.com> * Copyright (C) 2014 SUSE * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see <http://www.gnu.org/licenses/>. */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/module.h>#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 <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;}; /* * 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). */static 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;} static bool klp_is_object_loaded(struct klp_object *obj){ return !obj->name || obj->mod;} /* sets obj->mod if object is not vmlinux and module is found */static void klp_find_object_module(struct klp_object *obj){ struct module *mod; if (!klp_is_module(obj)) return; mutex_lock(&module_mutex); /* * We do not want to block removal of patched modules and therefore * we do not take a reference here. The patches are removed by * a going module handler instead. */ mod = find_module(obj->name); /* * Do not mess work of the module coming and going notifiers. * Note that the patch might still be needed before the going handler * is called. Module functions can be called even in the GOING state * until mod->exit() finishes. This is especially important for * patches that modify semantic of the functions. */ if (mod && mod->klp_alive) obj->mod = mod; 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; list_for_each_entry(mypatch, &klp_patches, list) if (mypatch == patch) return true; return false;} static bool klp_initialized(void){ return !!klp_root_kobj;} struct klp_find_arg { const char *objname; const char *name; unsigned long addr; unsigned long count; unsigned long pos;}; static int klp_find_callback(void *data, const char *name, struct module *mod, unsigned long addr){ struct klp_find_arg *args = data; if ((mod && !args->objname) || (!mod && args->objname)) return 0; if (strcmp(args->name, name)) return 0; if (args->objname && strcmp(args->objname, mod->name)) return 0; args->addr = addr; args->count++; /* * Finish the search when the symbol is found for the desired position * or the position is not defined for a non-unique symbol. */ if ((args->pos && (args->count == args->pos)) || (!args->pos && (args->count > 1))) return 1; return 0;} static int klp_find_object_symbol(const char *objname, const char *name, unsigned long sympos, unsigned long *addr){ struct klp_find_arg args = { .objname = objname, .name = name, .addr = 0, .count = 0, .pos = sympos, }; mutex_lock(&module_mutex); kallsyms_on_each_symbol(klp_find_callback, &args); mutex_unlock(&module_mutex); /* * Ensure an address was found. If sympos is 0, ensure symbol is unique; * otherwise ensure the symbol position count matches sympos. */ if (args.addr == 0) pr_err("symbol '%s' not found in symbol table\n", name); else if (args.count > 1 && sympos == 0) { pr_err("unresolvable ambiguity (%lu matches) on symbol '%s' in object '%s'\n", args.count, name, objname); } else if (sympos != args.count && sympos > 0) { pr_err("symbol position %lu for symbol '%s' in object '%s' not found\n", sympos, name, objname ? objname : "vmlinux"); } else { *addr = args.addr; return 0; } *addr = 0; return -EINVAL;} /* * external symbols are located outside the parent object (where the parent * object is either vmlinux or the kmod being patched). */static int klp_find_external_symbol(struct module *pmod, const char *name, unsigned long *addr){ const struct kernel_symbol *sym; /* first, check if it's an exported symbol */ preempt_disable(); sym = find_symbol(name, NULL, NULL, true, true); if (sym) { *addr = sym->value; preempt_enable(); return 0; } preempt_enable(); /* * Check if it's in another .o within the patch module. This also * checks that the external symbol is unique. */ return klp_find_object_symbol(pmod->name, name, 0, addr);} static int klp_write_object_relocations(struct module *pmod, struct klp_object *obj){ int ret = 0; unsigned long val; struct klp_reloc *reloc; if (WARN_ON(!klp_is_object_loaded(obj))) return -EINVAL; if (WARN_ON(!obj->relocs)) return -EINVAL; module_disable_ro(pmod); for (reloc = obj->relocs; reloc->name; reloc++) { /* discover the address of the referenced symbol */ if (reloc->external) { if (reloc->sympos > 0) { pr_err("non-zero sympos for external reloc symbol '%s' is not supported\n", reloc->name); ret = -EINVAL; goto out; } ret = klp_find_external_symbol(pmod, reloc->name, &val); } else ret = klp_find_object_symbol(obj->name, reloc->name, reloc->sympos, &val); if (ret) goto out; ret = klp_write_module_reloc(pmod, reloc->type, reloc->loc, val + reloc->addend); if (ret) { pr_err("relocation failed for symbol '%s' at 0x%016lx (%d)\n", reloc->name, val, ret); goto out; } } out: module_enable_ro(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();} 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)) { WARN_ON(unregister_ftrace_function(&ops->fops)); WARN_ON(ftrace_set_filter_ip(&ops->fops, func->old_addr, 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) { 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); INIT_LIST_HEAD(&ops->func_stack); list_add_rcu(&func->stack_node, &ops->func_stack); ret = ftrace_set_filter_ip(&ops->fops, func->old_addr, 0, 0); if (ret) { pr_err("failed to set ftrace filter for function '%s' (%d)\n", func->old_name, ret); goto err; } ret = register_ftrace_function(&ops->fops); if (ret) { pr_err("failed to register ftrace handler for function '%s' (%d)\n", func->old_name, ret); ftrace_set_filter_ip(&ops->fops, func->old_addr, 1, 0); goto err; } } else { list_add_rcu(&func->stack_node, &ops->func_stack); } func->state = KLP_ENABLED; return 0; err: list_del_rcu(&func->stack_node); list_del(&ops->node); kfree(ops); return ret;} static void klp_disable_object(struct klp_object *obj){ struct klp_func *func; klp_for_each_func(obj, func) if (func->state == KLP_ENABLED) klp_disable_func(func); obj->state = KLP_DISABLED;} static int klp_enable_object(struct klp_object *obj){ struct klp_func *func; int ret; if (WARN_ON(obj->state != KLP_DISABLED)) return -EINVAL; if (WARN_ON(!klp_is_object_loaded(obj))) return -EINVAL; klp_for_each_func(obj, func) { ret = klp_enable_func(func); if (ret) { klp_disable_object(obj); return ret; } } obj->state = KLP_ENABLED; return 0;} static int __klp_disable_patch(struct klp_patch *patch){ struct klp_object *obj; /* 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) 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); } patch->state = KLP_DISABLED; return 0;} /** * klp_disable_patch() - disables a registered patch * @patch: The registered, enabled patch to be disabled * * Unregisters the patched functions from ftrace. * * Return: 0 on success, otherwise error */int klp_disable_patch(struct klp_patch *patch){ int ret; mutex_lock(&klp_mutex); if (!klp_is_patch_registered(patch)) { ret = -EINVAL; goto err; } if (patch->state == KLP_DISABLED) { ret = -EINVAL; goto err; } ret = __klp_disable_patch(patch); err: mutex_unlock(&klp_mutex); return ret;}EXPORT_SYMBOL_GPL(klp_disable_patch); static int __klp_enable_patch(struct klp_patch *patch){ struct klp_object *obj; int ret; if (WARN_ON(patch->state != KLP_DISABLED)) 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) return -EBUSY; pr_notice_once("tainting kernel with TAINT_LIVEPATCH\n"); add_taint(TAINT_LIVEPATCH, LOCKDEP_STILL_OK); pr_notice("enabling patch '%s'\n", patch->mod->name); klp_for_each_object(patch, obj) { if (!klp_is_object_loaded(obj)) continue; ret = klp_enable_object(obj); if (ret) goto unregister; } patch->state = KLP_ENABLED;Lines 1–500 of 993. Load more
/* * core.c - Kernel Live Patching Core * * Copyright (C) 2014 Seth Jennings <sjenning@redhat.com> * Copyright (C) 2014 SUSE * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see <http://www.gnu.org/licenses/>. */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/module.h> #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 <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; }; /* * 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). */ static 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; } static bool klp_is_object_loaded(struct klp_object *obj) { return !obj->name || obj->mod; } /* sets obj->mod if object is not vmlinux and module is found */ static void klp_find_object_module(struct klp_object *obj) { struct module *mod; if (!klp_is_module(obj)) return; mutex_lock(&module_mutex); /* * We do not want to block removal of patched modules and therefore * we do not take a reference here. The patches are removed by * a going module handler instead. */ mod = find_module(obj->name); /* * Do not mess work of the module coming and going notifiers. * Note that the patch might still be needed before the going handler * is called. Module functions can be called even in the GOING state * until mod->exit() finishes. This is especially important for * patches that modify semantic of the functions. */ if (mod && mod->klp_alive) obj->mod = mod; 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; list_for_each_entry(mypatch, &klp_patches, list) if (mypatch == patch) return true; return false; } static bool klp_initialized(void) { return !!klp_root_kobj; } struct klp_find_arg { const char *objname; const char *name; unsigned long addr; unsigned long count; unsigned long pos; }; static int klp_find_callback(void *data, const char *name, struct module *mod, unsigned long addr) { struct klp_find_arg *args = data; if ((mod && !args->objname) || (!mod && args->objname)) return 0; if (strcmp(args->name, name)) return 0; if (args->objname && strcmp(args->objname, mod->name)) return 0; args->addr = addr; args->count++; /* * Finish the search when the symbol is found for the desired position * or the position is not defined for a non-unique symbol. */ if ((args->pos && (args->count == args->pos)) || (!args->pos && (args->count > 1))) return 1; return 0; } static int klp_find_object_symbol(const char *objname, const char *name, unsigned long sympos, unsigned long *addr) { struct klp_find_arg args = { .objname = objname, .name = name, .addr = 0, .count = 0, .pos = sympos, }; mutex_lock(&module_mutex); kallsyms_on_each_symbol(klp_find_callback, &args); mutex_unlock(&module_mutex); /* * Ensure an address was found. If sympos is 0, ensure symbol is unique; * otherwise ensure the symbol position count matches sympos. */ if (args.addr == 0) pr_err("symbol '%s' not found in symbol table\n", name); else if (args.count > 1 && sympos == 0) { pr_err("unresolvable ambiguity (%lu matches) on symbol '%s' in object '%s'\n", args.count, name, objname); } else if (sympos != args.count && sympos > 0) { pr_err("symbol position %lu for symbol '%s' in object '%s' not found\n", sympos, name, objname ? objname : "vmlinux"); } else { *addr = args.addr; return 0; } *addr = 0; return -EINVAL; } /* * external symbols are located outside the parent object (where the parent * object is either vmlinux or the kmod being patched). */ static int klp_find_external_symbol(struct module *pmod, const char *name, unsigned long *addr) { const struct kernel_symbol *sym; /* first, check if it's an exported symbol */ preempt_disable(); sym = find_symbol(name, NULL, NULL, true, true); if (sym) { *addr = sym->value; preempt_enable(); return 0; } preempt_enable(); /* * Check if it's in another .o within the patch module. This also * checks that the external symbol is unique. */ return klp_find_object_symbol(pmod->name, name, 0, addr); } static int klp_write_object_relocations(struct module *pmod, struct klp_object *obj) { int ret = 0; unsigned long val; struct klp_reloc *reloc; if (WARN_ON(!klp_is_object_loaded(obj))) return -EINVAL; if (WARN_ON(!obj->relocs)) return -EINVAL; module_disable_ro(pmod); for (reloc = obj->relocs; reloc->name; reloc++) { /* discover the address of the referenced symbol */ if (reloc->external) { if (reloc->sympos > 0) { pr_err("non-zero sympos for external reloc symbol '%s' is not supported\n", reloc->name); ret = -EINVAL; goto out; } ret = klp_find_external_symbol(pmod, reloc->name, &val); } else ret = klp_find_object_symbol(obj->name, reloc->name, reloc->sympos, &val); if (ret) goto out; ret = klp_write_module_reloc(pmod, reloc->type, reloc->loc, val + reloc->addend); if (ret) { pr_err("relocation failed for symbol '%s' at 0x%016lx (%d)\n", reloc->name, val, ret); goto out; } } out: module_enable_ro(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(); } 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)) { WARN_ON(unregister_ftrace_function(&ops->fops)); WARN_ON(ftrace_set_filter_ip(&ops->fops, func->old_addr, 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) { 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); INIT_LIST_HEAD(&ops->func_stack); list_add_rcu(&func->stack_node, &ops->func_stack); ret = ftrace_set_filter_ip(&ops->fops, func->old_addr, 0, 0); if (ret) { pr_err("failed to set ftrace filter for function '%s' (%d)\n", func->old_name, ret); goto err; } ret = register_ftrace_function(&ops->fops); if (ret) { pr_err("failed to register ftrace handler for function '%s' (%d)\n", func->old_name, ret); ftrace_set_filter_ip(&ops->fops, func->old_addr, 1, 0); goto err; } } else { list_add_rcu(&func->stack_node, &ops->func_stack); } func->state = KLP_ENABLED; return 0; err: list_del_rcu(&func->stack_node); list_del(&ops->node); kfree(ops); return ret; } static void klp_disable_object(struct klp_object *obj) { struct klp_func *func; klp_for_each_func(obj, func) if (func->state == KLP_ENABLED) klp_disable_func(func); obj->state = KLP_DISABLED; } static int klp_enable_object(struct klp_object *obj) { struct klp_func *func; int ret; if (WARN_ON(obj->state != KLP_DISABLED)) return -EINVAL; if (WARN_ON(!klp_is_object_loaded(obj))) return -EINVAL; klp_for_each_func(obj, func) { ret = klp_enable_func(func); if (ret) { klp_disable_object(obj); return ret; } } obj->state = KLP_ENABLED; return 0; } static int __klp_disable_patch(struct klp_patch *patch) { struct klp_object *obj; /* 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) 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); } patch->state = KLP_DISABLED; return 0; } /** * klp_disable_patch() - disables a registered patch * @patch: The registered, enabled patch to be disabled * * Unregisters the patched functions from ftrace. * * Return: 0 on success, otherwise error */ int klp_disable_patch(struct klp_patch *patch) { int ret; mutex_lock(&klp_mutex); if (!klp_is_patch_registered(patch)) { ret = -EINVAL; goto err; } if (patch->state == KLP_DISABLED) { ret = -EINVAL; goto err; } ret = __klp_disable_patch(patch); err: mutex_unlock(&klp_mutex); return ret; } EXPORT_SYMBOL_GPL(klp_disable_patch); static int __klp_enable_patch(struct klp_patch *patch) { struct klp_object *obj; int ret; if (WARN_ON(patch->state != KLP_DISABLED)) 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) return -EBUSY; pr_notice_once("tainting kernel with TAINT_LIVEPATCH\n"); add_taint(TAINT_LIVEPATCH, LOCKDEP_STILL_OK); pr_notice("enabling patch '%s'\n", patch->mod->name); klp_for_each_object(patch, obj) { if (!klp_is_object_loaded(obj)) continue; ret = klp_enable_object(obj); if (ret) goto unregister; } patch->state = KLP_ENABLED;