/* * 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> /** * 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){ if (!klp_is_module(obj)) return; mutex_lock(&module_mutex); /* * We don't need to take a reference on the module here because we have * the klp_mutex, which is also taken by the module notifier. This * prevents any module from unloading until we release the klp_mutex. */ obj->mod = find_module(obj->name); 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; /* * If count == 0, the symbol was not found. If count == 1, a unique * match was found and addr is set. If count > 1, there is * unresolvable ambiguity among "count" number of symbols with the same * name in the same object. */ unsigned long count;}; 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 might be overwritten if another match is found * but klp_find_object_symbol() handles this and only returns the * addr if count == 1. */ args->addr = addr; args->count++; return 0;} static int klp_find_object_symbol(const char *objname, const char *name, unsigned long *addr){ struct klp_find_arg args = { .objname = objname, .name = name, .addr = 0, .count = 0 }; kallsyms_on_each_symbol(klp_find_callback, &args); if (args.count == 0) pr_err("symbol '%s' not found in symbol table\n", name); else if (args.count > 1) pr_err("unresolvable ambiguity (%lu matches) on symbol '%s' in object '%s'\n", args.count, name, objname); else { *addr = args.addr; return 0; } *addr = 0; return -EINVAL;} struct klp_verify_args { const char *name; const unsigned long addr;}; static int klp_verify_callback(void *data, const char *name, struct module *mod, unsigned long addr){ struct klp_verify_args *args = data; if (!mod && !strcmp(args->name, name) && args->addr == addr) return 1; return 0;} static int klp_verify_vmlinux_symbol(const char *name, unsigned long addr){ struct klp_verify_args args = { .name = name, .addr = addr, }; if (kallsyms_on_each_symbol(klp_verify_callback, &args)) return 0; pr_err("symbol '%s' not found at specified address 0x%016lx, kernel mismatch?\n", name, addr); return -EINVAL;} static int klp_find_verify_func_addr(struct klp_object *obj, struct klp_func *func){ int ret; #if defined(CONFIG_RANDOMIZE_BASE) /* KASLR is enabled, disregard old_addr from user */ func->old_addr = 0;#endif if (!func->old_addr || klp_is_module(obj)) ret = klp_find_object_symbol(obj->name, func->old_name, &func->old_addr); else ret = klp_verify_vmlinux_symbol(func->old_name, func->old_addr); return ret;} /* * 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); preempt_enable(); if (sym) { *addr = sym->value; return 0; } /* otherwise check if it's in another .o within the patch module */ return klp_find_object_symbol(pmod->name, name, addr);} static int klp_write_object_relocations(struct module *pmod, struct klp_object *obj){ int ret; struct klp_reloc *reloc; if (WARN_ON(!klp_is_object_loaded(obj))) return -EINVAL; if (WARN_ON(!obj->relocs)) return -EINVAL; for (reloc = obj->relocs; reloc->name; reloc++) { if (!klp_is_module(obj)) { ret = klp_verify_vmlinux_symbol(reloc->name, reloc->val); if (ret) return ret; } else { /* module, reloc->val needs to be discovered */ if (reloc->external) ret = klp_find_external_symbol(pmod, reloc->name, &reloc->val); else ret = klp_find_object_symbol(obj->mod->name, reloc->name, &reloc->val); if (ret) return ret; } ret = klp_write_module_reloc(pmod, reloc->type, reloc->loc, reloc->val + reloc->addend); if (ret) { pr_err("relocation failed for symbol '%s' at 0x%016lx (%d)\n", reloc->name, reloc->val, ret); return ret; } } return 0;} 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); rcu_read_unlock(); if (WARN_ON_ONCE(!func)) return; klp_arch_set_pc(regs, (unsigned long)func->new_func);} static int klp_disable_func(struct klp_func *func){ struct klp_ops *ops; int ret; if (WARN_ON(func->state != KLP_ENABLED)) return -EINVAL; if (WARN_ON(!func->old_addr)) return -EINVAL; ops = klp_find_ops(func->old_addr); if (WARN_ON(!ops)) return -EINVAL; if (list_is_singular(&ops->func_stack)) { ret = unregister_ftrace_function(&ops->fops); if (ret) { pr_err("failed to unregister ftrace handler for function '%s' (%d)\n", func->old_name, ret); return ret; } ret = ftrace_set_filter_ip(&ops->fops, func->old_addr, 1, 0); if (ret) pr_warn("function unregister succeeded but failed to clear the filter\n"); list_del_rcu(&func->stack_node); list_del(&ops->node); kfree(ops); } else { list_del_rcu(&func->stack_node); } func->state = KLP_DISABLED; return 0;} 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 int klp_disable_object(struct klp_object *obj){ struct klp_func *func; int ret; for (func = obj->funcs; func->old_name; func++) { if (func->state != KLP_ENABLED) continue; ret = klp_disable_func(func); if (ret) return ret; } obj->state = KLP_DISABLED; return 0;} 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; for (func = obj->funcs; func->old_name; func++) { ret = klp_enable_func(func); if (ret) goto unregister; } obj->state = KLP_ENABLED; return 0; unregister: WARN_ON(klp_disable_object(obj)); return ret;} static int __klp_disable_patch(struct klp_patch *patch){ struct klp_object *obj; int ret; /* 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); for (obj = patch->objs; obj->funcs; obj++) { if (obj->state != KLP_ENABLED) continue; ret = klp_disable_object(obj); if (ret) return ret; } 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)Lines 1–500 of 1015. 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> /** * 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) { if (!klp_is_module(obj)) return; mutex_lock(&module_mutex); /* * We don't need to take a reference on the module here because we have * the klp_mutex, which is also taken by the module notifier. This * prevents any module from unloading until we release the klp_mutex. */ obj->mod = find_module(obj->name); 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; /* * If count == 0, the symbol was not found. If count == 1, a unique * match was found and addr is set. If count > 1, there is * unresolvable ambiguity among "count" number of symbols with the same * name in the same object. */ unsigned long count; }; 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 might be overwritten if another match is found * but klp_find_object_symbol() handles this and only returns the * addr if count == 1. */ args->addr = addr; args->count++; return 0; } static int klp_find_object_symbol(const char *objname, const char *name, unsigned long *addr) { struct klp_find_arg args = { .objname = objname, .name = name, .addr = 0, .count = 0 }; kallsyms_on_each_symbol(klp_find_callback, &args); if (args.count == 0) pr_err("symbol '%s' not found in symbol table\n", name); else if (args.count > 1) pr_err("unresolvable ambiguity (%lu matches) on symbol '%s' in object '%s'\n", args.count, name, objname); else { *addr = args.addr; return 0; } *addr = 0; return -EINVAL; } struct klp_verify_args { const char *name; const unsigned long addr; }; static int klp_verify_callback(void *data, const char *name, struct module *mod, unsigned long addr) { struct klp_verify_args *args = data; if (!mod && !strcmp(args->name, name) && args->addr == addr) return 1; return 0; } static int klp_verify_vmlinux_symbol(const char *name, unsigned long addr) { struct klp_verify_args args = { .name = name, .addr = addr, }; if (kallsyms_on_each_symbol(klp_verify_callback, &args)) return 0; pr_err("symbol '%s' not found at specified address 0x%016lx, kernel mismatch?\n", name, addr); return -EINVAL; } static int klp_find_verify_func_addr(struct klp_object *obj, struct klp_func *func) { int ret; #if defined(CONFIG_RANDOMIZE_BASE) /* KASLR is enabled, disregard old_addr from user */ func->old_addr = 0; #endif if (!func->old_addr || klp_is_module(obj)) ret = klp_find_object_symbol(obj->name, func->old_name, &func->old_addr); else ret = klp_verify_vmlinux_symbol(func->old_name, func->old_addr); return ret; } /* * 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); preempt_enable(); if (sym) { *addr = sym->value; return 0; } /* otherwise check if it's in another .o within the patch module */ return klp_find_object_symbol(pmod->name, name, addr); } static int klp_write_object_relocations(struct module *pmod, struct klp_object *obj) { int ret; struct klp_reloc *reloc; if (WARN_ON(!klp_is_object_loaded(obj))) return -EINVAL; if (WARN_ON(!obj->relocs)) return -EINVAL; for (reloc = obj->relocs; reloc->name; reloc++) { if (!klp_is_module(obj)) { ret = klp_verify_vmlinux_symbol(reloc->name, reloc->val); if (ret) return ret; } else { /* module, reloc->val needs to be discovered */ if (reloc->external) ret = klp_find_external_symbol(pmod, reloc->name, &reloc->val); else ret = klp_find_object_symbol(obj->mod->name, reloc->name, &reloc->val); if (ret) return ret; } ret = klp_write_module_reloc(pmod, reloc->type, reloc->loc, reloc->val + reloc->addend); if (ret) { pr_err("relocation failed for symbol '%s' at 0x%016lx (%d)\n", reloc->name, reloc->val, ret); return ret; } } return 0; } 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); rcu_read_unlock(); if (WARN_ON_ONCE(!func)) return; klp_arch_set_pc(regs, (unsigned long)func->new_func); } static int klp_disable_func(struct klp_func *func) { struct klp_ops *ops; int ret; if (WARN_ON(func->state != KLP_ENABLED)) return -EINVAL; if (WARN_ON(!func->old_addr)) return -EINVAL; ops = klp_find_ops(func->old_addr); if (WARN_ON(!ops)) return -EINVAL; if (list_is_singular(&ops->func_stack)) { ret = unregister_ftrace_function(&ops->fops); if (ret) { pr_err("failed to unregister ftrace handler for function '%s' (%d)\n", func->old_name, ret); return ret; } ret = ftrace_set_filter_ip(&ops->fops, func->old_addr, 1, 0); if (ret) pr_warn("function unregister succeeded but failed to clear the filter\n"); list_del_rcu(&func->stack_node); list_del(&ops->node); kfree(ops); } else { list_del_rcu(&func->stack_node); } func->state = KLP_DISABLED; return 0; } 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 int klp_disable_object(struct klp_object *obj) { struct klp_func *func; int ret; for (func = obj->funcs; func->old_name; func++) { if (func->state != KLP_ENABLED) continue; ret = klp_disable_func(func); if (ret) return ret; } obj->state = KLP_DISABLED; return 0; } 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; for (func = obj->funcs; func->old_name; func++) { ret = klp_enable_func(func); if (ret) goto unregister; } obj->state = KLP_ENABLED; return 0; unregister: WARN_ON(klp_disable_object(obj)); return ret; } static int __klp_disable_patch(struct klp_patch *patch) { struct klp_object *obj; int ret; /* 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); for (obj = patch->objs; obj->funcs; obj++) { if (obj->state != KLP_ENABLED) continue; ret = klp_disable_object(obj); if (ret) return ret; } 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)