handle_exit.c 4.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164
  1. /*
  2. * Copyright (C) 2012 - Virtual Open Systems and Columbia University
  3. * Author: Christoffer Dall <c.dall@virtualopensystems.com>
  4. *
  5. * This program is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License, version 2, as
  7. * published by the Free Software Foundation.
  8. *
  9. * This program is distributed in the hope that it will be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write to the Free Software
  16. * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17. */
  18. #include <linux/kvm.h>
  19. #include <linux/kvm_host.h>
  20. #include <asm/kvm_emulate.h>
  21. #include <asm/kvm_coproc.h>
  22. #include <asm/kvm_mmu.h>
  23. #include <asm/kvm_psci.h>
  24. #include <trace/events/kvm.h>
  25. #include "trace.h"
  26. #include "trace.h"
  27. typedef int (*exit_handle_fn)(struct kvm_vcpu *, struct kvm_run *);
  28. static int handle_svc_hyp(struct kvm_vcpu *vcpu, struct kvm_run *run)
  29. {
  30. /* SVC called from Hyp mode should never get here */
  31. kvm_debug("SVC called from Hyp mode shouldn't go here\n");
  32. BUG();
  33. return -EINVAL; /* Squash warning */
  34. }
  35. static int handle_hvc(struct kvm_vcpu *vcpu, struct kvm_run *run)
  36. {
  37. trace_kvm_hvc(*vcpu_pc(vcpu), *vcpu_reg(vcpu, 0),
  38. kvm_vcpu_hvc_get_imm(vcpu));
  39. if (kvm_psci_call(vcpu))
  40. return 1;
  41. kvm_inject_undefined(vcpu);
  42. return 1;
  43. }
  44. static int handle_smc(struct kvm_vcpu *vcpu, struct kvm_run *run)
  45. {
  46. if (kvm_psci_call(vcpu))
  47. return 1;
  48. kvm_inject_undefined(vcpu);
  49. return 1;
  50. }
  51. static int handle_pabt_hyp(struct kvm_vcpu *vcpu, struct kvm_run *run)
  52. {
  53. /* The hypervisor should never cause aborts */
  54. kvm_err("Prefetch Abort taken from Hyp mode at %#08lx (HSR: %#08x)\n",
  55. kvm_vcpu_get_hfar(vcpu), kvm_vcpu_get_hsr(vcpu));
  56. return -EFAULT;
  57. }
  58. static int handle_dabt_hyp(struct kvm_vcpu *vcpu, struct kvm_run *run)
  59. {
  60. /* This is either an error in the ws. code or an external abort */
  61. kvm_err("Data Abort taken from Hyp mode at %#08lx (HSR: %#08x)\n",
  62. kvm_vcpu_get_hfar(vcpu), kvm_vcpu_get_hsr(vcpu));
  63. return -EFAULT;
  64. }
  65. /**
  66. * kvm_handle_wfi - handle a wait-for-interrupts instruction executed by a guest
  67. * @vcpu: the vcpu pointer
  68. * @run: the kvm_run structure pointer
  69. *
  70. * Simply sets the wait_for_interrupts flag on the vcpu structure, which will
  71. * halt execution of world-switches and schedule other host processes until
  72. * there is an incoming IRQ or FIQ to the VM.
  73. */
  74. static int kvm_handle_wfi(struct kvm_vcpu *vcpu, struct kvm_run *run)
  75. {
  76. trace_kvm_wfi(*vcpu_pc(vcpu));
  77. kvm_vcpu_block(vcpu);
  78. return 1;
  79. }
  80. static exit_handle_fn arm_exit_handlers[] = {
  81. [HSR_EC_WFI] = kvm_handle_wfi,
  82. [HSR_EC_CP15_32] = kvm_handle_cp15_32,
  83. [HSR_EC_CP15_64] = kvm_handle_cp15_64,
  84. [HSR_EC_CP14_MR] = kvm_handle_cp14_access,
  85. [HSR_EC_CP14_LS] = kvm_handle_cp14_load_store,
  86. [HSR_EC_CP14_64] = kvm_handle_cp14_access,
  87. [HSR_EC_CP_0_13] = kvm_handle_cp_0_13_access,
  88. [HSR_EC_CP10_ID] = kvm_handle_cp10_id,
  89. [HSR_EC_SVC_HYP] = handle_svc_hyp,
  90. [HSR_EC_HVC] = handle_hvc,
  91. [HSR_EC_SMC] = handle_smc,
  92. [HSR_EC_IABT] = kvm_handle_guest_abort,
  93. [HSR_EC_IABT_HYP] = handle_pabt_hyp,
  94. [HSR_EC_DABT] = kvm_handle_guest_abort,
  95. [HSR_EC_DABT_HYP] = handle_dabt_hyp,
  96. };
  97. static exit_handle_fn kvm_get_exit_handler(struct kvm_vcpu *vcpu)
  98. {
  99. u8 hsr_ec = kvm_vcpu_trap_get_class(vcpu);
  100. if (hsr_ec >= ARRAY_SIZE(arm_exit_handlers) ||
  101. !arm_exit_handlers[hsr_ec]) {
  102. kvm_err("Unknown exception class: hsr: %#08x\n",
  103. (unsigned int)kvm_vcpu_get_hsr(vcpu));
  104. BUG();
  105. }
  106. return arm_exit_handlers[hsr_ec];
  107. }
  108. /*
  109. * Return > 0 to return to guest, < 0 on error, 0 (and set exit_reason) on
  110. * proper exit to userspace.
  111. */
  112. int handle_exit(struct kvm_vcpu *vcpu, struct kvm_run *run,
  113. int exception_index)
  114. {
  115. exit_handle_fn exit_handler;
  116. switch (exception_index) {
  117. case ARM_EXCEPTION_IRQ:
  118. return 1;
  119. case ARM_EXCEPTION_UNDEFINED:
  120. kvm_err("Undefined exception in Hyp mode at: %#08lx\n",
  121. kvm_vcpu_get_hyp_pc(vcpu));
  122. BUG();
  123. panic("KVM: Hypervisor undefined exception!\n");
  124. case ARM_EXCEPTION_DATA_ABORT:
  125. case ARM_EXCEPTION_PREF_ABORT:
  126. case ARM_EXCEPTION_HVC:
  127. /*
  128. * See ARM ARM B1.14.1: "Hyp traps on instructions
  129. * that fail their condition code check"
  130. */
  131. if (!kvm_condition_valid(vcpu)) {
  132. kvm_skip_instr(vcpu, kvm_vcpu_trap_il_is32bit(vcpu));
  133. return 1;
  134. }
  135. exit_handler = kvm_get_exit_handler(vcpu);
  136. return exit_handler(vcpu, run);
  137. default:
  138. kvm_pr_unimpl("Unsupported exception type: %d",
  139. exception_index);
  140. run->exit_reason = KVM_EXIT_INTERNAL_ERROR;
  141. return 0;
  142. }
  143. }