Dongjiu Geng | aa16508 | 2020-05-12 11:06:03 +0800 | [diff] [blame] | 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" |
Dongjiu Geng | 205cc75 | 2020-05-12 11:06:04 +0800 | [diff] [blame] | 26 | #include "qemu/error-report.h" |
Dongjiu Geng | a08a646 | 2020-05-12 11:06:05 +0800 | [diff] [blame] | 27 | #include "hw/acpi/generic_event_device.h" |
| 28 | #include "hw/nvram/fw_cfg.h" |
Dongjiu Geng | 558b9d8 | 2020-05-12 11:06:07 +0800 | [diff] [blame] | 29 | #include "qemu/uuid.h" |
Dongjiu Geng | aa16508 | 2020-05-12 11:06:03 +0800 | [diff] [blame] | 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 | |
Dongjiu Geng | 205cc75 | 2020-05-12 11:06:04 +0800 | [diff] [blame] | 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 | |
| 46 | /* |
Dongjiu Geng | 558b9d8 | 2020-05-12 11:06:07 +0800 | [diff] [blame] | 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 | |
| 76 | /* |
Dongjiu Geng | 205cc75 | 2020-05-12 11:06:04 +0800 | [diff] [blame] | 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 | |
Dongjiu Geng | aa16508 | 2020-05-12 11:06:03 +0800 | [diff] [blame] | 106 | /* |
Dongjiu Geng | 558b9d8 | 2020-05-12 11:06:07 +0800 | [diff] [blame] | 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; |
Dongjiu Geng | 558b9d8 | 2020-05-12 11:06:07 +0800 | [diff] [blame] | 207 | /* |
Dongjiu Geng | 4bf7c0c | 2020-07-27 16:12:10 +0100 | [diff] [blame] | 208 | * It should not run out of the preallocated memory if adding a new generic |
| 209 | * error data entry |
Dongjiu Geng | 558b9d8 | 2020-05-12 11:06:07 +0800 | [diff] [blame] | 210 | */ |
Dongjiu Geng | 4bf7c0c | 2020-07-27 16:12:10 +0100 | [diff] [blame] | 211 | assert((data_length + ACPI_GHES_GESB_SIZE) <= |
| 212 | ACPI_GHES_MAX_RAW_DATA_LENGTH); |
Dongjiu Geng | 558b9d8 | 2020-05-12 11:06:07 +0800 | [diff] [blame] | 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 | |
| 234 | /* |
Dongjiu Geng | aa16508 | 2020-05-12 11:06:03 +0800 | [diff] [blame] | 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 |
Peter Maydell | 9323e79 | 2022-06-08 19:38:47 +0100 | [diff] [blame] | 252 | * writable after (re)boot. |
Dongjiu Geng | aa16508 | 2020-05-12 11:06:03 +0800 | [diff] [blame] | 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 | } |
Dongjiu Geng | 205cc75 | 2020-05-12 11:06:04 +0800 | [diff] [blame] | 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 */ |
Marian Postevca | 602b458 | 2021-01-19 02:32:13 +0200 | [diff] [blame] | 362 | void acpi_build_hest(GArray *table_data, BIOSLinker *linker, |
| 363 | const char *oem_id, const char *oem_table_id) |
Dongjiu Geng | 205cc75 | 2020-05-12 11:06:04 +0800 | [diff] [blame] | 364 | { |
Igor Mammedov | 1322985 | 2021-09-24 08:27:34 -0400 | [diff] [blame] | 365 | AcpiTable table = { .sig = "HEST", .rev = 1, |
| 366 | .oem_id = oem_id, .oem_table_id = oem_table_id }; |
Dongjiu Geng | 205cc75 | 2020-05-12 11:06:04 +0800 | [diff] [blame] | 367 | |
Igor Mammedov | 1322985 | 2021-09-24 08:27:34 -0400 | [diff] [blame] | 368 | acpi_table_begin(&table, table_data); |
Dongjiu Geng | 205cc75 | 2020-05-12 11:06:04 +0800 | [diff] [blame] | 369 | |
| 370 | /* Error Source Count */ |
| 371 | build_append_int_noprefix(table_data, ACPI_GHES_ERROR_SOURCE_COUNT, 4); |
Dongjiu Geng | 205cc75 | 2020-05-12 11:06:04 +0800 | [diff] [blame] | 372 | build_ghes_v2(table_data, ACPI_HEST_SRC_ID_SEA, linker); |
| 373 | |
Igor Mammedov | 1322985 | 2021-09-24 08:27:34 -0400 | [diff] [blame] | 374 | acpi_table_end(linker, &table); |
Dongjiu Geng | 205cc75 | 2020-05-12 11:06:04 +0800 | [diff] [blame] | 375 | } |
Dongjiu Geng | a08a646 | 2020-05-12 11:06:05 +0800 | [diff] [blame] | 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); |
Peter Maydell | 1c81f57 | 2021-06-17 13:24:37 +0100 | [diff] [blame] | 387 | |
| 388 | ags->present = true; |
Dongjiu Geng | a08a646 | 2020-05-12 11:06:05 +0800 | [diff] [blame] | 389 | } |
Dongjiu Geng | 558b9d8 | 2020-05-12 11:06:07 +0800 | [diff] [blame] | 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 | } |
Peter Maydell | 1c81f57 | 2021-06-17 13:24:37 +0100 | [diff] [blame] | 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 | } |