kvm_host.h 7.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300
  1. /* SPDX-License-Identifier: GPL-2.0-only */
  2. /*
  3. * Copyright (C) 2019 Western Digital Corporation or its affiliates.
  4. *
  5. * Authors:
  6. * Anup Patel <anup.patel@wdc.com>
  7. */
  8. #ifndef __RISCV_KVM_HOST_H__
  9. #define __RISCV_KVM_HOST_H__
  10. #include <linux/types.h>
  11. #include <linux/kvm.h>
  12. #include <linux/kvm_types.h>
  13. #include <asm/kvm_vcpu_timer.h>
  14. #ifdef CONFIG_64BIT
  15. #define KVM_MAX_VCPUS (1U << 16)
  16. #else
  17. #define KVM_MAX_VCPUS (1U << 9)
  18. #endif
  19. #define KVM_USER_MEM_SLOTS 512
  20. #define KVM_HALT_POLL_NS_DEFAULT 500000
  21. #define KVM_VCPU_MAX_FEATURES 0
  22. #define KVM_REQ_SLEEP \
  23. KVM_ARCH_REQ_FLAGS(0, KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)
  24. #define KVM_REQ_VCPU_RESET KVM_ARCH_REQ(1)
  25. #define KVM_REQ_UPDATE_HGATP KVM_ARCH_REQ(2)
  26. struct kvm_vm_stat {
  27. ulong remote_tlb_flush;
  28. };
  29. struct kvm_vcpu_stat {
  30. u64 halt_successful_poll;
  31. u64 halt_attempted_poll;
  32. u64 halt_poll_success_ns;
  33. u64 halt_poll_fail_ns;
  34. u64 halt_poll_invalid;
  35. u64 halt_wakeup;
  36. u64 ecall_exit_stat;
  37. u64 wfi_exit_stat;
  38. u64 mmio_exit_user;
  39. u64 mmio_exit_kernel;
  40. u64 exits;
  41. };
  42. struct kvm_arch_memory_slot {
  43. };
  44. struct kvm_vmid {
  45. /*
  46. * Writes to vmid_version and vmid happen with vmid_lock held
  47. * whereas reads happen without any lock held.
  48. */
  49. unsigned long vmid_version;
  50. unsigned long vmid;
  51. };
  52. #define RVBM_STATUS_INIT 0
  53. #define RVBM_STATUS_START 1
  54. #define RVBM_STATUS_READY 2
  55. #define RVBM_STATUS_ACK 3
  56. #define RVBM_STATUS_MASK 0x7
  57. #define RVBM_WRITE BIT(7)
  58. struct khv_io {
  59. u64 status;
  60. u64 addr;
  61. u64 value;
  62. u64 reserved;
  63. };
  64. struct kvm_arch {
  65. /* stage2 vmid */
  66. struct kvm_vmid vmid;
  67. /* stage2 page table */
  68. pgd_t *pgd;
  69. phys_addr_t pgd_phys;
  70. /* Guest Timer */
  71. struct kvm_guest_timer timer;
  72. wait_queue_head_t waitq;
  73. struct khv_io *io_switch;
  74. volatile unsigned char __iomem *backend_intr_reg;
  75. volatile unsigned char __iomem *frontend_intr_reg;
  76. u32 enable_intr;
  77. u32 clear_intr;
  78. unsigned long khv_base;
  79. phys_addr_t khv_base_phys_addr;
  80. };
  81. struct kvm_mmio_decode {
  82. unsigned long insn;
  83. int insn_len;
  84. int len;
  85. int shift;
  86. int return_handled;
  87. };
  88. struct kvm_sbi_context {
  89. int return_handled;
  90. };
  91. #define KVM_MMU_PAGE_CACHE_NR_OBJS 32
  92. struct kvm_mmu_page_cache {
  93. int nobjs;
  94. void *objects[KVM_MMU_PAGE_CACHE_NR_OBJS];
  95. };
  96. struct kvm_cpu_trap {
  97. unsigned long sepc;
  98. unsigned long scause;
  99. unsigned long stval;
  100. unsigned long htval;
  101. unsigned long htinst;
  102. };
  103. struct kvm_cpu_context {
  104. unsigned long zero;
  105. unsigned long ra;
  106. unsigned long sp;
  107. unsigned long gp;
  108. unsigned long tp;
  109. unsigned long t0;
  110. unsigned long t1;
  111. unsigned long t2;
  112. unsigned long s0;
  113. unsigned long s1;
  114. unsigned long a0;
  115. unsigned long a1;
  116. unsigned long a2;
  117. unsigned long a3;
  118. unsigned long a4;
  119. unsigned long a5;
  120. unsigned long a6;
  121. unsigned long a7;
  122. unsigned long s2;
  123. unsigned long s3;
  124. unsigned long s4;
  125. unsigned long s5;
  126. unsigned long s6;
  127. unsigned long s7;
  128. unsigned long s8;
  129. unsigned long s9;
  130. unsigned long s10;
  131. unsigned long s11;
  132. unsigned long t3;
  133. unsigned long t4;
  134. unsigned long t5;
  135. unsigned long t6;
  136. unsigned long sepc;
  137. unsigned long sstatus;
  138. unsigned long hstatus;
  139. union __riscv_fp_state fp;
  140. };
  141. struct kvm_vcpu_csr {
  142. unsigned long vsstatus;
  143. unsigned long hie;
  144. unsigned long vstvec;
  145. unsigned long vsscratch;
  146. unsigned long vsepc;
  147. unsigned long vscause;
  148. unsigned long vstval;
  149. unsigned long hvip;
  150. unsigned long vsatp;
  151. unsigned long scounteren;
  152. };
  153. struct kvm_vcpu_arch {
  154. /* VCPU ran atleast once */
  155. bool ran_atleast_once;
  156. /* ISA feature bits (similar to MISA) */
  157. unsigned long isa;
  158. /* SSCRATCH, STVEC, and SCOUNTEREN of Host */
  159. unsigned long host_sscratch;
  160. unsigned long host_stvec;
  161. unsigned long host_scounteren;
  162. /* CPU context of Host */
  163. struct kvm_cpu_context host_context;
  164. /* CPU context of Guest VCPU */
  165. struct kvm_cpu_context guest_context;
  166. /* CPU CSR context of Guest VCPU */
  167. struct kvm_vcpu_csr guest_csr;
  168. /* CPU context upon Guest VCPU reset */
  169. struct kvm_cpu_context guest_reset_context;
  170. /* CPU CSR context upon Guest VCPU reset */
  171. struct kvm_vcpu_csr guest_reset_csr;
  172. /*
  173. * VCPU interrupts
  174. *
  175. * We have a lockless approach for tracking pending VCPU interrupts
  176. * implemented using atomic bitops. The irqs_pending bitmap represent
  177. * pending interrupts whereas irqs_pending_mask represent bits changed
  178. * in irqs_pending. Our approach is modeled around multiple producer
  179. * and single consumer problem where the consumer is the VCPU itself.
  180. */
  181. unsigned long irqs_pending;
  182. unsigned long irqs_pending_mask;
  183. /* VCPU Timer */
  184. struct kvm_vcpu_timer timer;
  185. /* MMIO instruction details */
  186. struct kvm_mmio_decode mmio_decode;
  187. /* SBI context */
  188. struct kvm_sbi_context sbi_context;
  189. /* Cache pages needed to program page tables with spinlock held */
  190. struct kvm_mmu_page_cache mmu_page_cache;
  191. /* VCPU power-off state */
  192. bool power_off;
  193. /* Don't run the VCPU (blocked) */
  194. bool pause;
  195. /* SRCU lock index for in-kernel run loop */
  196. int srcu_idx;
  197. };
  198. static inline void kvm_arch_hardware_unsetup(void) {}
  199. static inline void kvm_arch_sync_events(struct kvm *kvm) {}
  200. static inline void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) {}
  201. static inline void kvm_arch_sched_in(struct kvm_vcpu *vcpu, int cpu) {}
  202. static inline void kvm_arch_vcpu_block_finish(struct kvm_vcpu *vcpu) {}
  203. #define KVM_ARCH_WANT_MMU_NOTIFIER
  204. int kvm_unmap_hva_range(struct kvm *kvm, unsigned long start,
  205. unsigned long end, unsigned int flags);
  206. int kvm_set_spte_hva(struct kvm *kvm, unsigned long hva, pte_t pte);
  207. int kvm_age_hva(struct kvm *kvm, unsigned long start, unsigned long end);
  208. int kvm_test_age_hva(struct kvm *kvm, unsigned long hva);
  209. void __kvm_riscv_hfence_gvma_vmid_gpa(unsigned long gpa, unsigned long vmid);
  210. void __kvm_riscv_hfence_gvma_vmid(unsigned long vmid);
  211. void __kvm_riscv_hfence_gvma_gpa(unsigned long gpa);
  212. void __kvm_riscv_hfence_gvma_all(void);
  213. int kvm_riscv_stage2_map(struct kvm_vcpu *vcpu,
  214. struct kvm_memory_slot *memslot,
  215. gpa_t gpa, unsigned long hva, bool is_write);
  216. void kvm_riscv_stage2_flush_cache(struct kvm_vcpu *vcpu);
  217. int kvm_riscv_stage2_alloc_pgd(struct kvm *kvm);
  218. void kvm_riscv_stage2_free_pgd(struct kvm *kvm);
  219. void kvm_riscv_stage2_update_hgatp(struct kvm_vcpu *vcpu);
  220. void kvm_riscv_stage2_mode_detect(void);
  221. unsigned long kvm_riscv_stage2_mode(void);
  222. void kvm_riscv_stage2_vmid_detect(void);
  223. unsigned long kvm_riscv_stage2_vmid_bits(void);
  224. int kvm_riscv_stage2_vmid_init(struct kvm *kvm);
  225. bool kvm_riscv_stage2_vmid_ver_changed(struct kvm_vmid *vmid);
  226. void kvm_riscv_stage2_vmid_update(struct kvm_vcpu *vcpu);
  227. void __kvm_riscv_unpriv_trap(void);
  228. unsigned long kvm_riscv_vcpu_unpriv_read(struct kvm_vcpu *vcpu,
  229. bool read_insn,
  230. unsigned long guest_addr,
  231. struct kvm_cpu_trap *trap);
  232. void kvm_riscv_vcpu_trap_redirect(struct kvm_vcpu *vcpu,
  233. struct kvm_cpu_trap *trap);
  234. int kvm_riscv_vcpu_mmio_return(struct kvm_vcpu *vcpu, struct kvm_run *run);
  235. int kvm_riscv_vcpu_exit(struct kvm_vcpu *vcpu, struct kvm_run *run,
  236. struct kvm_cpu_trap *trap);
  237. void __kvm_riscv_switch_to(struct kvm_vcpu_arch *vcpu_arch);
  238. void __kvm_riscv_fp_f_save(struct kvm_cpu_context *context);
  239. void __kvm_riscv_fp_f_restore(struct kvm_cpu_context *context);
  240. void __kvm_riscv_fp_d_save(struct kvm_cpu_context *context);
  241. void __kvm_riscv_fp_d_restore(struct kvm_cpu_context *context);
  242. int kvm_riscv_vcpu_set_interrupt(struct kvm_vcpu *vcpu, unsigned int irq);
  243. int kvm_riscv_vcpu_unset_interrupt(struct kvm_vcpu *vcpu, unsigned int irq);
  244. void kvm_riscv_vcpu_flush_interrupts(struct kvm_vcpu *vcpu);
  245. void kvm_riscv_vcpu_sync_interrupts(struct kvm_vcpu *vcpu);
  246. bool kvm_riscv_vcpu_has_interrupts(struct kvm_vcpu *vcpu, unsigned long mask);
  247. void kvm_riscv_vcpu_power_off(struct kvm_vcpu *vcpu);
  248. void kvm_riscv_vcpu_power_on(struct kvm_vcpu *vcpu);
  249. int kvm_riscv_vcpu_sbi_return(struct kvm_vcpu *vcpu, struct kvm_run *run);
  250. int kvm_riscv_vcpu_sbi_ecall(struct kvm_vcpu *vcpu, struct kvm_run *run);
  251. #endif /* __RISCV_KVM_HOST_H__ */