arch/x86/kernel/cpu/microcode/core.c

   1 /*
   2  * CPU Microcode Update Driver for Linux
   3  *
   4  * Copyright (C) 2000-2006 Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
   5  *            2006      Shaohua Li <shaohua.li@intel.com>
   6  *            2013-2015 Borislav Petkov <bp@alien8.de>
   7  *
   8  * X86 CPU microcode early update for Linux:
   9  *
  10  *      Copyright (C) 2012 Fenghua Yu <fenghua.yu@intel.com>
  11  *                         H Peter Anvin" <hpa@zytor.com>
  12  *                (C) 2015 Borislav Petkov <bp@alien8.de>
  13  *
  14  * This driver allows to upgrade microcode on x86 processors.
  15  *
  16  * This program is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU General Public License
  18  * as published by the Free Software Foundation; either version
  19  * 2 of the License, or (at your option) any later version.
  20  */
  21
  22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  23
  24 #include <linux/platform_device.h>
  25 #include <linux/syscore_ops.h>
  26 #include <linux/miscdevice.h>
  27 #include <linux/capability.h>
  28 #include <linux/firmware.h>
  29 #include <linux/kernel.h>
  30 #include <linux/module.h>
  31 #include <linux/mutex.h>
  32 #include <linux/cpu.h>
  33 #include <linux/fs.h>
  34 #include <linux/mm.h>
  35
  36 #include <asm/microcode_intel.h>
  37 #include <asm/cpu_device_id.h>
  38 #include <asm/microcode_amd.h>
  39 #include <asm/perf_event.h>
  40 #include <asm/microcode.h>
  41 #include <asm/processor.h>
  42 #include <asm/cmdline.h>
  43
  44 MODULE_DESCRIPTION("Microcode Update Driver");
  45 MODULE_AUTHOR("Tigran Aivazian <tigran@aivazian.fsnet.co.uk>");
  46 MODULE_LICENSE("GPL");
  47
  48 #define MICROCODE_VERSION       "2.00"
  49
  50 static struct microcode_ops     *microcode_ops;
  51
  52 bool dis_ucode_ldr;
  53 module_param(dis_ucode_ldr, bool, 0);
  54
  55 /*
  56  * Synchronization.
  57  *
  58  * All non cpu-hotplug-callback call sites use:
  59  *
  60  * - microcode_mutex to synchronize with each other;
  61  * - get/put_online_cpus() to synchronize with
  62  *   the cpu-hotplug-callback call sites.
  63  *
  64  * We guarantee that only a single cpu is being
  65  * updated at any particular moment of time.
  66  */
  67 static DEFINE_MUTEX(microcode_mutex);
  68
  69 struct ucode_cpu_info           ucode_cpu_info[NR_CPUS];
  70 EXPORT_SYMBOL_GPL(ucode_cpu_info);
  71
  72 /*
  73  * Operations that are run on a target cpu:
  74  */
  75
  76 struct cpu_info_ctx {
  77         struct cpu_signature    *cpu_sig;
  78         int                     err;
  79 };
  80
  81 static bool __init check_loader_disabled_bsp(void)
  82 {
  83 #ifdef CONFIG_X86_32
  84         const char *cmdline = (const char *)__pa_nodebug(boot_command_line);
  85         const char *opt     = "dis_ucode_ldr";
  86         const char *option  = (const char *)__pa_nodebug(opt);
  87         bool *res = (bool *)__pa_nodebug(&dis_ucode_ldr);
  88
  89 #else /* CONFIG_X86_64 */
  90         const char *cmdline = boot_command_line;
  91         const char *option  = "dis_ucode_ldr";
  92         bool *res = &dis_ucode_ldr;
  93 #endif
  94
  95         if (cmdline_find_option_bool(cmdline, option))
  96                 *res = true;
  97
  98         return *res;
  99 }
 100
 101 extern struct builtin_fw __start_builtin_fw[];
 102 extern struct builtin_fw __end_builtin_fw[];
 103
 104 bool get_builtin_firmware(struct cpio_data *cd, const char *name)
 105 {
 106 #ifdef CONFIG_FW_LOADER
 107         struct builtin_fw *b_fw;
 108
 109         for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++) {
 110                 if (!strcmp(name, b_fw->name)) {
 111                         cd->size = b_fw->size;
 112                         cd->data = b_fw->data;
 113                         return true;
 114                 }
 115         }
 116 #endif
 117         return false;
 118 }
 119
 120 void __init load_ucode_bsp(void)
 121 {
 122         int vendor;
 123         unsigned int family;
 124
 125         if (check_loader_disabled_bsp())
 126                 return;
 127
 128         if (!have_cpuid_p())
 129                 return;
 130
 131         vendor = x86_vendor();
 132         family = x86_family();
 133
 134         switch (vendor) {
 135         case X86_VENDOR_INTEL:
 136                 if (family >= 6)
 137                         load_ucode_intel_bsp();
 138                 break;
 139         case X86_VENDOR_AMD:
 140                 if (family >= 0x10)
 141                         load_ucode_amd_bsp(family);
 142                 break;
 143         default:
 144                 break;
 145         }
 146 }
 147
 148 static bool check_loader_disabled_ap(void)
 149 {
 150 #ifdef CONFIG_X86_32
 151         return *((bool *)__pa_nodebug(&dis_ucode_ldr));
 152 #else
 153         return dis_ucode_ldr;
 154 #endif
 155 }
 156
 157 void load_ucode_ap(void)
 158 {
 159         int vendor, family;
 160
 161         if (check_loader_disabled_ap())
 162                 return;
 163
 164         if (!have_cpuid_p())
 165                 return;
 166
 167         vendor = x86_vendor();
 168         family = x86_family();
 169
 170         switch (vendor) {
 171         case X86_VENDOR_INTEL:
 172                 if (family >= 6)
 173                         load_ucode_intel_ap();
 174                 break;
 175         case X86_VENDOR_AMD:
 176                 if (family >= 0x10)
 177                         load_ucode_amd_ap();
 178                 break;
 179         default:
 180                 break;
 181         }
 182 }
 183
 184 int __init save_microcode_in_initrd(void)
 185 {
 186         struct cpuinfo_x86 *c = &boot_cpu_data;
 187
 188         switch (c->x86_vendor) {
 189         case X86_VENDOR_INTEL:
 190                 if (c->x86 >= 6)
 191                         save_microcode_in_initrd_intel();
 192                 break;
 193         case X86_VENDOR_AMD:
 194                 if (c->x86 >= 0x10)
 195                         save_microcode_in_initrd_amd();
 196                 break;
 197         default:
 198                 break;
 199         }
 200
 201         return 0;
 202 }
 203
 204 void reload_early_microcode(void)
 205 {
 206         int vendor, family;
 207
 208         vendor = x86_vendor();
 209         family = x86_family();
 210
 211         switch (vendor) {
 212         case X86_VENDOR_INTEL:
 213                 if (family >= 6)
 214                         reload_ucode_intel();
 215                 break;
 216         case X86_VENDOR_AMD:
 217                 if (family >= 0x10)
 218                         reload_ucode_amd();
 219                 break;
 220         default:
 221                 break;
 222         }
 223 }
 224
 225 static void collect_cpu_info_local(void *arg)
 226 {
 227         struct cpu_info_ctx *ctx = arg;
 228
 229         ctx->err = microcode_ops->collect_cpu_info(smp_processor_id(),
 230                                                    ctx->cpu_sig);
 231 }
 232
 233 static int collect_cpu_info_on_target(int cpu, struct cpu_signature *cpu_sig)
 234 {
 235         struct cpu_info_ctx ctx = { .cpu_sig = cpu_sig, .err = 0 };
 236         int ret;
 237
 238         ret = smp_call_function_single(cpu, collect_cpu_info_local, &ctx, 1);
 239         if (!ret)
 240                 ret = ctx.err;
 241
 242         return ret;
 243 }
 244
 245 static int collect_cpu_info(int cpu)
 246 {
 247         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
 248         int ret;
 249
 250         memset(uci, 0, sizeof(*uci));
 251
 252         ret = collect_cpu_info_on_target(cpu, &uci->cpu_sig);
 253         if (!ret)
 254                 uci->valid = 1;
 255
 256         return ret;
 257 }
 258
 259 struct apply_microcode_ctx {
 260         int err;
 261 };
 262
 263 static void apply_microcode_local(void *arg)
 264 {
 265         struct apply_microcode_ctx *ctx = arg;
 266
 267         ctx->err = microcode_ops->apply_microcode(smp_processor_id());
 268 }
 269
 270 static int apply_microcode_on_target(int cpu)
 271 {
 272         struct apply_microcode_ctx ctx = { .err = 0 };
 273         int ret;
 274
 275         ret = smp_call_function_single(cpu, apply_microcode_local, &ctx, 1);
 276         if (!ret)
 277                 ret = ctx.err;
 278
 279         return ret;
 280 }
 281
 282 #ifdef CONFIG_MICROCODE_OLD_INTERFACE
 283 static int do_microcode_update(const void __user *buf, size_t size)
 284 {
 285         int error = 0;
 286         int cpu;
 287
 288         for_each_online_cpu(cpu) {
 289                 struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
 290                 enum ucode_state ustate;
 291
 292                 if (!uci->valid)
 293                         continue;
 294
 295                 ustate = microcode_ops->request_microcode_user(cpu, buf, size);
 296                 if (ustate == UCODE_ERROR) {
 297                         error = -1;
 298                         break;
 299                 } else if (ustate == UCODE_OK)
 300                         apply_microcode_on_target(cpu);
 301         }
 302
 303         return error;
 304 }
 305
 306 static int microcode_open(struct inode *inode, struct file *file)
 307 {
 308         return capable(CAP_SYS_RAWIO) ? nonseekable_open(inode, file) : -EPERM;
 309 }
 310
 311 static ssize_t microcode_write(struct file *file, const char __user *buf,
 312                                size_t len, loff_t *ppos)
 313 {
 314         ssize_t ret = -EINVAL;
 315
 316         if ((len >> PAGE_SHIFT) > totalram_pages) {
 317                 pr_err("too much data (max %ld pages)\n", totalram_pages);
 318                 return ret;
 319         }
 320
 321         get_online_cpus();
 322         mutex_lock(&microcode_mutex);
 323
 324         if (do_microcode_update(buf, len) == 0)
 325                 ret = (ssize_t)len;
 326
 327         if (ret > 0)
 328                 perf_check_microcode();
 329
 330         mutex_unlock(&microcode_mutex);
 331         put_online_cpus();
 332
 333         return ret;
 334 }
 335
 336 static const struct file_operations microcode_fops = {
 337         .owner                  = THIS_MODULE,
 338         .write                  = microcode_write,
 339         .open                   = microcode_open,
 340         .llseek         = no_llseek,
 341 };
 342
 343 static struct miscdevice microcode_dev = {
 344         .minor                  = MICROCODE_MINOR,
 345         .name                   = "microcode",
 346         .nodename               = "cpu/microcode",
 347         .fops                   = &microcode_fops,
 348 };
 349
 350 static int __init microcode_dev_init(void)
 351 {
 352         int error;
 353
 354         error = misc_register(&microcode_dev);
 355         if (error) {
 356                 pr_err("can't misc_register on minor=%d\n", MICROCODE_MINOR);
 357                 return error;
 358         }
 359
 360         return 0;
 361 }
 362
 363 static void __exit microcode_dev_exit(void)
 364 {
 365         misc_deregister(&microcode_dev);
 366 }
 367
 368 MODULE_ALIAS_MISCDEV(MICROCODE_MINOR);
 369 MODULE_ALIAS("devname:cpu/microcode");
 370 #else
 371 #define microcode_dev_init()    0
 372 #define microcode_dev_exit()    do { } while (0)
 373 #endif
 374
 375 /* fake device for request_firmware */
 376 static struct platform_device   *microcode_pdev;
 377
 378 static int reload_for_cpu(int cpu)
 379 {
 380         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
 381         enum ucode_state ustate;
 382         int err = 0;
 383
 384         if (!uci->valid)
 385                 return err;
 386
 387         ustate = microcode_ops->request_microcode_fw(cpu, &microcode_pdev->dev, true);
 388         if (ustate == UCODE_OK)
 389                 apply_microcode_on_target(cpu);
 390         else
 391                 if (ustate == UCODE_ERROR)
 392                         err = -EINVAL;
 393         return err;
 394 }
 395
 396 static ssize_t reload_store(struct device *dev,
 397                             struct device_attribute *attr,
 398                             const char *buf, size_t size)
 399 {
 400         unsigned long val;
 401         int cpu;
 402         ssize_t ret = 0, tmp_ret;
 403
 404         ret = kstrtoul(buf, 0, &val);
 405         if (ret)
 406                 return ret;
 407
 408         if (val != 1)
 409                 return size;
 410
 411         get_online_cpus();
 412         mutex_lock(&microcode_mutex);
 413         for_each_online_cpu(cpu) {
 414                 tmp_ret = reload_for_cpu(cpu);
 415                 if (tmp_ret != 0)
 416                         pr_warn("Error reloading microcode on CPU %d\n", cpu);
 417
 418                 /* save retval of the first encountered reload error */
 419                 if (!ret)
 420                         ret = tmp_ret;
 421         }
 422         if (!ret)
 423                 perf_check_microcode();
 424         mutex_unlock(&microcode_mutex);
 425         put_online_cpus();
 426
 427         if (!ret)
 428                 ret = size;
 429
 430         return ret;
 431 }
 432
 433 static ssize_t version_show(struct device *dev,
 434                         struct device_attribute *attr, char *buf)
 435 {
 436         struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
 437
 438         return sprintf(buf, "0x%x\n", uci->cpu_sig.rev);
 439 }
 440
 441 static ssize_t pf_show(struct device *dev,
 442                         struct device_attribute *attr, char *buf)
 443 {
 444         struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
 445
 446         return sprintf(buf, "0x%x\n", uci->cpu_sig.pf);
 447 }
 448
 449 static DEVICE_ATTR(reload, 0200, NULL, reload_store);
 450 static DEVICE_ATTR(version, 0400, version_show, NULL);
 451 static DEVICE_ATTR(processor_flags, 0400, pf_show, NULL);
 452
 453 static struct attribute *mc_default_attrs[] = {
 454         &dev_attr_version.attr,
 455         &dev_attr_processor_flags.attr,
 456         NULL
 457 };
 458
 459 static struct attribute_group mc_attr_group = {
 460         .attrs                  = mc_default_attrs,
 461         .name                   = "microcode",
 462 };
 463
 464 static void microcode_fini_cpu(int cpu)
 465 {
 466         microcode_ops->microcode_fini_cpu(cpu);
 467 }
 468
 469 static enum ucode_state microcode_resume_cpu(int cpu)
 470 {
 471         pr_debug("CPU%d updated upon resume\n", cpu);
 472
 473         if (apply_microcode_on_target(cpu))
 474                 return UCODE_ERROR;
 475
 476         return UCODE_OK;
 477 }
 478
 479 static enum ucode_state microcode_init_cpu(int cpu, bool refresh_fw)
 480 {
 481         enum ucode_state ustate;
 482         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
 483
 484         if (uci && uci->valid)
 485                 return UCODE_OK;
 486
 487         if (collect_cpu_info(cpu))
 488                 return UCODE_ERROR;
 489
 490         /* --dimm. Trigger a delayed update? */
 491         if (system_state != SYSTEM_RUNNING)
 492                 return UCODE_NFOUND;
 493
 494         ustate = microcode_ops->request_microcode_fw(cpu, &microcode_pdev->dev,
 495                                                      refresh_fw);
 496
 497         if (ustate == UCODE_OK) {
 498                 pr_debug("CPU%d updated upon init\n", cpu);
 499                 apply_microcode_on_target(cpu);
 500         }
 501
 502         return ustate;
 503 }
 504
 505 static enum ucode_state microcode_update_cpu(int cpu)
 506 {
 507         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
 508
 509         if (uci->valid)
 510                 return microcode_resume_cpu(cpu);
 511
 512         return microcode_init_cpu(cpu, false);
 513 }
 514
 515 static int mc_device_add(struct device *dev, struct subsys_interface *sif)
 516 {
 517         int err, cpu = dev->id;
 518
 519         if (!cpu_online(cpu))
 520                 return 0;
 521
 522         pr_debug("CPU%d added\n", cpu);
 523
 524         err = sysfs_create_group(&dev->kobj, &mc_attr_group);
 525         if (err)
 526                 return err;
 527
 528         if (microcode_init_cpu(cpu, true) == UCODE_ERROR)
 529                 return -EINVAL;
 530
 531         return err;
 532 }
 533
 534 static void mc_device_remove(struct device *dev, struct subsys_interface *sif)
 535 {
 536         int cpu = dev->id;
 537
 538         if (!cpu_online(cpu))
 539                 return;
 540
 541         pr_debug("CPU%d removed\n", cpu);
 542         microcode_fini_cpu(cpu);
 543         sysfs_remove_group(&dev->kobj, &mc_attr_group);
 544 }
 545
 546 static struct subsys_interface mc_cpu_interface = {
 547         .name                   = "microcode",
 548         .subsys                 = &cpu_subsys,
 549         .add_dev                = mc_device_add,
 550         .remove_dev             = mc_device_remove,
 551 };
 552
 553 /**
 554  * mc_bp_resume - Update boot CPU microcode during resume.
 555  */
 556 static void mc_bp_resume(void)
 557 {
 558         int cpu = smp_processor_id();
 559         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
 560
 561         if (uci->valid && uci->mc)
 562                 microcode_ops->apply_microcode(cpu);
 563         else if (!uci->mc)
 564                 reload_early_microcode();
 565 }
 566
 567 static struct syscore_ops mc_syscore_ops = {
 568         .resume                 = mc_bp_resume,
 569 };
 570
 571 static int
 572 mc_cpu_callback(struct notifier_block *nb, unsigned long action, void *hcpu)
 573 {
 574         unsigned int cpu = (unsigned long)hcpu;
 575         struct device *dev;
 576
 577         dev = get_cpu_device(cpu);
 578
 579         switch (action & ~CPU_TASKS_FROZEN) {
 580         case CPU_ONLINE:
 581                 microcode_update_cpu(cpu);
 582                 pr_debug("CPU%d added\n", cpu);
 583                 /*
 584                  * "break" is missing on purpose here because we want to fall
 585                  * through in order to create the sysfs group.
 586                  */
 587
 588         case CPU_DOWN_FAILED:
 589                 if (sysfs_create_group(&dev->kobj, &mc_attr_group))
 590                         pr_err("Failed to create group for CPU%d\n", cpu);
 591                 break;
 592
 593         case CPU_DOWN_PREPARE:
 594                 /* Suspend is in progress, only remove the interface */
 595                 sysfs_remove_group(&dev->kobj, &mc_attr_group);
 596                 pr_debug("CPU%d removed\n", cpu);
 597                 break;
 598
 599         /*
 600          * case CPU_DEAD:
 601          *
 602          * When a CPU goes offline, don't free up or invalidate the copy of
 603          * the microcode in kernel memory, so that we can reuse it when the
 604          * CPU comes back online without unnecessarily requesting the userspace
 605          * for it again.
 606          */
 607         }
 608
 609         /* The CPU refused to come up during a system resume */
 610         if (action == CPU_UP_CANCELED_FROZEN)
 611                 microcode_fini_cpu(cpu);
 612
 613         return NOTIFY_OK;
 614 }
 615
 616 static struct notifier_block mc_cpu_notifier = {
 617         .notifier_call  = mc_cpu_callback,
 618 };
 619
 620 #ifdef MODULE
 621 /* Autoload on Intel and AMD systems */
 622 static const struct x86_cpu_id __initconst microcode_id[] = {
 623 #ifdef CONFIG_MICROCODE_INTEL
 624         { X86_VENDOR_INTEL, X86_FAMILY_ANY, X86_MODEL_ANY, },
 625 #endif
 626 #ifdef CONFIG_MICROCODE_AMD
 627         { X86_VENDOR_AMD, X86_FAMILY_ANY, X86_MODEL_ANY, },
 628 #endif
 629         {}
 630 };
 631 MODULE_DEVICE_TABLE(x86cpu, microcode_id);
 632 #endif
 633
 634 static struct attribute *cpu_root_microcode_attrs[] = {
 635         &dev_attr_reload.attr,
 636         NULL
 637 };
 638
 639 static struct attribute_group cpu_root_microcode_group = {
 640         .name  = "microcode",
 641         .attrs = cpu_root_microcode_attrs,
 642 };
 643
 644 int __init microcode_init(void)
 645 {
 646         struct cpuinfo_x86 *c = &boot_cpu_data;
 647         int error;
 648
 649         if (paravirt_enabled() || dis_ucode_ldr)
 650                 return -EINVAL;
 651
 652         if (c->x86_vendor == X86_VENDOR_INTEL)
 653                 microcode_ops = init_intel_microcode();
 654         else if (c->x86_vendor == X86_VENDOR_AMD)
 655                 microcode_ops = init_amd_microcode();
 656         else
 657                 pr_err("no support for this CPU vendor\n");
 658
 659         if (!microcode_ops)
 660                 return -ENODEV;
 661
 662         microcode_pdev = platform_device_register_simple("microcode", -1,
 663                                                          NULL, 0);
 664         if (IS_ERR(microcode_pdev))
 665                 return PTR_ERR(microcode_pdev);
 666
 667         get_online_cpus();
 668         mutex_lock(&microcode_mutex);
 669
 670         error = subsys_interface_register(&mc_cpu_interface);
 671         if (!error)
 672                 perf_check_microcode();
 673         mutex_unlock(&microcode_mutex);
 674         put_online_cpus();
 675
 676         if (error)
 677                 goto out_pdev;
 678
 679         error = sysfs_create_group(&cpu_subsys.dev_root->kobj,
 680                                    &cpu_root_microcode_group);
 681
 682         if (error) {
 683                 pr_err("Error creating microcode group!\n");
 684                 goto out_driver;
 685         }
 686
 687         error = microcode_dev_init();
 688         if (error)
 689                 goto out_ucode_group;
 690
 691         register_syscore_ops(&mc_syscore_ops);
 692         register_hotcpu_notifier(&mc_cpu_notifier);
 693
 694         pr_info("Microcode Update Driver: v" MICROCODE_VERSION
 695                 " <tigran@aivazian.fsnet.co.uk>, Peter Oruba\n");
 696
 697         return 0;
 698
 699  out_ucode_group:
 700         sysfs_remove_group(&cpu_subsys.dev_root->kobj,
 701                            &cpu_root_microcode_group);
 702
 703  out_driver:
 704         get_online_cpus();
 705         mutex_lock(&microcode_mutex);
 706
 707         subsys_interface_unregister(&mc_cpu_interface);
 708
 709         mutex_unlock(&microcode_mutex);
 710         put_online_cpus();
 711
 712  out_pdev:
 713         platform_device_unregister(microcode_pdev);
 714         return error;
 715
 716 }