1 /* 2 * livepatch.h - Kernel Live Patching Core 3 * 4 * Copyright (C) 2014 Seth Jennings <sjenning@redhat.com> 5 * Copyright (C) 2014 SUSE 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 2 10 * of the License, or (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, see <http://www.gnu.org/licenses/>. 19 */ 20 21 #ifndef _LINUX_LIVEPATCH_H_ 22 #define _LINUX_LIVEPATCH_H_ 23 24 #include <linux/module.h> 25 #include <linux/ftrace.h> 26 27 #if IS_ENABLED(CONFIG_LIVEPATCH) 28 29 #include <asm/livepatch.h> 30 31 enum klp_state { 32 KLP_DISABLED, 33 KLP_ENABLED 34 }; 35 36 /** 37 * struct klp_func - function structure for live patching 38 * @old_name: name of the function to be patched 39 * @new_func: pointer to the patched function code 40 * @old_sympos: a hint indicating which symbol position the old function 41 * can be found (optional) 42 * @old_addr: the address of the function being patched 43 * @kobj: kobject for sysfs resources 44 * @state: tracks function-level patch application state 45 * @stack_node: list node for klp_ops func_stack list 46 */ 47 struct klp_func { 48 /* external */ 49 const char *old_name; 50 void *new_func; 51 /* 52 * The old_sympos field is optional and can be used to resolve 53 * duplicate symbol names in livepatch objects. If this field is zero, 54 * it is expected the symbol is unique, otherwise patching fails. If 55 * this value is greater than zero then that occurrence of the symbol 56 * in kallsyms for the given object is used. 57 */ 58 unsigned long old_sympos; 59 60 /* internal */ 61 unsigned long old_addr; 62 struct kobject kobj; 63 enum klp_state state; 64 struct list_head stack_node; 65 }; 66 67 /** 68 * struct klp_reloc - relocation structure for live patching 69 * @loc: address where the relocation will be written 70 * @sympos: position in kallsyms to disambiguate symbols (optional) 71 * @type: ELF relocation type 72 * @name: name of the referenced symbol (for lookup/verification) 73 * @addend: offset from the referenced symbol 74 * @external: symbol is either exported or within the live patch module itself 75 */ 76 struct klp_reloc { 77 unsigned long loc; 78 unsigned long sympos; 79 unsigned long type; 80 const char *name; 81 int addend; 82 int external; 83 }; 84 85 /** 86 * struct klp_object - kernel object structure for live patching 87 * @name: module name (or NULL for vmlinux) 88 * @relocs: relocation entries to be applied at load time 89 * @funcs: function entries for functions to be patched in the object 90 * @kobj: kobject for sysfs resources 91 * @mod: kernel module associated with the patched object 92 * (NULL for vmlinux) 93 * @state: tracks object-level patch application state 94 */ 95 struct klp_object { 96 /* external */ 97 const char *name; 98 struct klp_reloc *relocs; 99 struct klp_func *funcs; 100 101 /* internal */ 102 struct kobject kobj; 103 struct module *mod; 104 enum klp_state state; 105 }; 106 107 /** 108 * struct klp_patch - patch structure for live patching 109 * @mod: reference to the live patch module 110 * @objs: object entries for kernel objects to be patched 111 * @list: list node for global list of registered patches 112 * @kobj: kobject for sysfs resources 113 * @state: tracks patch-level application state 114 */ 115 struct klp_patch { 116 /* external */ 117 struct module *mod; 118 struct klp_object *objs; 119 120 /* internal */ 121 struct list_head list; 122 struct kobject kobj; 123 enum klp_state state; 124 }; 125 126 #define klp_for_each_object(patch, obj) \ 127 for (obj = patch->objs; obj->funcs; obj++) 128 129 #define klp_for_each_func(obj, func) \ 130 for (func = obj->funcs; func->old_name; func++) 131 132 int klp_register_patch(struct klp_patch *); 133 int klp_unregister_patch(struct klp_patch *); 134 int klp_enable_patch(struct klp_patch *); 135 int klp_disable_patch(struct klp_patch *); 136 137 /* Called from the module loader during module coming/going states */ 138 int klp_module_coming(struct module *mod); 139 void klp_module_going(struct module *mod); 140 141 #else /* !CONFIG_LIVEPATCH */ 142 143 static inline int klp_module_coming(struct module *mod) { return 0; } 144 static inline void klp_module_going(struct module *mod) { } 145 146 #endif /* CONFIG_LIVEPATCH */ 147 148 #endif /* _LINUX_LIVEPATCH_H_ */ 149