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 <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 int klp_module_coming(struct module *mod)
 834 {
 835         int ret;
 836         struct klp_patch *patch;
 837         struct klp_object *obj;
 838
 839         if (WARN_ON(mod->state != MODULE_STATE_COMING))
 840                 return -EINVAL;
 841
 842         mutex_lock(&klp_mutex);
 843         /*
 844          * Each module has to know that klp_module_coming()
 845          * has been called. We never know what module will
 846          * get patched by a new patch.
 847          */
 848         mod->klp_alive = true;
 849
 850         list_for_each_entry(patch, &klp_patches, list) {
 851                 klp_for_each_object(patch, obj) {
 852                         if (!klp_is_module(obj) || strcmp(obj->name, mod->name))
 853                                 continue;
 854
 855                         obj->mod = mod;
 856
 857                         ret = klp_init_object_loaded(patch, obj);
 858                         if (ret) {
 859                                 pr_warn("failed to initialize patch '%s' for module '%s' (%d)\n",
 860                                         patch->mod->name, obj->mod->name, ret);
 861                                 goto err;
 862                         }
 863
 864                         /*
 865                          * Only patch the module if the patch is enabled or is
 866                          * in transition.
 867                          */
 868                         if (!patch->enabled && patch != klp_transition_patch)
 869                                 break;
 870
 871                         pr_notice("applying patch '%s' to loading module '%s'\n",
 872                                   patch->mod->name, obj->mod->name);
 873
 874                         ret = klp_patch_object(obj);
 875                         if (ret) {
 876                                 pr_warn("failed to apply patch '%s' to module '%s' (%d)\n",
 877                                         patch->mod->name, obj->mod->name, ret);
 878                                 goto err;
 879                         }
 880
 881                         break;
 882                 }
 883         }
 884
 885         mutex_unlock(&klp_mutex);
 886
 887         return 0;
 888
 889 err:
 890         /*
 891          * If a patch is unsuccessfully applied, return
 892          * error to the module loader.
 893          */
 894         pr_warn("patch '%s' failed for module '%s', refusing to load module '%s'\n",
 895                 patch->mod->name, obj->mod->name, obj->mod->name);
 896         mod->klp_alive = false;
 897         klp_free_object_loaded(obj);
 898         mutex_unlock(&klp_mutex);
 899
 900         return ret;
 901 }
 902
 903 void klp_module_going(struct module *mod)
 904 {
 905         struct klp_patch *patch;
 906         struct klp_object *obj;
 907
 908         if (WARN_ON(mod->state != MODULE_STATE_GOING &&
 909                     mod->state != MODULE_STATE_COMING))
 910                 return;
 911
 912         mutex_lock(&klp_mutex);
 913         /*
 914          * Each module has to know that klp_module_going()
 915          * has been called. We never know what module will
 916          * get patched by a new patch.
 917          */
 918         mod->klp_alive = false;
 919
 920         list_for_each_entry(patch, &klp_patches, list) {
 921                 klp_for_each_object(patch, obj) {
 922                         if (!klp_is_module(obj) || strcmp(obj->name, mod->name))
 923                                 continue;
 924
 925                         /*
 926                          * Only unpatch the module if the patch is enabled or
 927                          * is in transition.
 928                          */
 929                         if (patch->enabled || patch == klp_transition_patch) {
 930                                 pr_notice("reverting patch '%s' on unloading module '%s'\n",
 931                                           patch->mod->name, obj->mod->name);
 932                                 klp_unpatch_object(obj);
 933                         }
 934
 935                         klp_free_object_loaded(obj);
 936                         break;
 937                 }
 938         }
 939
 940         mutex_unlock(&klp_mutex);
 941 }
 942
 943 static int __init klp_init(void)
 944 {
 945         int ret;
 946
 947         ret = klp_check_compiler_support();
 948         if (ret) {
 949                 pr_info("Your compiler is too old; turning off.\n");
 950                 return -EINVAL;
 951         }
 952
 953         klp_root_kobj = kobject_create_and_add("livepatch", kernel_kobj);
 954         if (!klp_root_kobj)
 955                 return -ENOMEM;
 956
 957         return 0;
 958 }
 959
 960 module_init(klp_init);