Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2012,2013 - ARM Ltd |
| 3 | * Author: Marc Zyngier <marc.zyngier@arm.com> |
| 4 | * |
| 5 | * Derived from arch/arm/kvm/handle_exit.c: |
| 6 | * Copyright (C) 2012 - Virtual Open Systems and Columbia University |
| 7 | * Author: Christoffer Dall <c.dall@virtualopensystems.com> |
| 8 | * |
| 9 | * This program is free software; you can redistribute it and/or modify |
| 10 | * it under the terms of the GNU General Public License version 2 as |
| 11 | * published by the Free Software Foundation. |
| 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 |
| 19 | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
| 20 | */ |
| 21 | |
| 22 | #include <linux/kvm.h> |
| 23 | #include <linux/kvm_host.h> |
Mark Rutland | c6d01a9 | 2014-11-24 13:59:30 +0000 | [diff] [blame] | 24 | |
Marc Zyngier | 1a2fb94 | 2018-02-06 17:56:08 +0000 | [diff] [blame] | 25 | #include <kvm/arm_psci.h> |
| 26 | |
Mark Rutland | c6d01a9 | 2014-11-24 13:59:30 +0000 | [diff] [blame] | 27 | #include <asm/esr.h> |
James Morse | 0067df4 | 2018-01-15 19:39:05 +0000 | [diff] [blame] | 28 | #include <asm/exception.h> |
Marc Zyngier | 9d8415d | 2015-10-25 19:57:11 +0000 | [diff] [blame] | 29 | #include <asm/kvm_asm.h> |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 30 | #include <asm/kvm_coproc.h> |
Mark Rutland | c6d01a9 | 2014-11-24 13:59:30 +0000 | [diff] [blame] | 31 | #include <asm/kvm_emulate.h> |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 32 | #include <asm/kvm_mmu.h> |
Alex Bennée | e70dce7 | 2017-11-23 12:11:33 +0000 | [diff] [blame] | 33 | #include <asm/debug-monitors.h> |
James Morse | 3368bd8 | 2018-01-15 19:39:04 +0000 | [diff] [blame] | 34 | #include <asm/traps.h> |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 35 | |
Wei Huang | 0d97f884 | 2015-01-12 11:53:36 -0500 | [diff] [blame] | 36 | #define CREATE_TRACE_POINTS |
| 37 | #include "trace.h" |
| 38 | |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 39 | typedef int (*exit_handle_fn)(struct kvm_vcpu *, struct kvm_run *); |
| 40 | |
James Morse | 3368bd8 | 2018-01-15 19:39:04 +0000 | [diff] [blame] | 41 | static void kvm_handle_guest_serror(struct kvm_vcpu *vcpu, u32 esr) |
| 42 | { |
| 43 | if (!arm64_is_ras_serror(esr) || arm64_is_fatal_ras_serror(NULL, esr)) |
| 44 | kvm_inject_vabt(vcpu); |
| 45 | } |
| 46 | |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 47 | static int handle_hvc(struct kvm_vcpu *vcpu, struct kvm_run *run) |
| 48 | { |
Anup Patel | e8e7fcc | 2014-04-29 11:24:18 +0530 | [diff] [blame] | 49 | int ret; |
Marc Zyngier | dcd2e40 | 2012-12-12 18:52:05 +0000 | [diff] [blame] | 50 | |
Pavel Fedin | f6be563 | 2015-12-04 15:03:14 +0300 | [diff] [blame] | 51 | trace_kvm_hvc_arm64(*vcpu_pc(vcpu), vcpu_get_reg(vcpu, 0), |
Wei Huang | 0d97f884 | 2015-01-12 11:53:36 -0500 | [diff] [blame] | 52 | kvm_vcpu_hvc_get_imm(vcpu)); |
Amit Tomar | b19e689 | 2015-11-26 10:09:43 +0000 | [diff] [blame] | 53 | vcpu->stat.hvc_exit_stat++; |
Wei Huang | 0d97f884 | 2015-01-12 11:53:36 -0500 | [diff] [blame] | 54 | |
Marc Zyngier | 09e6be1 | 2018-02-06 17:56:12 +0000 | [diff] [blame] | 55 | ret = kvm_hvc_call_handler(vcpu); |
Anup Patel | e8e7fcc | 2014-04-29 11:24:18 +0530 | [diff] [blame] | 56 | if (ret < 0) { |
Marc Zyngier | c0938c7 | 2018-02-06 17:56:05 +0000 | [diff] [blame] | 57 | vcpu_set_reg(vcpu, 0, ~0UL); |
Anup Patel | e8e7fcc | 2014-04-29 11:24:18 +0530 | [diff] [blame] | 58 | return 1; |
| 59 | } |
| 60 | |
| 61 | return ret; |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 62 | } |
| 63 | |
| 64 | static int handle_smc(struct kvm_vcpu *vcpu, struct kvm_run *run) |
| 65 | { |
Marc Zyngier | f5115e8 | 2018-02-06 17:56:07 +0000 | [diff] [blame] | 66 | /* |
| 67 | * "If an SMC instruction executed at Non-secure EL1 is |
| 68 | * trapped to EL2 because HCR_EL2.TSC is 1, the exception is a |
| 69 | * Trap exception, not a Secure Monitor Call exception [...]" |
| 70 | * |
| 71 | * We need to advance the PC after the trap, as it would |
| 72 | * otherwise return to the same address... |
| 73 | */ |
Marc Zyngier | c0938c7 | 2018-02-06 17:56:05 +0000 | [diff] [blame] | 74 | vcpu_set_reg(vcpu, 0, ~0UL); |
Marc Zyngier | f5115e8 | 2018-02-06 17:56:07 +0000 | [diff] [blame] | 75 | kvm_skip_instr(vcpu, kvm_vcpu_trap_il_is32bit(vcpu)); |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 76 | return 1; |
| 77 | } |
| 78 | |
Suzuki K Poulose | 82e0191 | 2016-11-08 13:56:21 +0000 | [diff] [blame] | 79 | /* |
| 80 | * Guest access to FP/ASIMD registers are routed to this handler only |
| 81 | * when the system doesn't support FP/ASIMD. |
| 82 | */ |
| 83 | static int handle_no_fpsimd(struct kvm_vcpu *vcpu, struct kvm_run *run) |
| 84 | { |
| 85 | kvm_inject_undefined(vcpu); |
| 86 | return 1; |
| 87 | } |
| 88 | |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 89 | /** |
Marc Zyngier | d241aac | 2013-08-02 11:41:13 +0100 | [diff] [blame] | 90 | * kvm_handle_wfx - handle a wait-for-interrupts or wait-for-event |
| 91 | * instruction executed by a guest |
| 92 | * |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 93 | * @vcpu: the vcpu pointer |
| 94 | * |
Marc Zyngier | d241aac | 2013-08-02 11:41:13 +0100 | [diff] [blame] | 95 | * WFE: Yield the CPU and come back to this vcpu when the scheduler |
| 96 | * decides to. |
| 97 | * WFI: Simply call kvm_vcpu_block(), which will halt execution of |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 98 | * world-switches and schedule other host processes until there is an |
| 99 | * incoming IRQ or FIQ to the VM. |
| 100 | */ |
Marc Zyngier | d241aac | 2013-08-02 11:41:13 +0100 | [diff] [blame] | 101 | static int kvm_handle_wfx(struct kvm_vcpu *vcpu, struct kvm_run *run) |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 102 | { |
Paolo Bonzini | 1c6007d | 2015-01-23 13:39:51 +0100 | [diff] [blame] | 103 | if (kvm_vcpu_get_hsr(vcpu) & ESR_ELx_WFx_ISS_WFE) { |
Wei Huang | 0d97f884 | 2015-01-12 11:53:36 -0500 | [diff] [blame] | 104 | trace_kvm_wfx_arm64(*vcpu_pc(vcpu), true); |
Amit Tomar | b19e689 | 2015-11-26 10:09:43 +0000 | [diff] [blame] | 105 | vcpu->stat.wfe_exit_stat++; |
Longpeng(Mike) | f01fbd2 | 2017-08-08 12:05:35 +0800 | [diff] [blame] | 106 | kvm_vcpu_on_spin(vcpu, vcpu_mode_priv(vcpu)); |
Wei Huang | 0d97f884 | 2015-01-12 11:53:36 -0500 | [diff] [blame] | 107 | } else { |
| 108 | trace_kvm_wfx_arm64(*vcpu_pc(vcpu), false); |
Amit Tomar | b19e689 | 2015-11-26 10:09:43 +0000 | [diff] [blame] | 109 | vcpu->stat.wfi_exit_stat++; |
Marc Zyngier | d241aac | 2013-08-02 11:41:13 +0100 | [diff] [blame] | 110 | kvm_vcpu_block(vcpu); |
Andrew Jones | 6a6d73b | 2017-06-04 14:43:54 +0200 | [diff] [blame] | 111 | kvm_clear_request(KVM_REQ_UNHALT, vcpu); |
Wei Huang | 0d97f884 | 2015-01-12 11:53:36 -0500 | [diff] [blame] | 112 | } |
Marc Zyngier | d241aac | 2013-08-02 11:41:13 +0100 | [diff] [blame] | 113 | |
Christoffer Dall | 05e0127 | 2014-08-26 14:33:02 +0200 | [diff] [blame] | 114 | kvm_skip_instr(vcpu, kvm_vcpu_trap_il_is32bit(vcpu)); |
| 115 | |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 116 | return 1; |
| 117 | } |
| 118 | |
Alex Bennée | 4bd611c | 2015-07-07 17:29:57 +0100 | [diff] [blame] | 119 | /** |
| 120 | * kvm_handle_guest_debug - handle a debug exception instruction |
| 121 | * |
| 122 | * @vcpu: the vcpu pointer |
| 123 | * @run: access to the kvm_run structure for results |
| 124 | * |
| 125 | * We route all debug exceptions through the same handler. If both the |
| 126 | * guest and host are using the same debug facilities it will be up to |
| 127 | * userspace to re-inject the correct exception for guest delivery. |
| 128 | * |
| 129 | * @return: 0 (while setting run->exit_reason), -1 for error |
| 130 | */ |
| 131 | static int kvm_handle_guest_debug(struct kvm_vcpu *vcpu, struct kvm_run *run) |
| 132 | { |
| 133 | u32 hsr = kvm_vcpu_get_hsr(vcpu); |
| 134 | int ret = 0; |
| 135 | |
| 136 | run->exit_reason = KVM_EXIT_DEBUG; |
| 137 | run->debug.arch.hsr = hsr; |
| 138 | |
Mark Rutland | 561454e | 2016-05-31 12:33:02 +0100 | [diff] [blame] | 139 | switch (ESR_ELx_EC(hsr)) { |
Alex Bennée | 834bf88 | 2015-07-07 17:30:02 +0100 | [diff] [blame] | 140 | case ESR_ELx_EC_WATCHPT_LOW: |
| 141 | run->debug.arch.far = vcpu->arch.fault.far_el2; |
| 142 | /* fall through */ |
Alex Bennée | 337b99b | 2015-07-07 17:29:58 +0100 | [diff] [blame] | 143 | case ESR_ELx_EC_SOFTSTP_LOW: |
Alex Bennée | 834bf88 | 2015-07-07 17:30:02 +0100 | [diff] [blame] | 144 | case ESR_ELx_EC_BREAKPT_LOW: |
Alex Bennée | 4bd611c | 2015-07-07 17:29:57 +0100 | [diff] [blame] | 145 | case ESR_ELx_EC_BKPT32: |
| 146 | case ESR_ELx_EC_BRK64: |
| 147 | break; |
| 148 | default: |
| 149 | kvm_err("%s: un-handled case hsr: %#08x\n", |
| 150 | __func__, (unsigned int) hsr); |
| 151 | ret = -1; |
| 152 | break; |
| 153 | } |
| 154 | |
| 155 | return ret; |
| 156 | } |
| 157 | |
Mark Rutland | ba4dd15 | 2017-02-20 12:30:12 +0000 | [diff] [blame] | 158 | static int kvm_handle_unknown_ec(struct kvm_vcpu *vcpu, struct kvm_run *run) |
| 159 | { |
| 160 | u32 hsr = kvm_vcpu_get_hsr(vcpu); |
| 161 | |
| 162 | kvm_pr_unimpl("Unknown exception class: hsr: %#08x -- %s\n", |
| 163 | hsr, esr_get_class_string(hsr)); |
| 164 | |
| 165 | kvm_inject_undefined(vcpu); |
| 166 | return 1; |
| 167 | } |
| 168 | |
Dave Martin | aac45ff | 2017-10-31 15:51:17 +0000 | [diff] [blame] | 169 | static int handle_sve(struct kvm_vcpu *vcpu, struct kvm_run *run) |
| 170 | { |
| 171 | /* Until SVE is supported for guests: */ |
| 172 | kvm_inject_undefined(vcpu); |
| 173 | return 1; |
| 174 | } |
| 175 | |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 176 | static exit_handle_fn arm_exit_handlers[] = { |
Mark Rutland | ba4dd15 | 2017-02-20 12:30:12 +0000 | [diff] [blame] | 177 | [0 ... ESR_ELx_EC_MAX] = kvm_handle_unknown_ec, |
Mark Rutland | c6d01a9 | 2014-11-24 13:59:30 +0000 | [diff] [blame] | 178 | [ESR_ELx_EC_WFx] = kvm_handle_wfx, |
| 179 | [ESR_ELx_EC_CP15_32] = kvm_handle_cp15_32, |
| 180 | [ESR_ELx_EC_CP15_64] = kvm_handle_cp15_64, |
| 181 | [ESR_ELx_EC_CP14_MR] = kvm_handle_cp14_32, |
| 182 | [ESR_ELx_EC_CP14_LS] = kvm_handle_cp14_load_store, |
| 183 | [ESR_ELx_EC_CP14_64] = kvm_handle_cp14_64, |
| 184 | [ESR_ELx_EC_HVC32] = handle_hvc, |
| 185 | [ESR_ELx_EC_SMC32] = handle_smc, |
| 186 | [ESR_ELx_EC_HVC64] = handle_hvc, |
| 187 | [ESR_ELx_EC_SMC64] = handle_smc, |
| 188 | [ESR_ELx_EC_SYS64] = kvm_handle_sys_reg, |
Dave Martin | aac45ff | 2017-10-31 15:51:17 +0000 | [diff] [blame] | 189 | [ESR_ELx_EC_SVE] = handle_sve, |
Mark Rutland | c6d01a9 | 2014-11-24 13:59:30 +0000 | [diff] [blame] | 190 | [ESR_ELx_EC_IABT_LOW] = kvm_handle_guest_abort, |
| 191 | [ESR_ELx_EC_DABT_LOW] = kvm_handle_guest_abort, |
Alex Bennée | 337b99b | 2015-07-07 17:29:58 +0100 | [diff] [blame] | 192 | [ESR_ELx_EC_SOFTSTP_LOW]= kvm_handle_guest_debug, |
Alex Bennée | 834bf88 | 2015-07-07 17:30:02 +0100 | [diff] [blame] | 193 | [ESR_ELx_EC_WATCHPT_LOW]= kvm_handle_guest_debug, |
| 194 | [ESR_ELx_EC_BREAKPT_LOW]= kvm_handle_guest_debug, |
Alex Bennée | 4bd611c | 2015-07-07 17:29:57 +0100 | [diff] [blame] | 195 | [ESR_ELx_EC_BKPT32] = kvm_handle_guest_debug, |
| 196 | [ESR_ELx_EC_BRK64] = kvm_handle_guest_debug, |
Suzuki K Poulose | 82e0191 | 2016-11-08 13:56:21 +0000 | [diff] [blame] | 197 | [ESR_ELx_EC_FP_ASIMD] = handle_no_fpsimd, |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 198 | }; |
| 199 | |
| 200 | static exit_handle_fn kvm_get_exit_handler(struct kvm_vcpu *vcpu) |
| 201 | { |
Mark Rutland | 056bb5f | 2015-01-07 11:26:18 +0000 | [diff] [blame] | 202 | u32 hsr = kvm_vcpu_get_hsr(vcpu); |
Mark Rutland | 561454e | 2016-05-31 12:33:02 +0100 | [diff] [blame] | 203 | u8 hsr_ec = ESR_ELx_EC(hsr); |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 204 | |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 205 | return arm_exit_handlers[hsr_ec]; |
| 206 | } |
| 207 | |
| 208 | /* |
Alex Bennée | 7226bc2 | 2017-11-16 15:39:20 +0000 | [diff] [blame] | 209 | * We may be single-stepping an emulated instruction. If the emulation |
| 210 | * has been completed in the kernel, we can return to userspace with a |
| 211 | * KVM_EXIT_DEBUG, otherwise userspace needs to complete its |
| 212 | * emulation first. |
| 213 | */ |
| 214 | static int handle_trap_exceptions(struct kvm_vcpu *vcpu, struct kvm_run *run) |
| 215 | { |
| 216 | int handled; |
| 217 | |
| 218 | /* |
| 219 | * See ARM ARM B1.14.1: "Hyp traps on instructions |
| 220 | * that fail their condition code check" |
| 221 | */ |
| 222 | if (!kvm_condition_valid(vcpu)) { |
| 223 | kvm_skip_instr(vcpu, kvm_vcpu_trap_il_is32bit(vcpu)); |
| 224 | handled = 1; |
| 225 | } else { |
| 226 | exit_handle_fn exit_handler; |
| 227 | |
| 228 | exit_handler = kvm_get_exit_handler(vcpu); |
| 229 | handled = exit_handler(vcpu, run); |
| 230 | } |
| 231 | |
| 232 | /* |
| 233 | * kvm_arm_handle_step_debug() sets the exit_reason on the kvm_run |
| 234 | * structure if we need to return to userspace. |
| 235 | */ |
| 236 | if (handled > 0 && kvm_arm_handle_step_debug(vcpu, run)) |
| 237 | handled = 0; |
| 238 | |
| 239 | return handled; |
| 240 | } |
| 241 | |
| 242 | /* |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 243 | * Return > 0 to return to guest, < 0 on error, 0 (and set exit_reason) on |
| 244 | * proper exit to userspace. |
| 245 | */ |
| 246 | int handle_exit(struct kvm_vcpu *vcpu, struct kvm_run *run, |
| 247 | int exception_index) |
| 248 | { |
Marc Zyngier | ddb3d07 | 2016-09-06 14:02:06 +0100 | [diff] [blame] | 249 | if (ARM_SERROR_PENDING(exception_index)) { |
| 250 | u8 hsr_ec = ESR_ELx_EC(kvm_vcpu_get_hsr(vcpu)); |
| 251 | |
| 252 | /* |
| 253 | * HVC/SMC already have an adjusted PC, which we need |
| 254 | * to correct in order to return to after having |
| 255 | * injected the SError. |
| 256 | */ |
| 257 | if (hsr_ec == ESR_ELx_EC_HVC32 || hsr_ec == ESR_ELx_EC_HVC64 || |
| 258 | hsr_ec == ESR_ELx_EC_SMC32 || hsr_ec == ESR_ELx_EC_SMC64) { |
| 259 | u32 adj = kvm_vcpu_trap_il_is32bit(vcpu) ? 4 : 2; |
| 260 | *vcpu_pc(vcpu) -= adj; |
| 261 | } |
| 262 | |
Marc Zyngier | ddb3d07 | 2016-09-06 14:02:06 +0100 | [diff] [blame] | 263 | return 1; |
| 264 | } |
| 265 | |
| 266 | exception_index = ARM_EXCEPTION_CODE(exception_index); |
| 267 | |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 268 | switch (exception_index) { |
| 269 | case ARM_EXCEPTION_IRQ: |
| 270 | return 1; |
Marc Zyngier | 0215a6e | 2016-09-06 14:02:03 +0100 | [diff] [blame] | 271 | case ARM_EXCEPTION_EL1_SERROR: |
Alex Bennée | e70dce7 | 2017-11-23 12:11:33 +0000 | [diff] [blame] | 272 | /* We may still need to return for single-step */ |
| 273 | if (!(*vcpu_cpsr(vcpu) & DBG_SPSR_SS) |
| 274 | && kvm_arm_handle_step_debug(vcpu, run)) |
| 275 | return 0; |
| 276 | else |
| 277 | return 1; |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 278 | case ARM_EXCEPTION_TRAP: |
Alex Bennée | 7226bc2 | 2017-11-16 15:39:20 +0000 | [diff] [blame] | 279 | return handle_trap_exceptions(vcpu, run); |
James Morse | c94b0cf | 2016-04-27 17:47:04 +0100 | [diff] [blame] | 280 | case ARM_EXCEPTION_HYP_GONE: |
| 281 | /* |
| 282 | * EL2 has been reset to the hyp-stub. This happens when a guest |
| 283 | * is pre-empted by kvm_reboot()'s shutdown call. |
| 284 | */ |
| 285 | run->exit_reason = KVM_EXIT_FAIL_ENTRY; |
| 286 | return 0; |
Marc Zyngier | c4b1afd | 2012-12-10 16:40:41 +0000 | [diff] [blame] | 287 | default: |
| 288 | kvm_pr_unimpl("Unsupported exception type: %d", |
| 289 | exception_index); |
| 290 | run->exit_reason = KVM_EXIT_INTERNAL_ERROR; |
| 291 | return 0; |
| 292 | } |
| 293 | } |
James Morse | 3368bd8 | 2018-01-15 19:39:04 +0000 | [diff] [blame] | 294 | |
| 295 | /* For exit types that need handling before we can be preempted */ |
| 296 | void handle_exit_early(struct kvm_vcpu *vcpu, struct kvm_run *run, |
| 297 | int exception_index) |
| 298 | { |
James Morse | 0067df4 | 2018-01-15 19:39:05 +0000 | [diff] [blame] | 299 | if (ARM_SERROR_PENDING(exception_index)) { |
| 300 | if (this_cpu_has_cap(ARM64_HAS_RAS_EXTN)) { |
| 301 | u64 disr = kvm_vcpu_get_disr(vcpu); |
| 302 | |
| 303 | kvm_handle_guest_serror(vcpu, disr_to_esr(disr)); |
| 304 | } else { |
| 305 | kvm_inject_vabt(vcpu); |
| 306 | } |
| 307 | |
| 308 | return; |
| 309 | } |
| 310 | |
James Morse | 3368bd8 | 2018-01-15 19:39:04 +0000 | [diff] [blame] | 311 | exception_index = ARM_EXCEPTION_CODE(exception_index); |
| 312 | |
| 313 | if (exception_index == ARM_EXCEPTION_EL1_SERROR) |
| 314 | kvm_handle_guest_serror(vcpu, kvm_vcpu_get_hsr(vcpu)); |
| 315 | } |