include/linux/livepatch.h

   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  * @val:        address of the referenced symbol (optional,
  71  *              vmlinux patches only)
  72  * @type:       ELF relocation type
  73  * @name:       name of the referenced symbol (for lookup/verification)
  74  * @addend:     offset from the referenced symbol
  75  * @external:   symbol is either exported or within the live patch module itself
  76  */
  77 struct klp_reloc {
  78         unsigned long loc;
  79         unsigned long val;
  80         unsigned long type;
  81         const char *name;
  82         int addend;
  83         int external;
  84 };
  85
  86 /**
  87  * struct klp_object - kernel object structure for live patching
  88  * @name:       module name (or NULL for vmlinux)
  89  * @relocs:     relocation entries to be applied at load time
  90  * @funcs:      function entries for functions to be patched in the object
  91  * @kobj:       kobject for sysfs resources
  92  * @mod:        kernel module associated with the patched object
  93  *              (NULL for vmlinux)
  94  * @state:      tracks object-level patch application state
  95  */
  96 struct klp_object {
  97         /* external */
  98         const char *name;
  99         struct klp_reloc *relocs;
 100         struct klp_func *funcs;
 101
 102         /* internal */
 103         struct kobject kobj;
 104         struct module *mod;
 105         enum klp_state state;
 106 };
 107
 108 /**
 109  * struct klp_patch - patch structure for live patching
 110  * @mod:        reference to the live patch module
 111  * @objs:       object entries for kernel objects to be patched
 112  * @list:       list node for global list of registered patches
 113  * @kobj:       kobject for sysfs resources
 114  * @state:      tracks patch-level application state
 115  */
 116 struct klp_patch {
 117         /* external */
 118         struct module *mod;
 119         struct klp_object *objs;
 120
 121         /* internal */
 122         struct list_head list;
 123         struct kobject kobj;
 124         enum klp_state state;
 125 };
 126
 127 #define klp_for_each_object(patch, obj) \
 128         for (obj = patch->objs; obj->funcs; obj++)
 129
 130 #define klp_for_each_func(obj, func) \
 131         for (func = obj->funcs; func->old_name; func++)
 132
 133 int klp_register_patch(struct klp_patch *);
 134 int klp_unregister_patch(struct klp_patch *);
 135 int klp_enable_patch(struct klp_patch *);
 136 int klp_disable_patch(struct klp_patch *);
 137
 138 #endif /* CONFIG_LIVEPATCH */
 139
 140 #endif /* _LINUX_LIVEPATCH_H_ */