[mirror_qemu.git] / hw / acpi / ghes.c

/*
 * Support for generating APEI tables and recording CPER for Guests
 *
 * Copyright (c) 2020 HUAWEI TECHNOLOGIES CO., LTD.
 *
 * Author: Dongjiu Geng <gengdongjiu@huawei.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License along
 * with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include "qemu/osdep.h"
#include "qemu/units.h"
#include "hw/acpi/ghes.h"
#include "hw/acpi/aml-build.h"
#include "qemu/error-report.h"
#include "hw/acpi/generic_event_device.h"
#include "hw/nvram/fw_cfg.h"
#include "qemu/uuid.h"

#define ACPI_GHES_ERRORS_FW_CFG_FILE        "etc/hardware_errors"
#define ACPI_GHES_DATA_ADDR_FW_CFG_FILE     "etc/hardware_errors_addr"

/* The max size in bytes for one error block */
#define ACPI_GHES_MAX_RAW_DATA_LENGTH   (1 * KiB)

/* Now only support ARMv8 SEA notification type error source */
#define ACPI_GHES_ERROR_SOURCE_COUNT        1

/* Generic Hardware Error Source version 2 */
#define ACPI_GHES_SOURCE_GENERIC_ERROR_V2   10

/* Address offset in Generic Address Structure(GAS) */
#define GAS_ADDR_OFFSET 4

/*
 * The total size of Generic Error Data Entry
 * ACPI 6.1/6.2: 18.3.2.7.1 Generic Error Data,
 * Table 18-343 Generic Error Data Entry
 */
#define ACPI_GHES_DATA_LENGTH               72

/* The memory section CPER size, UEFI 2.6: N.2.5 Memory Error Section */
#define ACPI_GHES_MEM_CPER_LENGTH           80

/* Masks for block_status flags */
#define ACPI_GEBS_UNCORRECTABLE         1

/*
 * Total size for Generic Error Status Block except Generic Error Data Entries
 * ACPI 6.2: 18.3.2.7.1 Generic Error Data,
 * Table 18-380 Generic Error Status Block
 */
#define ACPI_GHES_GESB_SIZE                 20

/*
 * Values for error_severity field
 */
enum AcpiGenericErrorSeverity {
    ACPI_CPER_SEV_RECOVERABLE = 0,
    ACPI_CPER_SEV_FATAL = 1,
    ACPI_CPER_SEV_CORRECTED = 2,
    ACPI_CPER_SEV_NONE = 3,
};

/*
 * Hardware Error Notification
 * ACPI 4.0: 17.3.2.7 Hardware Error Notification
 * Composes dummy Hardware Error Notification descriptor of specified type
 */
static void build_ghes_hw_error_notification(GArray *table, const uint8_t type)
{
    /* Type */
    build_append_int_noprefix(table, type, 1);
    /*
     * Length:
     * Total length of the structure in bytes
     */
    build_append_int_noprefix(table, 28, 1);
    /* Configuration Write Enable */
    build_append_int_noprefix(table, 0, 2);
    /* Poll Interval */
    build_append_int_noprefix(table, 0, 4);
    /* Vector */
    build_append_int_noprefix(table, 0, 4);
    /* Switch To Polling Threshold Value */
    build_append_int_noprefix(table, 0, 4);
    /* Switch To Polling Threshold Window */
    build_append_int_noprefix(table, 0, 4);
    /* Error Threshold Value */
    build_append_int_noprefix(table, 0, 4);
    /* Error Threshold Window */
    build_append_int_noprefix(table, 0, 4);
}

/*
 * Generic Error Data Entry
 * ACPI 6.1: 18.3.2.7.1 Generic Error Data
 */
static void acpi_ghes_generic_error_data(GArray *table,
                const uint8_t *section_type, uint32_t error_severity,
                uint8_t validation_bits, uint8_t flags,
                uint32_t error_data_length, QemuUUID fru_id,
                uint64_t time_stamp)
{
    const uint8_t fru_text[20] = {0};

    /* Section Type */
    g_array_append_vals(table, section_type, 16);

    /* Error Severity */
    build_append_int_noprefix(table, error_severity, 4);
    /* Revision */
    build_append_int_noprefix(table, 0x300, 2);
    /* Validation Bits */
    build_append_int_noprefix(table, validation_bits, 1);
    /* Flags */
    build_append_int_noprefix(table, flags, 1);
    /* Error Data Length */
    build_append_int_noprefix(table, error_data_length, 4);

    /* FRU Id */
    g_array_append_vals(table, fru_id.data, ARRAY_SIZE(fru_id.data));

    /* FRU Text */
    g_array_append_vals(table, fru_text, sizeof(fru_text));

    /* Timestamp */
    build_append_int_noprefix(table, time_stamp, 8);
}

/*
 * Generic Error Status Block
 * ACPI 6.1: 18.3.2.7.1 Generic Error Data
 */
static void acpi_ghes_generic_error_status(GArray *table, uint32_t block_status,
                uint32_t raw_data_offset, uint32_t raw_data_length,
                uint32_t data_length, uint32_t error_severity)
{
    /* Block Status */
    build_append_int_noprefix(table, block_status, 4);
    /* Raw Data Offset */
    build_append_int_noprefix(table, raw_data_offset, 4);
    /* Raw Data Length */
    build_append_int_noprefix(table, raw_data_length, 4);
    /* Data Length */
    build_append_int_noprefix(table, data_length, 4);
    /* Error Severity */
    build_append_int_noprefix(table, error_severity, 4);
}

/* UEFI 2.6: N.2.5 Memory Error Section */
static void acpi_ghes_build_append_mem_cper(GArray *table,
                                            uint64_t error_physical_addr)
{
    /*
     * Memory Error Record
     */

    /* Validation Bits */
    build_append_int_noprefix(table,
                              (1ULL << 14) | /* Type Valid */
                              (1ULL << 1) /* Physical Address Valid */,
                              8);
    /* Error Status */
    build_append_int_noprefix(table, 0, 8);
    /* Physical Address */
    build_append_int_noprefix(table, error_physical_addr, 8);
    /* Skip all the detailed information normally found in such a record */
    build_append_int_noprefix(table, 0, 48);
    /* Memory Error Type */
    build_append_int_noprefix(table, 0 /* Unknown error */, 1);
    /* Skip all the detailed information normally found in such a record */
    build_append_int_noprefix(table, 0, 7);
}

static int acpi_ghes_record_mem_error(uint64_t error_block_address,
                                      uint64_t error_physical_addr)
{
    GArray *block;

    /* Memory Error Section Type */
    const uint8_t uefi_cper_mem_sec[] =
          UUID_LE(0xA5BC1114, 0x6F64, 0x4EDE, 0xB8, 0x63, 0x3E, 0x83, \
                  0xED, 0x7C, 0x83, 0xB1);

    /* invalid fru id: ACPI 4.0: 17.3.2.6.1 Generic Error Data,
     * Table 17-13 Generic Error Data Entry
     */
    QemuUUID fru_id = {};
    uint32_t data_length;

    block = g_array_new(false, true /* clear */, 1);

    /* This is the length if adding a new generic error data entry*/
    data_length = ACPI_GHES_DATA_LENGTH + ACPI_GHES_MEM_CPER_LENGTH;
    /*
     * It should not run out of the preallocated memory if adding a new generic
     * error data entry
     */
    assert((data_length + ACPI_GHES_GESB_SIZE) <=
            ACPI_GHES_MAX_RAW_DATA_LENGTH);

    /* Build the new generic error status block header */
    acpi_ghes_generic_error_status(block, ACPI_GEBS_UNCORRECTABLE,
        0, 0, data_length, ACPI_CPER_SEV_RECOVERABLE);

    /* Build this new generic error data entry header */
    acpi_ghes_generic_error_data(block, uefi_cper_mem_sec,
        ACPI_CPER_SEV_RECOVERABLE, 0, 0,
        ACPI_GHES_MEM_CPER_LENGTH, fru_id, 0);

    /* Build the memory section CPER for above new generic error data entry */
    acpi_ghes_build_append_mem_cper(block, error_physical_addr);

    /* Write the generic error data entry into guest memory */
    cpu_physical_memory_write(error_block_address, block->data, block->len);

    g_array_free(block, true);

    return 0;
}

/*
 * Build table for the hardware error fw_cfg blob.
 * Initialize "etc/hardware_errors" and "etc/hardware_errors_addr" fw_cfg blobs.
 * See docs/specs/acpi_hest_ghes.rst for blobs format.
 */
void build_ghes_error_table(GArray *hardware_errors, BIOSLinker *linker)
{
    int i, error_status_block_offset;

    /* Build error_block_address */
    for (i = 0; i < ACPI_GHES_ERROR_SOURCE_COUNT; i++) {
        build_append_int_noprefix(hardware_errors, 0, sizeof(uint64_t));
    }

    /* Build read_ack_register */
    for (i = 0; i < ACPI_GHES_ERROR_SOURCE_COUNT; i++) {
        /*
         * Initialize the value of read_ack_register to 1, so GHES can be
         * writeable after (re)boot.
         * ACPI 6.2: 18.3.2.8 Generic Hardware Error Source version 2
         * (GHESv2 - Type 10)
         */
        build_append_int_noprefix(hardware_errors, 1, sizeof(uint64_t));
    }

    /* Generic Error Status Block offset in the hardware error fw_cfg blob */
    error_status_block_offset = hardware_errors->len;

    /* Reserve space for Error Status Data Block */
    acpi_data_push(hardware_errors,
        ACPI_GHES_MAX_RAW_DATA_LENGTH * ACPI_GHES_ERROR_SOURCE_COUNT);

    /* Tell guest firmware to place hardware_errors blob into RAM */
    bios_linker_loader_alloc(linker, ACPI_GHES_ERRORS_FW_CFG_FILE,
                             hardware_errors, sizeof(uint64_t), false);

    for (i = 0; i < ACPI_GHES_ERROR_SOURCE_COUNT; i++) {
        /*
         * Tell firmware to patch error_block_address entries to point to
         * corresponding "Generic Error Status Block"
         */
        bios_linker_loader_add_pointer(linker,
            ACPI_GHES_ERRORS_FW_CFG_FILE, sizeof(uint64_t) * i,
            sizeof(uint64_t), ACPI_GHES_ERRORS_FW_CFG_FILE,
            error_status_block_offset + i * ACPI_GHES_MAX_RAW_DATA_LENGTH);
    }

    /*
     * tell firmware to write hardware_errors GPA into
     * hardware_errors_addr fw_cfg, once the former has been initialized.
     */
    bios_linker_loader_write_pointer(linker, ACPI_GHES_DATA_ADDR_FW_CFG_FILE,
        0, sizeof(uint64_t), ACPI_GHES_ERRORS_FW_CFG_FILE, 0);
}

/* Build Generic Hardware Error Source version 2 (GHESv2) */
static void build_ghes_v2(GArray *table_data, int source_id, BIOSLinker *linker)
{
    uint64_t address_offset;
    /*
     * Type:
     * Generic Hardware Error Source version 2(GHESv2 - Type 10)
     */
    build_append_int_noprefix(table_data, ACPI_GHES_SOURCE_GENERIC_ERROR_V2, 2);
    /* Source Id */
    build_append_int_noprefix(table_data, source_id, 2);
    /* Related Source Id */
    build_append_int_noprefix(table_data, 0xffff, 2);
    /* Flags */
    build_append_int_noprefix(table_data, 0, 1);
    /* Enabled */
    build_append_int_noprefix(table_data, 1, 1);

    /* Number of Records To Pre-allocate */
    build_append_int_noprefix(table_data, 1, 4);
    /* Max Sections Per Record */
    build_append_int_noprefix(table_data, 1, 4);
    /* Max Raw Data Length */
    build_append_int_noprefix(table_data, ACPI_GHES_MAX_RAW_DATA_LENGTH, 4);

    address_offset = table_data->len;
    /* Error Status Address */
    build_append_gas(table_data, AML_AS_SYSTEM_MEMORY, 0x40, 0,
                     4 /* QWord access */, 0);
    bios_linker_loader_add_pointer(linker, ACPI_BUILD_TABLE_FILE,
        address_offset + GAS_ADDR_OFFSET, sizeof(uint64_t),
        ACPI_GHES_ERRORS_FW_CFG_FILE, source_id * sizeof(uint64_t));

    switch (source_id) {
    case ACPI_HEST_SRC_ID_SEA:
        /*
         * Notification Structure
         * Now only enable ARMv8 SEA notification type
         */
        build_ghes_hw_error_notification(table_data, ACPI_GHES_NOTIFY_SEA);
        break;
    default:
        error_report("Not support this error source");
        abort();
    }

    /* Error Status Block Length */
    build_append_int_noprefix(table_data, ACPI_GHES_MAX_RAW_DATA_LENGTH, 4);

    /*
     * Read Ack Register
     * ACPI 6.1: 18.3.2.8 Generic Hardware Error Source
     * version 2 (GHESv2 - Type 10)
     */
    address_offset = table_data->len;
    build_append_gas(table_data, AML_AS_SYSTEM_MEMORY, 0x40, 0,
                     4 /* QWord access */, 0);
    bios_linker_loader_add_pointer(linker, ACPI_BUILD_TABLE_FILE,
        address_offset + GAS_ADDR_OFFSET,
        sizeof(uint64_t), ACPI_GHES_ERRORS_FW_CFG_FILE,
        (ACPI_GHES_ERROR_SOURCE_COUNT + source_id) * sizeof(uint64_t));

    /*
     * Read Ack Preserve field
     * We only provide the first bit in Read Ack Register to OSPM to write
     * while the other bits are preserved.
     */
    build_append_int_noprefix(table_data, ~0x1ULL, 8);
    /* Read Ack Write */
    build_append_int_noprefix(table_data, 0x1, 8);
}

/* Build Hardware Error Source Table */
void acpi_build_hest(GArray *table_data, BIOSLinker *linker,
                     const char *oem_id, const char *oem_table_id)
{
    AcpiTable table = { .sig = "HEST", .rev = 1,
                        .oem_id = oem_id, .oem_table_id = oem_table_id };

    acpi_table_begin(&table, table_data);

    /* Error Source Count */
    build_append_int_noprefix(table_data, ACPI_GHES_ERROR_SOURCE_COUNT, 4);
    build_ghes_v2(table_data, ACPI_HEST_SRC_ID_SEA, linker);

    acpi_table_end(linker, &table);
}

void acpi_ghes_add_fw_cfg(AcpiGhesState *ags, FWCfgState *s,
                          GArray *hardware_error)
{
    /* Create a read-only fw_cfg file for GHES */
    fw_cfg_add_file(s, ACPI_GHES_ERRORS_FW_CFG_FILE, hardware_error->data,
                    hardware_error->len);

    /* Create a read-write fw_cfg file for Address */
    fw_cfg_add_file_callback(s, ACPI_GHES_DATA_ADDR_FW_CFG_FILE, NULL, NULL,
        NULL, &(ags->ghes_addr_le), sizeof(ags->ghes_addr_le), false);

    ags->present = true;
}

int acpi_ghes_record_errors(uint8_t source_id, uint64_t physical_address)
{
    uint64_t error_block_addr, read_ack_register_addr, read_ack_register = 0;
    uint64_t start_addr;
    bool ret = -1;
    AcpiGedState *acpi_ged_state;
    AcpiGhesState *ags;

    assert(source_id < ACPI_HEST_SRC_ID_RESERVED);

    acpi_ged_state = ACPI_GED(object_resolve_path_type("", TYPE_ACPI_GED,
                                                       NULL));
    g_assert(acpi_ged_state);
    ags = &acpi_ged_state->ghes_state;

    start_addr = le64_to_cpu(ags->ghes_addr_le);

    if (physical_address) {

        if (source_id < ACPI_HEST_SRC_ID_RESERVED) {
            start_addr += source_id * sizeof(uint64_t);
        }

        cpu_physical_memory_read(start_addr, &error_block_addr,
                                 sizeof(error_block_addr));

        error_block_addr = le64_to_cpu(error_block_addr);

        read_ack_register_addr = start_addr +
            ACPI_GHES_ERROR_SOURCE_COUNT * sizeof(uint64_t);

        cpu_physical_memory_read(read_ack_register_addr,
                                 &read_ack_register, sizeof(read_ack_register));

        /* zero means OSPM does not acknowledge the error */
        if (!read_ack_register) {
            error_report("OSPM does not acknowledge previous error,"
                " so can not record CPER for current error anymore");
        } else if (error_block_addr) {
            read_ack_register = cpu_to_le64(0);
            /*
             * Clear the Read Ack Register, OSPM will write it to 1 when
             * it acknowledges this error.
             */
            cpu_physical_memory_write(read_ack_register_addr,
                &read_ack_register, sizeof(uint64_t));

            ret = acpi_ghes_record_mem_error(error_block_addr,
                                             physical_address);
        } else
            error_report("can not find Generic Error Status Block");
    }

    return ret;
}

bool acpi_ghes_present(void)
{
    AcpiGedState *acpi_ged_state;
    AcpiGhesState *ags;

    acpi_ged_state = ACPI_GED(object_resolve_path_type("", TYPE_ACPI_GED,
                                                       NULL));

    if (!acpi_ged_state) {
        return false;
    }
    ags = &acpi_ged_state->ghes_state;
    return ags->present;
}
Commit	Line	Data
aa16508f DG	1	/*
	2	* Support for generating APEI tables and recording CPER for Guests
	3	*
	4	* Copyright (c) 2020 HUAWEI TECHNOLOGIES CO., LTD.
	5	*
	6	* Author: Dongjiu Geng <gengdongjiu@huawei.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17
	18	* You should have received a copy of the GNU General Public License along
	19	* with this program; if not, see <http://www.gnu.org/licenses/>.
	20	*/
	21
	22	#include "qemu/osdep.h"
	23	#include "qemu/units.h"
	24	#include "hw/acpi/ghes.h"
	25	#include "hw/acpi/aml-build.h"
205cc75d	26	#include "qemu/error-report.h"
a08a6462 DG	27	#include "hw/acpi/generic_event_device.h"
a08a6462 DG	28	#include "hw/nvram/fw_cfg.h"
558b9d86	29	#include "qemu/uuid.h"
aa16508f DG	30
	31	#define ACPI_GHES_ERRORS_FW_CFG_FILE "etc/hardware_errors"
	32	#define ACPI_GHES_DATA_ADDR_FW_CFG_FILE "etc/hardware_errors_addr"
	33
	34	/* The max size in bytes for one error block */
	35	#define ACPI_GHES_MAX_RAW_DATA_LENGTH (1 * KiB)
	36
	37	/* Now only support ARMv8 SEA notification type error source */
	38	#define ACPI_GHES_ERROR_SOURCE_COUNT 1
	39
205cc75d DG	40	/* Generic Hardware Error Source version 2 */
	41	#define ACPI_GHES_SOURCE_GENERIC_ERROR_V2 10
	42
	43	/* Address offset in Generic Address Structure(GAS) */
	44	#define GAS_ADDR_OFFSET 4
	45
558b9d86 DG	46	/*
	47	* The total size of Generic Error Data Entry
	48	* ACPI 6.1/6.2: 18.3.2.7.1 Generic Error Data,
	49	* Table 18-343 Generic Error Data Entry
	50	*/
	51	#define ACPI_GHES_DATA_LENGTH 72
	52
	53	/* The memory section CPER size, UEFI 2.6: N.2.5 Memory Error Section */
	54	#define ACPI_GHES_MEM_CPER_LENGTH 80
	55
	56	/* Masks for block_status flags */
	57	#define ACPI_GEBS_UNCORRECTABLE 1
	58
	59	/*
	60	* Total size for Generic Error Status Block except Generic Error Data Entries
	61	* ACPI 6.2: 18.3.2.7.1 Generic Error Data,
	62	* Table 18-380 Generic Error Status Block
	63	*/
	64	#define ACPI_GHES_GESB_SIZE 20
	65
	66	/*
	67	* Values for error_severity field
	68	*/
	69	enum AcpiGenericErrorSeverity {
	70	ACPI_CPER_SEV_RECOVERABLE = 0,
	71	ACPI_CPER_SEV_FATAL = 1,
	72	ACPI_CPER_SEV_CORRECTED = 2,
	73	ACPI_CPER_SEV_NONE = 3,
	74	};
	75
205cc75d DG	76	/*
	77	* Hardware Error Notification
	78	* ACPI 4.0: 17.3.2.7 Hardware Error Notification
	79	* Composes dummy Hardware Error Notification descriptor of specified type
	80	*/
	81	static void build_ghes_hw_error_notification(GArray *table, const uint8_t type)
	82	{
	83	/* Type */
	84	build_append_int_noprefix(table, type, 1);
	85	/*
	86	* Length:
	87	* Total length of the structure in bytes
	88	*/
	89	build_append_int_noprefix(table, 28, 1);
	90	/* Configuration Write Enable */
	91	build_append_int_noprefix(table, 0, 2);
	92	/* Poll Interval */
	93	build_append_int_noprefix(table, 0, 4);
	94	/* Vector */
	95	build_append_int_noprefix(table, 0, 4);
	96	/* Switch To Polling Threshold Value */
	97	build_append_int_noprefix(table, 0, 4);
	98	/* Switch To Polling Threshold Window */
	99	build_append_int_noprefix(table, 0, 4);
	100	/* Error Threshold Value */
	101	build_append_int_noprefix(table, 0, 4);
	102	/* Error Threshold Window */
	103	build_append_int_noprefix(table, 0, 4);
	104	}
	105
558b9d86 DG	106	/*
	107	* Generic Error Data Entry
	108	* ACPI 6.1: 18.3.2.7.1 Generic Error Data
	109	*/
	110	static void acpi_ghes_generic_error_data(GArray *table,
	111	const uint8_t *section_type, uint32_t error_severity,
	112	uint8_t validation_bits, uint8_t flags,
	113	uint32_t error_data_length, QemuUUID fru_id,
	114	uint64_t time_stamp)
	115	{
	116	const uint8_t fru_text[20] = {0};
	117
	118	/* Section Type */
	119	g_array_append_vals(table, section_type, 16);
	120
	121	/* Error Severity */
	122	build_append_int_noprefix(table, error_severity, 4);
	123	/* Revision */
	124	build_append_int_noprefix(table, 0x300, 2);
	125	/* Validation Bits */
	126	build_append_int_noprefix(table, validation_bits, 1);
	127	/* Flags */
	128	build_append_int_noprefix(table, flags, 1);
	129	/* Error Data Length */
	130	build_append_int_noprefix(table, error_data_length, 4);
	131
	132	/* FRU Id */
	133	g_array_append_vals(table, fru_id.data, ARRAY_SIZE(fru_id.data));
	134
	135	/* FRU Text */
	136	g_array_append_vals(table, fru_text, sizeof(fru_text));
	137
	138	/* Timestamp */
	139	build_append_int_noprefix(table, time_stamp, 8);
	140	}
	141
	142	/*
	143	* Generic Error Status Block
	144	* ACPI 6.1: 18.3.2.7.1 Generic Error Data
	145	*/
	146	static void acpi_ghes_generic_error_status(GArray *table, uint32_t block_status,
	147	uint32_t raw_data_offset, uint32_t raw_data_length,
	148	uint32_t data_length, uint32_t error_severity)
	149	{
	150	/* Block Status */
	151	build_append_int_noprefix(table, block_status, 4);
	152	/* Raw Data Offset */
	153	build_append_int_noprefix(table, raw_data_offset, 4);
	154	/* Raw Data Length */
	155	build_append_int_noprefix(table, raw_data_length, 4);
	156	/* Data Length */
	157	build_append_int_noprefix(table, data_length, 4);
	158	/* Error Severity */
	159	build_append_int_noprefix(table, error_severity, 4);
	160	}
	161
	162	/* UEFI 2.6: N.2.5 Memory Error Section */
	163	static void acpi_ghes_build_append_mem_cper(GArray *table,
	164	uint64_t error_physical_addr)
	165	{
	166	/*
	167	* Memory Error Record
	168	*/
	169
170	/* Validation Bits */
171	build_append_int_noprefix(table,
172	(1ULL << 14) \| /* Type Valid */
173	(1ULL << 1) /* Physical Address Valid */,
174	8);
175	/* Error Status */
176	build_append_int_noprefix(table, 0, 8);
177	/* Physical Address */
178	build_append_int_noprefix(table, error_physical_addr, 8);
179	/* Skip all the detailed information normally found in such a record */
180	build_append_int_noprefix(table, 0, 48);
181	/* Memory Error Type */
182	build_append_int_noprefix(table, 0 /* Unknown error */, 1);
183	/* Skip all the detailed information normally found in such a record */
184	build_append_int_noprefix(table, 0, 7);
185	}
186
187	static int acpi_ghes_record_mem_error(uint64_t error_block_address,
188	uint64_t error_physical_addr)
189	{
190	GArray *block;
191
192	/* Memory Error Section Type */
193	const uint8_t uefi_cper_mem_sec[] =
194	UUID_LE(0xA5BC1114, 0x6F64, 0x4EDE, 0xB8, 0x63, 0x3E, 0x83, \
195	0xED, 0x7C, 0x83, 0xB1);
196
197	/* invalid fru id: ACPI 4.0: 17.3.2.6.1 Generic Error Data,
198	* Table 17-13 Generic Error Data Entry
199	*/
200	QemuUUID fru_id = {};
201	uint32_t data_length;
202
203	block = g_array_new(false, true /* clear */, 1);
204
205	/* This is the length if adding a new generic error data entry*/
206	data_length = ACPI_GHES_DATA_LENGTH + ACPI_GHES_MEM_CPER_LENGTH;
558b9d86	207	/*
4bf7c0cb DG	208	* It should not run out of the preallocated memory if adding a new generic
4bf7c0cb DG	209	* error data entry
558b9d86	210	*/
4bf7c0cb DG	211	assert((data_length + ACPI_GHES_GESB_SIZE) <=
4bf7c0cb DG	212	ACPI_GHES_MAX_RAW_DATA_LENGTH);
558b9d86 DG	213
	214	/* Build the new generic error status block header */
	215	acpi_ghes_generic_error_status(block, ACPI_GEBS_UNCORRECTABLE,
	216	0, 0, data_length, ACPI_CPER_SEV_RECOVERABLE);
	217
	218	/* Build this new generic error data entry header */
	219	acpi_ghes_generic_error_data(block, uefi_cper_mem_sec,
	220	ACPI_CPER_SEV_RECOVERABLE, 0, 0,
	221	ACPI_GHES_MEM_CPER_LENGTH, fru_id, 0);
	222
	223	/* Build the memory section CPER for above new generic error data entry */
	224	acpi_ghes_build_append_mem_cper(block, error_physical_addr);
	225
	226	/* Write the generic error data entry into guest memory */
	227	cpu_physical_memory_write(error_block_address, block->data, block->len);
	228
	229	g_array_free(block, true);
	230
	231	return 0;
	232	}
	233
aa16508f DG	234	/*
	235	* Build table for the hardware error fw_cfg blob.
	236	* Initialize "etc/hardware_errors" and "etc/hardware_errors_addr" fw_cfg blobs.
	237	* See docs/specs/acpi_hest_ghes.rst for blobs format.
	238	*/
	239	void build_ghes_error_table(GArray hardware_errors, BIOSLinker linker)
	240	{
	241	int i, error_status_block_offset;
	242
	243	/* Build error_block_address */
	244	for (i = 0; i < ACPI_GHES_ERROR_SOURCE_COUNT; i++) {
	245	build_append_int_noprefix(hardware_errors, 0, sizeof(uint64_t));
	246	}
	247
	248	/* Build read_ack_register */
	249	for (i = 0; i < ACPI_GHES_ERROR_SOURCE_COUNT; i++) {
	250	/*
	251	* Initialize the value of read_ack_register to 1, so GHES can be
	252	* writeable after (re)boot.
	253	* ACPI 6.2: 18.3.2.8 Generic Hardware Error Source version 2
	254	* (GHESv2 - Type 10)
	255	*/
	256	build_append_int_noprefix(hardware_errors, 1, sizeof(uint64_t));
	257	}
	258
	259	/* Generic Error Status Block offset in the hardware error fw_cfg blob */
	260	error_status_block_offset = hardware_errors->len;
	261
	262	/* Reserve space for Error Status Data Block */
	263	acpi_data_push(hardware_errors,
	264	ACPI_GHES_MAX_RAW_DATA_LENGTH * ACPI_GHES_ERROR_SOURCE_COUNT);
	265
	266	/* Tell guest firmware to place hardware_errors blob into RAM */
	267	bios_linker_loader_alloc(linker, ACPI_GHES_ERRORS_FW_CFG_FILE,
	268	hardware_errors, sizeof(uint64_t), false);
	269
	270	for (i = 0; i < ACPI_GHES_ERROR_SOURCE_COUNT; i++) {
	271	/*
	272	* Tell firmware to patch error_block_address entries to point to
	273	* corresponding "Generic Error Status Block"
	274	*/
	275	bios_linker_loader_add_pointer(linker,
	276	ACPI_GHES_ERRORS_FW_CFG_FILE, sizeof(uint64_t) * i,
	277	sizeof(uint64_t), ACPI_GHES_ERRORS_FW_CFG_FILE,
	278	error_status_block_offset + i * ACPI_GHES_MAX_RAW_DATA_LENGTH);
	279	}
	280
	281	/*
	282	* tell firmware to write hardware_errors GPA into
	283	* hardware_errors_addr fw_cfg, once the former has been initialized.
	284	*/
	285	bios_linker_loader_write_pointer(linker, ACPI_GHES_DATA_ADDR_FW_CFG_FILE,
	286	0, sizeof(uint64_t), ACPI_GHES_ERRORS_FW_CFG_FILE, 0);
	287	}
205cc75d DG	288
	289	/* Build Generic Hardware Error Source version 2 (GHESv2) */
	290	static void build_ghes_v2(GArray table_data, int source_id, BIOSLinker linker)
	291	{
	292	uint64_t address_offset;
	293	/*
	294	* Type:
	295	* Generic Hardware Error Source version 2(GHESv2 - Type 10)
	296	*/
	297	build_append_int_noprefix(table_data, ACPI_GHES_SOURCE_GENERIC_ERROR_V2, 2);
	298	/* Source Id */
	299	build_append_int_noprefix(table_data, source_id, 2);
	300	/* Related Source Id */
	301	build_append_int_noprefix(table_data, 0xffff, 2);
	302	/* Flags */
	303	build_append_int_noprefix(table_data, 0, 1);
	304	/* Enabled */
	305	build_append_int_noprefix(table_data, 1, 1);
	306
	307	/* Number of Records To Pre-allocate */
	308	build_append_int_noprefix(table_data, 1, 4);
	309	/* Max Sections Per Record */
	310	build_append_int_noprefix(table_data, 1, 4);
	311	/* Max Raw Data Length */
	312	build_append_int_noprefix(table_data, ACPI_GHES_MAX_RAW_DATA_LENGTH, 4);
	313
	314	address_offset = table_data->len;
	315	/* Error Status Address */
	316	build_append_gas(table_data, AML_AS_SYSTEM_MEMORY, 0x40, 0,
	317	4 /* QWord access */, 0);
	318	bios_linker_loader_add_pointer(linker, ACPI_BUILD_TABLE_FILE,
	319	address_offset + GAS_ADDR_OFFSET, sizeof(uint64_t),
	320	ACPI_GHES_ERRORS_FW_CFG_FILE, source_id * sizeof(uint64_t));
	321
	322	switch (source_id) {
	323	case ACPI_HEST_SRC_ID_SEA:
	324	/*
	325	* Notification Structure
	326	* Now only enable ARMv8 SEA notification type
	327	*/
	328	build_ghes_hw_error_notification(table_data, ACPI_GHES_NOTIFY_SEA);
	329	break;
	330	default:
	331	error_report("Not support this error source");
	332	abort();
	333	}
	334
	335	/* Error Status Block Length */
	336	build_append_int_noprefix(table_data, ACPI_GHES_MAX_RAW_DATA_LENGTH, 4);
	337
	338	/*
	339	* Read Ack Register
	340	* ACPI 6.1: 18.3.2.8 Generic Hardware Error Source
	341	* version 2 (GHESv2 - Type 10)
	342	*/
	343	address_offset = table_data->len;
	344	build_append_gas(table_data, AML_AS_SYSTEM_MEMORY, 0x40, 0,
	345	4 /* QWord access */, 0);
	346	bios_linker_loader_add_pointer(linker, ACPI_BUILD_TABLE_FILE,
	347	address_offset + GAS_ADDR_OFFSET,
	348	sizeof(uint64_t), ACPI_GHES_ERRORS_FW_CFG_FILE,
	349	(ACPI_GHES_ERROR_SOURCE_COUNT + source_id) * sizeof(uint64_t));
	350
	351	/*
352	* Read Ack Preserve field
353	* We only provide the first bit in Read Ack Register to OSPM to write
354	* while the other bits are preserved.
355	*/
356	build_append_int_noprefix(table_data, ~0x1ULL, 8);
357	/* Read Ack Write */
358	build_append_int_noprefix(table_data, 0x1, 8);
359	}
360
361	/* Build Hardware Error Source Table */
602b4582 MP	362	void acpi_build_hest(GArray table_data, BIOSLinker linker,
602b4582 MP	363	const char oem_id, const char oem_table_id)
205cc75d	364	{
13229858 IM	365	AcpiTable table = { .sig = "HEST", .rev = 1,
13229858 IM	366	.oem_id = oem_id, .oem_table_id = oem_table_id };
205cc75d	367
13229858	368	acpi_table_begin(&table, table_data);
205cc75d DG	369
	370	/* Error Source Count */
	371	build_append_int_noprefix(table_data, ACPI_GHES_ERROR_SOURCE_COUNT, 4);
205cc75d DG	372	build_ghes_v2(table_data, ACPI_HEST_SRC_ID_SEA, linker);
205cc75d DG	373
13229858	374	acpi_table_end(linker, &table);
205cc75d	375	}
a08a6462 DG	376
	377	void acpi_ghes_add_fw_cfg(AcpiGhesState ags, FWCfgState s,
	378	GArray *hardware_error)
	379	{
	380	/* Create a read-only fw_cfg file for GHES */
	381	fw_cfg_add_file(s, ACPI_GHES_ERRORS_FW_CFG_FILE, hardware_error->data,
	382	hardware_error->len);
	383
	384	/* Create a read-write fw_cfg file for Address */
	385	fw_cfg_add_file_callback(s, ACPI_GHES_DATA_ADDR_FW_CFG_FILE, NULL, NULL,
	386	NULL, &(ags->ghes_addr_le), sizeof(ags->ghes_addr_le), false);
1c81f573 PM	387
1c81f573 PM	388	ags->present = true;
a08a6462	389	}
558b9d86 DG	390
	391	int acpi_ghes_record_errors(uint8_t source_id, uint64_t physical_address)
	392	{
	393	uint64_t error_block_addr, read_ack_register_addr, read_ack_register = 0;
	394	uint64_t start_addr;
	395	bool ret = -1;
	396	AcpiGedState *acpi_ged_state;
	397	AcpiGhesState *ags;
	398
	399	assert(source_id < ACPI_HEST_SRC_ID_RESERVED);
	400
	401	acpi_ged_state = ACPI_GED(object_resolve_path_type("", TYPE_ACPI_GED,
	402	NULL));
	403	g_assert(acpi_ged_state);
	404	ags = &acpi_ged_state->ghes_state;
	405
	406	start_addr = le64_to_cpu(ags->ghes_addr_le);
	407
	408	if (physical_address) {
	409
	410	if (source_id < ACPI_HEST_SRC_ID_RESERVED) {
	411	start_addr += source_id * sizeof(uint64_t);
	412	}
	413
	414	cpu_physical_memory_read(start_addr, &error_block_addr,
	415	sizeof(error_block_addr));
	416
	417	error_block_addr = le64_to_cpu(error_block_addr);
	418
	419	read_ack_register_addr = start_addr +
	420	ACPI_GHES_ERROR_SOURCE_COUNT * sizeof(uint64_t);
	421
	422	cpu_physical_memory_read(read_ack_register_addr,
	423	&read_ack_register, sizeof(read_ack_register));
	424
	425	/* zero means OSPM does not acknowledge the error */
	426	if (!read_ack_register) {
	427	error_report("OSPM does not acknowledge previous error,"
	428	" so can not record CPER for current error anymore");
	429	} else if (error_block_addr) {
	430	read_ack_register = cpu_to_le64(0);
	431	/*
	432	* Clear the Read Ack Register, OSPM will write it to 1 when
	433	* it acknowledges this error.
	434	*/
	435	cpu_physical_memory_write(read_ack_register_addr,
	436	&read_ack_register, sizeof(uint64_t));
	437
	438	ret = acpi_ghes_record_mem_error(error_block_addr,
	439	physical_address);
	440	} else
	441	error_report("can not find Generic Error Status Block");
	442	}
	443
	444	return ret;
	445	}
1c81f573 PM	446
	447	bool acpi_ghes_present(void)
	448	{
	449	AcpiGedState *acpi_ged_state;
	450	AcpiGhesState *ags;
	451
	452	acpi_ged_state = ACPI_GED(object_resolve_path_type("", TYPE_ACPI_GED,
	453	NULL));
	454
	455	if (!acpi_ged_state) {
	456	return false;
	457	}
	458	ags = &acpi_ged_state->ghes_state;
	459	return ags->present;
	460	}