mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-06 02:24:14 +08:00
d0807da78e
Immediate flag has been used to disable per-task consistency and patch all tasks immediately. It could be useful if the patch doesn't change any function or data semantics. However, it causes problems on its own. The consistency problem is currently broken with respect to immediate patches. func a patches 1i 2i 3 When the patch 3 is applied, only 2i function is checked (by stack checking facility). There might be a task sleeping in 1i though. Such task is migrated to 3, because we do not check 1i in klp_check_stack_func() at all. Coming atomic replace feature would be easier to implement and more reliable without immediate. Thus, remove immediate feature completely and save us from the problems. Note that force feature has the similar problem. However it is considered as a last resort. If used, administrator should not apply any new live patches and should plan for reboot into an updated kernel. The architectures would now need to provide HAVE_RELIABLE_STACKTRACE to fully support livepatch. Signed-off-by: Miroslav Benes <mbenes@suse.cz> Acked-by: Josh Poimboeuf <jpoimboe@redhat.com> Signed-off-by: Jiri Kosina <jkosina@suse.cz>
159 lines
3.7 KiB
C
159 lines
3.7 KiB
C
/*
|
|
* Copyright (C) 2017 Joe Lawrence <joe.lawrence@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 <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/*
|
|
* livepatch-shadow-fix1.c - Shadow variables, livepatch demo
|
|
*
|
|
* Purpose
|
|
* -------
|
|
*
|
|
* Fixes the memory leak introduced in livepatch-shadow-mod through the
|
|
* use of a shadow variable. This fix demonstrates the "extending" of
|
|
* short-lived data structures by patching its allocation and release
|
|
* functions.
|
|
*
|
|
*
|
|
* Usage
|
|
* -----
|
|
*
|
|
* This module is not intended to be standalone. See the "Usage"
|
|
* section of livepatch-shadow-mod.c.
|
|
*/
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/livepatch.h>
|
|
#include <linux/slab.h>
|
|
|
|
/* Shadow variable enums */
|
|
#define SV_LEAK 1
|
|
|
|
/* Allocate new dummies every second */
|
|
#define ALLOC_PERIOD 1
|
|
/* Check for expired dummies after a few new ones have been allocated */
|
|
#define CLEANUP_PERIOD (3 * ALLOC_PERIOD)
|
|
/* Dummies expire after a few cleanup instances */
|
|
#define EXPIRE_PERIOD (4 * CLEANUP_PERIOD)
|
|
|
|
struct dummy {
|
|
struct list_head list;
|
|
unsigned long jiffies_expire;
|
|
};
|
|
|
|
struct dummy *livepatch_fix1_dummy_alloc(void)
|
|
{
|
|
struct dummy *d;
|
|
void *leak;
|
|
|
|
d = kzalloc(sizeof(*d), GFP_KERNEL);
|
|
if (!d)
|
|
return NULL;
|
|
|
|
d->jiffies_expire = jiffies +
|
|
msecs_to_jiffies(1000 * EXPIRE_PERIOD);
|
|
|
|
/*
|
|
* Patch: save the extra memory location into a SV_LEAK shadow
|
|
* variable. A patched dummy_free routine can later fetch this
|
|
* pointer to handle resource release.
|
|
*/
|
|
leak = kzalloc(sizeof(int), GFP_KERNEL);
|
|
klp_shadow_alloc(d, SV_LEAK, &leak, sizeof(leak), GFP_KERNEL);
|
|
|
|
pr_info("%s: dummy @ %p, expires @ %lx\n",
|
|
__func__, d, d->jiffies_expire);
|
|
|
|
return d;
|
|
}
|
|
|
|
void livepatch_fix1_dummy_free(struct dummy *d)
|
|
{
|
|
void **shadow_leak, *leak;
|
|
|
|
/*
|
|
* Patch: fetch the saved SV_LEAK shadow variable, detach and
|
|
* free it. Note: handle cases where this shadow variable does
|
|
* not exist (ie, dummy structures allocated before this livepatch
|
|
* was loaded.)
|
|
*/
|
|
shadow_leak = klp_shadow_get(d, SV_LEAK);
|
|
if (shadow_leak) {
|
|
leak = *shadow_leak;
|
|
klp_shadow_free(d, SV_LEAK);
|
|
kfree(leak);
|
|
pr_info("%s: dummy @ %p, prevented leak @ %p\n",
|
|
__func__, d, leak);
|
|
} else {
|
|
pr_info("%s: dummy @ %p leaked!\n", __func__, d);
|
|
}
|
|
|
|
kfree(d);
|
|
}
|
|
|
|
static struct klp_func funcs[] = {
|
|
{
|
|
.old_name = "dummy_alloc",
|
|
.new_func = livepatch_fix1_dummy_alloc,
|
|
},
|
|
{
|
|
.old_name = "dummy_free",
|
|
.new_func = livepatch_fix1_dummy_free,
|
|
}, { }
|
|
};
|
|
|
|
static struct klp_object objs[] = {
|
|
{
|
|
.name = "livepatch_shadow_mod",
|
|
.funcs = funcs,
|
|
}, { }
|
|
};
|
|
|
|
static struct klp_patch patch = {
|
|
.mod = THIS_MODULE,
|
|
.objs = objs,
|
|
};
|
|
|
|
static int livepatch_shadow_fix1_init(void)
|
|
{
|
|
int ret;
|
|
|
|
ret = klp_register_patch(&patch);
|
|
if (ret)
|
|
return ret;
|
|
ret = klp_enable_patch(&patch);
|
|
if (ret) {
|
|
WARN_ON(klp_unregister_patch(&patch));
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void livepatch_shadow_fix1_exit(void)
|
|
{
|
|
/* Cleanup any existing SV_LEAK shadow variables */
|
|
klp_shadow_free_all(SV_LEAK);
|
|
|
|
WARN_ON(klp_unregister_patch(&patch));
|
|
}
|
|
|
|
module_init(livepatch_shadow_fix1_init);
|
|
module_exit(livepatch_shadow_fix1_exit);
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_INFO(livepatch, "Y");
|