LXR linux/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
  31enum 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 */
  47struct 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 */
  76struct 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 */
  95struct 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 */
 115struct 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
 132int klp_register_patch(struct klp_patch *);
 133int klp_unregister_patch(struct klp_patch *);
 134int klp_enable_patch(struct klp_patch *);
 135int klp_disable_patch(struct klp_patch *);
 136
 137/* Called from the module loader during module coming/going states */
 138int klp_module_coming(struct module *mod);
 139void klp_module_going(struct module *mod);
 140
 141#else /* !CONFIG_LIVEPATCH */
 142
 143static inline int klp_module_coming(struct module *mod) { return 0; }
 144static inline void klp_module_going(struct module *mod) { }
 145
 146#endif /* CONFIG_LIVEPATCH */
 147
 148#endif /* _LINUX_LIVEPATCH_H_ */
 149