2 * core.c - Kernel Live Patching Core
4 * Copyright (C) 2014 Seth Jennings <sjenning@redhat.com>
5 * Copyright (C) 2014 SUSE
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, see <http://www.gnu.org/licenses/>.
21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
23 #include <linux/module.h>
24 #include <linux/kernel.h>
25 #include <linux/mutex.h>
26 #include <linux/slab.h>
27 #include <linux/ftrace.h>
28 #include <linux/list.h>
29 #include <linux/kallsyms.h>
30 #include <linux/livepatch.h>
31 #include <linux/elf.h>
32 #include <linux/moduleloader.h>
33 #include <asm/cacheflush.h>
36 * struct klp_ops - structure for tracking registered ftrace ops structs
38 * A single ftrace_ops is shared between all enabled replacement functions
39 * (klp_func structs) which have the same old_addr. This allows the switch
40 * between function versions to happen instantaneously by updating the klp_ops
41 * struct's func_stack list. The winner is the klp_func at the top of the
42 * func_stack (front of the list).
44 * @node: node for the global klp_ops list
45 * @func_stack: list head for the stack of klp_func's (active func is on top)
46 * @fops: registered ftrace ops struct
49 struct list_head node
;
50 struct list_head func_stack
;
51 struct ftrace_ops fops
;
55 * The klp_mutex protects the global lists and state transitions of any
56 * structure reachable from them. References to any structure must be obtained
57 * under mutex protection (except in klp_ftrace_handler(), which uses RCU to
58 * ensure it gets consistent data).
60 static DEFINE_MUTEX(klp_mutex
);
62 static LIST_HEAD(klp_patches
);
63 static LIST_HEAD(klp_ops
);
65 static struct kobject
*klp_root_kobj
;
67 static struct klp_ops
*klp_find_ops(unsigned long old_addr
)
70 struct klp_func
*func
;
72 list_for_each_entry(ops
, &klp_ops
, node
) {
73 func
= list_first_entry(&ops
->func_stack
, struct klp_func
,
75 if (func
->old_addr
== old_addr
)
82 static bool klp_is_module(struct klp_object
*obj
)
87 static bool klp_is_object_loaded(struct klp_object
*obj
)
89 return !obj
->name
|| obj
->mod
;
92 /* sets obj->mod if object is not vmlinux and module is found */
93 static void klp_find_object_module(struct klp_object
*obj
)
97 if (!klp_is_module(obj
))
100 mutex_lock(&module_mutex
);
102 * We do not want to block removal of patched modules and therefore
103 * we do not take a reference here. The patches are removed by
104 * klp_module_going() instead.
106 mod
= find_module(obj
->name
);
108 * Do not mess work of klp_module_coming() and klp_module_going().
109 * Note that the patch might still be needed before klp_module_going()
110 * is called. Module functions can be called even in the GOING state
111 * until mod->exit() finishes. This is especially important for
112 * patches that modify semantic of the functions.
114 if (mod
&& mod
->klp_alive
)
117 mutex_unlock(&module_mutex
);
120 /* klp_mutex must be held by caller */
121 static bool klp_is_patch_registered(struct klp_patch
*patch
)
123 struct klp_patch
*mypatch
;
125 list_for_each_entry(mypatch
, &klp_patches
, list
)
126 if (mypatch
== patch
)
132 static bool klp_initialized(void)
134 return !!klp_root_kobj
;
137 struct klp_find_arg
{
145 static int klp_find_callback(void *data
, const char *name
,
146 struct module
*mod
, unsigned long addr
)
148 struct klp_find_arg
*args
= data
;
150 if ((mod
&& !args
->objname
) || (!mod
&& args
->objname
))
153 if (strcmp(args
->name
, name
))
156 if (args
->objname
&& strcmp(args
->objname
, mod
->name
))
163 * Finish the search when the symbol is found for the desired position
164 * or the position is not defined for a non-unique symbol.
166 if ((args
->pos
&& (args
->count
== args
->pos
)) ||
167 (!args
->pos
&& (args
->count
> 1)))
173 static int klp_find_object_symbol(const char *objname
, const char *name
,
174 unsigned long sympos
, unsigned long *addr
)
176 struct klp_find_arg args
= {
184 mutex_lock(&module_mutex
);
185 kallsyms_on_each_symbol(klp_find_callback
, &args
);
186 mutex_unlock(&module_mutex
);
189 * Ensure an address was found. If sympos is 0, ensure symbol is unique;
190 * otherwise ensure the symbol position count matches sympos.
193 pr_err("symbol '%s' not found in symbol table\n", name
);
194 else if (args
.count
> 1 && sympos
== 0) {
195 pr_err("unresolvable ambiguity for symbol '%s' in object '%s'\n",
197 } else if (sympos
!= args
.count
&& sympos
> 0) {
198 pr_err("symbol position %lu for symbol '%s' in object '%s' not found\n",
199 sympos
, name
, objname
? objname
: "vmlinux");
209 static int klp_resolve_symbols(Elf_Shdr
*relasec
, struct module
*pmod
)
211 int i
, cnt
, vmlinux
, ret
;
212 char objname
[MODULE_NAME_LEN
];
213 char symname
[KSYM_NAME_LEN
];
214 char *strtab
= pmod
->core_kallsyms
.strtab
;
217 unsigned long sympos
, addr
;
220 * Since the field widths for objname and symname in the sscanf()
221 * call are hard-coded and correspond to MODULE_NAME_LEN and
222 * KSYM_NAME_LEN respectively, we must make sure that MODULE_NAME_LEN
223 * and KSYM_NAME_LEN have the values we expect them to have.
225 * Because the value of MODULE_NAME_LEN can differ among architectures,
226 * we use the smallest/strictest upper bound possible (56, based on
227 * the current definition of MODULE_NAME_LEN) to prevent overflows.
229 BUILD_BUG_ON(MODULE_NAME_LEN
< 56 || KSYM_NAME_LEN
!= 128);
231 relas
= (Elf_Rela
*) relasec
->sh_addr
;
232 /* For each rela in this klp relocation section */
233 for (i
= 0; i
< relasec
->sh_size
/ sizeof(Elf_Rela
); i
++) {
234 sym
= pmod
->core_kallsyms
.symtab
+ ELF_R_SYM(relas
[i
].r_info
);
235 if (sym
->st_shndx
!= SHN_LIVEPATCH
) {
236 pr_err("symbol %s is not marked as a livepatch symbol",
237 strtab
+ sym
->st_name
);
241 /* Format: .klp.sym.objname.symname,sympos */
242 cnt
= sscanf(strtab
+ sym
->st_name
,
243 ".klp.sym.%55[^.].%127[^,],%lu",
244 objname
, symname
, &sympos
);
246 pr_err("symbol %s has an incorrectly formatted name",
247 strtab
+ sym
->st_name
);
251 /* klp_find_object_symbol() treats a NULL objname as vmlinux */
252 vmlinux
= !strcmp(objname
, "vmlinux");
253 ret
= klp_find_object_symbol(vmlinux
? NULL
: objname
,
254 symname
, sympos
, &addr
);
258 sym
->st_value
= addr
;
264 static int klp_write_object_relocations(struct module
*pmod
,
265 struct klp_object
*obj
)
268 const char *objname
, *secname
;
269 char sec_objname
[MODULE_NAME_LEN
];
272 if (WARN_ON(!klp_is_object_loaded(obj
)))
275 objname
= klp_is_module(obj
) ? obj
->name
: "vmlinux";
277 module_disable_ro(pmod
);
278 /* For each klp relocation section */
279 for (i
= 1; i
< pmod
->klp_info
->hdr
.e_shnum
; i
++) {
280 sec
= pmod
->klp_info
->sechdrs
+ i
;
281 secname
= pmod
->klp_info
->secstrings
+ sec
->sh_name
;
282 if (!(sec
->sh_flags
& SHF_RELA_LIVEPATCH
))
286 * Format: .klp.rela.sec_objname.section_name
287 * See comment in klp_resolve_symbols() for an explanation
288 * of the selected field width value.
290 cnt
= sscanf(secname
, ".klp.rela.%55[^.]", sec_objname
);
292 pr_err("section %s has an incorrectly formatted name",
298 if (strcmp(objname
, sec_objname
))
301 ret
= klp_resolve_symbols(sec
, pmod
);
305 ret
= apply_relocate_add(pmod
->klp_info
->sechdrs
,
306 pmod
->core_kallsyms
.strtab
,
307 pmod
->klp_info
->symndx
, i
, pmod
);
312 module_enable_ro(pmod
);
316 static void notrace
klp_ftrace_handler(unsigned long ip
,
317 unsigned long parent_ip
,
318 struct ftrace_ops
*fops
,
319 struct pt_regs
*regs
)
322 struct klp_func
*func
;
324 ops
= container_of(fops
, struct klp_ops
, fops
);
327 func
= list_first_or_null_rcu(&ops
->func_stack
, struct klp_func
,
329 if (WARN_ON_ONCE(!func
))
332 klp_arch_set_pc(regs
, (unsigned long)func
->new_func
);
337 static void klp_disable_func(struct klp_func
*func
)
341 if (WARN_ON(func
->state
!= KLP_ENABLED
))
343 if (WARN_ON(!func
->old_addr
))
346 ops
= klp_find_ops(func
->old_addr
);
350 if (list_is_singular(&ops
->func_stack
)) {
351 WARN_ON(unregister_ftrace_function(&ops
->fops
));
352 WARN_ON(ftrace_set_filter_ip(&ops
->fops
, func
->old_addr
, 1, 0));
354 list_del_rcu(&func
->stack_node
);
355 list_del(&ops
->node
);
358 list_del_rcu(&func
->stack_node
);
361 func
->state
= KLP_DISABLED
;
364 static int klp_enable_func(struct klp_func
*func
)
369 if (WARN_ON(!func
->old_addr
))
372 if (WARN_ON(func
->state
!= KLP_DISABLED
))
375 ops
= klp_find_ops(func
->old_addr
);
377 ops
= kzalloc(sizeof(*ops
), GFP_KERNEL
);
381 ops
->fops
.func
= klp_ftrace_handler
;
382 ops
->fops
.flags
= FTRACE_OPS_FL_SAVE_REGS
|
383 FTRACE_OPS_FL_DYNAMIC
|
384 FTRACE_OPS_FL_IPMODIFY
;
386 list_add(&ops
->node
, &klp_ops
);
388 INIT_LIST_HEAD(&ops
->func_stack
);
389 list_add_rcu(&func
->stack_node
, &ops
->func_stack
);
391 ret
= ftrace_set_filter_ip(&ops
->fops
, func
->old_addr
, 0, 0);
393 pr_err("failed to set ftrace filter for function '%s' (%d)\n",
394 func
->old_name
, ret
);
398 ret
= register_ftrace_function(&ops
->fops
);
400 pr_err("failed to register ftrace handler for function '%s' (%d)\n",
401 func
->old_name
, ret
);
402 ftrace_set_filter_ip(&ops
->fops
, func
->old_addr
, 1, 0);
408 list_add_rcu(&func
->stack_node
, &ops
->func_stack
);
411 func
->state
= KLP_ENABLED
;
416 list_del_rcu(&func
->stack_node
);
417 list_del(&ops
->node
);
422 static void klp_disable_object(struct klp_object
*obj
)
424 struct klp_func
*func
;
426 klp_for_each_func(obj
, func
)
427 if (func
->state
== KLP_ENABLED
)
428 klp_disable_func(func
);
430 obj
->state
= KLP_DISABLED
;
433 static int klp_enable_object(struct klp_object
*obj
)
435 struct klp_func
*func
;
438 if (WARN_ON(obj
->state
!= KLP_DISABLED
))
441 if (WARN_ON(!klp_is_object_loaded(obj
)))
444 klp_for_each_func(obj
, func
) {
445 ret
= klp_enable_func(func
);
447 klp_disable_object(obj
);
451 obj
->state
= KLP_ENABLED
;
456 static int __klp_disable_patch(struct klp_patch
*patch
)
458 struct klp_object
*obj
;
460 /* enforce stacking: only the last enabled patch can be disabled */
461 if (!list_is_last(&patch
->list
, &klp_patches
) &&
462 list_next_entry(patch
, list
)->state
== KLP_ENABLED
)
465 pr_notice("disabling patch '%s'\n", patch
->mod
->name
);
467 klp_for_each_object(patch
, obj
) {
468 if (obj
->state
== KLP_ENABLED
)
469 klp_disable_object(obj
);
472 patch
->state
= KLP_DISABLED
;
478 * klp_disable_patch() - disables a registered patch
479 * @patch: The registered, enabled patch to be disabled
481 * Unregisters the patched functions from ftrace.
483 * Return: 0 on success, otherwise error
485 int klp_disable_patch(struct klp_patch
*patch
)
489 mutex_lock(&klp_mutex
);
491 if (!klp_is_patch_registered(patch
)) {
496 if (patch
->state
== KLP_DISABLED
) {
501 ret
= __klp_disable_patch(patch
);
504 mutex_unlock(&klp_mutex
);
507 EXPORT_SYMBOL_GPL(klp_disable_patch
);
509 static int __klp_enable_patch(struct klp_patch
*patch
)
511 struct klp_object
*obj
;
514 if (WARN_ON(patch
->state
!= KLP_DISABLED
))
517 /* enforce stacking: only the first disabled patch can be enabled */
518 if (patch
->list
.prev
!= &klp_patches
&&
519 list_prev_entry(patch
, list
)->state
== KLP_DISABLED
)
522 pr_notice_once("tainting kernel with TAINT_LIVEPATCH\n");
523 add_taint(TAINT_LIVEPATCH
, LOCKDEP_STILL_OK
);
525 pr_notice("enabling patch '%s'\n", patch
->mod
->name
);
527 klp_for_each_object(patch
, obj
) {
528 if (!klp_is_object_loaded(obj
))
531 ret
= klp_enable_object(obj
);
536 patch
->state
= KLP_ENABLED
;
541 WARN_ON(__klp_disable_patch(patch
));
546 * klp_enable_patch() - enables a registered patch
547 * @patch: The registered, disabled patch to be enabled
549 * Performs the needed symbol lookups and code relocations,
550 * then registers the patched functions with ftrace.
552 * Return: 0 on success, otherwise error
554 int klp_enable_patch(struct klp_patch
*patch
)
558 mutex_lock(&klp_mutex
);
560 if (!klp_is_patch_registered(patch
)) {
565 ret
= __klp_enable_patch(patch
);
568 mutex_unlock(&klp_mutex
);
571 EXPORT_SYMBOL_GPL(klp_enable_patch
);
576 * /sys/kernel/livepatch
577 * /sys/kernel/livepatch/<patch>
578 * /sys/kernel/livepatch/<patch>/enabled
579 * /sys/kernel/livepatch/<patch>/<object>
580 * /sys/kernel/livepatch/<patch>/<object>/<function,sympos>
583 static ssize_t
enabled_store(struct kobject
*kobj
, struct kobj_attribute
*attr
,
584 const char *buf
, size_t count
)
586 struct klp_patch
*patch
;
590 ret
= kstrtoul(buf
, 10, &val
);
594 if (val
!= KLP_DISABLED
&& val
!= KLP_ENABLED
)
597 patch
= container_of(kobj
, struct klp_patch
, kobj
);
599 mutex_lock(&klp_mutex
);
601 if (val
== patch
->state
) {
602 /* already in requested state */
607 if (val
== KLP_ENABLED
) {
608 ret
= __klp_enable_patch(patch
);
612 ret
= __klp_disable_patch(patch
);
617 mutex_unlock(&klp_mutex
);
622 mutex_unlock(&klp_mutex
);
626 static ssize_t
enabled_show(struct kobject
*kobj
,
627 struct kobj_attribute
*attr
, char *buf
)
629 struct klp_patch
*patch
;
631 patch
= container_of(kobj
, struct klp_patch
, kobj
);
632 return snprintf(buf
, PAGE_SIZE
-1, "%d\n", patch
->state
);
635 static struct kobj_attribute enabled_kobj_attr
= __ATTR_RW(enabled
);
636 static struct attribute
*klp_patch_attrs
[] = {
637 &enabled_kobj_attr
.attr
,
641 static void klp_kobj_release_patch(struct kobject
*kobj
)
644 * Once we have a consistency model we'll need to module_put() the
645 * patch module here. See klp_register_patch() for more details.
649 static struct kobj_type klp_ktype_patch
= {
650 .release
= klp_kobj_release_patch
,
651 .sysfs_ops
= &kobj_sysfs_ops
,
652 .default_attrs
= klp_patch_attrs
,
655 static void klp_kobj_release_object(struct kobject
*kobj
)
659 static struct kobj_type klp_ktype_object
= {
660 .release
= klp_kobj_release_object
,
661 .sysfs_ops
= &kobj_sysfs_ops
,
664 static void klp_kobj_release_func(struct kobject
*kobj
)
668 static struct kobj_type klp_ktype_func
= {
669 .release
= klp_kobj_release_func
,
670 .sysfs_ops
= &kobj_sysfs_ops
,
674 * Free all functions' kobjects in the array up to some limit. When limit is
675 * NULL, all kobjects are freed.
677 static void klp_free_funcs_limited(struct klp_object
*obj
,
678 struct klp_func
*limit
)
680 struct klp_func
*func
;
682 for (func
= obj
->funcs
; func
->old_name
&& func
!= limit
; func
++)
683 kobject_put(&func
->kobj
);
686 /* Clean up when a patched object is unloaded */
687 static void klp_free_object_loaded(struct klp_object
*obj
)
689 struct klp_func
*func
;
693 klp_for_each_func(obj
, func
)
698 * Free all objects' kobjects in the array up to some limit. When limit is
699 * NULL, all kobjects are freed.
701 static void klp_free_objects_limited(struct klp_patch
*patch
,
702 struct klp_object
*limit
)
704 struct klp_object
*obj
;
706 for (obj
= patch
->objs
; obj
->funcs
&& obj
!= limit
; obj
++) {
707 klp_free_funcs_limited(obj
, NULL
);
708 kobject_put(&obj
->kobj
);
712 static void klp_free_patch(struct klp_patch
*patch
)
714 klp_free_objects_limited(patch
, NULL
);
715 if (!list_empty(&patch
->list
))
716 list_del(&patch
->list
);
717 kobject_put(&patch
->kobj
);
720 static int klp_init_func(struct klp_object
*obj
, struct klp_func
*func
)
722 INIT_LIST_HEAD(&func
->stack_node
);
723 func
->state
= KLP_DISABLED
;
725 /* The format for the sysfs directory is <function,sympos> where sympos
726 * is the nth occurrence of this symbol in kallsyms for the patched
727 * object. If the user selects 0 for old_sympos, then 1 will be used
728 * since a unique symbol will be the first occurrence.
730 return kobject_init_and_add(&func
->kobj
, &klp_ktype_func
,
731 &obj
->kobj
, "%s,%lu", func
->old_name
,
732 func
->old_sympos
? func
->old_sympos
: 1);
735 /* parts of the initialization that is done only when the object is loaded */
736 static int klp_init_object_loaded(struct klp_patch
*patch
,
737 struct klp_object
*obj
)
739 struct klp_func
*func
;
742 ret
= klp_write_object_relocations(patch
->mod
, obj
);
746 klp_for_each_func(obj
, func
) {
747 ret
= klp_find_object_symbol(obj
->name
, func
->old_name
,
757 static int klp_init_object(struct klp_patch
*patch
, struct klp_object
*obj
)
759 struct klp_func
*func
;
766 obj
->state
= KLP_DISABLED
;
769 klp_find_object_module(obj
);
771 name
= klp_is_module(obj
) ? obj
->name
: "vmlinux";
772 ret
= kobject_init_and_add(&obj
->kobj
, &klp_ktype_object
,
773 &patch
->kobj
, "%s", name
);
777 klp_for_each_func(obj
, func
) {
778 ret
= klp_init_func(obj
, func
);
783 if (klp_is_object_loaded(obj
)) {
784 ret
= klp_init_object_loaded(patch
, obj
);
792 klp_free_funcs_limited(obj
, func
);
793 kobject_put(&obj
->kobj
);
797 static int klp_init_patch(struct klp_patch
*patch
)
799 struct klp_object
*obj
;
805 mutex_lock(&klp_mutex
);
807 patch
->state
= KLP_DISABLED
;
809 ret
= kobject_init_and_add(&patch
->kobj
, &klp_ktype_patch
,
810 klp_root_kobj
, "%s", patch
->mod
->name
);
814 klp_for_each_object(patch
, obj
) {
815 ret
= klp_init_object(patch
, obj
);
820 list_add_tail(&patch
->list
, &klp_patches
);
822 mutex_unlock(&klp_mutex
);
827 klp_free_objects_limited(patch
, obj
);
828 kobject_put(&patch
->kobj
);
830 mutex_unlock(&klp_mutex
);
835 * klp_unregister_patch() - unregisters a patch
836 * @patch: Disabled patch to be unregistered
838 * Frees the data structures and removes the sysfs interface.
840 * Return: 0 on success, otherwise error
842 int klp_unregister_patch(struct klp_patch
*patch
)
846 mutex_lock(&klp_mutex
);
848 if (!klp_is_patch_registered(patch
)) {
853 if (patch
->state
== KLP_ENABLED
) {
858 klp_free_patch(patch
);
861 mutex_unlock(&klp_mutex
);
864 EXPORT_SYMBOL_GPL(klp_unregister_patch
);
867 * klp_register_patch() - registers a patch
868 * @patch: Patch to be registered
870 * Initializes the data structure associated with the patch and
871 * creates the sysfs interface.
873 * Return: 0 on success, otherwise error
875 int klp_register_patch(struct klp_patch
*patch
)
879 if (!is_livepatch_module(patch
->mod
)) {
880 pr_err("module %s is not marked as a livepatch module",
885 if (!klp_initialized())
888 if (!patch
|| !patch
->mod
)
892 * A reference is taken on the patch module to prevent it from being
893 * unloaded. Right now, we don't allow patch modules to unload since
894 * there is currently no method to determine if a thread is still
895 * running in the patched code contained in the patch module once
896 * the ftrace registration is successful.
898 if (!try_module_get(patch
->mod
))
901 ret
= klp_init_patch(patch
);
903 module_put(patch
->mod
);
907 EXPORT_SYMBOL_GPL(klp_register_patch
);
909 int klp_module_coming(struct module
*mod
)
912 struct klp_patch
*patch
;
913 struct klp_object
*obj
;
915 if (WARN_ON(mod
->state
!= MODULE_STATE_COMING
))
918 mutex_lock(&klp_mutex
);
920 * Each module has to know that klp_module_coming()
921 * has been called. We never know what module will
922 * get patched by a new patch.
924 mod
->klp_alive
= true;
926 list_for_each_entry(patch
, &klp_patches
, list
) {
927 klp_for_each_object(patch
, obj
) {
928 if (!klp_is_module(obj
) || strcmp(obj
->name
, mod
->name
))
933 ret
= klp_init_object_loaded(patch
, obj
);
935 pr_warn("failed to initialize patch '%s' for module '%s' (%d)\n",
936 patch
->mod
->name
, obj
->mod
->name
, ret
);
940 if (patch
->state
== KLP_DISABLED
)
943 pr_notice("applying patch '%s' to loading module '%s'\n",
944 patch
->mod
->name
, obj
->mod
->name
);
946 ret
= klp_enable_object(obj
);
948 pr_warn("failed to apply patch '%s' to module '%s' (%d)\n",
949 patch
->mod
->name
, obj
->mod
->name
, ret
);
957 mutex_unlock(&klp_mutex
);
963 * If a patch is unsuccessfully applied, return
964 * error to the module loader.
966 pr_warn("patch '%s' failed for module '%s', refusing to load module '%s'\n",
967 patch
->mod
->name
, obj
->mod
->name
, obj
->mod
->name
);
968 mod
->klp_alive
= false;
969 klp_free_object_loaded(obj
);
970 mutex_unlock(&klp_mutex
);
975 void klp_module_going(struct module
*mod
)
977 struct klp_patch
*patch
;
978 struct klp_object
*obj
;
980 if (WARN_ON(mod
->state
!= MODULE_STATE_GOING
&&
981 mod
->state
!= MODULE_STATE_COMING
))
984 mutex_lock(&klp_mutex
);
986 * Each module has to know that klp_module_going()
987 * has been called. We never know what module will
988 * get patched by a new patch.
990 mod
->klp_alive
= false;
992 list_for_each_entry(patch
, &klp_patches
, list
) {
993 klp_for_each_object(patch
, obj
) {
994 if (!klp_is_module(obj
) || strcmp(obj
->name
, mod
->name
))
997 if (patch
->state
!= KLP_DISABLED
) {
998 pr_notice("reverting patch '%s' on unloading module '%s'\n",
999 patch
->mod
->name
, obj
->mod
->name
);
1000 klp_disable_object(obj
);
1003 klp_free_object_loaded(obj
);
1008 mutex_unlock(&klp_mutex
);
1011 static int __init
klp_init(void)
1015 ret
= klp_check_compiler_support();
1017 pr_info("Your compiler is too old; turning off.\n");
1021 klp_root_kobj
= kobject_create_and_add("livepatch", kernel_kobj
);
1028 module_init(klp_init
);