x86/microcode/intel: Remove intel_lib.c

Its functions are used in intel.c only now, so get rid of it. Make
functions static.

No functionality change.

Signed-off-by: Borislav Petkov <bp@suse.de>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Josh Poimboeuf <jpoimboe@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20161025095522.11964-11-bp@alien8.de
Signed-off-by: Ingo Molnar <mingo@kernel.org>

1 files changed, 153 insertions, 1 deletions

diff --git a/arch/x86/kernel/cpu/microcode/intel.c b/arch/x86/kernel/cpu/microcode/intel.c
index b84288e08098..5e631d2cf37f 100644
--- a/arch/x86/kernel/cpu/microcode/intel.c
+++ b/arch/x86/kernel/cpu/microcode/intel.c
@@ -61,6 +61,61 @@ static struct ucode_blobs {
         bool valid;
 } blobs;
 
+static inline bool cpu_signatures_match(unsigned int s1, unsigned int p1,
+                                        unsigned int s2, unsigned int p2)
+{
+        if (s1 != s2)
+                return false;
+
+        /* Processor flags are either both 0 ... */
+        if (!p1 && !p2)
+                return true;
+
+        /* ... or they intersect. */
+        return p1 & p2;
+}
+
+/*
+ * Returns 1 if update has been found, 0 otherwise.
+ */
+static int find_matching_signature(void *mc, unsigned int csig, int cpf)
+{
+        struct microcode_header_intel *mc_hdr = mc;
+        struct extended_sigtable *ext_hdr;
+        struct extended_signature *ext_sig;
+        int i;
+
+        if (cpu_signatures_match(csig, cpf, mc_hdr->sig, mc_hdr->pf))
+                return 1;
+
+        /* Look for ext. headers: */
+        if (get_totalsize(mc_hdr) <= get_datasize(mc_hdr) + MC_HEADER_SIZE)
+                return 0;
+
+        ext_hdr = mc + get_datasize(mc_hdr) + MC_HEADER_SIZE;
+        ext_sig = (void *)ext_hdr + EXT_HEADER_SIZE;
+
+        for (i = 0; i < ext_hdr->count; i++) {
+                if (cpu_signatures_match(csig, cpf, ext_sig->sig, ext_sig->pf))
+                        return 1;
+                ext_sig++;
+        }
+        return 0;
+}
+
+/*
+ * Returns 1 if update has been found, 0 otherwise.
+ */
+static int has_newer_microcode(void *mc, unsigned int csig, int cpf, int new_rev)
+{
+        struct microcode_header_intel *mc_hdr = mc;
+
+        if (mc_hdr->rev <= new_rev)
+                return 0;
+
+        return find_matching_signature(mc, csig, cpf);
+}
+
 /* Go through saved patches and find the one suitable for the current CPU. */
 static enum ucode_state
 find_microcode_patch(struct microcode_intel **saved,
@@ -291,6 +346,104 @@ static unsigned int _save_mc(struct microcode_intel **mc_saved,
         return num_saved;
 }
 
+static int microcode_sanity_check(void *mc, int print_err)
+{
+        unsigned long total_size, data_size, ext_table_size;
+        struct microcode_header_intel *mc_header = mc;
+        struct extended_sigtable *ext_header = NULL;
+        u32 sum, orig_sum, ext_sigcount = 0, i;
+        struct extended_signature *ext_sig;
+
+        total_size = get_totalsize(mc_header);
+        data_size = get_datasize(mc_header);
+
+        if (data_size + MC_HEADER_SIZE > total_size) {
+                if (print_err)
+                        pr_err("Error: bad microcode data file size.\n");
+                return -EINVAL;
+        }
+
+        if (mc_header->ldrver != 1 || mc_header->hdrver != 1) {
+                if (print_err)
+                        pr_err("Error: invalid/unknown microcode update format.\n");
+                return -EINVAL;
+        }
+
+        ext_table_size = total_size - (MC_HEADER_SIZE + data_size);
+        if (ext_table_size) {
+                u32 ext_table_sum = 0;
+                u32 *ext_tablep;
+
+                if ((ext_table_size < EXT_HEADER_SIZE)
+                 || ((ext_table_size - EXT_HEADER_SIZE) % EXT_SIGNATURE_SIZE)) {
+                        if (print_err)
+                                pr_err("Error: truncated extended signature table.\n");
+                        return -EINVAL;
+                }
+
+                ext_header = mc + MC_HEADER_SIZE + data_size;
+                if (ext_table_size != exttable_size(ext_header)) {
+                        if (print_err)
+                                pr_err("Error: extended signature table size mismatch.\n");
+                        return -EFAULT;
+                }
+
+                ext_sigcount = ext_header->count;
+
+                /*
+                 * Check extended table checksum: the sum of all dwords that
+                 * comprise a valid table must be 0.
+                 */
+                ext_tablep = (u32 *)ext_header;
+
+                i = ext_table_size / sizeof(u32);
+                while (i--)
+                        ext_table_sum += ext_tablep[i];
+
+                if (ext_table_sum) {
+                        if (print_err)
+                                pr_warn("Bad extended signature table checksum, aborting.\n");
+                        return -EINVAL;
+                }
+        }
+
+        /*
+         * Calculate the checksum of update data and header. The checksum of
+         * valid update data and header including the extended signature table
+         * must be 0.
+         */
+        orig_sum = 0;
+        i = (MC_HEADER_SIZE + data_size) / sizeof(u32);
+        while (i--)
+                orig_sum += ((u32 *)mc)[i];
+
+        if (orig_sum) {
+                if (print_err)
+                        pr_err("Bad microcode data checksum, aborting.\n");
+                return -EINVAL;
+        }
+
+        if (!ext_table_size)
+                return 0;
+
+        /*
+         * Check extended signature checksum: 0 => valid.
+         */
+        for (i = 0; i < ext_sigcount; i++) {
+                ext_sig = (void *)ext_header + EXT_HEADER_SIZE +
+                          EXT_SIGNATURE_SIZE * i;
+
+                sum = (mc_header->sig + mc_header->pf + mc_header->cksum) -
+                      (ext_sig->sig + ext_sig->pf + ext_sig->cksum);
+                if (sum) {
+                        if (print_err)
+                                pr_err("Bad extended signature checksum, aborting.\n");
+                        return -EINVAL;
+                }
+        }
+        return 0;
+}
+
 /*
  * Get microcode matching with BSP's model. Only CPUs with the same model as
  * BSP can stay in the platform.
@@ -1105,4 +1258,3 @@ struct microcode_ops * __init init_intel_microcode(void)
 
         return &microcode_intel_ops;
 }
-