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

TOMOYO Linux Cross Reference
Linux/arch/x86/kernel/cpu/microcode/core.c

Version: ~ [ linux-5.13-rc7 ] ~ [ linux-5.12.12 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.45 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.127 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.195 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.237 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.273 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.273 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * CPU Microcode Update Driver for Linux
  3  *
  4  * Copyright (C) 2000-2006 Tigran Aivazian <aivazian.tigran@gmail.com>
  5  *            2006      Shaohua Li <shaohua.li@intel.com>
  6  *            2013-2016 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) "microcode: " fmt
 23 
 24 #include <linux/platform_device.h>
 25 #include <linux/stop_machine.h>
 26 #include <linux/syscore_ops.h>
 27 #include <linux/miscdevice.h>
 28 #include <linux/capability.h>
 29 #include <linux/firmware.h>
 30 #include <linux/kernel.h>
 31 #include <linux/delay.h>
 32 #include <linux/mutex.h>
 33 #include <linux/cpu.h>
 34 #include <linux/nmi.h>
 35 #include <linux/fs.h>
 36 #include <linux/mm.h>
 37 
 38 #include <asm/microcode_intel.h>
 39 #include <asm/cpu_device_id.h>
 40 #include <asm/microcode_amd.h>
 41 #include <asm/perf_event.h>
 42 #include <asm/microcode.h>
 43 #include <asm/processor.h>
 44 #include <asm/cmdline.h>
 45 #include <asm/setup.h>
 46 
 47 #define DRIVER_VERSION  "2.2"
 48 
 49 static struct microcode_ops     *microcode_ops;
 50 static bool dis_ucode_ldr = true;
 51 
 52 bool initrd_gone;
 53 
 54 LIST_HEAD(microcode_cache);
 55 
 56 /*
 57  * Synchronization.
 58  *
 59  * All non cpu-hotplug-callback call sites use:
 60  *
 61  * - microcode_mutex to synchronize with each other;
 62  * - get/put_online_cpus() to synchronize with
 63  *   the cpu-hotplug-callback call sites.
 64  *
 65  * We guarantee that only a single cpu is being
 66  * updated at any particular moment of time.
 67  */
 68 static DEFINE_MUTEX(microcode_mutex);
 69 
 70 /*
 71  * Serialize late loading so that CPUs get updated one-by-one.
 72  */
 73 static DEFINE_RAW_SPINLOCK(update_lock);
 74 
 75 struct ucode_cpu_info           ucode_cpu_info[NR_CPUS];
 76 
 77 struct cpu_info_ctx {
 78         struct cpu_signature    *cpu_sig;
 79         int                     err;
 80 };
 81 
 82 /*
 83  * Those patch levels cannot be updated to newer ones and thus should be final.
 84  */
 85 static u32 final_levels[] = {
 86         0x01000098,
 87         0x0100009f,
 88         0x010000af,
 89         0, /* T-101 terminator */
 90 };
 91 
 92 /*
 93  * Check the current patch level on this CPU.
 94  *
 95  * Returns:
 96  *  - true: if update should stop
 97  *  - false: otherwise
 98  */
 99 static bool amd_check_current_patch_level(void)
100 {
101         u32 lvl, dummy, i;
102         u32 *levels;
103 
104         native_rdmsr(MSR_AMD64_PATCH_LEVEL, lvl, dummy);
105 
106         if (IS_ENABLED(CONFIG_X86_32))
107                 levels = (u32 *)__pa_nodebug(&final_levels);
108         else
109                 levels = final_levels;
110 
111         for (i = 0; levels[i]; i++) {
112                 if (lvl == levels[i])
113                         return true;
114         }
115         return false;
116 }
117 
118 static bool __init check_loader_disabled_bsp(void)
119 {
120         static const char *__dis_opt_str = "dis_ucode_ldr";
121 
122 #ifdef CONFIG_X86_32
123         const char *cmdline = (const char *)__pa_nodebug(boot_command_line);
124         const char *option  = (const char *)__pa_nodebug(__dis_opt_str);
125         bool *res = (bool *)__pa_nodebug(&dis_ucode_ldr);
126 
127 #else /* CONFIG_X86_64 */
128         const char *cmdline = boot_command_line;
129         const char *option  = __dis_opt_str;
130         bool *res = &dis_ucode_ldr;
131 #endif
132 
133         /*
134          * CPUID(1).ECX[31]: reserved for hypervisor use. This is still not
135          * completely accurate as xen pv guests don't see that CPUID bit set but
136          * that's good enough as they don't land on the BSP path anyway.
137          */
138         if (native_cpuid_ecx(1) & BIT(31))
139                 return *res;
140 
141         if (x86_cpuid_vendor() == X86_VENDOR_AMD) {
142                 if (amd_check_current_patch_level())
143                         return *res;
144         }
145 
146         if (cmdline_find_option_bool(cmdline, option) <= 0)
147                 *res = false;
148 
149         return *res;
150 }
151 
152 extern struct builtin_fw __start_builtin_fw[];
153 extern struct builtin_fw __end_builtin_fw[];
154 
155 bool get_builtin_firmware(struct cpio_data *cd, const char *name)
156 {
157 #ifdef CONFIG_FW_LOADER
158         struct builtin_fw *b_fw;
159 
160         for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++) {
161                 if (!strcmp(name, b_fw->name)) {
162                         cd->size = b_fw->size;
163                         cd->data = b_fw->data;
164                         return true;
165                 }
166         }
167 #endif
168         return false;
169 }
170 
171 void __init load_ucode_bsp(void)
172 {
173         unsigned int cpuid_1_eax;
174         bool intel = true;
175 
176         if (!have_cpuid_p())
177                 return;
178 
179         cpuid_1_eax = native_cpuid_eax(1);
180 
181         switch (x86_cpuid_vendor()) {
182         case X86_VENDOR_INTEL:
183                 if (x86_family(cpuid_1_eax) < 6)
184                         return;
185                 break;
186 
187         case X86_VENDOR_AMD:
188                 if (x86_family(cpuid_1_eax) < 0x10)
189                         return;
190                 intel = false;
191                 break;
192 
193         default:
194                 return;
195         }
196 
197         if (check_loader_disabled_bsp())
198                 return;
199 
200         if (intel)
201                 load_ucode_intel_bsp();
202         else
203                 load_ucode_amd_bsp(cpuid_1_eax);
204 }
205 
206 static bool check_loader_disabled_ap(void)
207 {
208 #ifdef CONFIG_X86_32
209         return *((bool *)__pa_nodebug(&dis_ucode_ldr));
210 #else
211         return dis_ucode_ldr;
212 #endif
213 }
214 
215 void load_ucode_ap(void)
216 {
217         unsigned int cpuid_1_eax;
218 
219         if (check_loader_disabled_ap())
220                 return;
221 
222         cpuid_1_eax = native_cpuid_eax(1);
223 
224         switch (x86_cpuid_vendor()) {
225         case X86_VENDOR_INTEL:
226                 if (x86_family(cpuid_1_eax) >= 6)
227                         load_ucode_intel_ap();
228                 break;
229         case X86_VENDOR_AMD:
230                 if (x86_family(cpuid_1_eax) >= 0x10)
231                         load_ucode_amd_ap(cpuid_1_eax);
232                 break;
233         default:
234                 break;
235         }
236 }
237 
238 static int __init save_microcode_in_initrd(void)
239 {
240         struct cpuinfo_x86 *c = &boot_cpu_data;
241         int ret = -EINVAL;
242 
243         switch (c->x86_vendor) {
244         case X86_VENDOR_INTEL:
245                 if (c->x86 >= 6)
246                         ret = save_microcode_in_initrd_intel();
247                 break;
248         case X86_VENDOR_AMD:
249                 if (c->x86 >= 0x10)
250                         ret = save_microcode_in_initrd_amd(cpuid_eax(1));
251                 break;
252         default:
253                 break;
254         }
255 
256         initrd_gone = true;
257 
258         return ret;
259 }
260 
261 struct cpio_data find_microcode_in_initrd(const char *path, bool use_pa)
262 {
263 #ifdef CONFIG_BLK_DEV_INITRD
264         unsigned long start = 0;
265         size_t size;
266 
267 #ifdef CONFIG_X86_32
268         struct boot_params *params;
269 
270         if (use_pa)
271                 params = (struct boot_params *)__pa_nodebug(&boot_params);
272         else
273                 params = &boot_params;
274 
275         size = params->hdr.ramdisk_size;
276 
277         /*
278          * Set start only if we have an initrd image. We cannot use initrd_start
279          * because it is not set that early yet.
280          */
281         if (size)
282                 start = params->hdr.ramdisk_image;
283 
284 # else /* CONFIG_X86_64 */
285         size  = (unsigned long)boot_params.ext_ramdisk_size << 32;
286         size |= boot_params.hdr.ramdisk_size;
287 
288         if (size) {
289                 start  = (unsigned long)boot_params.ext_ramdisk_image << 32;
290                 start |= boot_params.hdr.ramdisk_image;
291 
292                 start += PAGE_OFFSET;
293         }
294 # endif
295 
296         /*
297          * Fixup the start address: after reserve_initrd() runs, initrd_start
298          * has the virtual address of the beginning of the initrd. It also
299          * possibly relocates the ramdisk. In either case, initrd_start contains
300          * the updated address so use that instead.
301          *
302          * initrd_gone is for the hotplug case where we've thrown out initrd
303          * already.
304          */
305         if (!use_pa) {
306                 if (initrd_gone)
307                         return (struct cpio_data){ NULL, 0, "" };
308                 if (initrd_start)
309                         start = initrd_start;
310         } else {
311                 /*
312                  * The picture with physical addresses is a bit different: we
313                  * need to get the *physical* address to which the ramdisk was
314                  * relocated, i.e., relocated_ramdisk (not initrd_start) and
315                  * since we're running from physical addresses, we need to access
316                  * relocated_ramdisk through its *physical* address too.
317                  */
318                 u64 *rr = (u64 *)__pa_nodebug(&relocated_ramdisk);
319                 if (*rr)
320                         start = *rr;
321         }
322 
323         return find_cpio_data(path, (void *)start, size, NULL);
324 #else /* !CONFIG_BLK_DEV_INITRD */
325         return (struct cpio_data){ NULL, 0, "" };
326 #endif
327 }
328 
329 void reload_early_microcode(void)
330 {
331         int vendor, family;
332 
333         vendor = x86_cpuid_vendor();
334         family = x86_cpuid_family();
335 
336         switch (vendor) {
337         case X86_VENDOR_INTEL:
338                 if (family >= 6)
339                         reload_ucode_intel();
340                 break;
341         case X86_VENDOR_AMD:
342                 if (family >= 0x10)
343                         reload_ucode_amd();
344                 break;
345         default:
346                 break;
347         }
348 }
349 
350 static void collect_cpu_info_local(void *arg)
351 {
352         struct cpu_info_ctx *ctx = arg;
353 
354         ctx->err = microcode_ops->collect_cpu_info(smp_processor_id(),
355                                                    ctx->cpu_sig);
356 }
357 
358 static int collect_cpu_info_on_target(int cpu, struct cpu_signature *cpu_sig)
359 {
360         struct cpu_info_ctx ctx = { .cpu_sig = cpu_sig, .err = 0 };
361         int ret;
362 
363         ret = smp_call_function_single(cpu, collect_cpu_info_local, &ctx, 1);
364         if (!ret)
365                 ret = ctx.err;
366 
367         return ret;
368 }
369 
370 static int collect_cpu_info(int cpu)
371 {
372         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
373         int ret;
374 
375         memset(uci, 0, sizeof(*uci));
376 
377         ret = collect_cpu_info_on_target(cpu, &uci->cpu_sig);
378         if (!ret)
379                 uci->valid = 1;
380 
381         return ret;
382 }
383 
384 static void apply_microcode_local(void *arg)
385 {
386         enum ucode_state *err = arg;
387 
388         *err = microcode_ops->apply_microcode(smp_processor_id());
389 }
390 
391 static int apply_microcode_on_target(int cpu)
392 {
393         enum ucode_state err;
394         int ret;
395 
396         ret = smp_call_function_single(cpu, apply_microcode_local, &err, 1);
397         if (!ret) {
398                 if (err == UCODE_ERROR)
399                         ret = 1;
400         }
401         return ret;
402 }
403 
404 #ifdef CONFIG_MICROCODE_OLD_INTERFACE
405 static int do_microcode_update(const void __user *buf, size_t size)
406 {
407         int error = 0;
408         int cpu;
409 
410         for_each_online_cpu(cpu) {
411                 struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
412                 enum ucode_state ustate;
413 
414                 if (!uci->valid)
415                         continue;
416 
417                 ustate = microcode_ops->request_microcode_user(cpu, buf, size);
418                 if (ustate == UCODE_ERROR) {
419                         error = -1;
420                         break;
421                 } else if (ustate == UCODE_OK)
422                         apply_microcode_on_target(cpu);
423         }
424 
425         return error;
426 }
427 
428 static int microcode_open(struct inode *inode, struct file *file)
429 {
430         return capable(CAP_SYS_RAWIO) ? nonseekable_open(inode, file) : -EPERM;
431 }
432 
433 static ssize_t microcode_write(struct file *file, const char __user *buf,
434                                size_t len, loff_t *ppos)
435 {
436         ssize_t ret = -EINVAL;
437 
438         if ((len >> PAGE_SHIFT) > totalram_pages) {
439                 pr_err("too much data (max %ld pages)\n", totalram_pages);
440                 return ret;
441         }
442 
443         get_online_cpus();
444         mutex_lock(&microcode_mutex);
445 
446         if (do_microcode_update(buf, len) == 0)
447                 ret = (ssize_t)len;
448 
449         if (ret > 0)
450                 perf_check_microcode();
451 
452         mutex_unlock(&microcode_mutex);
453         put_online_cpus();
454 
455         return ret;
456 }
457 
458 static const struct file_operations microcode_fops = {
459         .owner                  = THIS_MODULE,
460         .write                  = microcode_write,
461         .open                   = microcode_open,
462         .llseek         = no_llseek,
463 };
464 
465 static struct miscdevice microcode_dev = {
466         .minor                  = MICROCODE_MINOR,
467         .name                   = "microcode",
468         .nodename               = "cpu/microcode",
469         .fops                   = &microcode_fops,
470 };
471 
472 static int __init microcode_dev_init(void)
473 {
474         int error;
475 
476         error = misc_register(&microcode_dev);
477         if (error) {
478                 pr_err("can't misc_register on minor=%d\n", MICROCODE_MINOR);
479                 return error;
480         }
481 
482         return 0;
483 }
484 
485 static void __exit microcode_dev_exit(void)
486 {
487         misc_deregister(&microcode_dev);
488 }
489 #else
490 #define microcode_dev_init()    0
491 #define microcode_dev_exit()    do { } while (0)
492 #endif
493 
494 /* fake device for request_firmware */
495 static struct platform_device   *microcode_pdev;
496 
497 /*
498  * Late loading dance. Why the heavy-handed stomp_machine effort?
499  *
500  * - HT siblings must be idle and not execute other code while the other sibling
501  *   is loading microcode in order to avoid any negative interactions caused by
502  *   the loading.
503  *
504  * - In addition, microcode update on the cores must be serialized until this
505  *   requirement can be relaxed in the future. Right now, this is conservative
506  *   and good.
507  */
508 #define SPINUNIT 100 /* 100 nsec */
509 
510 static int check_online_cpus(void)
511 {
512         unsigned int cpu;
513 
514         /*
515          * Make sure all CPUs are online.  It's fine for SMT to be disabled if
516          * all the primary threads are still online.
517          */
518         for_each_present_cpu(cpu) {
519                 if (topology_is_primary_thread(cpu) && !cpu_online(cpu)) {
520                         pr_err("Not all CPUs online, aborting microcode update.\n");
521                         return -EINVAL;
522                 }
523         }
524 
525         return 0;
526 }
527 
528 static atomic_t late_cpus_in;
529 static atomic_t late_cpus_out;
530 
531 static int __wait_for_cpus(atomic_t *t, long long timeout)
532 {
533         int all_cpus = num_online_cpus();
534 
535         atomic_inc(t);
536 
537         while (atomic_read(t) < all_cpus) {
538                 if (timeout < SPINUNIT) {
539                         pr_err("Timeout while waiting for CPUs rendezvous, remaining: %d\n",
540                                 all_cpus - atomic_read(t));
541                         return 1;
542                 }
543 
544                 ndelay(SPINUNIT);
545                 timeout -= SPINUNIT;
546 
547                 touch_nmi_watchdog();
548         }
549         return 0;
550 }
551 
552 /*
553  * Returns:
554  * < 0 - on error
555  *   0 - no update done
556  *   1 - microcode was updated
557  */
558 static int __reload_late(void *info)
559 {
560         int cpu = smp_processor_id();
561         enum ucode_state err;
562         int ret = 0;
563 
564         /*
565          * Wait for all CPUs to arrive. A load will not be attempted unless all
566          * CPUs show up.
567          * */
568         if (__wait_for_cpus(&late_cpus_in, NSEC_PER_SEC))
569                 return -1;
570 
571         raw_spin_lock(&update_lock);
572         apply_microcode_local(&err);
573         raw_spin_unlock(&update_lock);
574 
575         /* siblings return UCODE_OK because their engine got updated already */
576         if (err > UCODE_NFOUND) {
577                 pr_warn("Error reloading microcode on CPU %d\n", cpu);
578                 ret = -1;
579         } else if (err == UCODE_UPDATED || err == UCODE_OK) {
580                 ret = 1;
581         }
582 
583         /*
584          * Increase the wait timeout to a safe value here since we're
585          * serializing the microcode update and that could take a while on a
586          * large number of CPUs. And that is fine as the *actual* timeout will
587          * be determined by the last CPU finished updating and thus cut short.
588          */
589         if (__wait_for_cpus(&late_cpus_out, NSEC_PER_SEC * num_online_cpus()))
590                 panic("Timeout during microcode update!\n");
591 
592         return ret;
593 }
594 
595 /*
596  * Reload microcode late on all CPUs. Wait for a sec until they
597  * all gather together.
598  */
599 static int microcode_reload_late(void)
600 {
601         int ret;
602 
603         atomic_set(&late_cpus_in,  0);
604         atomic_set(&late_cpus_out, 0);
605 
606         ret = stop_machine_cpuslocked(__reload_late, NULL, cpu_online_mask);
607         if (ret > 0)
608                 microcode_check();
609 
610         return ret;
611 }
612 
613 static ssize_t reload_store(struct device *dev,
614                             struct device_attribute *attr,
615                             const char *buf, size_t size)
616 {
617         enum ucode_state tmp_ret = UCODE_OK;
618         int bsp = boot_cpu_data.cpu_index;
619         unsigned long val;
620         ssize_t ret = 0;
621 
622         ret = kstrtoul(buf, 0, &val);
623         if (ret)
624                 return ret;
625 
626         if (val != 1)
627                 return size;
628 
629         tmp_ret = microcode_ops->request_microcode_fw(bsp, &microcode_pdev->dev, true);
630         if (tmp_ret != UCODE_NEW)
631                 return size;
632 
633         get_online_cpus();
634 
635         ret = check_online_cpus();
636         if (ret)
637                 goto put;
638 
639         mutex_lock(&microcode_mutex);
640         ret = microcode_reload_late();
641         mutex_unlock(&microcode_mutex);
642 
643 put:
644         put_online_cpus();
645 
646         if (ret >= 0)
647                 ret = size;
648 
649         return ret;
650 }
651 
652 static ssize_t version_show(struct device *dev,
653                         struct device_attribute *attr, char *buf)
654 {
655         struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
656 
657         return sprintf(buf, "0x%x\n", uci->cpu_sig.rev);
658 }
659 
660 static ssize_t pf_show(struct device *dev,
661                         struct device_attribute *attr, char *buf)
662 {
663         struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
664 
665         return sprintf(buf, "0x%x\n", uci->cpu_sig.pf);
666 }
667 
668 static DEVICE_ATTR_WO(reload);
669 static DEVICE_ATTR(version, 0400, version_show, NULL);
670 static DEVICE_ATTR(processor_flags, 0400, pf_show, NULL);
671 
672 static struct attribute *mc_default_attrs[] = {
673         &dev_attr_version.attr,
674         &dev_attr_processor_flags.attr,
675         NULL
676 };
677 
678 static const struct attribute_group mc_attr_group = {
679         .attrs                  = mc_default_attrs,
680         .name                   = "microcode",
681 };
682 
683 static void microcode_fini_cpu(int cpu)
684 {
685         if (microcode_ops->microcode_fini_cpu)
686                 microcode_ops->microcode_fini_cpu(cpu);
687 }
688 
689 static enum ucode_state microcode_resume_cpu(int cpu)
690 {
691         if (apply_microcode_on_target(cpu))
692                 return UCODE_ERROR;
693 
694         pr_debug("CPU%d updated upon resume\n", cpu);
695 
696         return UCODE_OK;
697 }
698 
699 static enum ucode_state microcode_init_cpu(int cpu, bool refresh_fw)
700 {
701         enum ucode_state ustate;
702         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
703 
704         if (uci->valid)
705                 return UCODE_OK;
706 
707         if (collect_cpu_info(cpu))
708                 return UCODE_ERROR;
709 
710         /* --dimm. Trigger a delayed update? */
711         if (system_state != SYSTEM_RUNNING)
712                 return UCODE_NFOUND;
713 
714         ustate = microcode_ops->request_microcode_fw(cpu, &microcode_pdev->dev, refresh_fw);
715         if (ustate == UCODE_NEW) {
716                 pr_debug("CPU%d updated upon init\n", cpu);
717                 apply_microcode_on_target(cpu);
718         }
719 
720         return ustate;
721 }
722 
723 static enum ucode_state microcode_update_cpu(int cpu)
724 {
725         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
726 
727         /* Refresh CPU microcode revision after resume. */
728         collect_cpu_info(cpu);
729 
730         if (uci->valid)
731                 return microcode_resume_cpu(cpu);
732 
733         return microcode_init_cpu(cpu, false);
734 }
735 
736 static int mc_device_add(struct device *dev, struct subsys_interface *sif)
737 {
738         int err, cpu = dev->id;
739 
740         if (!cpu_online(cpu))
741                 return 0;
742 
743         pr_debug("CPU%d added\n", cpu);
744 
745         err = sysfs_create_group(&dev->kobj, &mc_attr_group);
746         if (err)
747                 return err;
748 
749         if (microcode_init_cpu(cpu, true) == UCODE_ERROR)
750                 return -EINVAL;
751 
752         return err;
753 }
754 
755 static void mc_device_remove(struct device *dev, struct subsys_interface *sif)
756 {
757         int cpu = dev->id;
758 
759         if (!cpu_online(cpu))
760                 return;
761 
762         pr_debug("CPU%d removed\n", cpu);
763         microcode_fini_cpu(cpu);
764         sysfs_remove_group(&dev->kobj, &mc_attr_group);
765 }
766 
767 static struct subsys_interface mc_cpu_interface = {
768         .name                   = "microcode",
769         .subsys                 = &cpu_subsys,
770         .add_dev                = mc_device_add,
771         .remove_dev             = mc_device_remove,
772 };
773 
774 /**
775  * mc_bp_resume - Update boot CPU microcode during resume.
776  */
777 static void mc_bp_resume(void)
778 {
779         int cpu = smp_processor_id();
780         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
781 
782         if (uci->valid && uci->mc)
783                 microcode_ops->apply_microcode(cpu);
784         else if (!uci->mc)
785                 reload_early_microcode();
786 }
787 
788 static struct syscore_ops mc_syscore_ops = {
789         .resume                 = mc_bp_resume,
790 };
791 
792 static int mc_cpu_online(unsigned int cpu)
793 {
794         struct device *dev;
795 
796         dev = get_cpu_device(cpu);
797         microcode_update_cpu(cpu);
798         pr_debug("CPU%d added\n", cpu);
799 
800         if (sysfs_create_group(&dev->kobj, &mc_attr_group))
801                 pr_err("Failed to create group for CPU%d\n", cpu);
802         return 0;
803 }
804 
805 static int mc_cpu_down_prep(unsigned int cpu)
806 {
807         struct device *dev;
808 
809         dev = get_cpu_device(cpu);
810         /* Suspend is in progress, only remove the interface */
811         sysfs_remove_group(&dev->kobj, &mc_attr_group);
812         pr_debug("CPU%d removed\n", cpu);
813 
814         return 0;
815 }
816 
817 static struct attribute *cpu_root_microcode_attrs[] = {
818         &dev_attr_reload.attr,
819         NULL
820 };
821 
822 static const struct attribute_group cpu_root_microcode_group = {
823         .name  = "microcode",
824         .attrs = cpu_root_microcode_attrs,
825 };
826 
827 int __init microcode_init(void)
828 {
829         struct cpuinfo_x86 *c = &boot_cpu_data;
830         int error;
831 
832         if (dis_ucode_ldr)
833                 return -EINVAL;
834 
835         if (c->x86_vendor == X86_VENDOR_INTEL)
836                 microcode_ops = init_intel_microcode();
837         else if (c->x86_vendor == X86_VENDOR_AMD)
838                 microcode_ops = init_amd_microcode();
839         else
840                 pr_err("no support for this CPU vendor\n");
841 
842         if (!microcode_ops)
843                 return -ENODEV;
844 
845         microcode_pdev = platform_device_register_simple("microcode", -1,
846                                                          NULL, 0);
847         if (IS_ERR(microcode_pdev))
848                 return PTR_ERR(microcode_pdev);
849 
850         get_online_cpus();
851         mutex_lock(&microcode_mutex);
852 
853         error = subsys_interface_register(&mc_cpu_interface);
854         if (!error)
855                 perf_check_microcode();
856         mutex_unlock(&microcode_mutex);
857         put_online_cpus();
858 
859         if (error)
860                 goto out_pdev;
861 
862         error = sysfs_create_group(&cpu_subsys.dev_root->kobj,
863                                    &cpu_root_microcode_group);
864 
865         if (error) {
866                 pr_err("Error creating microcode group!\n");
867                 goto out_driver;
868         }
869 
870         error = microcode_dev_init();
871         if (error)
872                 goto out_ucode_group;
873 
874         register_syscore_ops(&mc_syscore_ops);
875         cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN, "x86/microcode:online",
876                                   mc_cpu_online, mc_cpu_down_prep);
877 
878         pr_info("Microcode Update Driver: v%s.", DRIVER_VERSION);
879 
880         return 0;
881 
882  out_ucode_group:
883         sysfs_remove_group(&cpu_subsys.dev_root->kobj,
884                            &cpu_root_microcode_group);
885 
886  out_driver:
887         get_online_cpus();
888         mutex_lock(&microcode_mutex);
889 
890         subsys_interface_unregister(&mc_cpu_interface);
891 
892         mutex_unlock(&microcode_mutex);
893         put_online_cpus();
894 
895  out_pdev:
896         platform_device_unregister(microcode_pdev);
897         return error;
898 
899 }
900 fs_initcall(save_microcode_in_initrd);
901 late_initcall(microcode_init);
902 

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

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

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

osdn.jp