RepoMirrors
/
kpatch
mirror of https://github.com/dynup/kpatch
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
kpatch/kmod/core/kpatch.h

103 lines
2.5 KiB
C
Raw Normal View History

add documentation to core kmod files Signed-off-by: Seth Jennings <sjenning@redhat.com>
2014-02-11 20:01:00 +00:00
/*
* kpatch.h
*
* Copyright (C) 2014 Seth Jennings <sjenning@redhat.com>
kmod/core: remove unused old_func_name field Not needed, we can always add it again later if needed (for sanity checks, maybe)
2014-03-13 20:08:08 +00:00
* Copyright (C) 2013-2014 Josh Poimboeuf <jpoimboe@redhat.com>
add documentation to core kmod files Signed-off-by: Seth Jennings <sjenning@redhat.com>
2014-02-11 20:01:00 +00:00
*
add GPLv2 headers to source files
2014-03-05 03:34:03 +00:00
* 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
kmod/core: checkpatch and sparse fixes - checkpatch doesn't like the FSF address since it's subject to change - checkpatch doesn't like strings split by line - whitespace fix - sparse suggested to change some variables and functions to static
2014-05-01 17:19:41 +00:00
* along with this program; if not, see <https://www.gnu.org/licenses/>.
add GPLv2 headers to source files
2014-03-05 03:34:03 +00:00
*
use consistent naming for core and patch modules
2014-02-13 16:51:00 +00:00
* Contains the API for the core kpatch module used by the patch modules
add documentation to core kmod files Signed-off-by: Seth Jennings <sjenning@redhat.com>
2014-02-11 20:01:00 +00:00
*/
major rewrite to per-section function/data model Signed-off-by: Seth Jennings <sjenning@redhat.com>
2014-02-11 16:25:48 +00:00
#ifndef _KPATCH_H_
#define _KPATCH_H_
implement per-object patching/relocations The recent module patching code has exposed some problems with our data structures. We currently patch the funcs and dynrelas individually, which is kind of scary now that different objects can be patched at different times. Instead it's cleaner and safer to group them by patched object. This patch implements per-object patching and relocations by refactoring the interfaces: - Completely separate the create-diff-object <-> patch module interface from the patch module <-> core module interface. create-diff-object will include "kpatch-patch.h" but not "kpatch.h". Thus, create-diff-object has no knowledge about the core module's interfaces, and the core module has no knowledge about the patch module's special sections. - Newly added kpatch-patch.h defines the format of the patch module special sections. It's used by create-diff-object to create the special sections and used by the patch module to read them. - kpatch.h still defines the core module interfaces. Each kpatch_module has a list of kpatch_objects for each module object to be patched. Each kpatch_object has a list of kpatch_funcs and a list of kpatch_dynrelas. The patch module creates these lists when populating kpatch_module. This way of structuring the data allows us to patch funcs and dynrelas on a per patched object basis, which will allow us to catch more error scenarios and make the code easier to manage going forward. It also allows the use of much more common code between kpatch_register() and kpatch_module_notify().
2014-06-17 14:51:47 +00:00
#include <linux/types.h>
#include <linux/module.h>
enum kpatch_op {
KPATCH_OP_NONE,
KPATCH_OP_PATCH,
KPATCH_OP_UNPATCH,
};
struct kpatch_func {
/* public */
kmod/core: rename some variables For the sake of consistency and readability, rename some variables. Also change func->old_addr_end to func->old_size.
2014-03-14 18:22:59 +00:00
unsigned long new_addr;
fix activeness safety check when unpatching When unpatching, the activeness safety logic should check for the new function on the stack, not the old one. Fixes #64.
2014-04-21 16:49:58 +00:00
unsigned long new_size;
consolidate variables func->old_offset and func->old_addr to just old_addr To reduce redundancy, remove/change the old_offset fields in the kpatch_func and kpatch_patch_func structs to just old_addr. Since old_offset is being used as a placeholder for old_addr, might as well consolidate it to just one variable.
2014-08-14 16:23:33 +00:00
unsigned long old_addr;
kmod/core: rename some variables For the sake of consistency and readability, rename some variables. Also change func->old_addr_end to func->old_size.
2014-03-14 18:22:59 +00:00
unsigned long old_size;
Add CONFIG_RANDOMIZE_BASE KASLR support Backport the symbol lookup and checking code from upstream livepatch code that relies on a symbol position enumeration rather than a fixed memory address. Fixes #617.
2016-11-15 21:02:09 +00:00
unsigned long sympos;
implement per-object patching/relocations The recent module patching code has exposed some problems with our data structures. We currently patch the funcs and dynrelas individually, which is kind of scary now that different objects can be patched at different times. Instead it's cleaner and safer to group them by patched object. This patch implements per-object patching and relocations by refactoring the interfaces: - Completely separate the create-diff-object <-> patch module interface from the patch module <-> core module interface. create-diff-object will include "kpatch-patch.h" but not "kpatch.h". Thus, create-diff-object has no knowledge about the core module's interfaces, and the core module has no knowledge about the patch module's special sections. - Newly added kpatch-patch.h defines the format of the patch module special sections. It's used by create-diff-object to create the special sections and used by the patch module to read them. - kpatch.h still defines the core module interfaces. Each kpatch_module has a list of kpatch_objects for each module object to be patched. Each kpatch_object has a list of kpatch_funcs and a list of kpatch_dynrelas. The patch module creates these lists when populating kpatch_module. This way of structuring the data allows us to patch funcs and dynrelas on a per patched object basis, which will allow us to catch more error scenarios and make the code easier to manage going forward. It also allows the use of much more common code between kpatch_register() and kpatch_module_notify().
2014-06-17 14:51:47 +00:00
const char *name;
struct list_head list;
support forced patching Some functions in the kernel are always on the stack of some thread in the system. Attempts to patch these function will currently always fail the activeness safety check. However, through human inspection, it can be determined that, for a particular function, consistency is maintained even if the old and new versions of the function run concurrently. This commit introduces a KPATCH_FORCE_UNSAFE() macro to define patched functions that such be exempted from the activeness safety check. Signed-off-by: Seth Jennings <sjenning@redhat.com>
2014-07-02 17:35:18 +00:00
int force;
implement per-object patching/relocations The recent module patching code has exposed some problems with our data structures. We currently patch the funcs and dynrelas individually, which is kind of scary now that different objects can be patched at different times. Instead it's cleaner and safer to group them by patched object. This patch implements per-object patching and relocations by refactoring the interfaces: - Completely separate the create-diff-object <-> patch module interface from the patch module <-> core module interface. create-diff-object will include "kpatch-patch.h" but not "kpatch.h". Thus, create-diff-object has no knowledge about the core module's interfaces, and the core module has no knowledge about the patch module's special sections. - Newly added kpatch-patch.h defines the format of the patch module special sections. It's used by create-diff-object to create the special sections and used by the patch module to read them. - kpatch.h still defines the core module interfaces. Each kpatch_module has a list of kpatch_objects for each module object to be patched. Each kpatch_object has a list of kpatch_funcs and a list of kpatch_dynrelas. The patch module creates these lists when populating kpatch_module. This way of structuring the data allows us to patch funcs and dynrelas on a per patched object basis, which will allow us to catch more error scenarios and make the code easier to manage going forward. It also allows the use of much more common code between kpatch_register() and kpatch_module_notify().
2014-06-17 14:51:47 +00:00
/* private */
struct hlist_node node;
enum kpatch_op op;
kmod: restructure kpatch sysfs tree Restructure kpatch's sysfs interface and mirror the sysfs tree after livepatch's sysfs layout. With the current sysfs layout, we cannot distinguish which object a function belongs to, and we cannot tell which modules/objects are patched. Therefore, restructure the kpatch sysfs tree such that module/object information is available. With the new layout, each patched object has its own directory, with each function being a subdirectory of its object. Implement this by embedding a kobject struct within the kpatch_module, kpatch_func, and kpatch_object structs and supplying their ktypes and kobject release methods. Before: /sys/kernel/kpatch └── patches └── <patch_module> ├── checksum ├── enabled └── functions ├── <function> # from <object1> │ ├── new_addr │ └── old_addr ├── <function> # from <object2> │ ├── new_addr │ └── old_addr └─── <function> # from <object3> ├── new_addr └── old_addr After: /sys/kernel/kpatch └── <patch_module> ├── <object1> │   └── <function,sympos> │   ├── new_addr │   └── old_addr ├── <object2> │   └── <function,sympos> │   ├── new_addr │   └── old_addr ├── checksum ├── enabled └── <object3> └── <function,sympos> ├── new_addr └── old_addr
2017-02-28 03:17:11 +00:00
struct kobject kobj;
major rewrite to per-section function/data model Signed-off-by: Seth Jennings <sjenning@redhat.com>
2014-02-11 16:25:48 +00:00
};
dynrelas support, obsoleting link-vmlinux-syms This adds dynamic linking support for the patch modules. It is the first step toward supporting patching module code and relocatable kernels. Rela entries that reference non-included local and non-exported global symbols are converted to "dynrelas". These dynrelas are relocations that are done by the core module, not the kernel module linker. This allows the core module to apply offsets to the base addresses found in the base vmlinux or module. Signed-off-by: Seth Jennings <sjenning@redhat.com> Conflicts: kpatch-build/kpatch-build
2014-05-14 20:59:05 +00:00
struct kpatch_dynrela {
unsigned long dest;
unsigned long src;
unsigned long type;
Add CONFIG_RANDOMIZE_BASE KASLR support Backport the symbol lookup and checking code from upstream livepatch code that relies on a symbol position enumeration rather than a fixed memory address. Fixes #617.
2016-11-15 21:02:09 +00:00
unsigned long sympos;
implement per-object patching/relocations The recent module patching code has exposed some problems with our data structures. We currently patch the funcs and dynrelas individually, which is kind of scary now that different objects can be patched at different times. Instead it's cleaner and safer to group them by patched object. This patch implements per-object patching and relocations by refactoring the interfaces: - Completely separate the create-diff-object <-> patch module interface from the patch module <-> core module interface. create-diff-object will include "kpatch-patch.h" but not "kpatch.h". Thus, create-diff-object has no knowledge about the core module's interfaces, and the core module has no knowledge about the patch module's special sections. - Newly added kpatch-patch.h defines the format of the patch module special sections. It's used by create-diff-object to create the special sections and used by the patch module to read them. - kpatch.h still defines the core module interfaces. Each kpatch_module has a list of kpatch_objects for each module object to be patched. Each kpatch_object has a list of kpatch_funcs and a list of kpatch_dynrelas. The patch module creates these lists when populating kpatch_module. This way of structuring the data allows us to patch funcs and dynrelas on a per patched object basis, which will allow us to catch more error scenarios and make the code easier to manage going forward. It also allows the use of much more common code between kpatch_register() and kpatch_module_notify().
2014-06-17 14:51:47 +00:00
const char *name;
symbol location verification support This commit introduces functionality to verify the location of symbols used in both the patch and dynrelas sections. It adds significant protection from mismatches between the base and running kernels. Signed-off-by: Seth Jennings <sjenning@redhat.com>
2014-05-23 21:36:31 +00:00
int addend;
allow patched modules to call external functions When patching a kernel module, if we can't find a needed dynrela symbol, we currently assume it's exported. However, it's also possible that it's provided by another .o in the patch module. Add support for that. Fixes #445.
2014-10-04 02:47:35 +00:00
int external;
implement per-object patching/relocations The recent module patching code has exposed some problems with our data structures. We currently patch the funcs and dynrelas individually, which is kind of scary now that different objects can be patched at different times. Instead it's cleaner and safer to group them by patched object. This patch implements per-object patching and relocations by refactoring the interfaces: - Completely separate the create-diff-object <-> patch module interface from the patch module <-> core module interface. create-diff-object will include "kpatch-patch.h" but not "kpatch.h". Thus, create-diff-object has no knowledge about the core module's interfaces, and the core module has no knowledge about the patch module's special sections. - Newly added kpatch-patch.h defines the format of the patch module special sections. It's used by create-diff-object to create the special sections and used by the patch module to read them. - kpatch.h still defines the core module interfaces. Each kpatch_module has a list of kpatch_objects for each module object to be patched. Each kpatch_object has a list of kpatch_funcs and a list of kpatch_dynrelas. The patch module creates these lists when populating kpatch_module. This way of structuring the data allows us to patch funcs and dynrelas on a per patched object basis, which will allow us to catch more error scenarios and make the code easier to manage going forward. It also allows the use of much more common code between kpatch_register() and kpatch_module_notify().
2014-06-17 14:51:47 +00:00
struct list_head list;
dynrelas support, obsoleting link-vmlinux-syms This adds dynamic linking support for the patch modules. It is the first step toward supporting patching module code and relocatable kernels. Rela entries that reference non-included local and non-exported global symbols are converted to "dynrelas". These dynrelas are relocations that are done by the core module, not the kernel module linker. This allows the core module to apply offsets to the base addresses found in the base vmlinux or module. Signed-off-by: Seth Jennings <sjenning@redhat.com> Conflicts: kpatch-build/kpatch-build
2014-05-14 20:59:05 +00:00
};
implement per-object patching/relocations The recent module patching code has exposed some problems with our data structures. We currently patch the funcs and dynrelas individually, which is kind of scary now that different objects can be patched at different times. Instead it's cleaner and safer to group them by patched object. This patch implements per-object patching and relocations by refactoring the interfaces: - Completely separate the create-diff-object <-> patch module interface from the patch module <-> core module interface. create-diff-object will include "kpatch-patch.h" but not "kpatch.h". Thus, create-diff-object has no knowledge about the core module's interfaces, and the core module has no knowledge about the patch module's special sections. - Newly added kpatch-patch.h defines the format of the patch module special sections. It's used by create-diff-object to create the special sections and used by the patch module to read them. - kpatch.h still defines the core module interfaces. Each kpatch_module has a list of kpatch_objects for each module object to be patched. Each kpatch_object has a list of kpatch_funcs and a list of kpatch_dynrelas. The patch module creates these lists when populating kpatch_module. This way of structuring the data allows us to patch funcs and dynrelas on a per patched object basis, which will allow us to catch more error scenarios and make the code easier to manage going forward. It also allows the use of much more common code between kpatch_register() and kpatch_module_notify().
2014-06-17 14:51:47 +00:00
struct kpatch_object {
struct list_head list;
const char *name;
struct list_head funcs;
struct list_head dynrelas;
kmod: add support for in-kernel livepatch hooks Upstream 4.15 kernels provide support for pre and post (un)patch callbacks, inspired by the kpatch load hooks. Add support for them in the livepatch-patch-hook. At the same time, convert the kpatch hooks to use the same API. Signed-off-by: Joe Lawrence <joe.lawrence@redhat.com>
2018-01-04 19:13:19 +00:00
int (*pre_patch_callback)(struct kpatch_object *);
void (*post_patch_callback)(struct kpatch_object *);
void (*pre_unpatch_callback)(struct kpatch_object *);
void (*post_unpatch_callback)(struct kpatch_object *);
bool callbacks_enabled;
refactor core <-> patch interface Make kpatch_funs truly internal by: Defining it in core.c Adding a struct kpatch_internal, declared in kpatch.h and defined in core.c, that contains per patch module internal data. Adding an "internal" field to struct kpatch_modules. Allocating internal and funcs data in core.c, not in the patch module, since the patch module has no knowledge of kpatch_func anymore. Adding a "patch" field to kpatch_func that points directly to the kpatch_patch provided by the module (rather than a field-by-field copy) Signed-off-by: Seth Jennings <sjenning@redhat.com>
2014-05-12 19:36:10 +00:00
implement per-object patching/relocations The recent module patching code has exposed some problems with our data structures. We currently patch the funcs and dynrelas individually, which is kind of scary now that different objects can be patched at different times. Instead it's cleaner and safer to group them by patched object. This patch implements per-object patching and relocations by refactoring the interfaces: - Completely separate the create-diff-object <-> patch module interface from the patch module <-> core module interface. create-diff-object will include "kpatch-patch.h" but not "kpatch.h". Thus, create-diff-object has no knowledge about the core module's interfaces, and the core module has no knowledge about the patch module's special sections. - Newly added kpatch-patch.h defines the format of the patch module special sections. It's used by create-diff-object to create the special sections and used by the patch module to read them. - kpatch.h still defines the core module interfaces. Each kpatch_module has a list of kpatch_objects for each module object to be patched. Each kpatch_object has a list of kpatch_funcs and a list of kpatch_dynrelas. The patch module creates these lists when populating kpatch_module. This way of structuring the data allows us to patch funcs and dynrelas on a per patched object basis, which will allow us to catch more error scenarios and make the code easier to manage going forward. It also allows the use of much more common code between kpatch_register() and kpatch_module_notify().
2014-06-17 14:51:47 +00:00
/* private */
struct module *mod;
kmod: restructure kpatch sysfs tree Restructure kpatch's sysfs interface and mirror the sysfs tree after livepatch's sysfs layout. With the current sysfs layout, we cannot distinguish which object a function belongs to, and we cannot tell which modules/objects are patched. Therefore, restructure the kpatch sysfs tree such that module/object information is available. With the new layout, each patched object has its own directory, with each function being a subdirectory of its object. Implement this by embedding a kobject struct within the kpatch_module, kpatch_func, and kpatch_object structs and supplying their ktypes and kobject release methods. Before: /sys/kernel/kpatch └── patches └── <patch_module> ├── checksum ├── enabled └── functions ├── <function> # from <object1> │ ├── new_addr │ └── old_addr ├── <function> # from <object2> │ ├── new_addr │ └── old_addr └─── <function> # from <object3> ├── new_addr └── old_addr After: /sys/kernel/kpatch └── <patch_module> ├── <object1> │   └── <function,sympos> │   ├── new_addr │   └── old_addr ├── <object2> │   └── <function,sympos> │   ├── new_addr │   └── old_addr ├── checksum ├── enabled └── <object3> └── <function,sympos> ├── new_addr └── old_addr
2017-02-28 03:17:11 +00:00
struct kobject kobj;
implement per-object patching/relocations The recent module patching code has exposed some problems with our data structures. We currently patch the funcs and dynrelas individually, which is kind of scary now that different objects can be patched at different times. Instead it's cleaner and safer to group them by patched object. This patch implements per-object patching and relocations by refactoring the interfaces: - Completely separate the create-diff-object <-> patch module interface from the patch module <-> core module interface. create-diff-object will include "kpatch-patch.h" but not "kpatch.h". Thus, create-diff-object has no knowledge about the core module's interfaces, and the core module has no knowledge about the patch module's special sections. - Newly added kpatch-patch.h defines the format of the patch module special sections. It's used by create-diff-object to create the special sections and used by the patch module to read them. - kpatch.h still defines the core module interfaces. Each kpatch_module has a list of kpatch_objects for each module object to be patched. Each kpatch_object has a list of kpatch_funcs and a list of kpatch_dynrelas. The patch module creates these lists when populating kpatch_module. This way of structuring the data allows us to patch funcs and dynrelas on a per patched object basis, which will allow us to catch more error scenarios and make the code easier to manage going forward. It also allows the use of much more common code between kpatch_register() and kpatch_module_notify().
2014-06-17 14:51:47 +00:00
};
refactor core <-> patch interface Make kpatch_funs truly internal by: Defining it in core.c Adding a struct kpatch_internal, declared in kpatch.h and defined in core.c, that contains per patch module internal data. Adding an "internal" field to struct kpatch_modules. Allocating internal and funcs data in core.c, not in the patch module, since the patch module has no knowledge of kpatch_func anymore. Adding a "patch" field to kpatch_func that points directly to the kpatch_patch provided by the module (rather than a field-by-field copy) Signed-off-by: Seth Jennings <sjenning@redhat.com>
2014-05-12 19:36:10 +00:00
kmod: add new kpatch_module struct Put funcs, num_funcs, and mod in their own struct called kpatch_module. This allows us to keep patch module specific variables in one place (and we'll have more of these variables soon).
2014-04-21 16:29:01 +00:00
struct kpatch_module {
kmod/core: get rid of kpatch_internal The kpatch_internal struct is a good idea, in that it documents which parts of kpatch_module shouldn't be used by the patch module. But it creates extra code and will require more extra code if we want to keep a list of kpmods, which is needed to create a module notifier for module patching of future loaded modules. Embedding the private data directly in the public struct allows the code to be simpler: no extra kmallocs/kfrees, no need to store pointers between the public and private structs. I think the simpler code is worth the tradeoff (exposing implementation detail). Kernel code usually doesn't bother with hiding a internal struct data from other kernel code anyway. For example, see ftrace_ops or struct kprobe. The private fields are documented with a "private" comment.
2014-06-10 17:02:34 +00:00
/* public */
kmod: add new kpatch_module struct Put funcs, num_funcs, and mod in their own struct called kpatch_module. This allows us to keep patch module specific variables in one place (and we'll have more of these variables soon).
2014-04-21 16:29:01 +00:00
struct module *mod;
implement per-object patching/relocations The recent module patching code has exposed some problems with our data structures. We currently patch the funcs and dynrelas individually, which is kind of scary now that different objects can be patched at different times. Instead it's cleaner and safer to group them by patched object. This patch implements per-object patching and relocations by refactoring the interfaces: - Completely separate the create-diff-object <-> patch module interface from the patch module <-> core module interface. create-diff-object will include "kpatch-patch.h" but not "kpatch.h". Thus, create-diff-object has no knowledge about the core module's interfaces, and the core module has no knowledge about the patch module's special sections. - Newly added kpatch-patch.h defines the format of the patch module special sections. It's used by create-diff-object to create the special sections and used by the patch module to read them. - kpatch.h still defines the core module interfaces. Each kpatch_module has a list of kpatch_objects for each module object to be patched. Each kpatch_object has a list of kpatch_funcs and a list of kpatch_dynrelas. The patch module creates these lists when populating kpatch_module. This way of structuring the data allows us to patch funcs and dynrelas on a per patched object basis, which will allow us to catch more error scenarios and make the code easier to manage going forward. It also allows the use of much more common code between kpatch_register() and kpatch_module_notify().
2014-06-17 14:51:47 +00:00
struct list_head objects;
/* public read-only */
safe kpatch unload Currently the patch module calls kpatch_unregister in the patch module exit path. If the activeness safety check fails in kpatch_unregister, it's too late for the patch module to stop exiting, so all it can do is panic. Prevent this scenario by requiring the user to disable the patch module via sysfs before allowing the module to be unloaded. The sysfs write will fail if the activeness safety check fails. An rmmod will fail if the patch is still enabled. Also add support for this new unloading model in "kpatch unload".
2014-04-26 04:05:26 +00:00
bool enabled;
kmod/core: get rid of kpatch_internal The kpatch_internal struct is a good idea, in that it documents which parts of kpatch_module shouldn't be used by the patch module. But it creates extra code and will require more extra code if we want to keep a list of kpmods, which is needed to create a module notifier for module patching of future loaded modules. Embedding the private data directly in the public struct allows the code to be simpler: no extra kmallocs/kfrees, no need to store pointers between the public and private structs. I think the simpler code is worth the tradeoff (exposing implementation detail). Kernel code usually doesn't bother with hiding a internal struct data from other kernel code anyway. For example, see ftrace_ops or struct kprobe. The private fields are documented with a "private" comment.
2014-06-10 17:02:34 +00:00
/* private */
kmod/core: create global kpmod_list Create a list of registered patch modules, which will be used in the module notifier to patch future loaded modules. It will also be used to fix the kpatch replace race condition where it calls module_put too early.
2014-06-10 17:28:40 +00:00
struct list_head list;
kmod: restructure kpatch sysfs tree Restructure kpatch's sysfs interface and mirror the sysfs tree after livepatch's sysfs layout. With the current sysfs layout, we cannot distinguish which object a function belongs to, and we cannot tell which modules/objects are patched. Therefore, restructure the kpatch sysfs tree such that module/object information is available. With the new layout, each patched object has its own directory, with each function being a subdirectory of its object. Implement this by embedding a kobject struct within the kpatch_module, kpatch_func, and kpatch_object structs and supplying their ktypes and kobject release methods. Before: /sys/kernel/kpatch └── patches └── <patch_module> ├── checksum ├── enabled └── functions ├── <function> # from <object1> │ ├── new_addr │ └── old_addr ├── <function> # from <object2> │ ├── new_addr │ └── old_addr └─── <function> # from <object3> ├── new_addr └── old_addr After: /sys/kernel/kpatch └── <patch_module> ├── <object1> │   └── <function,sympos> │   ├── new_addr │   └── old_addr ├── <object2> │   └── <function,sympos> │   ├── new_addr │   └── old_addr ├── checksum ├── enabled └── <object3> └── <function,sympos> ├── new_addr └── old_addr
2017-02-28 03:17:11 +00:00
struct kobject kobj;
kmod: add new kpatch_module struct Put funcs, num_funcs, and mod in their own struct called kpatch_module. This allows us to keep patch module specific variables in one place (and we'll have more of these variables soon).
2014-04-21 16:29:01 +00:00
};
kmod: restructure kpatch sysfs tree Restructure kpatch's sysfs interface and mirror the sysfs tree after livepatch's sysfs layout. With the current sysfs layout, we cannot distinguish which object a function belongs to, and we cannot tell which modules/objects are patched. Therefore, restructure the kpatch sysfs tree such that module/object information is available. With the new layout, each patched object has its own directory, with each function being a subdirectory of its object. Implement this by embedding a kobject struct within the kpatch_module, kpatch_func, and kpatch_object structs and supplying their ktypes and kobject release methods. Before: /sys/kernel/kpatch └── patches └── <patch_module> ├── checksum ├── enabled └── functions ├── <function> # from <object1> │ ├── new_addr │ └── old_addr ├── <function> # from <object2> │ ├── new_addr │ └── old_addr └─── <function> # from <object3> ├── new_addr └── old_addr After: /sys/kernel/kpatch └── <patch_module> ├── <object1> │   └── <function,sympos> │   ├── new_addr │   └── old_addr ├── <object2> │   └── <function,sympos> │   ├── new_addr │   └── old_addr ├── checksum ├── enabled └── <object3> └── <function,sympos> ├── new_addr └── old_addr
2017-02-28 03:17:11 +00:00
extern struct kobject *kpatch_root_kobj;
safe kpatch unload Currently the patch module calls kpatch_unregister in the patch module exit path. If the activeness safety check fails in kpatch_unregister, it's too late for the patch module to stop exiting, so all it can do is panic. Prevent this scenario by requiring the user to disable the patch module via sysfs before allowing the module to be unloaded. The sysfs write will fail if the activeness safety check fails. An rmmod will fail if the patch is still enabled. Also add support for this new unloading model in "kpatch unload".
2014-04-26 04:05:26 +00:00
kpatch replace Allow the user to atomically replace all existing modules with a new "kpatch replace" command. This provides a safe way to do atomic upgrades for cumulative patch module updates.
2014-04-28 21:18:29 +00:00
extern int kpatch_register(struct kpatch_module *kpmod, bool replace);
kmod: add new kpatch_module struct Put funcs, num_funcs, and mod in their own struct called kpatch_module. This allows us to keep patch module specific variables in one place (and we'll have more of these variables soon).
2014-04-21 16:29:01 +00:00
extern int kpatch_unregister(struct kpatch_module *kpmod);
major rewrite to per-section function/data model Signed-off-by: Seth Jennings <sjenning@redhat.com>
2014-02-11 16:25:48 +00:00
add support for shadow variables This adds support for shadow variables, which allow you to add new "shadow" fields to existing data structures. To allow patches to call the shadow functions in the core module, I had to add a funky hack to use --warn-unresolved-symbols when linking, which allows the patched vmlinux to link with the missing symbols. I also added greps to the log file to ensure that only unresolved symbols to kpatch_shadow_* are allowed. We can remove this hack once the core module gets moved into the kernel tree. Fixes #314.
2014-08-29 16:27:33 +00:00
extern void *kpatch_shadow_alloc(void *obj, char *var, size_t size, gfp_t gfp);
extern void kpatch_shadow_free(void *obj, char *var);
extern void *kpatch_shadow_get(void *obj, char *var);
major rewrite to per-section function/data model Signed-off-by: Seth Jennings <sjenning@redhat.com>
2014-02-11 16:25:48 +00:00
#endif /* _KPATCH_H_ */