livepatch: Additional fixes for callbacks feature
Petr Mladek
maintainercover livepatch: Additional fixes for callbacks feature
I have found few small problems when reviewing the patch adding (un)patch callback, see
https://lkml.kernel.org/r/[email protected]
Feel free to merge them with the original patch if still possible.
Petr Mladek (2):
livepatch: Correctly call klp_post_unpatch_callback() in error paths
livepatch: __klp_disable_patch() should never be called for disabled
patches
kernel/livepatch/core.c | 9 +++++---- kernel/livepatch/core.h | 8 +++++--- 2 files changed, 10 insertions(+), 7 deletions(-)
Signature · 1 line
1.8.5.6
Petr Mladek
maintainerPATCH 1/2 livepatch: Correctly call klp_post_unpatch_callback() in error paths
The flag post_unpatch_enabled in struct klp_callbacks is need in the error paths. We need to call the post_unpatch callback only when the pre_patch one was called.
We should clear the flag in klp_post_unpatch_callback() to make sure that the callback is not called twice. It makes the API more safe.
Note that we actually would call the callback twice in klp_module_coming() when klp_patch_object() fails. In this case, we explicitly call klp_post_unpatch_callback() for the failed object. And we are going to call it once again when reverting operations for all the patches by reusing the klp_module_going() code. There is a patch doing this in the queue.
There was another mistake in the error path in klp_comming_module(). It called klp_post_unpatch_callback() only when
patch != klp_transition_patch. But klp_pre_patch_callback() was called even for this patch.
In fact, we could remove klp_post_unpatch_callback() from the error path at all because it will be covered by the reuse of the klp_module_going() code. But I think that it is cleaner this way. For example, someone might later decide to call the callback only when obj->patched flag is set.
Finally, I used this opportunity to make klp_pre_patch_callback() more readable.
--- kernel/livepatch/core.c | 4 +--- kernel/livepatch/core.h | 8 +++++--- 2 files changed, 6 insertions(+), 6 deletions(-)
kernel/livepatch/core.c +1 -3
@@ -894,9 +894,7 @@ int klp_module_coming(struct module *mod)pr_warn ("failed to apply patch '%s' to module '%s' (%d)\n" , patch->mod->name, obj->mod->name, ret); -if (patch != klp_transition_patch) -klp_post_unpatch_callback (obj); - +klp_post_unpatch_callback (obj); goto err; }
kernel/livepatch/core.h +5 -3
@@ -12,10 +12,10 @@ static inline bool klp_is_object_loaded(struct klp_object *obj)static inline int klp_pre_patch_callback (struct klp_object *obj) { -int ret; +int ret =0 ; - ret = (obj->callbacks.pre_patch) ? - (*obj->callbacks.pre_patch)(obj) :0 ; +if (obj->callbacks.pre_patch) + ret = (*obj->callbacks.pre_patch)(obj); obj->callbacks.post_unpatch_enabled = !ret;
@@ -39,6 +39,8 @@ static inline void klp_post_unpatch_callback(struct klp_object *obj)if (obj->callbacks.post_unpatch_enabled && obj->callbacks.post_unpatch) (*obj->callbacks.post_unpatch)(obj); + + obj->callbacks.post_unpatch_enabled = false; }#endif /* _LIVEPATCH_CORE_H */
Signature · 1 line
1.8.5.6
Re: [PATCH 1/2] livepatch: Correctly call klp_post_unpatch_callback() in error paths
Quoted 1 line · Petr Mladek
Hi Petr,
Thank you for these fixups! I ran them through the tests in Documentation/livepatch/callbacks.txt just to be safe and it looks good. I wish I had added a few tests for klp_patch_object() failures, but I would have needed to somehow force those errors. At that point I'd have more of a regression test than a human readable document.
Anyway, if this set can be squashed into for-4.15/callbacks, then great. If not, then may I suggest a few rewordings/cleanups for this commit message:
Quoted 7 lines
The flag
post_unpatch_enabledin structklp_callbacksis need in the error paths. We need to call thepost_unpatchcallback only when thepre_patchone was called.We should clear the flag in
klp_post_unpatch_callback()to make sure that the callback is not called twice. It makes the API more safe.
The post_unpatch_enabled flag in struct klp_callbacks is set when a pre-patch callback successfully executes, indicating that we need to call a corresponding post-unpatch callback when the patch is reverted. This is true for ordinary patch disable as well as the error paths of klp_patch_object() callers.
Quoted 7 lines
Note that we actually would call the callback twice in
klp_module_coming()whenklp_patch_object()fails. In this case, we explicitly callklp_post_unpatch_callback()for the failed object. And we are going to call it once again when reverting operations for all the patches by reusing theklp_module_going()code. There is a patch doing this in the queue.
As currently coded, we inadvertently execute the post-patch callback twice in klp_module_coming() when klp_patch_object() fails:
- We explicitly call klp_post_unpatch_callback() for the failed object
- We call it again for the same object (and all the others) via klp_cleanup_module_patches_limited()
We should clear the flag in klp_post_unpatch_callback() to make sure that the callback is not called twice. It makes the API more safe.
(We could have removed the callback from the former error path as it would be covered by the latter call, but I think that is is cleaner to clear the post_unpatch_enabled after its invoked. For example, someone might later decide to call the callback only when obj->patched flag is set.)
Quoted 4 lines
There was another mistake in the error path in
klp_comming_module(). It calledklp_post_unpatch_callback()only when
patch !=klp_transition_patch. Butklp_pre_patch_callback()was called even for this patch.
There is another mistake in the error path of klp_coming_module() in which it skips the post-unpatch callback for the klp_transition_patch. However, the pre-patch callback was called even for this patch, so be sure to make the corresponding callbacks for all patches.
Quoted 6 lines
In fact, we could remove
klp_post_unpatch_callback()from the error path at all because it will be covered by the reuse of theklp_module_going()code. But I think that it is cleaner this way. For example, someone might later decide to call the callback only whenobj->patchedflag is set.
JL: (Moved up above.)
Quoted 3 lines
Finally, I used this opportunity to make
klp_pre_patch_callback()more readable.
JL: Agreed that this is clearer to read, thanks.
Quoted 2 lines
Signed-off-by Petr Mladek <[email protected]>
Quoted 54 lines
--- kernel/livepatch/core.c | 4 +--- kernel/livepatch/core.h | 8 +++++--- 2 files changed, 6 insertions(+), 6 deletions(-)kernel/livepatch/core.c +1
-3@@ -894,9 +894,7 @@ int klp_module_coming(struct module *mod)pr_warn ("failed to apply patch '%s' to module '%s' (%d)\n" , patch->mod->name, obj->mod->name, ret); -if (patch != klp_transition_patch) -klp_post_unpatch_callback (obj); - +klp_post_unpatch_callback (obj); goto err; }kernel/livepatch/core.h +5
-3@@ -12,10 +12,10 @@ static inline bool klp_is_object_loaded(struct klp_object *obj)static inline int klp_pre_patch_callback (struct klp_object *obj) { -int ret; +int ret =0 ; - ret = (obj->callbacks.pre_patch) ? - (*obj->callbacks.pre_patch)(obj) :0 ; +if (obj->callbacks.pre_patch) + ret = (*obj->callbacks.pre_patch)(obj); obj->callbacks.post_unpatch_enabled = !ret;@@ -39,6 +39,8 @@ static inline void klp_post_unpatch_callback(struct klp_object *obj)if (obj->callbacks.post_unpatch_enabled && obj->callbacks.post_unpatch) (*obj->callbacks.post_unpatch)(obj); + + obj->callbacks.post_unpatch_enabled = false; }#endif /* _LIVEPATCH_CORE_H */ Signature · 6 lines
1.8.5.6 -- To unsubscribe from this list: send the line "unsubscribe live-patching" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Petr Mladek
maintainerPATCH 2/2 livepatch: __klp_disable_patch() should never be called for disabled patches
In reply to Petr Mladek__klp_disable_patch() should never be called when the patch is not enabled. Let's add the same warning that we have in __klp_enable_patch().
This allows to remove the check when calling klp_pre_unpatch_callback(). It was strange anyway because it repeatedly checked per-patch flag for each patched object.
--- kernel/livepatch/core.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
kernel/livepatch/core.c +4 -1
@@ -282,6 +282,9 @@ static int __klp_disable_patch(struct klp_patch *patch) {struct klp_object *obj; +if (WARN_ON (!patch->enabled)) +return -EINVAL ; +if (klp_transition_patch)return -EBUSY ;
@@ -293,7 +296,7 @@ static int __klp_disable_patch(struct klp_patch *patch)klp_init_transition (patch,KLP_UNPATCHED );klp_for_each_object (patch, obj) -if (patch->enabled && obj->patched) +if (obj->patched)klp_pre_unpatch_callback (obj);/*
Signature · 1 line
1.8.5.6
Re: [PATCH 2/2] livepatch: __klp_disable_patch() should never be called for disabled patches
Quoted 37 lines · Petr Mladek
__klp_disable_patch()should never be called when the patch is not enabled. Let's add the same warning that we have in__klp_enable_patch().This allows to remove the check when calling
klp_pre_unpatch_callback(). It was strange anyway because it repeatedly checked per-patch flag for each patched object.Signed-off-by Petr Mladek <[email protected]>--- kernel/livepatch/core.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)kernel/livepatch/core.c +4
-1@@ -282,6 +282,9 @@ static int __klp_disable_patch(struct klp_patch *patch) {struct klp_object *obj; +if (WARN_ON (!patch->enabled)) +return -EINVAL ; +if (klp_transition_patch)return -EBUSY ;@@ -293,7 +296,7 @@ static int __klp_disable_patch(struct klp_patch *patch)klp_init_transition (patch,KLP_UNPATCHED );klp_for_each_object (patch, obj) -if (patch->enabled && obj->patched) +if (obj->patched)klp_pre_unpatch_callback (obj);/* Signature · 1 line
1.8.5.6
Looks reasonable to me and cleans up the klp_pre_unpatch_callback() calling condition.
Miroslav Benes
maintainerRe: [PATCH 2/2] livepatch: __klp_disable_patch() should never be called for disabled patches
In reply to Petr MladekQuoted 8 lines · Petr Mladek
__klp_disable_patch()should never be called when the patch is not enabled. Let's add the same warning that we have in__klp_enable_patch().This allows to remove the check when calling
klp_pre_unpatch_callback(). It was strange anyway because it repeatedly checked per-patch flag for each patched object.Signed-off-by Petr Mladek <[email protected]>
Heh, this is not a new thing. See
http://lkml.kernel.org/r/[email protected]
I don't know why it got lost. Those were crazy times...
Miroslav
Quoted 30 lines
--- kernel/livepatch/core.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)kernel/livepatch/core.c +4
-1@@ -282,6 +282,9 @@ static int __klp_disable_patch(struct klp_patch *patch) {struct klp_object *obj; +if (WARN_ON (!patch->enabled)) +return -EINVAL ; +if (klp_transition_patch)return -EBUSY ;@@ -293,7 +296,7 @@ static int __klp_disable_patch(struct klp_patch *patch)klp_init_transition (patch,KLP_UNPATCHED );klp_for_each_object (patch, obj) -if (patch->enabled && obj->patched) +if (obj->patched)klp_pre_unpatch_callback (obj);/* Signature · 1 line
1.8.5.6
Jiri Kosina
AppliedQuoted 5 lines · Petr Mladek
I have found few small problems when reviewing the patch adding (un)patch callback, see
https://lkml.kernel.org/r/[email protected]
Feel free to merge them with the original patch if still possible.
Quoted 8 lines
Petr Mladek (2):
livepatch: Correctly callklp_post_unpatch_callback()in error paths
livepatch:__klp_disable_patch()should never be called for disabled
patcheskernel/livepatch/core.c | 9 +++++---- kernel/livepatch/core.h | 8 +++++--- 2 files changed, 10 insertions(+), 7 deletions(-)
Applied to for-4.15/callbacks (with Joe's changelog comments incorporated). Thanks,
Signature · 2 lines
Jiri Kosina SUSE Labs