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