kernel/livepatch/core.c

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