xref: /src/sys/dev/acpi/apei_einj.c

/*	$NetBSD: apei_einj.c,v 1.7 2024/03/28 13:40:08 riastradh Exp $	*/

/*-
 * Copyright (c) 2024 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * APEI EINJ -- Error Injection Table
 *
 * https://uefi.org/specs/ACPI/6.5/18_Platform_Error_Interfaces.html#error-injection
 *
 * XXX Consider a /dev node with ioctls for error injection rather than
 * the somewhat kooky sysctl interface.  By representing an error
 * injection request in a structure, we can serialize access to the
 * platform's EINJ operational context.  However, this also requires
 * some nontrivial userland support; maybe relying on the user to tread
 * carefully with error injection is fine -- after all, many types of
 * error injection will cause a system halt/panic.
 *
 * XXX Properly expose SET_ERROR_TYPE_WITH_ADDRESS, which has a more
 * complicated relationship with its RegisterRegion field.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: apei_einj.c,v 1.7 2024/03/28 13:40:08 riastradh Exp $");

#include <sys/types.h>

#include <sys/device.h>
#include <sys/sysctl.h>
#include <sys/systm.h>

#include <dev/acpi/acpivar.h>
#include <dev/acpi/apei_einjvar.h>
#include <dev/acpi/apei_interp.h>
#include <dev/acpi/apei_mapreg.h>
#include <dev/acpi/apei_reg.h>
#include <dev/acpi/apeivar.h>

#include "ioconf.h"

#define	_COMPONENT	ACPI_RESOURCE_COMPONENT
ACPI_MODULE_NAME	("apei")

static void apei_einj_instfunc(ACPI_WHEA_HEADER *, struct apei_mapreg *,
    void *, uint32_t *, uint32_t);
static uint64_t apei_einj_act(struct apei_softc *, enum AcpiEinjActions,
    uint64_t);
static uint64_t apei_einj_trigger(struct apei_softc *, uint64_t);
static int apei_einj_action_sysctl(SYSCTLFN_ARGS);
static int apei_einj_trigger_sysctl(SYSCTLFN_ARGS);
static int apei_einj_types_sysctl(SYSCTLFN_ARGS);

/*
 * apei_einj_action
 *
 *	Symbolic names of the APEI EINJ (Error Injection) logical actions
 *	are taken (and downcased) from:
 *
 *	https://uefi.org/specs/ACPI/6.5/18_Platform_Error_Interfaces.html#error-injection-actions
 */
static const char *const apei_einj_action[] = {
	[ACPI_EINJ_BEGIN_OPERATION] = "begin_injection_operation",
	[ACPI_EINJ_GET_TRIGGER_TABLE] = "get_trigger_error_action_table",
	[ACPI_EINJ_SET_ERROR_TYPE] = "set_error_type",
	[ACPI_EINJ_GET_ERROR_TYPE] = "get_error_type",
	[ACPI_EINJ_END_OPERATION] = "end_operation",
	[ACPI_EINJ_EXECUTE_OPERATION] = "execute_operation",
	[ACPI_EINJ_CHECK_BUSY_STATUS] = "check_busy_status",
	[ACPI_EINJ_GET_COMMAND_STATUS] = "get_command_status",
	[ACPI_EINJ_SET_ERROR_TYPE_WITH_ADDRESS] = "set_error_type_with_address",
	[ACPI_EINJ_GET_EXECUTE_TIMINGS] = "get_execute_operation_timings",
};

/*
 * apei_einj_instruction
 *
 *	Symbolic names of the APEI EINJ (Error Injection) instructions to
 *	implement logical actions are taken (and downcased) from:
 *
 *	https://uefi.org/specs/ACPI/6.5/18_Platform_Error_Interfaces.html#injection-instructions-table
 */

static const char *const apei_einj_instruction[] = {
	[ACPI_EINJ_READ_REGISTER] = "read_register",
	[ACPI_EINJ_READ_REGISTER_VALUE] = "read_register",
	[ACPI_EINJ_WRITE_REGISTER] = "write_register",
	[ACPI_EINJ_WRITE_REGISTER_VALUE] = "write_register_value",
	[ACPI_EINJ_NOOP] = "noop",
};

/*
 * apei_einj_instreg
 *
 *	Table of which instructions use a register operand.
 *
 *	Must match apei_einj_instfunc.
 */
static const bool apei_einj_instreg[] = {
	[ACPI_EINJ_READ_REGISTER] = true,
	[ACPI_EINJ_READ_REGISTER_VALUE] = true,
	[ACPI_EINJ_WRITE_REGISTER] = true,
	[ACPI_EINJ_WRITE_REGISTER_VALUE] = true,
	[ACPI_EINJ_NOOP] = false,
};

/*
 * apei_einj_attach(sc)
 *
 *	Scan the Error Injection table to ascertain what error
 *	injection actions the firmware supports and how to perform
 *	them.  Create sysctl nodes for triggering error injection.
 */
void
apei_einj_attach(struct apei_softc *sc)
{
	ACPI_TABLE_EINJ *einj = sc->sc_tab.einj;
	struct apei_einj_softc *jsc = &sc->sc_einj;
	ACPI_EINJ_ENTRY *entry;
	const struct sysctlnode *sysctl_einj;
	const struct sysctlnode *sysctl_einj_action;
	uint32_t i, nentries, maxnentries;
	unsigned action;
	int error;

	/*
	 * Verify the table length, table header length, and
	 * instruction entry count are all sensible.  If the header is
	 * truncated, stop here; if the entries are truncated, stop at
	 * the largest integral number of full entries that fits.
	 */
	if (einj->Header.Length < sizeof(*einj)) {
		aprint_error_dev(sc->sc_dev, "EINJ: truncated table:"
		    " %"PRIu32" < %zu minimum bytes\n",
		    einj->Header.Length, sizeof(*einj));
		return;
	}
	if (einj->HeaderLength <
	    sizeof(*einj) - offsetof(ACPI_TABLE_EINJ, HeaderLength)) {
		aprint_error_dev(sc->sc_dev, "EINJ: truncated header:"
		    " %"PRIu32" < %zu bytes\n",
		    einj->HeaderLength,
		    sizeof(*einj) - offsetof(ACPI_TABLE_EINJ, HeaderLength));
		return;
	}
	nentries = einj->Entries;
	maxnentries = (einj->Header.Length - sizeof(*einj))/sizeof(*entry);
	if (nentries > maxnentries) {
		aprint_error_dev(sc->sc_dev, "EINJ: excessive entries:"
		    " %"PRIu32", truncating to %"PRIu32"\n",
		    nentries, maxnentries);
		nentries = maxnentries;
	}
	if (nentries*sizeof(*entry) < einj->Header.Length - sizeof(*einj)) {
		aprint_error_dev(sc->sc_dev, "EINJ:"
		    " %zu bytes of trailing garbage after last entry\n",
		    einj->Header.Length - nentries*sizeof(*entry));
	}

	/*
	 * Create sysctl hw.acpi.apei.einj for all EINJ-related knobs.
	 */
	error = sysctl_createv(&sc->sc_sysctllog, 0,
	    &sc->sc_sysctlroot, &sysctl_einj, 0,
	    CTLTYPE_NODE, "einj",
	    SYSCTL_DESCR("Error injection"),
	    NULL, 0, NULL, 0,
	    CTL_CREATE, CTL_EOL);
	if (error) {
		aprint_error_dev(sc->sc_dev, "failed to create"
		    " hw.acpi.apei.einj: %d\n", error);
		sysctl_einj = NULL;
	}

	/*
	 * Create an interpreter for EINJ actions.
	 */
	jsc->jsc_interp = apei_interp_create("EINJ",
	    apei_einj_action, __arraycount(apei_einj_action),
	    apei_einj_instruction, __arraycount(apei_einj_instruction),
	    apei_einj_instreg, /*instvalid*/NULL, apei_einj_instfunc);

	/*
	 * Compile the interpreter from the EINJ action instruction
	 * table.
	 */
	entry = (ACPI_EINJ_ENTRY *)(einj + 1);
	for (i = 0; i < nentries; i++, entry++)
		apei_interp_pass1_load(jsc->jsc_interp, i, &entry->WheaHeader);
	entry = (ACPI_EINJ_ENTRY *)(einj + 1);
	for (i = 0; i < nentries; i++, entry++) {
		apei_interp_pass2_verify(jsc->jsc_interp, i,
		    &entry->WheaHeader);
	}
	apei_interp_pass3_alloc(jsc->jsc_interp);
	entry = (ACPI_EINJ_ENTRY *)(einj + 1);
	for (i = 0; i < nentries; i++, entry++) {
		apei_interp_pass4_assemble(jsc->jsc_interp, i,
		    &entry->WheaHeader);
	}
	apei_interp_pass5_verify(jsc->jsc_interp);

	/*
	 * Create sysctl hw.acpi.apei.einj.action for individual actions.
	 */
	error = sysctl_einj == NULL ? ENOENT :
	    sysctl_createv(&sc->sc_sysctllog, 0,
		&sysctl_einj, &sysctl_einj_action, 0,
		CTLTYPE_NODE, "action",
		SYSCTL_DESCR("EINJ actions"),
		NULL, 0, NULL, 0,
		CTL_CREATE, CTL_EOL);
	if (error) {
		aprint_error_dev(sc->sc_dev, "failed to create"
		    " hw.acpi.apei.einj.action: %d\n", error);
		sysctl_einj_action = NULL;
	}

	/*
	 * Create sysctl nodes for each action we know about.
	 */
	for (action = 0; action < __arraycount(apei_einj_action); action++) {
		if (apei_einj_action[action] == NULL)
			continue;

		/*
		 * Check to see if there are any instructions for this
		 * action.
		 *
		 * XXX Maybe add this to the apei_interp.h abstraction.
		 */
		entry = (ACPI_EINJ_ENTRY *)(einj + 1);
		for (i = 0; i < nentries; i++, entry++) {
			ACPI_WHEA_HEADER *const header = &entry->WheaHeader;

			if (action == header->Action)
				break;
		}
		if (i == nentries) {
			/*
			 * No instructions for this action, so assume
			 * it's not supported.
			 */
			continue;
		}

		/*
		 * Create a sysctl knob to perform the action.
		 */
		error = sysctl_einj_action == NULL ? ENOENT :
		    sysctl_createv(&sc->sc_sysctllog, 0,
			&sysctl_einj_action, NULL, CTLFLAG_READWRITE,
			CTLTYPE_QUAD, apei_einj_action[action],
			NULL,	/* description */
			&apei_einj_action_sysctl, 0, NULL, 0,
			action, CTL_EOL);
		if (error) {
			aprint_error_dev(sc->sc_dev, "failed to create"
			    " sysctl hw.acpi.apei.einj.action.%s: %d\n",
			    apei_einj_action[action], error);
			continue;
		}
	}

	/*
	 * Create a sysctl knob to trigger error.
	 */
	error = sysctl_einj == NULL ? ENOENT :
	    sysctl_createv(&sc->sc_sysctllog, 0,
		&sysctl_einj, NULL, CTLFLAG_READWRITE,
		CTLTYPE_QUAD, "trigger",
		NULL,	/* description */
		&apei_einj_trigger_sysctl, 0, NULL, 0,
		CTL_CREATE, CTL_EOL);
	if (error) {
		aprint_error_dev(sc->sc_dev, "failed to create"
		    " sysctl hw.acpi.apei.einj.trigger: %d\n",
		    error);
	}

	/*
	 * Query the available types of error to inject and print it to
	 * dmesg.
	 *
	 * https://uefi.org/specs/ACPI/6.5/18_Platform_Error_Interfaces.html#error-types
	 */
	uint64_t types = apei_einj_act(sc, ACPI_EINJ_GET_ERROR_TYPE, 0);
	char typesbuf[1024], *typesp;
	/* XXX define this format somewhere */
	snprintb_m(typesbuf, sizeof(typesbuf), "\177\020"
	    "b\000"	"PROC_CORRECTABLE\0"
	    "b\001"	"PROC_UNCORRECTABLE\0"
	    "b\002"	"PROC_FATAL\0"
	    "b\003"	"MEM_CORRECTABLE\0"
	    "b\004"	"MEM_UNCORRECTABLE\0"
	    "b\005"	"MEM_FATAL\0"
	    "b\006"	"PCIE_CORRECTABLE\0"
	    "b\007"	"PCIE_UNCORRECTABLE\0"
	    "b\010"	"PCIE_FATAL\0"
	    "b\011"	"PLAT_CORRECTABLE\0"
	    "b\012"	"PLAT_UNCORRECTABLE\0"
	    "b\013"	"PLAT_FATAL\0"
	    "b\014"	"CXLCACHE_CORRECTABLE\0"
	    "b\015"	"CXLCACHE_UNCORRECTABLE\0"
	    "b\016"	"CXLCACHE_FATAL\0"
	    "b\017"	"CXLMEM_CORRECTABLE\0"
	    "b\020"	"CXLMEM_UNCORRECTABLE\0"
	    "b\021"	"CXLMEM_FATAL\0"
//	    "f\022\014"	"reserved\0"
	    "b\036"	"EINJv2\0"
	    "b\037"	"VENDOR\0"
	    "\0", types, 36);
	for (typesp = typesbuf; strlen(typesp); typesp += strlen(typesp) + 1) {
		aprint_normal_dev(sc->sc_dev, "EINJ: can inject:"
		    " %s\n", typesp);
	}

	/*
	 * Create a sysctl knob to query the available types of error
	 * to inject.  In principle this could change dynamically, so
	 * we'll make it dynamic.
	 */
	error = sysctl_einj == NULL ? ENOENT :
	    sysctl_createv(&sc->sc_sysctllog, 0,
		&sysctl_einj, NULL, 0,
		CTLTYPE_QUAD, "types",
		SYSCTL_DESCR("Types of errors that can be injected"),
		&apei_einj_types_sysctl, 0, NULL, 0,
		CTL_CREATE, CTL_EOL);
	if (error) {
		aprint_error_dev(sc->sc_dev, "failed to create"
		    " sysctl hw.acpi.apei.einj.types: %d\n",
		    error);
	}
}

/*
 * apei_einj_detach(sc)
 *
 *	Free any software resources associated with the Error Injection
 *	table.
 */
void
apei_einj_detach(struct apei_softc *sc)
{
	struct apei_einj_softc *jsc = &sc->sc_einj;

	if (jsc->jsc_interp) {
		apei_interp_destroy(jsc->jsc_interp);
		jsc->jsc_interp = NULL;
	}
}

/*
 * struct apei_einj_machine
 *
 *	Machine state for executing EINJ instructions.
 */
struct apei_einj_machine {
	struct apei_softc	*sc;
	uint64_t		x;	/* in */
	uint64_t		y;	/* out */
};

/*
 * apei_einj_instfunc(header, cookie, &ip, maxip)
 *
 *	Run a single instruction in the service of performing an EINJ
 *	action.  Updates the EINJ machine at cookie in place.
 *
 *	This doesn't read or write ip.  The TRIGGER_ERROR logic relies
 *	on this; if you change the fact, you must update that logic
 *	too.
 */
static void
apei_einj_instfunc(ACPI_WHEA_HEADER *header, struct apei_mapreg *map,
    void *cookie, uint32_t *ipp, uint32_t maxip)
{
	struct apei_einj_machine *M = cookie;

	/*
	 * Abbreviate some of the intermediate quantities to make the
	 * instruction logic conciser and more legible.
	 */
	const uint8_t BitOffset = header->RegisterRegion.BitOffset;
	const uint64_t Mask = header->Mask;
	const uint64_t Value = header->Value;
	ACPI_GENERIC_ADDRESS *const reg = &header->RegisterRegion;
	const bool preserve_register = header->Flags & ACPI_EINJ_PRESERVE;

	aprint_debug_dev(M->sc->sc_dev, "%s: instr=0x%02"PRIx8
	    " (%s)"
	    " Address=0x%"PRIx64
	    " BitOffset=%"PRIu8" Mask=0x%"PRIx64" Value=0x%"PRIx64
	    " Flags=0x%"PRIx8"\n",
	    __func__, header->Instruction,
	    (header->Instruction < __arraycount(apei_einj_instruction)
		? apei_einj_instruction[header->Instruction]
		: "unknown"),
	    reg->Address,
	    BitOffset, Mask, Value,
	    header->Flags);

	/*
	 * Zero-initialize the output by default.
	 */
	M->y = 0;

	/*
	 * Dispatch the instruction.
	 */
	switch (header->Instruction) {
	case ACPI_EINJ_READ_REGISTER:
		M->y = apei_read_register(reg, map, Mask);
		break;
	case ACPI_EINJ_READ_REGISTER_VALUE: {
		uint64_t v;

		v = apei_read_register(reg, map, Mask);
		M->y = (v == Value ? 1 : 0);
		break;
	}
	case ACPI_EINJ_WRITE_REGISTER:
		apei_write_register(reg, map, Mask, preserve_register, M->x);
		break;
	case ACPI_EINJ_WRITE_REGISTER_VALUE:
		apei_write_register(reg, map, Mask, preserve_register, Value);
		break;
	case ACPI_EINJ_NOOP:
		break;
	default:		/* XXX unreachable */
		break;
	}
}

/*
 * apei_einj_act(sc, action, x)
 *
 *	Perform the named EINJ action with input x, by executing the
 *	instruction defined for the action by the EINJ, and return the
 *	output.
 */
static uint64_t
apei_einj_act(struct apei_softc *sc, enum AcpiEinjActions action,
    uint64_t x)
{
	struct apei_einj_softc *const jsc = &sc->sc_einj;
	struct apei_einj_machine einj_machine, *const M = &einj_machine;

	aprint_debug_dev(sc->sc_dev, "%s: action=%d (%s) input=0x%"PRIx64"\n",
	    __func__,
	    action,
	    (action < __arraycount(apei_einj_action)
		? apei_einj_action[action]
		: "unknown"),
	    x);

	/*
	 * Initialize the machine to execute the action's instructions.
	 */
	memset(M, 0, sizeof(*M));
	M->sc = sc;
	M->x = x;		/* input */
	M->y = 0;		/* output */

	/*
	 * Run the interpreter.
	 */
	apei_interpret(jsc->jsc_interp, action, M);

	/*
	 * Return the result.
	 */
	aprint_debug_dev(sc->sc_dev, "%s: output=0x%"PRIx64"\n", __func__,
	    M->y);
	return M->y;
}

/*
 * apei_einj_trigger(sc, x)
 *
 *	Obtain the TRIGGER_ERROR action table and, if there is anything
 *	to be done with it, execute it with input x and return the
 *	output.  If nothing is to be done, return 0.
 */
static uint64_t
apei_einj_trigger(struct apei_softc *sc, uint64_t x)
{
	uint64_t teatab_pa;
	ACPI_EINJ_TRIGGER *teatab = NULL;
	size_t mapsize = 0, tabsize, bodysize;
	ACPI_EINJ_ENTRY *entry;
	struct apei_einj_machine einj_machine, *const M = &einj_machine;
	uint32_t i, nentries;

	/*
	 * Initialize the machine to execute the TRIGGER_ERROR action's
	 * instructions.  Do this early to keep the error branches
	 * simpler.
	 */
	memset(M, 0, sizeof(*M));
	M->sc = sc;
	M->x = x;		/* input */
	M->y = 0;		/* output */

	/*
	 * Get the TRIGGER_ERROR action table's physical address.
	 */
	teatab_pa = apei_einj_act(sc, ACPI_EINJ_GET_TRIGGER_TABLE, 0);

	/*
	 * Map just the header.  We don't know how large the table is
	 * because we get that from the header.
	 */
	mapsize = sizeof(*teatab);
	teatab = AcpiOsMapMemory(teatab_pa, mapsize);

	/*
	 * If there's no entries, stop here -- nothing to do separately
	 * to trigger an error report.
	 */
	nentries = teatab->EntryCount;
	if (nentries == 0)
		goto out;

	/*
	 * If the header size or the table size is nonsense, bail.
	 */
	if (teatab->HeaderSize < sizeof(*teatab) ||
	    teatab->TableSize < teatab->HeaderSize) {
		device_printf(sc->sc_dev, "TRIGGER_ERROR action table:"
		    " invalid sizes:"
		    " HeaderSize=%"PRIu32" TableSize=%"PRIu32"\n",
		    teatab->HeaderSize, teatab->TableSize);
	}

	/*
	 * If the revision is nonzero, we don't know what to do.  I've
	 * only seen revision zero so far, and the spec doesn't say
	 * anything about revisions that I've found.
	 */
	if (teatab->Revision != 0) {
		device_printf(sc->sc_dev, "TRIGGER_ERROR action table:"
		    " unknown revision: %"PRIx32"\n", teatab->Revision);
		goto out;
	}

	/*
	 * Truncate the table to the number of entries requested and
	 * ignore trailing garbage if the table is long, or round the
	 * number of entries down to what fits in the table if the
	 * table is short.
	 */
	tabsize = teatab->TableSize;
	bodysize = tabsize - teatab->HeaderSize;
	if (nentries < howmany(bodysize, sizeof(ACPI_EINJ_ENTRY))) {
		device_printf(sc->sc_dev, "TRIGGER_ERROR action table:"
		    " %zu bytes of trailing garbage\n",
		    tabsize - nentries*sizeof(ACPI_EINJ_ENTRY));
		bodysize = nentries*sizeof(ACPI_EINJ_ENTRY);
		tabsize = teatab->HeaderSize + bodysize;
	} else if (nentries > howmany(bodysize, sizeof(ACPI_EINJ_ENTRY))) {
		device_printf(sc->sc_dev, "TRIGGER_ERROR action table:"
		    " truncated to %zu entries\n",
		    nentries*sizeof(ACPI_EINJ_ENTRY));
		nentries = howmany(bodysize, sizeof(ACPI_EINJ_ENTRY));
		bodysize = nentries*sizeof(ACPI_EINJ_ENTRY);
		tabsize = teatab->HeaderSize + bodysize;
	}

	/*
	 * Unmap the header and map the whole table instead.
	 */
	AcpiOsUnmapMemory(teatab, mapsize);
	mapsize = tabsize;
	teatab = AcpiOsMapMemory(teatab_pa, mapsize);

	/*
	 * Now iterate over the EINJ-type entries and execute the
	 * trigger error action instructions -- but skip if they're not
	 * for the TRIGGER_ERROR action, and stop if they're truncated.
	 *
	 * Entries are fixed-size, so we can just index them.
	 */
	entry = (ACPI_EINJ_ENTRY *)((char *)teatab + teatab->HeaderSize);
	for (i = 0; i < nentries; i++) {
		ACPI_WHEA_HEADER *const header = &entry[i].WheaHeader;

		/*
		 * Verify the action is TRIGGER_ERROR.  If not, skip.
		 */
		if (header->Action != ACPI_EINJ_TRIGGER_ERROR) {
			device_printf(sc->sc_dev, "TRIGGER_ERROR action table:"
			    " other action: %"PRIu32" (%s)\n",
			    header->Action,
			    (header->Action < __arraycount(apei_einj_action)
				? apei_einj_action[header->Action]
				: "unknown"));
			continue;
		}

		/*
		 * Verify the instruction.
		 */
		if (header->Instruction >= __arraycount(apei_einj_instreg)) {
			device_printf(sc->sc_dev, "TRIGGER_ERROR action table:"
			    " unknown instruction: %"PRIu32"\n",
			    header->Instruction);
			continue;
		}

		/*
		 * Map the register if needed.
		 */
		struct apei_mapreg *map = NULL;
		if (apei_einj_instreg[header->Instruction]) {
			map = apei_mapreg_map(&header->RegisterRegion);
			if (map == NULL) {
				device_printf(sc->sc_dev, "TRIGGER_ERROR"
				    " action table: failed to map register\n");
				continue;
			}
		}

		/*
		 * Execute the instruction.  Since there's only one
		 * action, we don't bother with the apei_interp
		 * machinery to collate instruction tables for each
		 * action.  EINJ instructions don't change ip.
		 */
		uint32_t ip = i + 1;
		apei_einj_instfunc(header, map, M, &ip, nentries);
		KASSERT(ip == i + 1);

		/*
		 * Unmap the register if mapped.
		 */
		if (map != NULL)
			apei_mapreg_unmap(&header->RegisterRegion, map);
	}

out:	if (teatab) {
		AcpiOsUnmapMemory(teatab, mapsize);
		teatab = NULL;
		mapsize = 0;
	}
	return M->y;
}

/*
 * apei_einj_action_sysctl:
 *
 *	Handle sysctl queries under hw.acpi.apei.einj.action.*.
 */
static int
apei_einj_action_sysctl(SYSCTLFN_ARGS)
{
	device_t apei0 = NULL;
	struct apei_softc *sc;
	enum AcpiEinjActions action;
	struct sysctlnode node = *rnode;
	uint64_t v;
	int error;

	/*
	 * As a defence against mistakes, require the user to specify a
	 * write.
	 */
	if (newp == NULL) {
		error = ENOENT;
		goto out;
	}

	/*
	 * Take a reference to the apei0 device so it doesn't go away
	 * while we're working, and get the softc.
	 */
	if ((apei0 = device_lookup_acquire(&apei_cd, 0)) == NULL) {
		error = ENXIO;
		goto out;
	}
	sc = device_private(apei0);

	/*
	 * Fail if there's no EINJ.
	 */
	if (sc->sc_tab.einj == NULL) {
		error = ENODEV;
		goto out;
	}

	/*
	 * Identify the requested action.  If we don't recognize it,
	 * fail with EINVAL.
	 */
	switch (node.sysctl_num) {
	case ACPI_EINJ_BEGIN_OPERATION:
	case ACPI_EINJ_GET_TRIGGER_TABLE:
	case ACPI_EINJ_SET_ERROR_TYPE:
	case ACPI_EINJ_GET_ERROR_TYPE:
	case ACPI_EINJ_END_OPERATION:
	case ACPI_EINJ_EXECUTE_OPERATION:
	case ACPI_EINJ_CHECK_BUSY_STATUS:
	case ACPI_EINJ_GET_COMMAND_STATUS:
	case ACPI_EINJ_SET_ERROR_TYPE_WITH_ADDRESS:
	case ACPI_EINJ_GET_EXECUTE_TIMINGS:
		action = node.sysctl_num;
		break;
	default:
		error = ENOENT;
		goto out;
	}

	/*
	 * Kludge: Copy the `new value' for the sysctl in as an input
	 * to the injection action.
	 */
	error = sysctl_copyin(curlwp, newp, &v, sizeof(v));
	if (error)
		goto out;

	/*
	 * Perform the EINJ action by following the table's
	 * instructions.
	 */
	v = apei_einj_act(sc, action, v);

	/*
	 * Return the output of the operation as the `old value' of the
	 * sysctl.  This also updates v with what was written to the
	 * sysctl was written, but we don't care because we already
	 * read that in and acted on it.
	 */
	node.sysctl_data = &v;
	error = sysctl_lookup(SYSCTLFN_CALL(&node));

out:	if (apei0) {
		device_release(apei0);
		apei0 = NULL;
	}
	return error;
}

/*
 * apei_einj_trigger_sysctl
 *
 *	Handle sysctl hw.acpi.apei.einj.trigger.
 */
static int
apei_einj_trigger_sysctl(SYSCTLFN_ARGS)
{
	device_t apei0 = NULL;
	struct apei_softc *sc;
	struct sysctlnode node = *rnode;
	uint64_t v;
	int error;

	/*
	 * As a defence against mistakes, require the user to specify a
	 * write.
	 */
	if (newp == NULL) {
		error = ENOENT;
		goto out;
	}

	/*
	 * Take a reference to the apei0 device so it doesn't go away
	 * while we're working, and get the softc.
	 */
	if ((apei0 = device_lookup_acquire(&apei_cd, 0)) == NULL) {
		error = ENXIO;
		goto out;
	}
	sc = device_private(apei0);

	/*
	 * Fail if there's no EINJ.
	 */
	if (sc->sc_tab.einj == NULL) {
		error = ENODEV;
		goto out;
	}

	/*
	 * Kludge: Copy the `new value' for the sysctl in as an input
	 * to the trigger action.
	 */
	error = sysctl_copyin(curlwp, newp, &v, sizeof(v));
	if (error)
		goto out;

	/*
	 * Perform the TRIGGER_ERROR action.
	 */
	v = apei_einj_trigger(sc, v);

	/*
	 * Return the output of the operation as the `old value' of the
	 * sysctl.  This also updates v with what was written to the
	 * sysctl was written, but we don't care because we already
	 * read that in and acted on it.
	 */
	node.sysctl_data = &v;
	error = sysctl_lookup(SYSCTLFN_CALL(&node));

out:	if (apei0) {
		device_release(apei0);
		apei0 = NULL;
	}
	return error;
}

/*
 * apei_einj_types_sysctl
 *
 *	Handle sysctl hw.acpi.apei.einj.types.
 */
static int
apei_einj_types_sysctl(SYSCTLFN_ARGS)
{
	device_t apei0 = NULL;
	struct apei_softc *sc;
	struct sysctlnode node = *rnode;
	uint64_t types;
	int error;

	/*
	 * Take a reference to the apei0 device so it doesn't go away
	 * while we're working, and get the softc.
	 *
	 * XXX Is this necessary?  Shouldn't sysctl_teardown take care
	 * of preventing new sysctl calls and waiting until all pending
	 * sysctl calls are done?
	 */
	if ((apei0 = device_lookup_acquire(&apei_cd, 0)) == NULL) {
		error = ENXIO;
		goto out;
	}
	sc = device_private(apei0);

	/*
	 * Fail if there's no EINJ.
	 */
	if (sc->sc_tab.einj == NULL) {
		error = ENODEV;
		goto out;
	}

	/*
	 * Perform the GET_ERROR_TYPE action and return the value to
	 * sysctl.
	 *
	 * XXX Should this do it between BEGIN_INJECTION_OPERATION and
	 * END_OPERATION?
	 */
	types = apei_einj_act(sc, ACPI_EINJ_GET_ERROR_TYPE, 0);
	node.sysctl_data = &types;
	error = sysctl_lookup(SYSCTLFN_CALL(&node));

out:	if (apei0) {
		device_release(apei0);
		apei0 = NULL;
	}
	return error;
}