~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/livepatch/core.c

Version: ~ [ linux-4.14 ] ~ [ linux-4.13.12 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.61 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.97 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.46 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.80 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.50 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.95 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.27.62 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * core.c - Kernel Live Patching Core
  3  *
  4  * Copyright (C) 2014 Seth Jennings <sjenning@redhat.com>
  5  * Copyright (C) 2014 SUSE
  6  *
  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.
 11  *
 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.
 16  *
 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/>.
 19  */
 20 
 21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 22 
 23 #include <linux/module.h>
 24 #include <linux/kernel.h>
 25 #include <linux/mutex.h>
 26 #include <linux/slab.h>
 27 #include <linux/list.h>
 28 #include <linux/kallsyms.h>
 29 #include <linux/livepatch.h>
 30 #include <linux/elf.h>
 31 #include <linux/moduleloader.h>
 32 #include <linux/completion.h>
 33 #include <asm/cacheflush.h>
 34 #include "core.h"
 35 #include "patch.h"
 36 #include "transition.h"
 37 
 38 /*
 39  * klp_mutex is a coarse lock which serializes access to klp data.  All
 40  * accesses to klp-related variables and structures must have mutex protection,
 41  * except within the following functions which carefully avoid the need for it:
 42  *
 43  * - klp_ftrace_handler()
 44  * - klp_update_patch_state()
 45  */
 46 DEFINE_MUTEX(klp_mutex);
 47 
 48 static LIST_HEAD(klp_patches);
 49 
 50 static struct kobject *klp_root_kobj;
 51 
 52 static bool klp_is_module(struct klp_object *obj)
 53 {
 54         return obj->name;
 55 }
 56 
 57 static bool klp_is_object_loaded(struct klp_object *obj)
 58 {
 59         return !obj->name || obj->mod;
 60 }
 61 
 62 /* sets obj->mod if object is not vmlinux and module is found */
 63 static void klp_find_object_module(struct klp_object *obj)
 64 {
 65         struct module *mod;
 66 
 67         if (!klp_is_module(obj))
 68                 return;
 69 
 70         mutex_lock(&module_mutex);
 71         /*
 72          * We do not want to block removal of patched modules and therefore
 73          * we do not take a reference here. The patches are removed by
 74          * klp_module_going() instead.
 75          */
 76         mod = find_module(obj->name);
 77         /*
 78          * Do not mess work of klp_module_coming() and klp_module_going().
 79          * Note that the patch might still be needed before klp_module_going()
 80          * is called. Module functions can be called even in the GOING state
 81          * until mod->exit() finishes. This is especially important for
 82          * patches that modify semantic of the functions.
 83          */
 84         if (mod && mod->klp_alive)
 85                 obj->mod = mod;
 86 
 87         mutex_unlock(&module_mutex);
 88 }
 89 
 90 static bool klp_is_patch_registered(struct klp_patch *patch)
 91 {
 92         struct klp_patch *mypatch;
 93 
 94         list_for_each_entry(mypatch, &klp_patches, list)
 95                 if (mypatch == patch)
 96                         return true;
 97 
 98         return false;
 99 }
100 
101 static bool klp_initialized(void)
102 {
103         return !!klp_root_kobj;
104 }
105 
106 struct klp_find_arg {
107         const char *objname;
108         const char *name;
109         unsigned long addr;
110         unsigned long count;
111         unsigned long pos;
112 };
113 
114 static int klp_find_callback(void *data, const char *name,
115                              struct module *mod, unsigned long addr)
116 {
117         struct klp_find_arg *args = data;
118 
119         if ((mod && !args->objname) || (!mod && args->objname))
120                 return 0;
121 
122         if (strcmp(args->name, name))
123                 return 0;
124 
125         if (args->objname && strcmp(args->objname, mod->name))
126                 return 0;
127 
128         args->addr = addr;
129         args->count++;
130 
131         /*
132          * Finish the search when the symbol is found for the desired position
133          * or the position is not defined for a non-unique symbol.
134          */
135         if ((args->pos && (args->count == args->pos)) ||
136             (!args->pos && (args->count > 1)))
137                 return 1;
138 
139         return 0;
140 }
141 
142 static int klp_find_object_symbol(const char *objname, const char *name,
143                                   unsigned long sympos, unsigned long *addr)
144 {
145         struct klp_find_arg args = {
146                 .objname = objname,
147                 .name = name,
148                 .addr = 0,
149                 .count = 0,
150                 .pos = sympos,
151         };
152 
153         mutex_lock(&module_mutex);
154         if (objname)
155                 module_kallsyms_on_each_symbol(klp_find_callback, &args);
156         else
157                 kallsyms_on_each_symbol(klp_find_callback, &args);
158         mutex_unlock(&module_mutex);
159 
160         /*
161          * Ensure an address was found. If sympos is 0, ensure symbol is unique;
162          * otherwise ensure the symbol position count matches sympos.
163          */
164         if (args.addr == 0)
165                 pr_err("symbol '%s' not found in symbol table\n", name);
166         else if (args.count > 1 && sympos == 0) {
167                 pr_err("unresolvable ambiguity for symbol '%s' in object '%s'\n",
168                        name, objname);
169         } else if (sympos != args.count && sympos > 0) {
170                 pr_err("symbol position %lu for symbol '%s' in object '%s' not found\n",
171                        sympos, name, objname ? objname : "vmlinux");
172         } else {
173                 *addr = args.addr;
174                 return 0;
175         }
176 
177         *addr = 0;
178         return -EINVAL;
179 }
180 
181 static int klp_resolve_symbols(Elf_Shdr *relasec, struct module *pmod)
182 {
183         int i, cnt, vmlinux, ret;
184         char objname[MODULE_NAME_LEN];
185         char symname[KSYM_NAME_LEN];
186         char *strtab = pmod->core_kallsyms.strtab;
187         Elf_Rela *relas;
188         Elf_Sym *sym;
189         unsigned long sympos, addr;
190 
191         /*
192          * Since the field widths for objname and symname in the sscanf()
193          * call are hard-coded and correspond to MODULE_NAME_LEN and
194          * KSYM_NAME_LEN respectively, we must make sure that MODULE_NAME_LEN
195          * and KSYM_NAME_LEN have the values we expect them to have.
196          *
197          * Because the value of MODULE_NAME_LEN can differ among architectures,
198          * we use the smallest/strictest upper bound possible (56, based on
199          * the current definition of MODULE_NAME_LEN) to prevent overflows.
200          */
201         BUILD_BUG_ON(MODULE_NAME_LEN < 56 || KSYM_NAME_LEN != 128);
202 
203         relas = (Elf_Rela *) relasec->sh_addr;
204         /* For each rela in this klp relocation section */
205         for (i = 0; i < relasec->sh_size / sizeof(Elf_Rela); i++) {
206                 sym = pmod->core_kallsyms.symtab + ELF_R_SYM(relas[i].r_info);
207                 if (sym->st_shndx != SHN_LIVEPATCH) {
208                         pr_err("symbol %s is not marked as a livepatch symbol\n",
209                                strtab + sym->st_name);
210                         return -EINVAL;
211                 }
212 
213                 /* Format: .klp.sym.objname.symname,sympos */
214                 cnt = sscanf(strtab + sym->st_name,
215                              ".klp.sym.%55[^.].%127[^,],%lu",
216                              objname, symname, &sympos);
217                 if (cnt != 3) {
218                         pr_err("symbol %s has an incorrectly formatted name\n",
219                                strtab + sym->st_name);
220                         return -EINVAL;
221                 }
222 
223                 /* klp_find_object_symbol() treats a NULL objname as vmlinux */
224                 vmlinux = !strcmp(objname, "vmlinux");
225                 ret = klp_find_object_symbol(vmlinux ? NULL : objname,
226                                              symname, sympos, &addr);
227                 if (ret)
228                         return ret;
229 
230                 sym->st_value = addr;
231         }
232 
233         return 0;
234 }
235 
236 static int klp_write_object_relocations(struct module *pmod,
237                                         struct klp_object *obj)
238 {
239         int i, cnt, ret = 0;
240         const char *objname, *secname;
241         char sec_objname[MODULE_NAME_LEN];
242         Elf_Shdr *sec;
243 
244         if (WARN_ON(!klp_is_object_loaded(obj)))
245                 return -EINVAL;
246 
247         objname = klp_is_module(obj) ? obj->name : "vmlinux";
248 
249         /* For each klp relocation section */
250         for (i = 1; i < pmod->klp_info->hdr.e_shnum; i++) {
251                 sec = pmod->klp_info->sechdrs + i;
252                 secname = pmod->klp_info->secstrings + sec->sh_name;
253                 if (!(sec->sh_flags & SHF_RELA_LIVEPATCH))
254                         continue;
255 
256                 /*
257                  * Format: .klp.rela.sec_objname.section_name
258                  * See comment in klp_resolve_symbols() for an explanation
259                  * of the selected field width value.
260                  */
261                 cnt = sscanf(secname, ".klp.rela.%55[^.]", sec_objname);
262                 if (cnt != 1) {
263                         pr_err("section %s has an incorrectly formatted name\n",
264                                secname);
265                         ret = -EINVAL;
266                         break;
267                 }
268 
269                 if (strcmp(objname, sec_objname))
270                         continue;
271 
272                 ret = klp_resolve_symbols(sec, pmod);
273                 if (ret)
274                         break;
275 
276                 ret = apply_relocate_add(pmod->klp_info->sechdrs,
277                                          pmod->core_kallsyms.strtab,
278                                          pmod->klp_info->symndx, i, pmod);
279                 if (ret)
280                         break;
281         }
282 
283         return ret;
284 }
285 
286 static int __klp_disable_patch(struct klp_patch *patch)
287 {
288         if (klp_transition_patch)
289                 return -EBUSY;
290 
291         /* enforce stacking: only the last enabled patch can be disabled */
292         if (!list_is_last(&patch->list, &klp_patches) &&
293             list_next_entry(patch, list)->enabled)
294                 return -EBUSY;
295 
296         klp_init_transition(patch, KLP_UNPATCHED);
297 
298         /*
299          * Enforce the order of the func->transition writes in
300          * klp_init_transition() and the TIF_PATCH_PENDING writes in
301          * klp_start_transition().  In the rare case where klp_ftrace_handler()
302          * is called shortly after klp_update_patch_state() switches the task,
303          * this ensures the handler sees that func->transition is set.
304          */
305         smp_wmb();
306 
307         klp_start_transition();
308         klp_try_complete_transition();
309         patch->enabled = false;
310 
311         return 0;
312 }
313 
314 /**
315  * klp_disable_patch() - disables a registered patch
316  * @patch:      The registered, enabled patch to be disabled
317  *
318  * Unregisters the patched functions from ftrace.
319  *
320  * Return: 0 on success, otherwise error
321  */
322 int klp_disable_patch(struct klp_patch *patch)
323 {
324         int ret;
325 
326         mutex_lock(&klp_mutex);
327 
328         if (!klp_is_patch_registered(patch)) {
329                 ret = -EINVAL;
330                 goto err;
331         }
332 
333         if (!patch->enabled) {
334                 ret = -EINVAL;
335                 goto err;
336         }
337 
338         ret = __klp_disable_patch(patch);
339 
340 err:
341         mutex_unlock(&klp_mutex);
342         return ret;
343 }
344 EXPORT_SYMBOL_GPL(klp_disable_patch);
345 
346 static int __klp_enable_patch(struct klp_patch *patch)
347 {
348         struct klp_object *obj;
349         int ret;
350 
351         if (klp_transition_patch)
352                 return -EBUSY;
353 
354         if (WARN_ON(patch->enabled))
355                 return -EINVAL;
356 
357         /* enforce stacking: only the first disabled patch can be enabled */
358         if (patch->list.prev != &klp_patches &&
359             !list_prev_entry(patch, list)->enabled)
360                 return -EBUSY;
361 
362         /*
363          * A reference is taken on the patch module to prevent it from being
364          * unloaded.
365          *
366          * Note: For immediate (no consistency model) patches we don't allow
367          * patch modules to unload since there is no safe/sane method to
368          * determine if a thread is still running in the patched code contained
369          * in the patch module once the ftrace registration is successful.
370          */
371         if (!try_module_get(patch->mod))
372                 return -ENODEV;
373 
374         pr_notice("enabling patch '%s'\n", patch->mod->name);
375 
376         klp_init_transition(patch, KLP_PATCHED);
377 
378         /*
379          * Enforce the order of the func->transition writes in
380          * klp_init_transition() and the ops->func_stack writes in
381          * klp_patch_object(), so that klp_ftrace_handler() will see the
382          * func->transition updates before the handler is registered and the
383          * new funcs become visible to the handler.
384          */
385         smp_wmb();
386 
387         klp_for_each_object(patch, obj) {
388                 if (!klp_is_object_loaded(obj))
389                         continue;
390 
391                 ret = klp_patch_object(obj);
392                 if (ret) {
393                         pr_warn("failed to enable patch '%s'\n",
394                                 patch->mod->name);
395 
396                         klp_cancel_transition();
397                         return ret;
398                 }
399         }
400 
401         klp_start_transition();
402         klp_try_complete_transition();
403         patch->enabled = true;
404 
405         return 0;
406 }
407 
408 /**
409  * klp_enable_patch() - enables a registered patch
410  * @patch:      The registered, disabled patch to be enabled
411  *
412  * Performs the needed symbol lookups and code relocations,
413  * then registers the patched functions with ftrace.
414  *
415  * Return: 0 on success, otherwise error
416  */
417 int klp_enable_patch(struct klp_patch *patch)
418 {
419         int ret;
420 
421         mutex_lock(&klp_mutex);
422 
423         if (!klp_is_patch_registered(patch)) {
424                 ret = -EINVAL;
425                 goto err;
426         }
427 
428         ret = __klp_enable_patch(patch);
429 
430 err:
431         mutex_unlock(&klp_mutex);
432         return ret;
433 }
434 EXPORT_SYMBOL_GPL(klp_enable_patch);
435 
436 /*
437  * Sysfs Interface
438  *
439  * /sys/kernel/livepatch
440  * /sys/kernel/livepatch/<patch>
441  * /sys/kernel/livepatch/<patch>/enabled
442  * /sys/kernel/livepatch/<patch>/transition
443  * /sys/kernel/livepatch/<patch>/<object>
444  * /sys/kernel/livepatch/<patch>/<object>/<function,sympos>
445  */
446 
447 static ssize_t enabled_store(struct kobject *kobj, struct kobj_attribute *attr,
448                              const char *buf, size_t count)
449 {
450         struct klp_patch *patch;
451         int ret;
452         bool enabled;
453 
454         ret = kstrtobool(buf, &enabled);
455         if (ret)
456                 return ret;
457 
458         patch = container_of(kobj, struct klp_patch, kobj);
459 
460         mutex_lock(&klp_mutex);
461 
462         if (!klp_is_patch_registered(patch)) {
463                 /*
464                  * Module with the patch could either disappear meanwhile or is
465                  * not properly initialized yet.
466                  */
467                 ret = -EINVAL;
468                 goto err;
469         }
470 
471         if (patch->enabled == enabled) {
472                 /* already in requested state */
473                 ret = -EINVAL;
474                 goto err;
475         }
476 
477         if (patch == klp_transition_patch) {
478                 klp_reverse_transition();
479         } else if (enabled) {
480                 ret = __klp_enable_patch(patch);
481                 if (ret)
482                         goto err;
483         } else {
484                 ret = __klp_disable_patch(patch);
485                 if (ret)
486                         goto err;
487         }
488 
489         mutex_unlock(&klp_mutex);
490 
491         return count;
492 
493 err:
494         mutex_unlock(&klp_mutex);
495         return ret;
496 }
497 
498 static ssize_t enabled_show(struct kobject *kobj,
499                             struct kobj_attribute *attr, char *buf)
500 {
501         struct klp_patch *patch;
502 
503         patch = container_of(kobj, struct klp_patch, kobj);
504         return snprintf(buf, PAGE_SIZE-1, "%d\n", patch->enabled);
505 }
506 
507 static ssize_t transition_show(struct kobject *kobj,
508                                struct kobj_attribute *attr, char *buf)
509 {
510         struct klp_patch *patch;
511 
512         patch = container_of(kobj, struct klp_patch, kobj);
513         return snprintf(buf, PAGE_SIZE-1, "%d\n",
514                         patch == klp_transition_patch);
515 }
516 
517 static struct kobj_attribute enabled_kobj_attr = __ATTR_RW(enabled);
518 static struct kobj_attribute transition_kobj_attr = __ATTR_RO(transition);
519 static struct attribute *klp_patch_attrs[] = {
520         &enabled_kobj_attr.attr,
521         &transition_kobj_attr.attr,
522         NULL
523 };
524 
525 static void klp_kobj_release_patch(struct kobject *kobj)
526 {
527         struct klp_patch *patch;
528 
529         patch = container_of(kobj, struct klp_patch, kobj);
530         complete(&patch->finish);
531 }
532 
533 static struct kobj_type klp_ktype_patch = {
534         .release = klp_kobj_release_patch,
535         .sysfs_ops = &kobj_sysfs_ops,
536         .default_attrs = klp_patch_attrs,
537 };
538 
539 static void klp_kobj_release_object(struct kobject *kobj)
540 {
541 }
542 
543 static struct kobj_type klp_ktype_object = {
544         .release = klp_kobj_release_object,
545         .sysfs_ops = &kobj_sysfs_ops,
546 };
547 
548 static void klp_kobj_release_func(struct kobject *kobj)
549 {
550 }
551 
552 static struct kobj_type klp_ktype_func = {
553         .release = klp_kobj_release_func,
554         .sysfs_ops = &kobj_sysfs_ops,
555 };
556 
557 /*
558  * Free all functions' kobjects in the array up to some limit. When limit is
559  * NULL, all kobjects are freed.
560  */
561 static void klp_free_funcs_limited(struct klp_object *obj,
562                                    struct klp_func *limit)
563 {
564         struct klp_func *func;
565 
566         for (func = obj->funcs; func->old_name && func != limit; func++)
567                 kobject_put(&func->kobj);
568 }
569 
570 /* Clean up when a patched object is unloaded */
571 static void klp_free_object_loaded(struct klp_object *obj)
572 {
573         struct klp_func *func;
574 
575         obj->mod = NULL;
576 
577         klp_for_each_func(obj, func)
578                 func->old_addr = 0;
579 }
580 
581 /*
582  * Free all objects' kobjects in the array up to some limit. When limit is
583  * NULL, all kobjects are freed.
584  */
585 static void klp_free_objects_limited(struct klp_patch *patch,
586                                      struct klp_object *limit)
587 {
588         struct klp_object *obj;
589 
590         for (obj = patch->objs; obj->funcs && obj != limit; obj++) {
591                 klp_free_funcs_limited(obj, NULL);
592                 kobject_put(&obj->kobj);
593         }
594 }
595 
596 static void klp_free_patch(struct klp_patch *patch)
597 {
598         klp_free_objects_limited(patch, NULL);
599         if (!list_empty(&patch->list))
600                 list_del(&patch->list);
601 }
602 
603 static int klp_init_func(struct klp_object *obj, struct klp_func *func)
604 {
605         if (!func->old_name || !func->new_func)
606                 return -EINVAL;
607 
608         INIT_LIST_HEAD(&func->stack_node);
609         func->patched = false;
610         func->transition = false;
611 
612         /* The format for the sysfs directory is <function,sympos> where sympos
613          * is the nth occurrence of this symbol in kallsyms for the patched
614          * object. If the user selects 0 for old_sympos, then 1 will be used
615          * since a unique symbol will be the first occurrence.
616          */
617         return kobject_init_and_add(&func->kobj, &klp_ktype_func,
618                                     &obj->kobj, "%s,%lu", func->old_name,
619                                     func->old_sympos ? func->old_sympos : 1);
620 }
621 
622 /* Arches may override this to finish any remaining arch-specific tasks */
623 void __weak arch_klp_init_object_loaded(struct klp_patch *patch,
624                                         struct klp_object *obj)
625 {
626 }
627 
628 /* parts of the initialization that is done only when the object is loaded */
629 static int klp_init_object_loaded(struct klp_patch *patch,
630                                   struct klp_object *obj)
631 {
632         struct klp_func *func;
633         int ret;
634 
635         module_disable_ro(patch->mod);
636         ret = klp_write_object_relocations(patch->mod, obj);
637         if (ret) {
638                 module_enable_ro(patch->mod, true);
639                 return ret;
640         }
641 
642         arch_klp_init_object_loaded(patch, obj);
643         module_enable_ro(patch->mod, true);
644 
645         klp_for_each_func(obj, func) {
646                 ret = klp_find_object_symbol(obj->name, func->old_name,
647                                              func->old_sympos,
648                                              &func->old_addr);
649                 if (ret)
650                         return ret;
651 
652                 ret = kallsyms_lookup_size_offset(func->old_addr,
653                                                   &func->old_size, NULL);
654                 if (!ret) {
655                         pr_err("kallsyms size lookup failed for '%s'\n",
656                                func->old_name);
657                         return -ENOENT;
658                 }
659 
660                 ret = kallsyms_lookup_size_offset((unsigned long)func->new_func,
661                                                   &func->new_size, NULL);
662                 if (!ret) {
663                         pr_err("kallsyms size lookup failed for '%s' replacement\n",
664                                func->old_name);
665                         return -ENOENT;
666                 }
667         }
668 
669         return 0;
670 }
671 
672 static int klp_init_object(struct klp_patch *patch, struct klp_object *obj)
673 {
674         struct klp_func *func;
675         int ret;
676         const char *name;
677 
678         if (!obj->funcs)
679                 return -EINVAL;
680 
681         obj->patched = false;
682         obj->mod = NULL;
683 
684         klp_find_object_module(obj);
685 
686         name = klp_is_module(obj) ? obj->name : "vmlinux";
687         ret = kobject_init_and_add(&obj->kobj, &klp_ktype_object,
688                                    &patch->kobj, "%s", name);
689         if (ret)
690                 return ret;
691 
692         klp_for_each_func(obj, func) {
693                 ret = klp_init_func(obj, func);
694                 if (ret)
695                         goto free;
696         }
697 
698         if (klp_is_object_loaded(obj)) {
699                 ret = klp_init_object_loaded(patch, obj);
700                 if (ret)
701                         goto free;
702         }
703 
704         return 0;
705 
706 free:
707         klp_free_funcs_limited(obj, func);
708         kobject_put(&obj->kobj);
709         return ret;
710 }
711 
712 static int klp_init_patch(struct klp_patch *patch)
713 {
714         struct klp_object *obj;
715         int ret;
716 
717         if (!patch->objs)
718                 return -EINVAL;
719 
720         mutex_lock(&klp_mutex);
721 
722         patch->enabled = false;
723         init_completion(&patch->finish);
724 
725         ret = kobject_init_and_add(&patch->kobj, &klp_ktype_patch,
726                                    klp_root_kobj, "%s", patch->mod->name);
727         if (ret) {
728                 mutex_unlock(&klp_mutex);
729                 return ret;
730         }
731 
732         klp_for_each_object(patch, obj) {
733                 ret = klp_init_object(patch, obj);
734                 if (ret)
735                         goto free;
736         }
737 
738         list_add_tail(&patch->list, &klp_patches);
739 
740         mutex_unlock(&klp_mutex);
741 
742         return 0;
743 
744 free:
745         klp_free_objects_limited(patch, obj);
746 
747         mutex_unlock(&klp_mutex);
748 
749         kobject_put(&patch->kobj);
750         wait_for_completion(&patch->finish);
751 
752         return ret;
753 }
754 
755 /**
756  * klp_unregister_patch() - unregisters a patch
757  * @patch:      Disabled patch to be unregistered
758  *
759  * Frees the data structures and removes the sysfs interface.
760  *
761  * Return: 0 on success, otherwise error
762  */
763 int klp_unregister_patch(struct klp_patch *patch)
764 {
765         int ret;
766 
767         mutex_lock(&klp_mutex);
768 
769         if (!klp_is_patch_registered(patch)) {
770                 ret = -EINVAL;
771                 goto err;
772         }
773 
774         if (patch->enabled) {
775                 ret = -EBUSY;
776                 goto err;
777         }
778 
779         klp_free_patch(patch);
780 
781         mutex_unlock(&klp_mutex);
782 
783         kobject_put(&patch->kobj);
784         wait_for_completion(&patch->finish);
785 
786         return 0;
787 err:
788         mutex_unlock(&klp_mutex);
789         return ret;
790 }
791 EXPORT_SYMBOL_GPL(klp_unregister_patch);
792 
793 /**
794  * klp_register_patch() - registers a patch
795  * @patch:      Patch to be registered
796  *
797  * Initializes the data structure associated with the patch and
798  * creates the sysfs interface.
799  *
800  * There is no need to take the reference on the patch module here. It is done
801  * later when the patch is enabled.
802  *
803  * Return: 0 on success, otherwise error
804  */
805 int klp_register_patch(struct klp_patch *patch)
806 {
807         if (!patch || !patch->mod)
808                 return -EINVAL;
809 
810         if (!is_livepatch_module(patch->mod)) {
811                 pr_err("module %s is not marked as a livepatch module\n",
812                        patch->mod->name);
813                 return -EINVAL;
814         }
815 
816         if (!klp_initialized())
817                 return -ENODEV;
818 
819         /*
820          * Architectures without reliable stack traces have to set
821          * patch->immediate because there's currently no way to patch kthreads
822          * with the consistency model.
823          */
824         if (!klp_have_reliable_stack() && !patch->immediate) {
825                 pr_err("This architecture doesn't have support for the livepatch consistency model.\n");
826                 return -ENOSYS;
827         }
828 
829         return klp_init_patch(patch);
830 }
831 EXPORT_SYMBOL_GPL(klp_register_patch);
832 
833 /*
834  * Remove parts of patches that touch a given kernel module. The list of
835  * patches processed might be limited. When limit is NULL, all patches
836  * will be handled.
837  */
838 static void klp_cleanup_module_patches_limited(struct module *mod,
839                                                struct klp_patch *limit)
840 {
841         struct klp_patch *patch;
842         struct klp_object *obj;
843 
844         list_for_each_entry(patch, &klp_patches, list) {
845                 if (patch == limit)
846                         break;
847 
848                 klp_for_each_object(patch, obj) {
849                         if (!klp_is_module(obj) || strcmp(obj->name, mod->name))
850                                 continue;
851 
852                         /*
853                          * Only unpatch the module if the patch is enabled or
854                          * is in transition.
855                          */
856                         if (patch->enabled || patch == klp_transition_patch) {
857                                 pr_notice("reverting patch '%s' on unloading module '%s'\n",
858                                           patch->mod->name, obj->mod->name);
859                                 klp_unpatch_object(obj);
860                         }
861 
862                         klp_free_object_loaded(obj);
863                         break;
864                 }
865         }
866 }
867 
868 int klp_module_coming(struct module *mod)
869 {
870         int ret;
871         struct klp_patch *patch;
872         struct klp_object *obj;
873 
874         if (WARN_ON(mod->state != MODULE_STATE_COMING))
875                 return -EINVAL;
876 
877         mutex_lock(&klp_mutex);
878         /*
879          * Each module has to know that klp_module_coming()
880          * has been called. We never know what module will
881          * get patched by a new patch.
882          */
883         mod->klp_alive = true;
884 
885         list_for_each_entry(patch, &klp_patches, list) {
886                 klp_for_each_object(patch, obj) {
887                         if (!klp_is_module(obj) || strcmp(obj->name, mod->name))
888                                 continue;
889 
890                         obj->mod = mod;
891 
892                         ret = klp_init_object_loaded(patch, obj);
893                         if (ret) {
894                                 pr_warn("failed to initialize patch '%s' for module '%s' (%d)\n",
895                                         patch->mod->name, obj->mod->name, ret);
896                                 goto err;
897                         }
898 
899                         /*
900                          * Only patch the module if the patch is enabled or is
901                          * in transition.
902                          */
903                         if (!patch->enabled && patch != klp_transition_patch)
904                                 break;
905 
906                         pr_notice("applying patch '%s' to loading module '%s'\n",
907                                   patch->mod->name, obj->mod->name);
908 
909                         ret = klp_patch_object(obj);
910                         if (ret) {
911                                 pr_warn("failed to apply patch '%s' to module '%s' (%d)\n",
912                                         patch->mod->name, obj->mod->name, ret);
913                                 goto err;
914                         }
915 
916                         break;
917                 }
918         }
919 
920         mutex_unlock(&klp_mutex);
921 
922         return 0;
923 
924 err:
925         /*
926          * If a patch is unsuccessfully applied, return
927          * error to the module loader.
928          */
929         pr_warn("patch '%s' failed for module '%s', refusing to load module '%s'\n",
930                 patch->mod->name, obj->mod->name, obj->mod->name);
931         mod->klp_alive = false;
932         klp_cleanup_module_patches_limited(mod, patch);
933         mutex_unlock(&klp_mutex);
934 
935         return ret;
936 }
937 
938 void klp_module_going(struct module *mod)
939 {
940         if (WARN_ON(mod->state != MODULE_STATE_GOING &&
941                     mod->state != MODULE_STATE_COMING))
942                 return;
943 
944         mutex_lock(&klp_mutex);
945         /*
946          * Each module has to know that klp_module_going()
947          * has been called. We never know what module will
948          * get patched by a new patch.
949          */
950         mod->klp_alive = false;
951 
952         klp_cleanup_module_patches_limited(mod, NULL);
953 
954         mutex_unlock(&klp_mutex);
955 }
956 
957 static int __init klp_init(void)
958 {
959         int ret;
960 
961         ret = klp_check_compiler_support();
962         if (ret) {
963                 pr_info("Your compiler is too old; turning off.\n");
964                 return -EINVAL;
965         }
966 
967         klp_root_kobj = kobject_create_and_add("livepatch", kernel_kobj);
968         if (!klp_root_kobj)
969                 return -ENOMEM;
970 
971         return 0;
972 }
973 
974 module_init(klp_init);
975 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp