ucode.c File Reference

Microcode updates. More...

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <errno.h>
#include <ipxe/uaccess.h>
#include <ipxe/umalloc.h>
#include <ipxe/image.h>
#include <ipxe/cpuid.h>
#include <ipxe/msr.h>
#include <ipxe/mp.h>
#include <ipxe/timer.h>
#include <ipxe/ucode.h>

Go to the source code of this file.

Data Structures
union	ucode_vendor_id
	A CPU vendor string. More...
struct	ucode_vendor
	A CPU vendor. More...
struct	ucode_update
	A microcode update. More...
struct	ucode_summary
	A microcode update summary. More...

Macros
#define	UCODE_MAX_HT   8
	Maximum number of hyperthread siblings. More...
#define	UCODE_WAIT_MS   10
	Time to wait for a microcode update to complete. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static const char *	ucode_vendor_name (const union ucode_vendor_id *vendor)
	Get CPU vendor name (for debugging) More...
static int	ucode_status (struct ucode_update *update, struct ucode_control *control, struct ucode_summary *summary, unsigned int id, int optional)
	Check status report. More...
static int	ucode_update_all (struct image *image, struct ucode_update *update, struct ucode_summary *summary)
	Update microcode on all CPUs. More...
static void	ucode_describe (struct image *image, size_t start, const struct ucode_vendor *vendor, const struct ucode_descriptor *desc, uint32_t platforms, struct ucode_update *update)
	Add descriptor to list (if applicable) More...
static int	ucode_verify (struct image *image, size_t start, size_t len)
	Verify checksum. More...
static int	ucode_parse_intel (struct image *image, size_t start, struct ucode_update *update)
	Parse Intel microcode image. More...
static int	ucode_parse_amd (struct image *image, size_t start, struct ucode_update *update)
	Parse AMD microcode image. More...
static int	ucode_parse (struct image *image, struct ucode_update *update)
	Parse microcode image. More...
static int	ucode_exec (struct image *image)
	Execute microcode update. More...
static int	ucode_probe (struct image *image)
	Probe microcode update image. More...
struct image_type ucode_image_type	__image_type (PROBE_NORMAL)
	Microcode update image type. More...

Variables
static struct ucode_vendor	ucode_intel
	Intel CPU vendor. More...
static struct ucode_vendor	ucode_amd
	AMD CPU vendor. More...
static struct ucode_vendor *	ucode_vendors []
	List of known CPU vendors. More...

Detailed Description

Microcode updates.

Definition in file ucode.c.

Macro Definition Documentation

UCODE_MAX_HT

#define UCODE_MAX_HT   8

Maximum number of hyperthread siblings.

Microcode updates must not be performed on hyperthread siblings at the same time, since they share microcode storage.

Hyperthread siblings are always the lowest level of the CPU topology and correspond to the least significant bits of the APIC ID. We may therefore avoid collisions by performing the microcode updates in batches, with each batch targeting just one value for the least significant N bits of the APIC ID.

We assume that no CPUs exist with more than this number of hyperthread siblings. (This must be a power of two.)

Definition at line 60 of file ucode.c.

UCODE_WAIT_MS

#define UCODE_WAIT_MS   10

Time to wait for a microcode update to complete.

Definition at line 63 of file ucode.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

ucode_vendor_name()

static const char* ucode_vendor_name ( const union ucode_vendor_id *  vendor )

static

Get CPU vendor name (for debugging)

Parameters

vendor

CPU vendor

Return values

name

Name

Definition at line 135 of file ucode.c.

                                                                              {
        static union {
                union ucode_vendor_id vendor;
                char text[ sizeof ( *vendor ) + 1 /* NUL */ ];
        } u;

        /* Construct name */
        memcpy ( &u.vendor, vendor, sizeof ( u.vendor ) );
        u.text[ sizeof ( u.text ) - 1 ] = '\0';
        return u.text;
}

References memcpy(), u, and vendor.

Referenced by ucode_describe(), and ucode_exec().

ucode_status()

static int ucode_status ( struct ucode_update *  update, struct ucode_control *  control, struct ucode_summary *  summary, unsigned int  id, int  optional  )

static

Check status report.

Parameters

update	Microcode update
control	Microcode update control
summary	Microcode update summary
id	APIC ID
optional	Status report is optional

Return values

rc	Return status code

Definition at line 157 of file ucode.c.

                                                          {
        struct ucode_status status;
        struct ucode_descriptor *desc;

        /* Sanity check */
        assert ( id <= control->apic_max );

        /* Read status report */
        copy_from_user ( &status, phys_to_user ( control->status ),
                         ( id * sizeof ( status ) ), sizeof ( status ) );

        /* Ignore empty optional status reports */
        if ( optional && ( ! status.signature ) )
                return 0;
        DBGC ( update, "UCODE %#08x signature %#08x ucode %#08x->%#08x\n",
               id, status.signature, status.before, status.after );

        /* Check CPU signature */
        if ( ! status.signature ) {
                DBGC2 ( update, "UCODE %#08x has no signature\n", id );
                return -ENOENT;
        }

        /* Check APIC ID is correct */
        if ( status.id != id ) {
                DBGC ( update, "UCODE %#08x wrong APIC ID %#08x\n",
                       id, status.id );
                return -EINVAL;
        }

        /* Check that maximum APIC ID was not exceeded */
        if ( control->apic_unexpected ) {
                DBGC ( update, "UCODE %#08x saw unexpected APIC ID %#08x\n",
                       id, control->apic_unexpected );
                return -ERANGE;
        }

        /* Check microcode was not downgraded */
        if ( status.after < status.before ) {
                DBGC ( update, "UCODE %#08x was downgraded %#08x->%#08x\n",
                       id, status.before, status.after );
                return -ENOTTY;
        }

        /* Check that expected updates (if any) were applied */
        for ( desc = update->desc ; desc->signature ; desc++ ) {
                if ( ( desc->signature == status.signature ) &&
                     ( status.after < desc->version ) ) {
                        DBGC ( update, "UCODE %#08x failed update %#08x->%#08x "
                               "(wanted %#08x)\n", id, status.before,
                               status.after, desc->version );
                        return -EIO;
                }
        }

        /* Update summary */
        summary->count++;
        if ( status.before < summary->low )
                summary->low = status.before;
        if ( status.after > summary->high )
                summary->high = status.after;

        return 0;
}

References apic_max, assert(), control, copy_from_user(), ucode_summary::count, DBGC, DBGC2, desc, ucode_update::desc, EINVAL, EIO, ENOENT, ENOTTY, ERANGE, ucode_summary::high, ucode_summary::low, phys_to_user(), and status.

ucode_update_all()

static int ucode_update_all ( struct image *  image, struct ucode_update *  update, struct ucode_summary *  summary  )

static

Update microcode on all CPUs.

Parameters

image	Microcode image
update	Microcode update
summary	Microcode update summary to fill in

Return values

rc	Return status code

Definition at line 233 of file ucode.c.

                                                              {
        struct ucode_control control;
        struct ucode_vendor *vendor;
        userptr_t status;
        unsigned int max;
        unsigned int i;
        size_t len;
        int rc;

        /* Initialise summary */
        summary->count = 0;
        summary->low = UCODE_VERSION_MAX;
        summary->high = UCODE_VERSION_MIN;

        /* Allocate status reports */
        max = mp_max_cpuid();
        len = ( ( max + 1 ) * sizeof ( struct ucode_status ) );
        status = umalloc ( len );
        if ( ! status ) {
                DBGC ( image, "UCODE %s could not allocate %d status reports\n",
                       image->name, ( max + 1 ) );
                rc = -ENOMEM;
                goto err_alloc;
        }
        memset_user ( status, 0, 0, len );

        /* Construct control structure */
        memset ( &control, 0, sizeof ( control ) );
        control.desc = virt_to_phys ( update->desc );
        control.status = user_to_phys ( status, 0 );
        vendor = update->vendor;
        if ( vendor ) {
                control.ver_clear = vendor->ver_clear;
                control.ver_high = vendor->ver_high;
                control.trigger_msr = vendor->trigger_msr;
        } else {
                assert ( update->count == 0 );
        }
        control.apic_max = max;

        /* Update microcode on boot processor */
        mp_exec_boot ( ucode_update, &control );
        if ( ( rc = ucode_status ( update, &control, summary,
                                   mp_boot_cpuid(), 0 ) ) != 0 ) {
                DBGC ( image, "UCODE %s failed on boot processor: %s\n",
                       image->name, strerror ( rc ) );
                goto err_boot;
        }

        /* Update microcode on application processors, avoiding
         * simultaneous updates on hyperthread siblings.
         */
        build_assert ( ( UCODE_MAX_HT & ( UCODE_MAX_HT - 1 ) ) == 0 );
        control.apic_mask = ( UCODE_MAX_HT - 1 );
        for ( ; control.apic_test <= control.apic_mask ; control.apic_test++ ) {
                mp_start_all ( ucode_update, &control );
                mdelay ( UCODE_WAIT_MS );
        }

        /* Check status reports */
        summary->count = 0;
        for ( i = 0 ; i <= max ; i++ ) {
                if ( ( rc = ucode_status ( update, &control, summary,
                                           i, 1 ) ) != 0 ) {
                        goto err_status;
                }
        }

        /* Success */
        rc = 0;

 err_status:
 err_boot:
        ufree ( status );
 err_alloc:
        return rc;
}

References assert(), build_assert, control, ucode_update::count, ucode_summary::count, DBGC, ucode_update::desc, ENOMEM, ucode_summary::high, len, ucode_summary::low, max, mdelay(), memset(), memset_user(), mp_boot_cpuid(), mp_exec_boot(), mp_max_cpuid(), mp_start_all(), image::name, rc, status, strerror(), UCODE_MAX_HT, UCODE_VERSION_MAX, UCODE_VERSION_MIN, UCODE_WAIT_MS, ufree(), umalloc(), user_to_phys(), ucode_update::vendor, vendor, and virt_to_phys().

Referenced by ucode_exec().

ucode_describe()

static void ucode_describe ( struct image *  image, size_t  start, const struct ucode_vendor *  vendor, const struct ucode_descriptor *  desc, uint32_t  platforms, struct ucode_update *  update  )

static

Add descriptor to list (if applicable)

Parameters

image	Microcode image
start	Starting offset within image
vendor	CPU vendor
desc	Microcode descriptor
platforms	Supported platforms, or 0 for all platforms
update	Microcode update

Definition at line 323 of file ucode.c.

                                                                               {

        /* Dump descriptor information */
        DBGC2 ( image, "UCODE %s+%#04zx %s %#08x", image->name, start,
                ucode_vendor_name ( &vendor->id ), desc->signature );
        if ( platforms )
                DBGC2 ( image, " (%#02x)", platforms );
        DBGC2 ( image, " version %#08x\n", desc->version );

        /* Check applicability */
        if ( vendor != update->vendor )
                return;
        if ( ( desc->signature ^ update->signature ) & UCODE_SIGNATURE_MASK )
                return;
        if ( platforms && ( ! ( platforms & update->platform ) ) )
                return;

        /* Add descriptor, if applicable */
        if ( update->desc ) {
                memcpy ( &update->desc[update->count], desc, sizeof ( *desc ) );
                DBGC ( image, "UCODE %s+%#04zx found %s %#08x version %#08x\n",
                       image->name, start, ucode_vendor_name ( &vendor->id ),
                       desc->signature, desc->version );
        }
        update->count++;
}

References ucode_update::count, DBGC, DBGC2, desc, ucode_update::desc, memcpy(), image::name, ucode_update::platform, platforms, ucode_update::signature, start, UCODE_SIGNATURE_MASK, ucode_vendor_name(), ucode_update::vendor, and vendor.

Referenced by ucode_parse_amd(), and ucode_parse_intel().

ucode_verify()

static int ucode_verify ( struct image *  image, size_t  start, size_t  len  )

static

Verify checksum.

Parameters

image	Microcode image
start	Starting offset
len	Length

Return values

rc	Return status code

Definition at line 361 of file ucode.c.

                                                                          {
        uint32_t checksum = 0;
        uint32_t dword;
        size_t offset;

        /* Check length is a multiple of dwords */
        if ( ( len % sizeof ( dword ) ) != 0 ) {
                DBGC ( image, "UCODE %s+%#04zx invalid length %#zx\n",
                       image->name, start, len );
                return -EINVAL;
        }

        /* Calculate checksum */
        for ( offset = start ; len ;
              offset += sizeof ( dword ), len -= sizeof ( dword ) ) {
                copy_from_user ( &dword, image->data, offset,
                                 sizeof ( dword ) );
                checksum += dword;
        }
        if ( checksum != 0 ) {
                DBGC ( image, "UCODE %s+%#04zx bad checksum %#08x\n",
                       image->name, start, checksum );
                return -EINVAL;
        }

        return 0;
}

References checksum, copy_from_user(), image::data, DBGC, EINVAL, len, image::name, offset, and start.

Referenced by ucode_parse_intel().

ucode_parse_intel()

static int ucode_parse_intel ( struct image *  image, size_t  start, struct ucode_update *  update  )

static

Parse Intel microcode image.

Parameters

image	Microcode image
start	Starting offset within image
update	Microcode update

Return values

len	Length consumed, or negative error

Definition at line 397 of file ucode.c.

                                                             {
        struct intel_ucode_header hdr;
        struct intel_ucode_ext_header exthdr;
        struct intel_ucode_ext ext;
        struct ucode_descriptor desc;
        size_t remaining;
        size_t offset;
        size_t data_len;
        size_t len;
        unsigned int i;
        int rc;

        /* Read header */
        remaining = ( image->len - start );
        if ( remaining < sizeof ( hdr ) ) {
                DBGC ( image, "UCODE %s+%#04zx too small for Intel header\n",
                       image->name, start );
                return -ENOEXEC;
        }
        copy_from_user ( &hdr, image->data, start, sizeof ( hdr ) );

        /* Determine lengths */
        data_len = hdr.data_len;
        if ( ! data_len )
                data_len = INTEL_UCODE_DATA_LEN;
        len = hdr.len;
        if ( ! len )
                len = ( sizeof ( hdr ) + data_len );

        /* Verify a selection of fields */
        if ( ( hdr.hver != INTEL_UCODE_HVER ) ||
             ( hdr.lver != INTEL_UCODE_LVER ) ||
             ( len < sizeof ( hdr ) ) ||
             ( len > remaining ) ||
             ( data_len > ( len - sizeof ( hdr ) ) ) ||
             ( ( data_len % sizeof ( uint32_t ) ) != 0 ) ||
             ( ( len % INTEL_UCODE_ALIGN ) != 0 ) ) {
                DBGC2 ( image, "UCODE %s+%#04zx is not an Intel update\n",
                        image->name, start );
                return -EINVAL;
        }
        DBGC2 ( image, "UCODE %s+%#04zx is an Intel update\n",
                image->name, start );

        /* Verify checksum */
        if ( ( rc = ucode_verify ( image, start, len ) ) != 0 )
                return rc;

        /* Populate descriptor */
        desc.signature = hdr.signature;
        desc.version = hdr.version;
        desc.address = user_to_phys ( image->data,
                                      ( start + sizeof ( hdr ) ) );

        /* Add non-extended descriptor, if applicable */
        ucode_describe ( image, start, &ucode_intel, &desc, hdr.platforms,
                         update );

        /* Construct extended descriptors, if applicable */
        offset = ( sizeof ( hdr ) + data_len );
        if ( offset <= ( len - sizeof ( exthdr ) ) ) {

                /* Read extended header */
                copy_from_user ( &exthdr, image->data, ( start + offset ),
                                 sizeof ( exthdr ) );
                offset += sizeof ( exthdr );

                /* Read extended signatures */
                for ( i = 0 ; i < exthdr.count ; i++ ) {

                        /* Read extended signature */
                        if ( offset > ( len - sizeof ( ext ) ) ) {
                                DBGC ( image, "UCODE %s+%#04zx extended "
                                       "signature overrun\n",
                                       image->name, start );
                                return -EINVAL;
                        }
                        copy_from_user ( &ext, image->data, ( start + offset ),
                                         sizeof ( ext ) );
                        offset += sizeof ( ext );

                        /* Avoid duplicating non-extended descriptor */
                        if ( ( ext.signature == hdr.signature ) &&
                             ( ext.platforms == hdr.platforms ) ) {
                                continue;
                        }

                        /* Construct descriptor, if applicable */
                        desc.signature = ext.signature;
                        ucode_describe ( image, start, &ucode_intel, &desc,
                                         ext.platforms, update );
                }
        }

        return len;
}

References copy_from_user(), intel_ucode_ext_header::count, image::data, data_len, DBGC, DBGC2, desc, EINVAL, ENOEXEC, ext, hdr, INTEL_UCODE_ALIGN, INTEL_UCODE_DATA_LEN, INTEL_UCODE_HVER, INTEL_UCODE_LVER, len, image::len, image::name, offset, rc, start, ucode_describe(), ucode_intel, ucode_verify(), and user_to_phys().

Referenced by ucode_parse().

ucode_parse_amd()

static int ucode_parse_amd ( struct image *  image, size_t  start, struct ucode_update *  update  )

static

Parse AMD microcode image.

Parameters

image	Microcode image
start	Starting offset within image
update	Microcode update

Return values

len	Length consumed, or negative error

Definition at line 503 of file ucode.c.

                                                           {
        struct amd_ucode_header hdr;
        struct amd_ucode_equivalence equiv;
        struct amd_ucode_patch_header phdr;
        struct amd_ucode_patch patch;
        struct ucode_descriptor desc;
        size_t remaining;
        size_t offset;
        unsigned int count;
        unsigned int used;
        unsigned int i;

        /* Read header */
        remaining = ( image->len - start );
        if ( remaining < sizeof ( hdr ) ) {
                DBGC ( image, "UCODE %s+%#04zx too small for AMD header\n",
                       image->name, start );
                return -ENOEXEC;
        }
        copy_from_user ( &hdr, image->data, start, sizeof ( hdr ) );

        /* Check header */
        if ( hdr.magic != AMD_UCODE_MAGIC ) {
                DBGC2 ( image, "UCODE %s+%#04zx is not an AMD update\n",
                        image->name, start );
                return -ENOEXEC;
        }
        DBGC2 ( image, "UCODE %s+%#04zx is an AMD update\n",
                image->name, start );
        if ( hdr.type != AMD_UCODE_EQUIV_TYPE ) {
                DBGC ( image, "UCODE %s+%#04zx unsupported equivalence table "
                       "type %d\n", image->name, start, hdr.type );
                return -ENOTSUP;
        }
        if ( hdr.len > ( remaining - sizeof ( hdr ) ) ) {
                DBGC ( image, "UCODE %s+%#04zx truncated equivalence table\n",
                       image->name, start );
                return -EINVAL;
        }

        /* Count number of equivalence table entries */
        offset = sizeof ( hdr );
        for ( count = 0 ; offset < ( sizeof ( hdr ) + hdr.len ) ;
              count++, offset += sizeof ( equiv ) ) {
                copy_from_user ( &equiv, image->data, ( start + offset ),
                                 sizeof ( equiv ) );
                if ( ! equiv.signature )
                        break;
        }
        DBGC2 ( image, "UCODE %s+%#04zx has %d equivalence table entries\n",
                image->name, start, count );

        /* Parse available updates */
        offset = ( sizeof ( hdr ) + hdr.len );
        used = 0;
        while ( used < count ) {

                /* Read patch header */
                if ( ( offset + sizeof ( phdr ) ) > remaining ) {
                        DBGC ( image, "UCODE %s+%#04zx truncated patch "
                               "header\n", image->name, start );
                        return -EINVAL;
                }
                copy_from_user ( &phdr, image->data, ( start + offset ),
                                 sizeof ( phdr ) );
                offset += sizeof ( phdr );

                /* Validate patch header */
                if ( phdr.type != AMD_UCODE_PATCH_TYPE ) {
                        DBGC ( image, "UCODE %s+%#04zx unsupported patch type "
                               "%d\n", image->name, start, phdr.type );
                        return -ENOTSUP;
                }
                if ( phdr.len < sizeof ( patch ) ) {
                        DBGC ( image, "UCODE %s+%#04zx underlength patch\n",
                               image->name, start );
                        return -EINVAL;
                }
                if ( phdr.len > ( remaining - offset ) ) {
                        DBGC ( image, "UCODE %s+%#04zx truncated patch\n",
                               image->name, start );
                        return -EINVAL;
                }

                /* Read patch and construct descriptor */
                copy_from_user ( &patch, image->data, ( start + offset ),
                                 sizeof ( patch ) );
                desc.version = patch.version;
                desc.address = user_to_phys ( image->data, ( start + offset ) );
                offset += phdr.len;

                /* Parse equivalence table to find matching signatures */
                for ( i = 0 ; i < count ; i++ ) {
                        copy_from_user ( &equiv, image->data,
                                         ( start + sizeof ( hdr ) +
                                           ( i * ( sizeof ( equiv ) ) ) ),
                                         sizeof ( equiv ) );
                        if ( patch.id == equiv.id ) {
                                desc.signature = equiv.signature;
                                ucode_describe ( image, start, &ucode_amd,
                                                 &desc, 0, update );
                                used++;
                        }
                }
        }

        return offset;
}

References AMD_UCODE_EQUIV_TYPE, AMD_UCODE_MAGIC, AMD_UCODE_PATCH_TYPE, copy_from_user(), count, image::data, DBGC, DBGC2, desc, EINVAL, ENOEXEC, ENOTSUP, hdr, amd_ucode_equivalence::id, amd_ucode_patch::id, image::len, amd_ucode_patch_header::len, image::name, offset, amd_ucode_equivalence::signature, start, amd_ucode_patch_header::type, ucode_amd, ucode_describe(), user_to_phys(), and amd_ucode_patch::version.

Referenced by ucode_parse().

ucode_parse()

static int ucode_parse ( struct image *  image, struct ucode_update *  update  )

static

Parse microcode image.

Parameters

image	Microcode image
update	Microcode update

Return values

rc	Return status code

Definition at line 620 of file ucode.c.

                                                                            {
        size_t start;
        int len;

        /* Attempt to parse concatenated microcode updates */
        for ( start = 0 ; start < image->len ; start += len ) {

                /* Attempt to parse as Intel microcode */
                len = ucode_parse_intel ( image, start, update );
                if ( len > 0 )
                        continue;

                /* Attempt to parse as AMD microcode */
                len = ucode_parse_amd ( image, start, update );
                if ( len > 0 )
                        continue;

                /* Not a recognised microcode format */
                DBGC ( image, "UCODE %s+%zx not recognised\n",
                       image->name, start );
                return -ENOEXEC;
        }

        return 0;
}

References DBGC, ENOEXEC, len, image::len, image::name, start, ucode_parse_amd(), and ucode_parse_intel().

Referenced by ucode_exec().

ucode_exec()

static int ucode_exec ( struct image *  image )

static

Execute microcode update.

Parameters

image

Microcode image

Return values

rc	Return status code

Definition at line 652 of file ucode.c.

                                              {
        struct ucode_update update;
        struct ucode_vendor *vendor;
        struct ucode_summary summary;
        union ucode_vendor_id id;
        uint64_t platform_id;
        uint32_t discard_a;
        uint32_t discard_b;
        uint32_t discard_c;
        uint32_t discard_d;
        unsigned int check;
        unsigned int i;
        size_t len;
        int rc;

        /* Initialise update */
        memset ( &update, 0, sizeof ( update ) );
        cpuid ( CPUID_VENDOR_ID, 0, &discard_a, &id.dword[0], &id.dword[2],
                &id.dword[1] );
        cpuid ( CPUID_FEATURES, 0, &update.signature, &discard_b,
                &discard_c, &discard_d );

        /* Identify CPU vendor, if recognised */
        for ( i = 0 ; i < ( sizeof ( ucode_vendors ) /
                            sizeof ( ucode_vendors[0] ) ) ; i++ ) {
                vendor = ucode_vendors[i];
                if ( memcmp ( &id, &vendor->id, sizeof ( id ) ) == 0 )
                        update.vendor = vendor;
        }

        /* Identify platform, if applicable */
        if ( update.vendor == &ucode_intel ) {
                platform_id = rdmsr ( MSR_PLATFORM_ID );
                update.platform =
                        ( 1 << MSR_PLATFORM_ID_VALUE ( platform_id ) );
        }

        /* Count number of matching update descriptors */
        DBGC ( image, "UCODE %s applying to %s %#08x",
               image->name, ucode_vendor_name ( &id ), update.signature );
        if ( update.platform )
                DBGC ( image, " (%#02x)", update.platform );
        DBGC ( image, "\n" );
        if ( ( rc = ucode_parse ( image, &update ) ) != 0 )
                goto err_count;
        DBGC ( image, "UCODE %s found %d matching update(s)\n",
               image->name, update.count );

        /* Allocate descriptors */
        len = ( ( update.count + 1 /* terminator */ ) *
                sizeof ( update.desc[0] ) );
        update.desc = zalloc ( len );
        if ( ! update.desc ) {
                rc = -ENOMEM;
                goto err_alloc;
        }

        /* Populate descriptors */
        check = update.count;
        update.count = 0;
        if ( ( rc = ucode_parse ( image, &update ) ) != 0 )
                goto err_parse;
        assert ( check == update.count );

        /* Perform update */
        if ( ( rc = ucode_update_all ( image, &update, &summary ) ) != 0 )
                goto err_update;

        /* Print summary if directed to do so */
        if ( image->cmdline && ( strstr ( image->cmdline, "-v" ) ) ) {
                printf ( "Microcode: " );
                if ( summary.low == summary.high ) {
                        printf ( "already version %#x", summary.low );
                } else {
                        printf ( "updated version %#x->%#x",
                                 summary.low, summary.high );
                }
                printf ( " (x%d)\n", summary.count );
        }

 err_update:
 err_parse:
        free ( update.desc );
 err_alloc:
 err_count:
        return rc;
}

References assert(), image::cmdline, ucode_update::count, ucode_summary::count, CPUID_FEATURES, CPUID_VENDOR_ID, DBGC, ucode_update::desc, discard_c, ENOMEM, free, ucode_summary::high, id, len, ucode_summary::low, memcmp(), memset(), MSR_PLATFORM_ID, MSR_PLATFORM_ID_VALUE, image::name, ucode_update::platform, platform_id, printf(), rc, ucode_update::signature, strstr(), ucode_intel, ucode_parse(), ucode_update_all(), ucode_vendor_name(), ucode_vendors, ucode_update::vendor, vendor, and zalloc().

ucode_probe()

static int ucode_probe ( struct image *  image )

static

Probe microcode update image.

Parameters

image

Microcode image

Return values

rc	Return status code

Definition at line 746 of file ucode.c.

                                               {
        union {
                struct intel_ucode_header intel;
                struct amd_ucode_header amd;
        } header;

        /* Sanity check */
        if ( image->len < sizeof ( header )  ) {
                DBGC ( image, "UCODE %s too short\n", image->name );
                return -ENOEXEC;
        }

        /* Read first microcode image header */
        copy_from_user ( &header, image->data, 0, sizeof ( header ) );

        /* Check for something that looks like an Intel update
         *
         * Intel updates unfortunately have no magic signatures or
         * other easily verifiable fields.  We check a small selection
         * of header fields that can be easily verified.
         *
         * We do not attempt to fully parse the update, since we want
         * errors to be reported at the point of attempting to execute
         * the image, and do not want to have a microcode image
         * erroneously treated as a PXE boot executable.
         */
        if ( ( header.intel.hver == INTEL_UCODE_HVER ) &&
             ( header.intel.lver == INTEL_UCODE_LVER ) &&
             ( ( header.intel.date.century == 0x19 ) ||
               ( ( header.intel.date.century >= 0x20 ) &&
                 ( header.intel.date.century <= 0x29 ) ) ) ) {
                DBGC ( image, "UCODE %s+%#04zx looks like an Intel update\n",
                       image->name, ( ( size_t ) 0 ) );
                return 0;
        }

        /* Check for AMD update signature */
        if ( ( header.amd.magic == AMD_UCODE_MAGIC ) &&
             ( header.amd.type == AMD_UCODE_EQUIV_TYPE ) ) {
                DBGC ( image, "UCODE %s+%#04zx looks like an AMD update\n",
                       image->name, ( ( size_t ) 0 ) );
                return 0;
        }

        return -ENOEXEC;
}

References AMD_UCODE_EQUIV_TYPE, AMD_UCODE_MAGIC, copy_from_user(), image::data, DBGC, ENOEXEC, header, INTEL_UCODE_HVER, INTEL_UCODE_LVER, image::len, and image::name.

__image_type()

struct image_type ucode_image_type __image_type

(

PROBE_NORMAL

)

Microcode update image type.

Variable Documentation

ucode_intel

struct ucode_vendor ucode_intel

static

Initial value:

= {
        .id = { .string = "GenuineIntel" },
        .ver_clear = 1,
        .ver_high = 1,
        .trigger_msr = MSR_UCODE_TRIGGER_INTEL,
}

Intel CPU vendor.

Definition at line 110 of file ucode.c.

Referenced by ucode_exec(), and ucode_parse_intel().

ucode_amd

struct ucode_vendor ucode_amd

static

Initial value:

= {
        .id = { .string = "AuthenticAMD" },
        .trigger_msr = MSR_UCODE_TRIGGER_AMD,
}

AMD CPU vendor.

Definition at line 118 of file ucode.c.

Referenced by ucode_parse_amd().

ucode_vendors

struct ucode_vendor* ucode_vendors[]

static

Initial value:

= {
        &ucode_intel,
        &ucode_amd,
}

List of known CPU vendors.

Definition at line 124 of file ucode.c.

Referenced by ucode_exec().