livepatch: new API to track system state changes
Subsystems (3)
Petr Mladek
maintainerv4 cover livepatch: new API to track system state changes
Hi,
this is another piece in the puzzle that helps to maintain more livepatches.
Especially pre/post (un)patch callbacks might change a system state. Any newly installed livepatch has to somehow deal with system state modifications done be already installed livepatches.
This patchset provides a simple and generic API that helps to keep and pass information between the livepatches. It is also usable to prevent loading incompatible livepatches.
Changes since v3:
+ selftests compilation error [kbuild test robot]
+ fix copyright in selftests [Joe]
+ used macros for the module names in selftests [Joe]
+ allow zero state version [Josh]
+ slightly refactor the code for checking state version [Josh]
+ fix few typos reported by checkpatch.pl [Petr]
+ added Acks [Joe]
Changes since v2:
+ Typo fixes [Miroslav]
+ Move the documentation at the end of the list [Miroslav]
+ Add Miroslav's acks
Changes since v1:
+ Use "unsigned long" instead of "int" for "state.id" [Nicolai]
+ Use "unsigned int" instead of "int" for "state.version [Petr]
+ Include "state.h" to avoid warning about non-static func [Miroslav]
+ Simplify logic in klp_is_state_compatible() [Miroslav]
+ Document how livepatches should handle the state [Nicolai]
+ Fix some typos, formulation, module metadata [Joe, Miroslav]
Petr Mladek (5):
livepatch: Keep replaced patches until post_patch callback is called
livepatch: Basic API to track system state changes
livepatch: Allow to distinguish different version of system state
changes
livepatch: Documentation of the new API for tracking system state
changes
livepatch: Selftests of the API for tracking system state changes
Documentation/livepatch/index.rst | 1 + Documentation/livepatch/system-state.rst | 167 +++++++++++++++++++++ include/linux/livepatch.h | 17 +++ kernel/livepatch/Makefile | 2 +- kernel/livepatch/core.c | 44 ++++-- kernel/livepatch/core.h | 5 +- kernel/livepatch/state.c | 119 +++++++++++++++ kernel/livepatch/state.h | 9 ++ kernel/livepatch/transition.c | 12 +- lib/livepatch/Makefile | 5 +- lib/livepatch/test_klp_state.c | 162 ++++++++++++++++++++ lib/livepatch/test_klp_state2.c | 191 ++++++++++++++++++++++++ lib/livepatch/test_klp_state3.c | 5 + tools/testing/selftests/livepatch/Makefile | 3 +- tools/testing/selftests/livepatch/test-state.sh | 180 ++++++++++++++++++++++ 15 files changed, 901 insertions(+), 21 deletions(-) create mode 100644 Documentation/livepatch/system-state.rst create mode 100644 kernel/livepatch/state.c create mode 100644 kernel/livepatch/state.h create mode 100644 lib/livepatch/test_klp_state.c create mode 100644 lib/livepatch/test_klp_state2.c create mode 100644 lib/livepatch/test_klp_state3.c create mode 100755 tools/testing/selftests/livepatch/test-state.sh
Signature · 1 line
2.16.4
Petr Mladek
maintainerPATCH v4 1/5 livepatch: Keep replaced patches until post_patch callback is called
Pre/post (un)patch callbacks might manipulate the system state. Cumulative livepatches might need to take over the changes made by the replaced ones. For this they might need to access some data stored or referenced by the old livepatches.
Therefore the replaced livepatches have to stay around until post_patch() callback is called. It is achieved by calling the free functions later. It is the same location where disabled livepatches have already been freed.
--- kernel/livepatch/core.c | 36 ++++++++++++++++++++++++++---------- kernel/livepatch/core.h | 5 +++-- kernel/livepatch/transition.c | 12 ++++++------ 3 files changed, 35 insertions(+), 18 deletions(-)
kernel/livepatch/core.c +26 -10
@@ -632,7 +632,7 @@ static void klp_free_objects_dynamic(struct klp_patch *patch)* The operation must be completed by calling klp_free_patch_finish() * outside klp_mutex. */ -void klp_free_patch_start (struct klp_patch *patch) +static void klp_free_patch_start (struct klp_patch *patch) {if (!list_empty (&patch->list))list_del (&patch->list);
@@ -677,6 +677,23 @@ static void klp_free_patch_work_fn(struct work_struct *work)klp_free_patch_finish (patch); } +void klp_free_patch_async (struct klp_patch *patch) +{ +klp_free_patch_start (patch); +schedule_work (&patch->free_work); +} + +void klp_free_replaced_patches_async (struct klp_patch *new_patch) +{ +struct klp_patch *old_patch, *tmp_patch; + +klp_for_each_patch_safe (old_patch, tmp_patch) { +if (old_patch == new_patch) +return ; +klp_free_patch_async (old_patch); + } +} +static int klp_init_func (struct klp_object *obj,struct klp_func *func) {if (!func->old_name)
@@ -1022,12 +1039,13 @@ int klp_enable_patch(struct klp_patch *patch)EXPORT_SYMBOL_GPL (klp_enable_patch);/* -* This function removes replaced patches. +* This function unpatches objects from the replaced livepatches. * * We could be pretty aggressive here. It is called in the situation where -* these structures are no longer accessible. All functions are redirected -* by the klp_transition_patch. They use either a new code or they are in -* the original code because of the special nop function patches. +* these structures are no longer accessed from the ftrace handler. +* All functions are redirected by the klp_transition_patch. They +* use either a new code or they are in the original code because +* of the special nop function patches. * * The only exception is when the transition was forced. In this case, * klp_ftrace_handler() might still see the replaced patch on the stack.
@@ -1035,18 +1053,16 @@ EXPORT_SYMBOL_GPL(klp_enable_patch);* thanks to RCU. We only have to keep the patches on the system. Also * this is handled transparently by patch->module_put. */ -void klp_discard_replaced_patches (struct klp_patch *new_patch) +void klp_unpatch_replaced_patches (struct klp_patch *new_patch) { -struct klp_patch *old_patch, *tmp_patch; +struct klp_patch *old_patch; -klp_for_each_patch_safe (old_patch, tmp_patch) { +klp_for_each_patch (old_patch) {if (old_patch == new_patch)return ; old_patch->enabled = false;klp_unpatch_objects (old_patch); -klp_free_patch_start (old_patch); -schedule_work (&old_patch->free_work); } }
kernel/livepatch/core.h +3 -2
@@ -13,8 +13,9 @@ extern struct list_head klp_patches;#define klp_for_each_patch (patch) \ list_for_each_entry(patch, &klp_patches, list) -void klp_free_patch_start (struct klp_patch *patch); -void klp_discard_replaced_patches (struct klp_patch *new_patch); +void klp_free_patch_async (struct klp_patch *patch); +void klp_free_replaced_patches_async (struct klp_patch *new_patch); +void klp_unpatch_replaced_patches (struct klp_patch *new_patch);void klp_discard_nops (struct klp_patch *new_patch);static inline bool klp_is_object_loaded (struct klp_object *obj)
kernel/livepatch/transition.c +6 -6
@@ -78,7 +78,7 @@ static void klp_complete_transition(void) klp_target_state == KLP_PATCHED ? "patching" : "unpatching");if (klp_transition_patch->replace && klp_target_state ==KLP_PATCHED ) { -klp_discard_replaced_patches (klp_transition_patch); +klp_unpatch_replaced_patches (klp_transition_patch);klp_discard_nops (klp_transition_patch); }
@@ -446,14 +446,14 @@ void klp_try_complete_transition(void)klp_complete_transition ();/* -* It would make more sense to free the patch in +* It would make more sense to free the unused patches in * klp_complete_transition() but it is called also * from klp_cancel_transition(). */ -if (!patch->enabled) { -klp_free_patch_start (patch); -schedule_work (&patch->free_work); - } +if (!patch->enabled) +klp_free_patch_async (patch); +else if (patch->replace) +klp_free_replaced_patches_async (patch); }/*
Signature · 1 line
2.16.4
Petr Mladek
maintainerPATCH v4 2/5 livepatch: Basic API to track system state changes
In reply to Petr MladekThis is another step how to help maintaining more livepatches.
One big help was the atomic replace and cumulative livepatches. These livepatches replace the already installed ones. Therefore it should be enough when each cumulative livepatch is consistent.
The problems might come with shadow variables and callbacks. They might change the system behavior or state so that it is no longer safe to go back and use an older livepatch or the original kernel code. Also, a new livepatch must be able to detect changes which were made by the already installed livepatches.
This is where the livepatch system state tracking gets useful. It allows to:
- find whether a system state has already been modified by previous livepatches
- store data needed to manipulate and restore the system state
The information about the manipulated system states is stored in an array of struct klp_state. It can be searched by two new functions klp_get_state() and klp_get_prev_state().
The dependencies are going to be solved by a version field added later. The only important information is that it will be allowed to modify the same state by more non-cumulative livepatches. It is similar to allowing to modify the same function several times. The livepatch author is responsible for preventing incompatible changes.
--- include/linux/livepatch.h | 15 +++++++++ kernel/livepatch/Makefile | 2 +- kernel/livepatch/state.c | 83 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 99 insertions(+), 1 deletion(-) create mode 100644 kernel/livepatch/state.c
include/linux/livepatch.h +15 -0
@@ -130,10 +130,21 @@ struct klp_object {bool patched; }; +/** +* struct klp_state - state of the system modified by the livepatch +* @id: system state identifier (non-zero) +* @data: custom data +*/ +struct klp_state { +unsigned long id; +void *data; +}; +/** * struct klp_patch - patch structure for live patching * @mod: reference to the live patch module * @objs: object entries for kernel objects to be patched +* @states: system states that can get modified * @replace: replace all actively used patches * @list: list node for global list of actively used patches * @kobj: kobject for sysfs resources
@@ -147,6 +158,7 @@ struct klp_patch {/* external */ struct module *mod;struct klp_object *objs; +struct klp_state *states;bool replace;/* internal */
@@ -217,6 +229,9 @@ void *klp_shadow_get_or_alloc(void *obj, unsigned long id,void klp_shadow_free (void *obj,unsigned long id,klp_shadow_dtor_t dtor);void klp_shadow_free_all (unsigned long id,klp_shadow_dtor_t dtor); +struct klp_state *klp_get_state (struct klp_patch *patch,unsigned long id); +struct klp_state *klp_get_prev_state (unsigned long id); +#else /* !CONFIG_LIVEPATCH */ static inline int klp_module_coming (struct module *mod) {return 0 ; }
kernel/livepatch/Makefile +1 -1
@@ -1,4 +1,4 @@ # SPDX-License-Identifier: GPL-2.0-only obj-$(CONFIG_LIVEPATCH) += livepatch.o -livepatch-objs := core.o patch.o shadow.o transition.o +livepatch-objs := core.o patch.o shadow.o state.o transition.o
kernel/livepatch/state.c new file +83 -0
83 lines not on this page · raw message
Signature · 1 line
2.16.4
Petr Mladek
maintainerPATCH v4 3/5 livepatch: Allow to distinguish different version of system state changes
In reply to Petr MladekThe atomic replace runs pre/post (un)install callbacks only from the new livepatch. There are several reasons for this:
+ Simplicity: clear ordering of operations, no interactions between old and new callbacks.
+ Reliability: only new livepatch knows what changes can already be made by older livepatches and how to take over the state.
+ Testing: the atomic replace can be properly tested only when a newer livepatch is available. It might be too late to fix unwanted effect
of callbacks from older livepatches.
It might happen that an older change is not enough and the same system state has to be modified another way. Different changes need to get distinguished by a version number added to struct klp_state.
The version can also be used to prevent loading incompatible livepatches. The check is done when the livepatch is enabled. The rules are:
+ Any completely new system state modification is allowed.
+ System state modifications with the same or higher version are allowed for already modified system states.
+ Cumulative livepatches must handle all system state modifications from already installed livepatches.
+ Non-cumulative livepatches are allowed to touch already modified system states.
--- include/linux/livepatch.h | 2 ++ kernel/livepatch/core.c | 8 ++++++++ kernel/livepatch/state.c | 36 ++++++++++++++++++++++++++++++++++++ kernel/livepatch/state.h | 9 +++++++++ 4 files changed, 55 insertions(+) create mode 100644 kernel/livepatch/state.h
include/linux/livepatch.h +2 -0
@@ -133,10 +133,12 @@ struct klp_object {/** * struct klp_state - state of the system modified by the livepatch * @id: system state identifier (non-zero) +* @version: version of the change * @data: custom data */ struct klp_state {unsigned long id; +unsigned int version;void *data; };
kernel/livepatch/core.c +8 -0
@@ -22,6 +22,7 @@#include <asm/cacheflush.h> #include "core.h" #include "patch.h" +#include "state.h" #include "transition.h" /*
@@ -1009,6 +1010,13 @@ int klp_enable_patch(struct klp_patch *patch)mutex_lock (&klp_mutex); +if (!klp_is_patch_compatible (patch)) { +pr_err ("Livepatch patch (%s) is not compatible with the already installed livepatches.\n" , + patch->mod->name); +mutex_unlock (&klp_mutex); +return -EINVAL ; + } + ret =klp_init_patch_early (patch);if (ret) {mutex_unlock (&klp_mutex);
kernel/livepatch/state.c +36 -0
@@ -9,6 +9,7 @@#include <linux/livepatch.h> #include "core.h" +#include "state.h" #include "transition.h" #define klp_for_each_state (patch, state) \
@@ -81,3 +82,38 @@ struct klp_state *klp_get_prev_state(unsigned long id)return last_state; }EXPORT_SYMBOL_GPL (klp_get_prev_state); + +/* Check if the patch is able to deal with the existing system state. */ +static bool klp_is_state_compatible (struct klp_patch *patch, +struct klp_state *old_state) +{ +struct klp_state *state; + + state =klp_get_state (patch, old_state->id); + +/* A cumulative livepatch must handle all already modified states. */ +if (!state) +return !patch->replace; + +return state->version >= old_state->version; +} + +/* +* Check that the new livepatch will not break the existing system states. +* Cumulative patches must handle all already modified states. +* Non-cumulative patches can touch already modified states. +*/ +bool klp_is_patch_compatible (struct klp_patch *patch) +{ +struct klp_patch *old_patch; +struct klp_state *old_state; + +klp_for_each_patch (old_patch) { +klp_for_each_state (old_patch, old_state) { +if (!klp_is_state_compatible (patch, old_state)) +return false; + } + } + +return true; +}
kernel/livepatch/state.h new file +9 -0
@@ -0,0 +1,9 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _LIVEPATCH_STATE_H +#define _LIVEPATCH_STATE_H + +#include <linux/livepatch.h> + +bool klp_is_patch_compatible (struct klp_patch *patch); + +#endif /* _LIVEPATCH_STATE_H */
Signature · 1 line
2.16.4
Petr Mladek
maintainerPATCH v4 4/5 livepatch: Documentation of the new API for tracking system state changes
In reply to Petr MladekDocumentation explaining the motivation, capabilities, and usage of the new API for tracking system state changes.
--- Documentation/livepatch/index.rst | 1 + Documentation/livepatch/system-state.rst | 167 +++++++++++++++++++++++++++++++ 2 files changed, 168 insertions(+) create mode 100644 Documentation/livepatch/system-state.rst
Documentation/livepatch/index.rst +1 -0
@@ -12,6 +12,7 @@ Kernel Livepatching cumulative-patches module-elf-format shadow-vars + system-state .. only:: subproject and html
Documentation/livepatch/system-state.rst new file +167 -0
167 lines not on this page · raw message
Signature · 1 line
2.16.4
Petr Mladek
maintainerPATCH v4 5/5 livepatch: Selftests of the API for tracking system state changes
In reply to Petr MladekFour selftests for the new API.
--- lib/livepatch/Makefile | 5 +- lib/livepatch/test_klp_state.c | 162 ++++++++++++++++++++ lib/livepatch/test_klp_state2.c | 191 ++++++++++++++++++++++++ lib/livepatch/test_klp_state3.c | 5 + tools/testing/selftests/livepatch/Makefile | 3 +- tools/testing/selftests/livepatch/test-state.sh | 180 ++++++++++++++++++++++ 6 files changed, 544 insertions(+), 2 deletions(-) create mode 100644 lib/livepatch/test_klp_state.c create mode 100644 lib/livepatch/test_klp_state2.c create mode 100644 lib/livepatch/test_klp_state3.c create mode 100755 tools/testing/selftests/livepatch/test-state.sh
lib/livepatch/Makefile +4 -1
@@ -8,7 +8,10 @@ obj-$(CONFIG_TEST_LIVEPATCH) += test_klp_atomic_replace.o \ test_klp_callbacks_busy.o \ test_klp_callbacks_mod.o \ test_klp_livepatch.o \ - test_klp_shadow_vars.o + test_klp_shadow_vars.o \ + test_klp_state.o \ + test_klp_state2.o \ + test_klp_state3.o # Target modules to be livepatched require CC_FLAGS_FTRACE CFLAGS_test_klp_callbacks_busy.o += $(CC_FLAGS_FTRACE)
lib/livepatch/test_klp_state.c new file +162 -0
162 lines not on this page · raw message
lib/livepatch/test_klp_state2.c new file +191 -0
191 lines not on this page · raw message
lib/livepatch/test_klp_state3.c new file +5 -0
@@ -0,0 +1,5 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (C) 2019 SUSE + +/* The console loglevel fix is the same in the next cumulative patch. */ +#include "test_klp_state2.c"
tools/testing/selftests/livepatch/Makefile +2 -1
@@ -4,6 +4,7 @@ TEST_PROGS_EXTENDED := functions.sh TEST_PROGS := \ test-livepatch.sh \ test-callbacks.sh \ - test-shadow-vars.sh + test-shadow-vars.sh \ + test-state.sh include ../lib.mk
tools/testing/selftests/livepatch/test-state.sh new file +180 -0
180 lines not on this page · raw message
Signature · 1 line
2.16.4
Quoted 15 lines · Petr Mladek
Hi,
this is another piece in the puzzle that helps to maintain more livepatches.
Especially pre/post (un)patch callbacks might change a system state. Any newly installed livepatch has to somehow deal with system state modifications done be already installed livepatches.
This patchset provides a simple and generic API that helps to keep and pass information between the livepatches. It is also usable to prevent loading incompatible livepatches.
Changes since v3:
Quoted 7 lines
+ selftests compilation error [kbuild test robot]
+ fix copyright in selftests [Joe]
+ used macros for the module names in selftests [Joe]
+ allow zero state version [Josh]
+ slightly refactor the code for checking state version [Josh]
+ fix few typos reported by checkpatch.pl [Petr]
+ added Acks [Joe]
Signature · 1 line
Josh
Petr Mladek
maintainerQuoted 24 lines · Josh Poimboeuf
Quoted 15 lines · Petr Mladek
Hi,
this is another piece in the puzzle that helps to maintain more livepatches.
Especially pre/post (un)patch callbacks might change a system state. Any newly installed livepatch has to somehow deal with system state modifications done be already installed livepatches.
This patchset provides a simple and generic API that helps to keep and pass information between the livepatches. It is also usable to prevent loading incompatible livepatches.
Changes since v3:
Quoted 7 lines
+ selftests compilation error [kbuild test robot]
+ fix copyright in selftests [Joe]
+ used macros for the module names in selftests [Joe]
+ allow zero state version [Josh]
+ slightly refactor the code for checking state version [Josh]
+ fix few typos reported by checkpatch.pl [Petr]
+ added Acks [Joe]
Quoted 1 line
Acked-by Josh Poimboeuf <[email protected]>
The patchset has been commited into livepatch.git, branch for-5.5/system-state.
Best Regards,
Petr