From 77b285f7f6ed637ee2576ae96744211ce9691567 Mon Sep 17 00:00:00 2001 From: zhenwei pi Date: Wed, 30 Sep 2020 18:04:39 +0800 Subject: [PATCH] qapi/run-state.json: introduce memory failure event Introduce memory failure events for hypervisor and guest. This lets mft: Need exactly one file argument. Try `mft --help' for more information. Suggested by Peter Maydell, rename events name&description to make them architecture-neutral; and suggested by Paolo, add more info to distinguish a mce is AR/AO, and if a previous MCE was still being processed in the guest. Signed-off-by: zhenwei pi Message-Id: <20200930100440.1060708-3-pizhenwei@bytedance.com> Signed-off-by: Paolo Bonzini --- qapi/run-state.json | 90 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 90 insertions(+) diff --git a/qapi/run-state.json b/qapi/run-state.json index 7cc9f96a5b..964c8ef391 100644 --- a/qapi/run-state.json +++ b/qapi/run-state.json @@ -475,3 +475,93 @@ 'psw-mask': 'uint64', 'psw-addr': 'uint64', 'reason': 'S390CrashReason' } } + +## +# @MEMORY_FAILURE: +# +# Emitted when a memory failure occurs on host side. +# +# @recipient: recipient is defined as @MemoryFailureRecipient. +# +# @action: action that has been taken. action is defined as @MemoryFailureAction. +# +# @flags: flags for MemoryFailureAction. action is defined as @MemoryFailureFlags. +# +# Since: 5.2 +# +# Example: +# +# <- { "event": "MEMORY_FAILURE", +# "data": { "recipient": "hypervisor", +# "action": "fatal", +# "flags": { 'action-required': false } } +# +## +{ 'event': 'MEMORY_FAILURE', + 'data': { 'recipient': 'MemoryFailureRecipient', + 'action': 'MemoryFailureAction', + 'flags': 'MemoryFailureFlags'} } + +## +# @MemoryFailureRecipient: +# +# Hardware memory failure occurs, handled by recipient. +# +# @hypervisor: memory failure at QEMU process address space. +# (none guest memory, but used by QEMU itself). +# +# @guest: memory failure at guest memory, +# +# Since: 5.2 +# +## +{ 'enum': 'MemoryFailureRecipient', + 'data': [ 'hypervisor', + 'guest' ] } + + +## +# @MemoryFailureAction: +# +# Actions taken by QEMU in response to a hardware memory failure. +# +# @ignore: the memory failure could be ignored. This will only be the case +# for action-optional failures. +# +# @inject: memory failure occurred in guest memory, the guest enabled MCE +# handling mechanism, and QEMU could inject the MCE into the guest +# successfully. +# +# @fatal: the failure is unrecoverable. This occurs for action-required +# failures if the recipient is the hypervisor; QEMU will exit. +# +# @reset: the failure is unrecoverable but confined to the guest. This +# occurs if the recipient is a guest guest which is not ready +# to handle memory failures. +# +# Since: 5.2 +# +## +{ 'enum': 'MemoryFailureAction', + 'data': [ 'ignore', + 'inject', + 'fatal', + 'reset' ] } + +## +# @MemoryFailureFlags: +# +# Additional information on memory failures. +# +# @action-required: whether a memory failure event is action-required +# or action-optional (e.g. a failure during memory scrub). +# +# @recursive: whether the failure occurred while the previous +# failure was still in progress. +# +# Since: 5.2 +# +## +{ 'struct': 'MemoryFailureFlags', + 'data': { 'action-required': 'bool', + 'recursive': 'bool'} }