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

50 lines
1.2 KiB
C
Raw Normal View History

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
/*
* kpatch-patch.h
*
* Copyright (C) 2014 Josh Poimboeuf <jpoimboe@redhat.com>
*
* 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 <https://www.gnu.org/licenses/>.
*
* Contains the structs used for the patch module special sections
*/
fix review comments
2014-06-18 17:23:38 +00:00
#ifndef _KPATCH_PATCH_H_
#define _KPATCH_PATCH_H_
fix undefined symbols for future loaded modules When patching module A, if one of the new function's relas reference a symbol in module B, we currently just leave it as a normal rela. But if module B hasn't been loaded yet, the patch module will fail to load due to the rela's reference to an undefined symbol. The fix is to convert these relas to dynrelas, which can be resolved later in the module notifier when A is loaded. Also added support for the R_X86_64_NONE relocation type, needed for dynrelas which reference __fentry__.
2014-06-18 14:48:51 +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_patch_func {
unsigned long new_addr;
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;
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
unsigned long old_size;
char *name;
char *objname;
};
struct kpatch_patch_dynrela {
unsigned long dest;
unsigned long src;
unsigned long type;
char *name;
char *objname;
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
int addend;
};
fix review comments
2014-06-18 17:23:38 +00:00
add user-defined load/unload hook support This commit enables the ability to create user-defined hooks as part of the normal code patch that can do preparatory work for the application of the patch. This work could include, but is not limited to, changing data structure semantics. The user may define a new function as part of the patch and mark it as a load-time or unload-time hook with the kpatch_load_hook() and kpatch_unload_hook() macros. These macros are in an include file that gets copied into the source tree at include/linux/kpatch-hooks.h at patch build time. The signature for both hooks is "int kpatch_unload_hook(void)". For now, the return code is ignored. The hooks may not fail. They also run in stop_machine() context and may not sleep. These hooks, more or less, must follow all the rules of interrupt context code.
2014-06-27 17:01:39 +00:00
struct kpatch_patch_hook {
fixup review comments Signed-off-by: Seth Jennings <sjenning@redhat.com>
2014-07-01 17:22:16 +00:00
void (*hook)(void);
add user-defined load/unload hook support This commit enables the ability to create user-defined hooks as part of the normal code patch that can do preparatory work for the application of the patch. This work could include, but is not limited to, changing data structure semantics. The user may define a new function as part of the patch and mark it as a load-time or unload-time hook with the kpatch_load_hook() and kpatch_unload_hook() macros. These macros are in an include file that gets copied into the source tree at include/linux/kpatch-hooks.h at patch build time. The signature for both hooks is "int kpatch_unload_hook(void)". For now, the return code is ignored. The hooks may not fail. They also run in stop_machine() context and may not sleep. These hooks, more or less, must follow all the rules of interrupt context code.
2014-06-27 17:01:39 +00:00
char *objname;
};
fix review comments
2014-06-18 17:23:38 +00:00
#endif /* _KPATCH_PATCH_H_ */