cmd/ucodeadm/ucodeadm.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright (c) 2018, Joyent, Inc.
 * Copyright 2022 OmniOS Community Edition (OmniOSce) Association.
 * Copyright 2025 Oxide Computer Company
 */

#include <sys/bitext.h>
#include <sys/types.h>
#include <sys/processor.h>
#include <sys/sysmacros.h>
#include <sys/ucode.h>
#include <sys/ucode_intel.h>
#include <sys/ucode_amd.h>
#include <sys/utsname.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
#include <fcntl.h>
#include <errno.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <syslog.h>
#include <time.h>
#include <ctype.h>
#include <assert.h>
#include <libgen.h>
#include <limits.h>
#include <locale.h>
#include <libintl.h>
#include <ucode/ucode_errno.h>
#include <ucode/ucode_utils_intel.h>
#include <ucode/ucode_utils_amd.h>

#define	UCODE_OPT_INSTALL	0x0001
#define	UCODE_OPT_UPDATE	0x0002
#define	UCODE_OPT_VERSION	0x0004
#define	UCODE_OPT_LIST		0x0008

static const char ucode_dev[] = "/dev/" UCODE_DRIVER_NAME;

static char	*cmdname;

#define	UCODE_INSTALL_COMMON_PATH ".f"

/*
 * The maximum directory path length that can be provided via -R has
 * to allow for appending the files within the microcode bundles.
 */
#define	UCODE_MAX_PATH_LEN (PATH_MAX - \
    MAX(UCODE_MAX_NAME_LEN_INTEL, UCODE_MAX_NAME_LEN_AMD) - 1)

static bool ucode_debug = false;

static ucode_errno_t ucode_convert_amd(const char *, uint8_t **, size_t *);
static ucode_errno_t ucode_convert_intel(const char *, uint8_t **, size_t *);

static ucode_errno_t ucode_gen_files_amd(uint8_t *, size_t, const char *);
static ucode_errno_t ucode_gen_files_intel(uint8_t *, size_t, const char *);

static void ucode_list_amd(uint8_t *, size_t);
static void ucode_list_intel(uint8_t *, size_t);

typedef struct ucode_source {
	const char	*us_prefix;
	const char	*us_vendor;
	ucode_errno_t	(*us_convert)(const char *, uint8_t **, size_t *);
	ucode_errno_t	(*us_gen_files)(uint8_t *, size_t, const char *);
	ucode_errno_t	(*us_validate)(uint8_t *, size_t);
	void		(*us_list)(uint8_t *, size_t);
} ucode_source_t;

static const ucode_source_t ucode_sources[] = {
	{
		.us_prefix	= "intel",
		.us_vendor	= "GenuineIntel",
		.us_convert	= ucode_convert_intel,
		.us_gen_files	= ucode_gen_files_intel,
		.us_validate	= ucode_validate_intel,
		.us_list	= ucode_list_intel,
	},
	{
		.us_prefix	= "amd",
		.us_vendor	= "AuthenticAMD",
		.us_convert	= ucode_convert_amd,
		.us_gen_files	= ucode_gen_files_amd,
		.us_validate	= ucode_validate_amd,
		.us_list	= ucode_list_amd,
	}
};

const ucode_source_t *ucode;

static void
dbgprintf(const char *format, ...)
{
	if (ucode_debug) {
		va_list alist;
		va_start(alist, format);
		(void) vfprintf(stderr, format, alist);
		va_end(alist);
	}
}

static void
usage(bool verbose)
{
	(void) fprintf(stderr, gettext("usage:\n"));
	(void) fprintf(stderr, "\t%s -v\n", cmdname);
	if (verbose) {
		(void) fprintf(stderr,
		    gettext("\t\t Shows running microcode version.\n\n"));
	}

	(void) fprintf(stderr, "\t%s -u [-t type] microcode-file\n", cmdname);
	if (verbose) {
		(void) fprintf(stderr, gettext("\t\t Updates microcode to the "
		    "latest matching version found in\n"
		    "\t\t microcode-file.\n\n"));
	}

	(void) fprintf(stderr, "\t%s -l [-t type] microcode-file\n", cmdname);
	if (verbose) {
		(void) fprintf(stderr, gettext("\t\t Displays details of the "
		    "microcode file's contents.\n\n"));
	}

	(void) fprintf(stderr,
	    "\t%s -i [-t type] [-R path] microcode-file\n", cmdname);
	if (verbose) {
		(void) fprintf(stderr, gettext("\t\t Installs microcode to be "
		    "used for subsequent boots.\n"));
	}
	(void) fprintf(stderr, gettext(
	    "\nThe type of the microcode file must either be specified with "
	    "the -t option\nor microcode-file must start with the vendor name "
	    "prefix, either \"intel\"\nor \"amd\", so that the type can be "
	    "inferred from it.\n\n"));
}

static void
ucode_perror(const char *str, ucode_errno_t rc)
{
	(void) fprintf(stderr, "%s: %s: %s\n", cmdname, str,
	    errno == 0 ? ucode_strerror(rc) : strerror(errno));
	errno = 0;
}

static int
bcd_to_int(uint8_t b)
{
	int high = (b >> 4) & 0xf;
	int low = b & 0xf;

	if (high > 9 || low > 9)
		return (-1);
	return (high * 10 + low);
}

/*
 * Extract the family, model and stepping values from a 32-bit CPU signature.
 * These bit fields are defined by the Intel Application Note AP-485
 * "Intel Processor Identification and the CPUID Instruction"
 */
static void
ucode_fms(uint32_t sig, uint8_t *family, uint8_t *model, uint8_t *stepping)
{
	const uint8_t xfamily = bitx32(sig, 27, 20);
	const uint8_t bfamily = bitx32(sig, 11, 8);
	const uint8_t xmodel = bitx32(sig, 19, 16);
	const uint8_t bmodel = bitx32(sig, 7, 4);

	*family = bfamily == 0xf ? bfamily + xfamily : bfamily;
	*model = bfamily == 0x6 || bfamily == 0xf ?
	    (xmodel << 4) | bmodel : bmodel;
	*stepping = bitx32(sig, 3, 0);
}

/*
 * AMD microcode updates use a compressed 16-bit CPU identifier called an
 * Equivalent Processor ID. The compression is achieved by removing the base
 * family field, and assuming it is always 0xf, and reducing the size of the
 * extended family field to 4 bits such that only families up to 0x1e can be
 * represented. The structure is:
 *
 *    [15:12] Extended Family (i.e. family - 0xf)
 *    [11:4]  Model
 *    [3:0]   Stepping
 *
 * This function expands an AMD Equivalent Processor ID to a traditional
 * 32-bit CPU signature.
 */
static uint32_t
amd_equivcpu_to_sig(uint16_t equiv)
{
	uint16_t xfamily, model, stepping;
	uint32_t sig = 0;

	xfamily = bitx16(equiv, 15, 12);
	model = bitx16(equiv, 11, 4);
	stepping = bitx16(equiv, 3, 0);

	sig = bitset32(sig, 27, 20, xfamily);			/* ext family */
	sig = bitset32(sig, 11, 8, 0xf);			/* family */
	sig = bitset32(sig, 19, 16, bitx16(model, 7, 4));	/* ext model */
	sig = bitset32(sig, 7, 4, bitx16(model, 3, 0));		/* model */
	sig = bitset32(sig, 3, 0, stepping);

	return (sig);
}

/*
 * Load a microcode release which is in AMD's binary container format. If the
 * provided file appears to be a raw binary update, cons up a container
 * containing just that patch.
 */
static ucode_errno_t
ucode_convert_amd(const char *infile, uint8_t **bufp, size_t *sizep)
{
	ucode_header_amd_t *patch;
	ucode_section_amd_t *section;
	ucode_eqtbl_amd_t *eq;
	int month, day, yearl, fd;
	size_t csize;
	ssize_t rsize;
	uint8_t *buf = *bufp;
	size_t size = *sizep;

	if (infile == NULL || buf == NULL || size == 0)
		return (EM_INVALIDARG);

	if ((fd = open(infile, O_RDONLY)) < 0)
		return (EM_SYS);

	rsize = read(fd, buf, size);
	if (rsize < 0) {
		int _errno = errno;
		(void) close(fd);
		errno = _errno;
		return (EM_SYS);
	}

	(void) close(fd);

	if (rsize == 0)
		return (EM_FILEFORMAT);

	size = rsize;

	/*
	 * AMD microcode is distributed in two forms. As container/bundle files
	 * or as individual binary patches. If this looks like a container,
	 * we're done.
	 */
	if (ucode->us_validate(buf, size) == EM_OK) {
		*sizep = size;
		return (EM_OK);
	}

	/*
	 * Otherwise, see if this looks like a binary patch. We're limited in
	 * what we can check here but we can look at the date field to see if
	 * it is plausible. That field is encoded as a kind of packed
	 * BCD 0xMMDDYYYY.
	 */
	patch = (ucode_header_amd_t *)*bufp;
	month = bcd_to_int(bitx32(patch->uh_date, 31, 24));
	day = bcd_to_int(bitx32(patch->uh_date, 23, 16));
	yearl = bcd_to_int(bitx32(patch->uh_date, 7, 0));
	if (day < 1 || day > 31 || month < 1 || month > 12 ||
	    yearl < 0 || yearl > 99) {
		dbgprintf("implausible date code: 0x%x\n", patch->uh_date);
		return (EM_FILEFORMAT);
	}

	/* It's plausibly a binary patch; cons up a container */
	dbgprintf("creating microcode container\n");
	csize =
	    sizeof (uint32_t) +			/* Magic */
	    2 * sizeof (ucode_section_amd_t) +	/* TLV headers */
	    2 * sizeof (ucode_eqtbl_amd_t);	/* Equivalence table */
	if (size > SIZE_MAX - csize) {
		dbgprintf("container size too large (patch size %zu)\n", size);
		return (EM_FILEFORMAT);
	}
	csize += size;				/* Patch payload */

	buf = realloc(*bufp, csize);
	if (buf == NULL)
		return (EM_SYS);

	/* Relocate the patch data */
	patch = (ucode_header_amd_t *)(buf + csize - size);
	bcopy(buf, patch, size);

	/* Build the container */
	*(uint32_t *)buf = UCODE_AMD_CONTAINER_MAGIC;

	/* Equivalence table section */
	section = (ucode_section_amd_t *)(buf + sizeof (uint32_t));
	eq = (ucode_eqtbl_amd_t *)section->usa_data;

	section->usa_type = UCODE_AMD_CONTAINER_TYPE_EQUIV;
	section->usa_size = 2 * sizeof (*eq);
	eq->ue_equiv_cpu = patch->uh_cpu_rev;
	eq->ue_inst_cpu = amd_equivcpu_to_sig(patch->uh_cpu_rev);
	/* Create the equivalence table terminator record */
	bzero(eq + 1, sizeof (*eq));

	/* Patch section */
	section =
	    (ucode_section_amd_t *)(section->usa_data + section->usa_size);
	section->usa_type = UCODE_AMD_CONTAINER_TYPE_PATCH;
	section->usa_size = size;

	*bufp = buf;
	*sizep = csize;

	return (EM_OK);
}

/*
 * Convert text format microcode release into binary format.
 */
#define	LINESIZE	120	/* copyright line sometimes is longer than 80 */
static ucode_errno_t
ucode_convert_intel(const char *infile, uint8_t **bufp, size_t *sizep)
{
	char linebuf[LINESIZE];
	FILE *infd = NULL;
	bool firstline = true;
	size_t count = 0;
	uint8_t	*buf = *bufp;
	size_t size = *sizep;
	uint32_t *intbuf = (uint32_t *)(uintptr_t)buf;

	if (infile == NULL || buf == NULL || size == 0)
		return (EM_INVALIDARG);

	if ((infd = fopen(infile, "r")) == NULL)
		return (EM_SYS);

	while (fgets(linebuf, LINESIZE, infd)) {

		/* Check to see if we are processing a binary file */
		if (firstline && !isprint(linebuf[0])) {
			if (fseek(infd, 0, SEEK_SET) == 0)
				count = fread(buf, 1, size, infd);

			(void) fclose(infd);

			if (count == 0)
				return (EM_FILEFORMAT);

			*sizep = count;
			return (EM_OK);
		}

		firstline = false;

		/* Skip blank lines */
		if (strlen(linebuf) == 1)
			continue;

		/* Skip lines with all spaces or tabs */
		if (strcspn(linebuf, " \t") == 0)
			continue;

		/* Text file.  Skip comments. */
		if (linebuf[0] == '/')
			continue;

		if (sscanf(linebuf, "%x, %x, %x, %x",
		    &intbuf[count], &intbuf[count+1],
		    &intbuf[count+2], &intbuf[count+3]) != 4)
			break;

		count += 4;
	}

	(void) fclose(infd);

	/*
	 * If we get here, we are processing a text format file
	 * where "count" is used to count the number of integers
	 * read.  Convert it to number of characters read.
	 */
	*sizep = count * sizeof (int);

	return (EM_OK);
}

/*
 * Returns 0 if no need to update the link; -1 otherwise
 */
static int
ucode_should_update_intel(char *filename, uint32_t new_rev)
{
	int		fd;
	struct stat	statbuf;
	ucode_header_intel_t header;

	/*
	 * If the file or link already exists, check to see if
	 * it is necessary to update it.
	 */
	if (stat(filename, &statbuf) == 0) {
		if ((fd = open(filename, O_RDONLY)) == -1)
			return (-1);

		if (read(fd, &header, sizeof (header)) == -1) {
			(void) close(fd);
			return (-1);
		}

		(void) close(fd);

		if (header.uh_rev >= new_rev)
			return (0);
	}

	return (-1);
}

/*
 * Generate microcode binary files.  Must be called after ucode_validate().
 */
static ucode_errno_t
ucode_gen_files_amd(uint8_t *buf, size_t size, const char *path)
{
	char common_path[PATH_MAX];
	int fd;
	uint16_t last_cpu_rev = 0;
	uint32_t counter = 0;
	int n;

	/* write container file */
	n = snprintf(common_path, sizeof (common_path), "%s/container", path);
	if (n >= sizeof (common_path)) {
		dbgprintf("failed to construct container path\n");
		return (EM_FILEFORMAT);
	}

	dbgprintf("path = %s\n", common_path);
	fd = open(common_path, O_WRONLY | O_CREAT | O_TRUNC,
	    S_IRUSR | S_IRGRP | S_IROTH);

	if (fd == -1) {
		ucode_perror(common_path, EM_SYS);
		return (EM_SYS);
	}

	if (write(fd, buf, size) != size) {
		(void) close(fd);
		ucode_perror(common_path, EM_SYS);
		return (EM_SYS);
	}

	(void) close(fd);

	/* skip over magic number, the file has already been validated */
	buf += sizeof (uint32_t);
	size -= sizeof (uint32_t);

	while (size > sizeof (ucode_section_amd_t)) {
		ucode_section_amd_t *section = (ucode_section_amd_t *)buf;
		int n;

		switch (section->usa_type) {
		case UCODE_AMD_CONTAINER_TYPE_EQUIV:
			n = snprintf(common_path, sizeof (common_path), "%s/%s",
			    path, UCODE_AMD_EQUIVALENCE_TABLE_NAME);
			break;
		case UCODE_AMD_CONTAINER_TYPE_PATCH: {
			ucode_header_amd_t *uh =
			    (ucode_header_amd_t *)section->usa_data;

			if (uh->uh_cpu_rev != last_cpu_rev) {
				last_cpu_rev = uh->uh_cpu_rev;
				counter = 0;
			}

			n = snprintf(common_path, sizeof (common_path),
			    "%s/%04X-%02X", path, uh->uh_cpu_rev, counter++);
			break;
		}
		default:
			/*
			 * Since the container has already been validated, this
			 * should never happen.
			 */
			return (EM_FILEFORMAT);
		}

		if (n >= sizeof (common_path)) {
			dbgprintf("failed to construct component path\n");
			return (EM_FILEFORMAT);
		}

		dbgprintf("path = %s\n", common_path);
		fd = open(common_path, O_WRONLY | O_CREAT | O_TRUNC,
		    S_IRUSR | S_IRGRP | S_IROTH);

		if (fd == -1) {
			ucode_perror(common_path, EM_SYS);
			return (EM_SYS);
		}

		if (write(fd, section->usa_data, section->usa_size) !=
		    section->usa_size) {
			(void) close(fd);
			ucode_perror(common_path, EM_SYS);
			return (EM_SYS);
		}

		(void) close(fd);

		size -= section->usa_size + sizeof (ucode_section_amd_t);
		buf += section->usa_size + sizeof (ucode_section_amd_t);
	}

	return (EM_OK);
}

static ucode_errno_t
ucode_gen_files_intel(uint8_t *buf, size_t size, const char *path)
{
	size_t	remaining;
	char	common_path[PATH_MAX];
	DIR	*dirp;
	struct dirent *dp;
	int n;

	n = snprintf(common_path, sizeof (common_path), "%s/%s", path,
	    UCODE_INSTALL_COMMON_PATH);
	if (n >= sizeof (common_path)) {
		dbgprintf("failed to construct path for %s\n",
		    UCODE_INSTALL_COMMON_PATH);
		return (EM_FILEFORMAT);
	}

	if (mkdirp(common_path, 0755) == -1 && errno != EEXIST) {
		ucode_perror(common_path, EM_SYS);
		return (EM_SYS);
	}

	for (remaining = size; remaining > 0; ) {
		uint32_t	total_size, body_size, offset;
		char		firstname[PATH_MAX];
		char		name[PATH_MAX];
		int		i;
		uint8_t		*curbuf = &buf[size - remaining];
		ucode_header_intel_t	*uhp;
		ucode_ext_table_intel_t *extp;

		uhp = (ucode_header_intel_t *)(uintptr_t)curbuf;

		total_size = UCODE_TOTAL_SIZE_INTEL(uhp->uh_total_size);
		body_size = UCODE_BODY_SIZE_INTEL(uhp->uh_body_size);

		remaining -= total_size;

		n = snprintf(firstname, sizeof (common_path), "%s/%08X-%02X",
		    common_path, uhp->uh_signature, uhp->uh_proc_flags);
		if (n >= sizeof (common_path)) {
			dbgprintf("failed to construct component path\n");
			return (EM_FILEFORMAT);
		}
		dbgprintf("firstname = %s\n", firstname);

		if (ucode_should_update_intel(firstname, uhp->uh_rev) != 0) {
			int fd;

			/* Remove the existing one first */
			(void) unlink(firstname);

			if ((fd = open(firstname, O_WRONLY | O_CREAT | O_TRUNC,
			    S_IRUSR | S_IRGRP | S_IROTH)) == -1) {
				ucode_perror(firstname, EM_SYS);
				return (EM_SYS);
			}

			if (write(fd, curbuf, total_size) != total_size) {
				(void) close(fd);
				ucode_perror(firstname, EM_SYS);
				return (EM_SYS);
			}

			(void) close(fd);
		}

		/*
		 * Only 1 byte of the proc_flags field is used, therefore
		 * we only need to match 8 potential platform ids.
		 */
		for (i = 0; i < 8; i++) {
			uint32_t platid = uhp->uh_proc_flags & (1 << i);

			if (platid == 0 && uhp->uh_proc_flags != 0)
				continue;

			n = snprintf(name, sizeof (common_path),
			    "%s/%08X-%02X", path, uhp->uh_signature, platid);
			if (n >= sizeof (common_path)) {
				dbgprintf("failed to construct platid path\n");
				return (EM_FILEFORMAT);
			}

			dbgprintf("proc_flags = %x, platid = %x, name = %s\n",
			    uhp->uh_proc_flags, platid, name);

			if (ucode_should_update_intel(name,
			    uhp->uh_rev) != 0) {
				/* Remove the existing one first */
				(void) unlink(name);
				if (link(firstname, name) == -1) {
					ucode_perror(name, EM_SYS);
					return (EM_SYS);
				}
			}

			if (uhp->uh_proc_flags == 0)
				break;
		}

		offset = UCODE_HEADER_SIZE_INTEL + body_size;

		/* Check to see if there is extended signature table */
		if (total_size == offset)
			continue;

		/* There is extended signature table.  More processing. */
		extp = (ucode_ext_table_intel_t *)&curbuf[offset];

		for (i = 0; i < extp->uet_count; i++) {
			ucode_ext_sig_intel_t *uesp = &extp->uet_ext_sig[i];
			int j;

			for (j = 0; j < 8; j++) {
				uint32_t id = uesp->ues_proc_flags & (1 << j);

				if (id == 0 && uesp->ues_proc_flags)
					continue;

				n = snprintf(name, sizeof (common_path),
				    "%s/%08X-%02X", path,
				    uesp->ues_signature, id);
				if (n >= sizeof (common_path)) {
					dbgprintf(
					    "failed to construct ext path\n");
					return (EM_FILEFORMAT);
				}

				dbgprintf("extsig: proc_flags = %x, "
				    "platid = %x, name = %s\n",
				    uesp->ues_proc_flags, id, name);

				if (ucode_should_update_intel(name,
				    uhp->uh_rev) != 0) {
					/* Remove the existing one first */
					(void) unlink(name);
					if (link(firstname, name) == -1) {
						ucode_perror(name, EM_SYS);
						return (EM_SYS);
					}
				}

				if (uesp->ues_proc_flags == 0)
					break;
			}
		}

	}

	/*
	 * Remove files with no links to them.  These are probably
	 * obsolete microcode files.
	 */
	if ((dirp = opendir(common_path)) == NULL) {
		ucode_perror(common_path, EM_SYS);
		return (EM_SYS);
	}

	while ((dp = readdir(dirp)) != NULL) {
		char filename[PATH_MAX];
		struct stat statbuf;

		n = snprintf(filename, sizeof (common_path),
		    "%s/%s", common_path, dp->d_name);
		if (n >= sizeof (common_path) || stat(filename, &statbuf) == -1)
			continue;

		if ((statbuf.st_mode & S_IFMT) == S_IFREG) {
			if (statbuf.st_nlink == 1)
				(void) unlink(filename);
		}
	}

	(void) closedir(dirp);

	return (EM_OK);
}

static void
ucode_list_intel(uint8_t *buf, size_t size)
{
	size_t remaining;

	printf("Microcode patches:\n");
	for (remaining = size; remaining > 0; ) {
		uint8_t *curbuf = &buf[size - remaining];
		uint8_t family, model, stepping;
		uint32_t total_size, body_size, offset;
		ucode_header_intel_t *uhp;
		ucode_ext_table_intel_t *extp;

		uhp = (ucode_header_intel_t *)(uintptr_t)curbuf;

		total_size = UCODE_TOTAL_SIZE_INTEL(uhp->uh_total_size);
		body_size = UCODE_BODY_SIZE_INTEL(uhp->uh_body_size);

		remaining -= total_size;

		ucode_fms(uhp->uh_signature, &family, &model, &stepping);

		printf(
		    "    %08lX-%02lX -> Family=%02x Model=%02x Stepping=%02x\n",
		    uhp->uh_signature, uhp->uh_proc_flags,
		    family, model, stepping);
		printf(
		    "    %14s Date=%08lX Bytes=%lu\n", "",
		    uhp->uh_date, uhp->uh_body_size);

		offset = UCODE_HEADER_SIZE_INTEL + body_size;

		/* Check to see if there is extended signature table */
		if (total_size == offset)
			continue;

		printf("Extended Signature Table:\n");

		extp = (ucode_ext_table_intel_t *)&curbuf[offset];

		for (uint32_t i = 0; i < extp->uet_count; i++) {
			ucode_ext_sig_intel_t *uesp = &extp->uet_ext_sig[i];

			ucode_fms(uesp->ues_signature,
			    &family, &model, &stepping);

			printf(
			    "    %08lX-%02lX -> Family=%02x Model=%02x "
			    "Stepping=%02x\n",
			    uesp->ues_signature, uesp->ues_proc_flags,
			    family, model, stepping);
		}
	}
}

static void
ucode_list_amd(uint8_t *buf, size_t size)
{
	uint32_t last_type = UINT32_MAX;

	/* The file has already been validated. Skip over magic number */
	buf += sizeof (uint32_t);
	size -= sizeof (uint32_t);

	while (size > sizeof (ucode_section_amd_t)) {
		ucode_section_amd_t *section = (ucode_section_amd_t *)buf;

		switch (section->usa_type) {
		case UCODE_AMD_CONTAINER_TYPE_EQUIV: {
			ucode_eqtbl_amd_t *eq =
			    (ucode_eqtbl_amd_t *)section->usa_data;

			if (last_type != section->usa_type) {
				printf("Equivalence table:\n");
				last_type = section->usa_type;
			}
			for (uint_t i = 0; eq->ue_inst_cpu != 0 &&
			    i < section->usa_size / sizeof (*eq); eq++, i++) {
				uint8_t family, model, stepping;

				ucode_fms(eq->ue_inst_cpu, &family, &model,
				    &stepping);

				printf("    %08lX Family=%02x Model=%02x "
				    "Stepping=%02x -> %04X\n",
				    eq->ue_inst_cpu, family, model,
				    stepping, eq->ue_equiv_cpu);
			}
			break;
		}
		case UCODE_AMD_CONTAINER_TYPE_PATCH: {
			ucode_header_amd_t *uh =
			    (ucode_header_amd_t *)section->usa_data;

			if (uh->uh_cpu_rev == 0)
				break;

			if (last_type != section->usa_type) {
				printf("Microcode patches:\n");
				last_type = section->usa_type;
			}

			printf("    %4X -> Patch=%08lX Date=%08lX Bytes=%lu\n",
			    uh->uh_cpu_rev, uh->uh_patch_id, uh->uh_date,
			    section->usa_size);

			break;
		}
		default:
			break;
		}

		size -= section->usa_size + sizeof (ucode_section_amd_t);
		buf += section->usa_size + sizeof (ucode_section_amd_t);
	}
}

/*
 * Returns 0 on success, 2 on usage error, and 3 on operation error.
 */
int
main(int argc, char *argv[])
{
	int	c;
	int	action = 0;
	int	actcount = 0;
	int	typeindex = -1;
	char	*path = NULL;
	char	*filename = NULL;
	int	errflg = 0;
	int	dev_fd = -1;
	int	fd = -1;
	bool	verbose = false;
	bool	needfile = false;
	uint8_t	*buf = NULL;
	ucode_errno_t	rc = EM_OK;
	processorid_t	cpuid_max;
	struct stat filestat;
	size_t ucode_size = 0;

	(void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);

	cmdname = basename(argv[0]);

	while ((c = getopt(argc, argv, "idhluvVR:t:")) != EOF) {
		switch (c) {

		case 'd':
			ucode_debug = true;
			break;

		case 'i':
			action |= UCODE_OPT_INSTALL;
			actcount++;
			needfile = true;
			break;

		case 'l':
			action |= UCODE_OPT_LIST;
			actcount++;
			needfile = true;
			break;

		case 't':
			if (typeindex != -1) {
				(void) fprintf(stderr, gettext(
				    "-t can only be specified once\n"));
				errflg++;
				break;
			}
			for (uint_t i = 0; i < ARRAY_SIZE(ucode_sources); i++) {
				if (strcmp(optarg,
				    ucode_sources[i].us_prefix) == 0) {
					typeindex = i;
					break;
				}
			}
			if (typeindex == -1) {
				(void) fprintf(stderr,
				    gettext("Unknown microcode type, %s\n"),
				    optarg);
				errflg++;
			}
			break;

		case 'u':
			action |= UCODE_OPT_UPDATE;
			actcount++;
			needfile = true;
			break;

		case 'v':
			action |= UCODE_OPT_VERSION;
			actcount++;
			break;

		case 'R':
			if (optarg[0] == '-') {
				errflg++;
			} else if (strlen(optarg) > UCODE_MAX_PATH_LEN) {
				(void) fprintf(stderr,
				    gettext("Alternate path too long\n"));
				errflg++;
			} else if ((path = strdup(optarg)) == NULL) {
				errflg++;
			}

			break;

		case 'V':
			verbose = true;
			break;

		case 'h':
			usage(true);
			return (0);

		default:
			usage(verbose);
			return (2);
		}
	}

	if (actcount == 0) {
		(void) fprintf(stderr, gettext("%s: One of -i, -l, -u or -v "
		    "must be provided.\n"), cmdname);
		usage(verbose);
		return (2);
	}

	if (actcount != 1) {
		(void) fprintf(stderr, gettext("%s: options -i, -l, -u and -v "
		    "are mutually exclusive.\n"), cmdname);
		usage(verbose);
		return (2);
	}

	if (typeindex != -1 && !needfile) {
		(void) fprintf(stderr, gettext("%s: option -t requires one of "
		    "-i, -l or -u\n"), cmdname);
		usage(verbose);
		return (2);
	}

	if (optind <= argc - 1)
		filename = argv[optind];
	else if (needfile)
		errflg++;

	if (errflg || action == 0) {
		usage(verbose);
		return (2);
	}

	/*
	 * Convert from the vendor-shipped format to individual microcode files.
	 */
	if (needfile) {
		if (typeindex != -1) {
			ucode = &ucode_sources[typeindex];
		} else {
			for (uint_t i = 0; i < ARRAY_SIZE(ucode_sources); i++) {
				const ucode_source_t *src = &ucode_sources[i];

				dbgprintf("i = %d, filestr = %s, "
				    "filename = %s\n",
				    i, src->us_prefix, filename);
				if (strncasecmp(src->us_prefix,
				    basename(filename),
				    strlen(src->us_prefix)) == 0) {
					ucode = src;
					break;
				}
			}
		}

		if (ucode == NULL) {
			rc = EM_NOVENDOR;
			(void) fprintf(stderr, "%s: %s.\n\n"
			    "Either specify the type with the -t option, "
			    "or rename the file such that\nits name begins "
			    "with a vendor string.\n",
			    cmdname, ucode_strerror(rc));
			goto out;
		}

		dbgprintf("Selected microcode type %s (%s)\n",
		    ucode->us_prefix, ucode->us_vendor);

		if ((stat(filename, &filestat)) < 0) {
			rc = EM_SYS;
			ucode_perror(filename, rc);
			goto out;
		}

		if ((filestat.st_mode & S_IFMT) != S_IFREG &&
		    (filestat.st_mode & S_IFMT) != S_IFLNK) {
			rc = EM_FILEFORMAT;
			ucode_perror(filename, rc);
			goto out;
		}

		ucode_size = filestat.st_size;
		if ((buf = malloc(ucode_size)) == NULL) {
			rc = EM_SYS;
			ucode_perror(filename, rc);
			goto out;
		}

		rc = ucode->us_convert(filename, &buf, &ucode_size);
		if (rc != EM_OK) {
			ucode_perror(filename, rc);
			goto out;
		}

		dbgprintf("ucode_size = %zd\n", ucode_size);

		if ((rc = ucode->us_validate(buf, ucode_size)) != EM_OK) {
			ucode_perror(filename, rc);
			goto out;
		}
	}

	if (action & UCODE_OPT_LIST) {
		ucode->us_list(buf, ucode_size);
		goto out;
	}

	if (action & UCODE_OPT_INSTALL) {
		/*
		 * If no path is provided by the -R option, put the files in
		 * /platform/<arch>/ucode/<ucode_vendor_str>/.
		 */
		if (path == NULL) {
			struct utsname uts;

			if (uname(&uts) == -1) {
				perror("Unable to retrieve system uname");
				goto out;
			}

			if ((path = malloc(PATH_MAX)) == NULL) {
				rc = EM_SYS;
				ucode_perror("malloc", rc);
				goto out;
			}

			(void) snprintf(path, PATH_MAX, "/platform/%s/ucode/%s",
			    uts.machine, ucode->us_vendor);
		}

		if (mkdirp(path, 0755) == -1 && errno != EEXIST) {
			rc = EM_SYS;
			ucode_perror(path, rc);
			goto out;
		}

		rc = ucode->us_gen_files(buf, ucode_size, path);

		goto out;
	}

	if ((dev_fd = open(ucode_dev, O_RDONLY)) == -1) {
		rc = EM_SYS;
		ucode_perror(ucode_dev, rc);
		goto out;
	}

	if (action & UCODE_OPT_VERSION) {
		int tmprc;
		uint32_t *revp = NULL;
		int i;
		struct ucode_get_rev_struct info;

		cpuid_max = (processorid_t)sysconf(_SC_CPUID_MAX);

		if ((revp = (uint32_t *)
		    malloc(cpuid_max * sizeof (uint32_t))) == NULL) {
			rc = EM_SYS;
			ucode_perror("malloc", rc);
			goto out;
		}

		for (i = 0; i < cpuid_max; i++)
			revp[i] = (uint32_t)-1;

		info.ugv_rev = revp;
		info.ugv_size = cpuid_max;
		info.ugv_errno = EM_OK;
		tmprc = ioctl(dev_fd, UCODE_GET_VERSION, &info);
		rc = info.ugv_errno;

		if (tmprc && rc == EM_OK) {
			rc = EM_SYS;
		}

		if (rc == EM_OK) {
			(void) printf(gettext("CPU\tMicrocode Version\n"));
			for (i = 0; i < cpuid_max; i++) {
				if (info.ugv_rev[i] == (uint32_t)-1)
					continue;
				(void) printf("%d\t0x%x\n", i, info.ugv_rev[i]);
			}
		} else {
			ucode_perror(gettext("get microcode version"), rc);
		}

		if (revp)
			free(revp);
	}

	if (action & UCODE_OPT_UPDATE) {
		int tmprc;
		struct ucode_write_struct uw_struct;

		uw_struct.uw_size = ucode_size;
		uw_struct.uw_ucode = buf;
		uw_struct.uw_errno = EM_OK;
		tmprc = ioctl(dev_fd, UCODE_UPDATE, &uw_struct);
		rc = uw_struct.uw_errno;

		if (rc == EM_OK) {
			if (tmprc) {
				rc = EM_SYS;
				ucode_perror(ucode_dev, rc);
			}
		} else if (rc == EM_NOMATCH || rc == EM_HIGHERREV) {
			ucode_perror(filename, rc);
		} else {
			ucode_perror(gettext("microcode update"), rc);
		}
	}

out:
	if (dev_fd != -1)
		(void) close(dev_fd);

	if (fd != -1)
		(void) close(fd);

	free(buf);
	free(path);

	if (rc != EM_OK)
		return (3);

	return (0);
}