diff options
133 files changed, 5170 insertions, 2239 deletions
diff --git a/Documentation/virtual/kvm/00-INDEX b/Documentation/virtual/kvm/00-INDEX new file mode 100644 index 000000000000..641ec9220179 --- /dev/null +++ b/Documentation/virtual/kvm/00-INDEX | |||
| @@ -0,0 +1,24 @@ | |||
| 1 | 00-INDEX | ||
| 2 | - this file. | ||
| 3 | api.txt | ||
| 4 | - KVM userspace API. | ||
| 5 | cpuid.txt | ||
| 6 | - KVM-specific cpuid leaves (x86). | ||
| 7 | devices/ | ||
| 8 | - KVM_CAP_DEVICE_CTRL userspace API. | ||
| 9 | hypercalls.txt | ||
| 10 | - KVM hypercalls. | ||
| 11 | locking.txt | ||
| 12 | - notes on KVM locks. | ||
| 13 | mmu.txt | ||
| 14 | - the x86 kvm shadow mmu. | ||
| 15 | msr.txt | ||
| 16 | - KVM-specific MSRs (x86). | ||
| 17 | nested-vmx.txt | ||
| 18 | - notes on nested virtualization for Intel x86 processors. | ||
| 19 | ppc-pv.txt | ||
| 20 | - the paravirtualization interface on PowerPC. | ||
| 21 | review-checklist.txt | ||
| 22 | - review checklist for KVM patches. | ||
| 23 | timekeeping.txt | ||
| 24 | - timekeeping virtualization for x86-based architectures. | ||
diff --git a/Documentation/virtual/kvm/api.txt b/Documentation/virtual/kvm/api.txt index 858aecf21db2..a30035dd4c26 100644 --- a/Documentation/virtual/kvm/api.txt +++ b/Documentation/virtual/kvm/api.txt | |||
| @@ -1122,9 +1122,9 @@ struct kvm_cpuid2 { | |||
| 1122 | struct kvm_cpuid_entry2 entries[0]; | 1122 | struct kvm_cpuid_entry2 entries[0]; |
| 1123 | }; | 1123 | }; |
| 1124 | 1124 | ||
| 1125 | #define KVM_CPUID_FLAG_SIGNIFCANT_INDEX 1 | 1125 | #define KVM_CPUID_FLAG_SIGNIFCANT_INDEX BIT(0) |
| 1126 | #define KVM_CPUID_FLAG_STATEFUL_FUNC 2 | 1126 | #define KVM_CPUID_FLAG_STATEFUL_FUNC BIT(1) |
| 1127 | #define KVM_CPUID_FLAG_STATE_READ_NEXT 4 | 1127 | #define KVM_CPUID_FLAG_STATE_READ_NEXT BIT(2) |
| 1128 | 1128 | ||
| 1129 | struct kvm_cpuid_entry2 { | 1129 | struct kvm_cpuid_entry2 { |
| 1130 | __u32 function; | 1130 | __u32 function; |
| @@ -1810,6 +1810,50 @@ registers, find a list below: | |||
| 1810 | PPC | KVM_REG_PPC_TLB3PS | 32 | 1810 | PPC | KVM_REG_PPC_TLB3PS | 32 |
| 1811 | PPC | KVM_REG_PPC_EPTCFG | 32 | 1811 | PPC | KVM_REG_PPC_EPTCFG | 32 |
| 1812 | PPC | KVM_REG_PPC_ICP_STATE | 64 | 1812 | PPC | KVM_REG_PPC_ICP_STATE | 64 |
| 1813 | PPC | KVM_REG_PPC_TB_OFFSET | 64 | ||
| 1814 | PPC | KVM_REG_PPC_SPMC1 | 32 | ||
| 1815 | PPC | KVM_REG_PPC_SPMC2 | 32 | ||
| 1816 | PPC | KVM_REG_PPC_IAMR | 64 | ||
| 1817 | PPC | KVM_REG_PPC_TFHAR | 64 | ||
| 1818 | PPC | KVM_REG_PPC_TFIAR | 64 | ||
| 1819 | PPC | KVM_REG_PPC_TEXASR | 64 | ||
| 1820 | PPC | KVM_REG_PPC_FSCR | 64 | ||
| 1821 | PPC | KVM_REG_PPC_PSPB | 32 | ||
| 1822 | PPC | KVM_REG_PPC_EBBHR | 64 | ||
| 1823 | PPC | KVM_REG_PPC_EBBRR | 64 | ||
| 1824 | PPC | KVM_REG_PPC_BESCR | 64 | ||
| 1825 | PPC | KVM_REG_PPC_TAR | 64 | ||
| 1826 | PPC | KVM_REG_PPC_DPDES | 64 | ||
| 1827 | PPC | KVM_REG_PPC_DAWR | 64 | ||
| 1828 | PPC | KVM_REG_PPC_DAWRX | 64 | ||
| 1829 | PPC | KVM_REG_PPC_CIABR | 64 | ||
| 1830 | PPC | KVM_REG_PPC_IC | 64 | ||
| 1831 | PPC | KVM_REG_PPC_VTB | 64 | ||
| 1832 | PPC | KVM_REG_PPC_CSIGR | 64 | ||
| 1833 | PPC | KVM_REG_PPC_TACR | 64 | ||
| 1834 | PPC | KVM_REG_PPC_TCSCR | 64 | ||
| 1835 | PPC | KVM_REG_PPC_PID | 64 | ||
| 1836 | PPC | KVM_REG_PPC_ACOP | 64 | ||
| 1837 | PPC | KVM_REG_PPC_VRSAVE | 32 | ||
| 1838 | PPC | KVM_REG_PPC_LPCR | 64 | ||
| 1839 | PPC | KVM_REG_PPC_PPR | 64 | ||
| 1840 | PPC | KVM_REG_PPC_ARCH_COMPAT 32 | ||
| 1841 | PPC | KVM_REG_PPC_TM_GPR0 | 64 | ||
| 1842 | ... | ||
| 1843 | PPC | KVM_REG_PPC_TM_GPR31 | 64 | ||
| 1844 | PPC | KVM_REG_PPC_TM_VSR0 | 128 | ||
| 1845 | ... | ||
| 1846 | PPC | KVM_REG_PPC_TM_VSR63 | 128 | ||
| 1847 | PPC | KVM_REG_PPC_TM_CR | 64 | ||
| 1848 | PPC | KVM_REG_PPC_TM_LR | 64 | ||
| 1849 | PPC | KVM_REG_PPC_TM_CTR | 64 | ||
| 1850 | PPC | KVM_REG_PPC_TM_FPSCR | 64 | ||
| 1851 | PPC | KVM_REG_PPC_TM_AMR | 64 | ||
| 1852 | PPC | KVM_REG_PPC_TM_PPR | 64 | ||
| 1853 | PPC | KVM_REG_PPC_TM_VRSAVE | 64 | ||
| 1854 | PPC | KVM_REG_PPC_TM_VSCR | 32 | ||
| 1855 | PPC | KVM_REG_PPC_TM_DSCR | 64 | ||
| 1856 | PPC | KVM_REG_PPC_TM_TAR | 64 | ||
| 1813 | 1857 | ||
| 1814 | ARM registers are mapped using the lower 32 bits. The upper 16 of that | 1858 | ARM registers are mapped using the lower 32 bits. The upper 16 of that |
| 1815 | is the register group type, or coprocessor number: | 1859 | is the register group type, or coprocessor number: |
| @@ -2304,7 +2348,31 @@ Possible features: | |||
| 2304 | Depends on KVM_CAP_ARM_EL1_32BIT (arm64 only). | 2348 | Depends on KVM_CAP_ARM_EL1_32BIT (arm64 only). |
| 2305 | 2349 | ||
| 2306 | 2350 | ||
| 2307 | 4.83 KVM_GET_REG_LIST | 2351 | 4.83 KVM_ARM_PREFERRED_TARGET |
| 2352 | |||
| 2353 | Capability: basic | ||
| 2354 | Architectures: arm, arm64 | ||
| 2355 | Type: vm ioctl | ||
| 2356 | Parameters: struct struct kvm_vcpu_init (out) | ||
| 2357 | Returns: 0 on success; -1 on error | ||
| 2358 | Errors: | ||
| 2359 | ENODEV: no preferred target available for the host | ||
| 2360 | |||
| 2361 | This queries KVM for preferred CPU target type which can be emulated | ||
| 2362 | by KVM on underlying host. | ||
| 2363 | |||
| 2364 | The ioctl returns struct kvm_vcpu_init instance containing information | ||
| 2365 | about preferred CPU target type and recommended features for it. The | ||
| 2366 | kvm_vcpu_init->features bitmap returned will have feature bits set if | ||
| 2367 | the preferred target recommends setting these features, but this is | ||
| 2368 | not mandatory. | ||
| 2369 | |||
| 2370 | The information returned by this ioctl can be used to prepare an instance | ||
| 2371 | of struct kvm_vcpu_init for KVM_ARM_VCPU_INIT ioctl which will result in | ||
| 2372 | in VCPU matching underlying host. | ||
| 2373 | |||
| 2374 | |||
| 2375 | 4.84 KVM_GET_REG_LIST | ||
| 2308 | 2376 | ||
| 2309 | Capability: basic | 2377 | Capability: basic |
| 2310 | Architectures: arm, arm64 | 2378 | Architectures: arm, arm64 |
| @@ -2323,8 +2391,7 @@ struct kvm_reg_list { | |||
| 2323 | This ioctl returns the guest registers that are supported for the | 2391 | This ioctl returns the guest registers that are supported for the |
| 2324 | KVM_GET_ONE_REG/KVM_SET_ONE_REG calls. | 2392 | KVM_GET_ONE_REG/KVM_SET_ONE_REG calls. |
| 2325 | 2393 | ||
| 2326 | 2394 | 4.85 KVM_ARM_SET_DEVICE_ADDR | |
| 2327 | 4.84 KVM_ARM_SET_DEVICE_ADDR | ||
| 2328 | 2395 | ||
| 2329 | Capability: KVM_CAP_ARM_SET_DEVICE_ADDR | 2396 | Capability: KVM_CAP_ARM_SET_DEVICE_ADDR |
| 2330 | Architectures: arm, arm64 | 2397 | Architectures: arm, arm64 |
| @@ -2362,7 +2429,7 @@ must be called after calling KVM_CREATE_IRQCHIP, but before calling | |||
| 2362 | KVM_RUN on any of the VCPUs. Calling this ioctl twice for any of the | 2429 | KVM_RUN on any of the VCPUs. Calling this ioctl twice for any of the |
| 2363 | base addresses will return -EEXIST. | 2430 | base addresses will return -EEXIST. |
| 2364 | 2431 | ||
| 2365 | 4.85 KVM_PPC_RTAS_DEFINE_TOKEN | 2432 | 4.86 KVM_PPC_RTAS_DEFINE_TOKEN |
| 2366 | 2433 | ||
| 2367 | Capability: KVM_CAP_PPC_RTAS | 2434 | Capability: KVM_CAP_PPC_RTAS |
| 2368 | Architectures: ppc | 2435 | Architectures: ppc |
| @@ -2661,6 +2728,77 @@ and usually define the validity of a groups of registers. (e.g. one bit | |||
| 2661 | }; | 2728 | }; |
| 2662 | 2729 | ||
| 2663 | 2730 | ||
| 2731 | 4.81 KVM_GET_EMULATED_CPUID | ||
| 2732 | |||
| 2733 | Capability: KVM_CAP_EXT_EMUL_CPUID | ||
| 2734 | Architectures: x86 | ||
| 2735 | Type: system ioctl | ||
| 2736 | Parameters: struct kvm_cpuid2 (in/out) | ||
| 2737 | Returns: 0 on success, -1 on error | ||
| 2738 | |||
| 2739 | struct kvm_cpuid2 { | ||
| 2740 | __u32 nent; | ||
| 2741 | __u32 flags; | ||
| 2742 | struct kvm_cpuid_entry2 entries[0]; | ||
| 2743 | }; | ||
| 2744 | |||
| 2745 | The member 'flags' is used for passing flags from userspace. | ||
| 2746 | |||
| 2747 | #define KVM_CPUID_FLAG_SIGNIFCANT_INDEX BIT(0) | ||
| 2748 | #define KVM_CPUID_FLAG_STATEFUL_FUNC BIT(1) | ||
| 2749 | #define KVM_CPUID_FLAG_STATE_READ_NEXT BIT(2) | ||
| 2750 | |||
| 2751 | struct kvm_cpuid_entry2 { | ||
| 2752 | __u32 function; | ||
| 2753 | __u32 index; | ||
| 2754 | __u32 flags; | ||
| 2755 | __u32 eax; | ||
| 2756 | __u32 ebx; | ||
| 2757 | __u32 ecx; | ||
| 2758 | __u32 edx; | ||
| 2759 | __u32 padding[3]; | ||
| 2760 | }; | ||
| 2761 | |||
| 2762 | This ioctl returns x86 cpuid features which are emulated by | ||
| 2763 | kvm.Userspace can use the information returned by this ioctl to query | ||
| 2764 | which features are emulated by kvm instead of being present natively. | ||
| 2765 | |||
| 2766 | Userspace invokes KVM_GET_EMULATED_CPUID by passing a kvm_cpuid2 | ||
| 2767 | structure with the 'nent' field indicating the number of entries in | ||
| 2768 | the variable-size array 'entries'. If the number of entries is too low | ||
| 2769 | to describe the cpu capabilities, an error (E2BIG) is returned. If the | ||
| 2770 | number is too high, the 'nent' field is adjusted and an error (ENOMEM) | ||
| 2771 | is returned. If the number is just right, the 'nent' field is adjusted | ||
| 2772 | to the number of valid entries in the 'entries' array, which is then | ||
| 2773 | filled. | ||
| 2774 | |||
| 2775 | The entries returned are the set CPUID bits of the respective features | ||
| 2776 | which kvm emulates, as returned by the CPUID instruction, with unknown | ||
| 2777 | or unsupported feature bits cleared. | ||
| 2778 | |||
| 2779 | Features like x2apic, for example, may not be present in the host cpu | ||
| 2780 | but are exposed by kvm in KVM_GET_SUPPORTED_CPUID because they can be | ||
| 2781 | emulated efficiently and thus not included here. | ||
| 2782 | |||
| 2783 | The fields in each entry are defined as follows: | ||
| 2784 | |||
| 2785 | function: the eax value used to obtain the entry | ||
| 2786 | index: the ecx value used to obtain the entry (for entries that are | ||
| 2787 | affected by ecx) | ||
| 2788 | flags: an OR of zero or more of the following: | ||
| 2789 | KVM_CPUID_FLAG_SIGNIFCANT_INDEX: | ||
| 2790 | if the index field is valid | ||
| 2791 | KVM_CPUID_FLAG_STATEFUL_FUNC: | ||
| 2792 | if cpuid for this function returns different values for successive | ||
| 2793 | invocations; there will be several entries with the same function, | ||
| 2794 | all with this flag set | ||
| 2795 | KVM_CPUID_FLAG_STATE_READ_NEXT: | ||
| 2796 | for KVM_CPUID_FLAG_STATEFUL_FUNC entries, set if this entry is | ||
| 2797 | the first entry to be read by a cpu | ||
| 2798 | eax, ebx, ecx, edx: the values returned by the cpuid instruction for | ||
| 2799 | this function/index combination | ||
| 2800 | |||
| 2801 | |||
| 2664 | 6. Capabilities that can be enabled | 2802 | 6. Capabilities that can be enabled |
| 2665 | ----------------------------------- | 2803 | ----------------------------------- |
| 2666 | 2804 | ||
diff --git a/Documentation/virtual/kvm/cpuid.txt b/Documentation/virtual/kvm/cpuid.txt index 22ff659bc0fb..3c65feb83010 100644 --- a/Documentation/virtual/kvm/cpuid.txt +++ b/Documentation/virtual/kvm/cpuid.txt | |||
| @@ -43,6 +43,13 @@ KVM_FEATURE_CLOCKSOURCE2 || 3 || kvmclock available at msrs | |||
| 43 | KVM_FEATURE_ASYNC_PF || 4 || async pf can be enabled by | 43 | KVM_FEATURE_ASYNC_PF || 4 || async pf can be enabled by |
| 44 | || || writing to msr 0x4b564d02 | 44 | || || writing to msr 0x4b564d02 |
| 45 | ------------------------------------------------------------------------------ | 45 | ------------------------------------------------------------------------------ |
| 46 | KVM_FEATURE_STEAL_TIME || 5 || steal time can be enabled by | ||
| 47 | || || writing to msr 0x4b564d03. | ||
| 48 | ------------------------------------------------------------------------------ | ||
| 49 | KVM_FEATURE_PV_EOI || 6 || paravirtualized end of interrupt | ||
| 50 | || || handler can be enabled by writing | ||
| 51 | || || to msr 0x4b564d04. | ||
| 52 | ------------------------------------------------------------------------------ | ||
| 46 | KVM_FEATURE_PV_UNHALT || 7 || guest checks this feature bit | 53 | KVM_FEATURE_PV_UNHALT || 7 || guest checks this feature bit |
| 47 | || || before enabling paravirtualized | 54 | || || before enabling paravirtualized |
| 48 | || || spinlock support. | 55 | || || spinlock support. |
diff --git a/Documentation/virtual/kvm/devices/vfio.txt b/Documentation/virtual/kvm/devices/vfio.txt new file mode 100644 index 000000000000..ef51740c67ca --- /dev/null +++ b/Documentation/virtual/kvm/devices/vfio.txt | |||
| @@ -0,0 +1,22 @@ | |||
| 1 | VFIO virtual device | ||
| 2 | =================== | ||
| 3 | |||
| 4 | Device types supported: | ||
| 5 | KVM_DEV_TYPE_VFIO | ||
| 6 | |||
| 7 | Only one VFIO instance may be created per VM. The created device | ||
| 8 | tracks VFIO groups in use by the VM and features of those groups | ||
| 9 | important to the correctness and acceleration of the VM. As groups | ||
| 10 | are enabled and disabled for use by the VM, KVM should be updated | ||
| 11 | about their presence. When registered with KVM, a reference to the | ||
| 12 | VFIO-group is held by KVM. | ||
| 13 | |||
| 14 | Groups: | ||
| 15 | KVM_DEV_VFIO_GROUP | ||
| 16 | |||
| 17 | KVM_DEV_VFIO_GROUP attributes: | ||
| 18 | KVM_DEV_VFIO_GROUP_ADD: Add a VFIO group to VFIO-KVM device tracking | ||
| 19 | KVM_DEV_VFIO_GROUP_DEL: Remove a VFIO group from VFIO-KVM device tracking | ||
| 20 | |||
| 21 | For each, kvm_device_attr.addr points to an int32_t file descriptor | ||
| 22 | for the VFIO group. | ||
diff --git a/Documentation/virtual/kvm/locking.txt b/Documentation/virtual/kvm/locking.txt index 41b7ac9884b5..f8869410d40c 100644 --- a/Documentation/virtual/kvm/locking.txt +++ b/Documentation/virtual/kvm/locking.txt | |||
| @@ -132,10 +132,14 @@ See the comments in spte_has_volatile_bits() and mmu_spte_update(). | |||
| 132 | ------------ | 132 | ------------ |
| 133 | 133 | ||
| 134 | Name: kvm_lock | 134 | Name: kvm_lock |
| 135 | Type: raw_spinlock | 135 | Type: spinlock_t |
| 136 | Arch: any | 136 | Arch: any |
| 137 | Protects: - vm_list | 137 | Protects: - vm_list |
| 138 | - hardware virtualization enable/disable | 138 | |
| 139 | Name: kvm_count_lock | ||
| 140 | Type: raw_spinlock_t | ||
| 141 | Arch: any | ||
| 142 | Protects: - hardware virtualization enable/disable | ||
| 139 | Comment: 'raw' because hardware enabling/disabling must be atomic /wrt | 143 | Comment: 'raw' because hardware enabling/disabling must be atomic /wrt |
| 140 | migration. | 144 | migration. |
| 141 | 145 | ||
| @@ -151,3 +155,14 @@ Type: spinlock_t | |||
| 151 | Arch: any | 155 | Arch: any |
| 152 | Protects: -shadow page/shadow tlb entry | 156 | Protects: -shadow page/shadow tlb entry |
| 153 | Comment: it is a spinlock since it is used in mmu notifier. | 157 | Comment: it is a spinlock since it is used in mmu notifier. |
| 158 | |||
| 159 | Name: kvm->srcu | ||
| 160 | Type: srcu lock | ||
| 161 | Arch: any | ||
| 162 | Protects: - kvm->memslots | ||
| 163 | - kvm->buses | ||
| 164 | Comment: The srcu read lock must be held while accessing memslots (e.g. | ||
| 165 | when using gfn_to_* functions) and while accessing in-kernel | ||
| 166 | MMIO/PIO address->device structure mapping (kvm->buses). | ||
| 167 | The srcu index can be stored in kvm_vcpu->srcu_idx per vcpu | ||
| 168 | if it is needed by multiple functions. | ||
diff --git a/MAINTAINERS b/MAINTAINERS index f3ef1d1f6029..583af4b72ad0 100644 --- a/MAINTAINERS +++ b/MAINTAINERS | |||
| @@ -4871,7 +4871,8 @@ KERNEL VIRTUAL MACHINE (KVM) | |||
| 4871 | M: Gleb Natapov <gleb@redhat.com> | 4871 | M: Gleb Natapov <gleb@redhat.com> |
| 4872 | M: Paolo Bonzini <pbonzini@redhat.com> | 4872 | M: Paolo Bonzini <pbonzini@redhat.com> |
| 4873 | L: kvm@vger.kernel.org | 4873 | L: kvm@vger.kernel.org |
| 4874 | W: http://linux-kvm.org | 4874 | W: http://www.linux-kvm.org |
| 4875 | T: git git://git.kernel.org/pub/scm/virt/kvm/kvm.git | ||
| 4875 | S: Supported | 4876 | S: Supported |
| 4876 | F: Documentation/*/kvm*.txt | 4877 | F: Documentation/*/kvm*.txt |
| 4877 | F: Documentation/virtual/kvm/ | 4878 | F: Documentation/virtual/kvm/ |
diff --git a/arch/arm/include/asm/kvm_arm.h b/arch/arm/include/asm/kvm_arm.h index 64e96960de29..1d3153c7eb41 100644 --- a/arch/arm/include/asm/kvm_arm.h +++ b/arch/arm/include/asm/kvm_arm.h | |||
| @@ -57,6 +57,7 @@ | |||
| 57 | * TSC: Trap SMC | 57 | * TSC: Trap SMC |
| 58 | * TSW: Trap cache operations by set/way | 58 | * TSW: Trap cache operations by set/way |
| 59 | * TWI: Trap WFI | 59 | * TWI: Trap WFI |
| 60 | * TWE: Trap WFE | ||
| 60 | * TIDCP: Trap L2CTLR/L2ECTLR | 61 | * TIDCP: Trap L2CTLR/L2ECTLR |
| 61 | * BSU_IS: Upgrade barriers to the inner shareable domain | 62 | * BSU_IS: Upgrade barriers to the inner shareable domain |
| 62 | * FB: Force broadcast of all maintainance operations | 63 | * FB: Force broadcast of all maintainance operations |
| @@ -67,7 +68,7 @@ | |||
| 67 | */ | 68 | */ |
| 68 | #define HCR_GUEST_MASK (HCR_TSC | HCR_TSW | HCR_TWI | HCR_VM | HCR_BSU_IS | \ | 69 | #define HCR_GUEST_MASK (HCR_TSC | HCR_TSW | HCR_TWI | HCR_VM | HCR_BSU_IS | \ |
| 69 | HCR_FB | HCR_TAC | HCR_AMO | HCR_IMO | HCR_FMO | \ | 70 | HCR_FB | HCR_TAC | HCR_AMO | HCR_IMO | HCR_FMO | \ |
| 70 | HCR_SWIO | HCR_TIDCP) | 71 | HCR_TWE | HCR_SWIO | HCR_TIDCP) |
| 71 | #define HCR_VIRT_EXCP_MASK (HCR_VA | HCR_VI | HCR_VF) | 72 | #define HCR_VIRT_EXCP_MASK (HCR_VA | HCR_VI | HCR_VF) |
| 72 | 73 | ||
| 73 | /* System Control Register (SCTLR) bits */ | 74 | /* System Control Register (SCTLR) bits */ |
| @@ -95,12 +96,12 @@ | |||
| 95 | #define TTBCR_IRGN1 (3 << 24) | 96 | #define TTBCR_IRGN1 (3 << 24) |
| 96 | #define TTBCR_EPD1 (1 << 23) | 97 | #define TTBCR_EPD1 (1 << 23) |
| 97 | #define TTBCR_A1 (1 << 22) | 98 | #define TTBCR_A1 (1 << 22) |
| 98 | #define TTBCR_T1SZ (3 << 16) | 99 | #define TTBCR_T1SZ (7 << 16) |
| 99 | #define TTBCR_SH0 (3 << 12) | 100 | #define TTBCR_SH0 (3 << 12) |
| 100 | #define TTBCR_ORGN0 (3 << 10) | 101 | #define TTBCR_ORGN0 (3 << 10) |
| 101 | #define TTBCR_IRGN0 (3 << 8) | 102 | #define TTBCR_IRGN0 (3 << 8) |
| 102 | #define TTBCR_EPD0 (1 << 7) | 103 | #define TTBCR_EPD0 (1 << 7) |
| 103 | #define TTBCR_T0SZ 3 | 104 | #define TTBCR_T0SZ (7 << 0) |
| 104 | #define HTCR_MASK (TTBCR_T0SZ | TTBCR_IRGN0 | TTBCR_ORGN0 | TTBCR_SH0) | 105 | #define HTCR_MASK (TTBCR_T0SZ | TTBCR_IRGN0 | TTBCR_ORGN0 | TTBCR_SH0) |
| 105 | 106 | ||
| 106 | /* Hyp System Trap Register */ | 107 | /* Hyp System Trap Register */ |
| @@ -208,6 +209,8 @@ | |||
| 208 | #define HSR_EC_DABT (0x24) | 209 | #define HSR_EC_DABT (0x24) |
| 209 | #define HSR_EC_DABT_HYP (0x25) | 210 | #define HSR_EC_DABT_HYP (0x25) |
| 210 | 211 | ||
| 212 | #define HSR_WFI_IS_WFE (1U << 0) | ||
| 213 | |||
| 211 | #define HSR_HVC_IMM_MASK ((1UL << 16) - 1) | 214 | #define HSR_HVC_IMM_MASK ((1UL << 16) - 1) |
| 212 | 215 | ||
| 213 | #define HSR_DABT_S1PTW (1U << 7) | 216 | #define HSR_DABT_S1PTW (1U << 7) |
diff --git a/arch/arm/include/asm/kvm_asm.h b/arch/arm/include/asm/kvm_asm.h index a2f43ddcc300..661da11f76f4 100644 --- a/arch/arm/include/asm/kvm_asm.h +++ b/arch/arm/include/asm/kvm_asm.h | |||
| @@ -39,7 +39,7 @@ | |||
| 39 | #define c6_IFAR 17 /* Instruction Fault Address Register */ | 39 | #define c6_IFAR 17 /* Instruction Fault Address Register */ |
| 40 | #define c7_PAR 18 /* Physical Address Register */ | 40 | #define c7_PAR 18 /* Physical Address Register */ |
| 41 | #define c7_PAR_high 19 /* PAR top 32 bits */ | 41 | #define c7_PAR_high 19 /* PAR top 32 bits */ |
| 42 | #define c9_L2CTLR 20 /* Cortex A15 L2 Control Register */ | 42 | #define c9_L2CTLR 20 /* Cortex A15/A7 L2 Control Register */ |
| 43 | #define c10_PRRR 21 /* Primary Region Remap Register */ | 43 | #define c10_PRRR 21 /* Primary Region Remap Register */ |
| 44 | #define c10_NMRR 22 /* Normal Memory Remap Register */ | 44 | #define c10_NMRR 22 /* Normal Memory Remap Register */ |
| 45 | #define c12_VBAR 23 /* Vector Base Address Register */ | 45 | #define c12_VBAR 23 /* Vector Base Address Register */ |
diff --git a/arch/arm/include/asm/kvm_emulate.h b/arch/arm/include/asm/kvm_emulate.h index a464e8d7b6c5..0fa90c962ac8 100644 --- a/arch/arm/include/asm/kvm_emulate.h +++ b/arch/arm/include/asm/kvm_emulate.h | |||
| @@ -157,4 +157,55 @@ static inline u32 kvm_vcpu_hvc_get_imm(struct kvm_vcpu *vcpu) | |||
| 157 | return kvm_vcpu_get_hsr(vcpu) & HSR_HVC_IMM_MASK; | 157 | return kvm_vcpu_get_hsr(vcpu) & HSR_HVC_IMM_MASK; |
| 158 | } | 158 | } |
| 159 | 159 | ||
| 160 | static inline unsigned long kvm_vcpu_get_mpidr(struct kvm_vcpu *vcpu) | ||
| 161 | { | ||
| 162 | return vcpu->arch.cp15[c0_MPIDR]; | ||
| 163 | } | ||
| 164 | |||
| 165 | static inline void kvm_vcpu_set_be(struct kvm_vcpu *vcpu) | ||
| 166 | { | ||
| 167 | *vcpu_cpsr(vcpu) |= PSR_E_BIT; | ||
| 168 | } | ||
| 169 | |||
| 170 | static inline bool kvm_vcpu_is_be(struct kvm_vcpu *vcpu) | ||
| 171 | { | ||
| 172 | return !!(*vcpu_cpsr(vcpu) & PSR_E_BIT); | ||
| 173 | } | ||
| 174 | |||
| 175 | static inline unsigned long vcpu_data_guest_to_host(struct kvm_vcpu *vcpu, | ||
| 176 | unsigned long data, | ||
| 177 | unsigned int len) | ||
| 178 | { | ||
| 179 | if (kvm_vcpu_is_be(vcpu)) { | ||
| 180 | switch (len) { | ||
| 181 | case 1: | ||
| 182 | return data & 0xff; | ||
| 183 | case 2: | ||
| 184 | return be16_to_cpu(data & 0xffff); | ||
| 185 | default: | ||
| 186 | return be32_to_cpu(data); | ||
| 187 | } | ||
| 188 | } | ||
| 189 | |||
| 190 | return data; /* Leave LE untouched */ | ||
| 191 | } | ||
| 192 | |||
| 193 | static inline unsigned long vcpu_data_host_to_guest(struct kvm_vcpu *vcpu, | ||
| 194 | unsigned long data, | ||
| 195 | unsigned int len) | ||
| 196 | { | ||
| 197 | if (kvm_vcpu_is_be(vcpu)) { | ||
| 198 | switch (len) { | ||
| 199 | case 1: | ||
| 200 | return data & 0xff; | ||
| 201 | case 2: | ||
| 202 | return cpu_to_be16(data & 0xffff); | ||
| 203 | default: | ||
| 204 | return cpu_to_be32(data); | ||
| 205 | } | ||
| 206 | } | ||
| 207 | |||
| 208 | return data; /* Leave LE untouched */ | ||
| 209 | } | ||
| 210 | |||
| 160 | #endif /* __ARM_KVM_EMULATE_H__ */ | 211 | #endif /* __ARM_KVM_EMULATE_H__ */ |
diff --git a/arch/arm/include/asm/kvm_host.h b/arch/arm/include/asm/kvm_host.h index 7d22517d8071..8a6f6db14ee4 100644 --- a/arch/arm/include/asm/kvm_host.h +++ b/arch/arm/include/asm/kvm_host.h | |||
| @@ -38,11 +38,6 @@ | |||
| 38 | 38 | ||
| 39 | #define KVM_VCPU_MAX_FEATURES 1 | 39 | #define KVM_VCPU_MAX_FEATURES 1 |
| 40 | 40 | ||
| 41 | /* We don't currently support large pages. */ | ||
| 42 | #define KVM_HPAGE_GFN_SHIFT(x) 0 | ||
| 43 | #define KVM_NR_PAGE_SIZES 1 | ||
| 44 | #define KVM_PAGES_PER_HPAGE(x) (1UL<<31) | ||
| 45 | |||
| 46 | #include <kvm/arm_vgic.h> | 41 | #include <kvm/arm_vgic.h> |
| 47 | 42 | ||
| 48 | struct kvm_vcpu; | 43 | struct kvm_vcpu; |
| @@ -154,6 +149,7 @@ struct kvm_vcpu_stat { | |||
| 154 | struct kvm_vcpu_init; | 149 | struct kvm_vcpu_init; |
| 155 | int kvm_vcpu_set_target(struct kvm_vcpu *vcpu, | 150 | int kvm_vcpu_set_target(struct kvm_vcpu *vcpu, |
| 156 | const struct kvm_vcpu_init *init); | 151 | const struct kvm_vcpu_init *init); |
| 152 | int kvm_vcpu_preferred_target(struct kvm_vcpu_init *init); | ||
| 157 | unsigned long kvm_arm_num_regs(struct kvm_vcpu *vcpu); | 153 | unsigned long kvm_arm_num_regs(struct kvm_vcpu *vcpu); |
| 158 | int kvm_arm_copy_reg_indices(struct kvm_vcpu *vcpu, u64 __user *indices); | 154 | int kvm_arm_copy_reg_indices(struct kvm_vcpu *vcpu, u64 __user *indices); |
| 159 | struct kvm_one_reg; | 155 | struct kvm_one_reg; |
diff --git a/arch/arm/include/asm/kvm_mmu.h b/arch/arm/include/asm/kvm_mmu.h index 9b28c41f4ba9..77de4a41cc50 100644 --- a/arch/arm/include/asm/kvm_mmu.h +++ b/arch/arm/include/asm/kvm_mmu.h | |||
| @@ -62,6 +62,12 @@ phys_addr_t kvm_get_idmap_vector(void); | |||
| 62 | int kvm_mmu_init(void); | 62 | int kvm_mmu_init(void); |
| 63 | void kvm_clear_hyp_idmap(void); | 63 | void kvm_clear_hyp_idmap(void); |
| 64 | 64 | ||
| 65 | static inline void kvm_set_pmd(pmd_t *pmd, pmd_t new_pmd) | ||
| 66 | { | ||
| 67 | *pmd = new_pmd; | ||
| 68 | flush_pmd_entry(pmd); | ||
| 69 | } | ||
| 70 | |||
| 65 | static inline void kvm_set_pte(pte_t *pte, pte_t new_pte) | 71 | static inline void kvm_set_pte(pte_t *pte, pte_t new_pte) |
| 66 | { | 72 | { |
| 67 | *pte = new_pte; | 73 | *pte = new_pte; |
| @@ -103,9 +109,15 @@ static inline void kvm_set_s2pte_writable(pte_t *pte) | |||
| 103 | pte_val(*pte) |= L_PTE_S2_RDWR; | 109 | pte_val(*pte) |= L_PTE_S2_RDWR; |
| 104 | } | 110 | } |
| 105 | 111 | ||
| 112 | static inline void kvm_set_s2pmd_writable(pmd_t *pmd) | ||
| 113 | { | ||
| 114 | pmd_val(*pmd) |= L_PMD_S2_RDWR; | ||
| 115 | } | ||
| 116 | |||
| 106 | struct kvm; | 117 | struct kvm; |
| 107 | 118 | ||
| 108 | static inline void coherent_icache_guest_page(struct kvm *kvm, gfn_t gfn) | 119 | static inline void coherent_icache_guest_page(struct kvm *kvm, hva_t hva, |
| 120 | unsigned long size) | ||
| 109 | { | 121 | { |
| 110 | /* | 122 | /* |
| 111 | * If we are going to insert an instruction page and the icache is | 123 | * If we are going to insert an instruction page and the icache is |
| @@ -120,8 +132,7 @@ static inline void coherent_icache_guest_page(struct kvm *kvm, gfn_t gfn) | |||
| 120 | * need any kind of flushing (DDI 0406C.b - Page B3-1392). | 132 | * need any kind of flushing (DDI 0406C.b - Page B3-1392). |
| 121 | */ | 133 | */ |
| 122 | if (icache_is_pipt()) { | 134 | if (icache_is_pipt()) { |
| 123 | unsigned long hva = gfn_to_hva(kvm, gfn); | 135 | __cpuc_coherent_user_range(hva, hva + size); |
| 124 | __cpuc_coherent_user_range(hva, hva + PAGE_SIZE); | ||
| 125 | } else if (!icache_is_vivt_asid_tagged()) { | 136 | } else if (!icache_is_vivt_asid_tagged()) { |
| 126 | /* any kind of VIPT cache */ | 137 | /* any kind of VIPT cache */ |
| 127 | __flush_icache_all(); | 138 | __flush_icache_all(); |
diff --git a/arch/arm/include/asm/pgtable-3level.h b/arch/arm/include/asm/pgtable-3level.h index 39c54cfa03e9..4f9503908dca 100644 --- a/arch/arm/include/asm/pgtable-3level.h +++ b/arch/arm/include/asm/pgtable-3level.h | |||
| @@ -126,6 +126,8 @@ | |||
| 126 | #define L_PTE_S2_RDONLY (_AT(pteval_t, 1) << 6) /* HAP[1] */ | 126 | #define L_PTE_S2_RDONLY (_AT(pteval_t, 1) << 6) /* HAP[1] */ |
| 127 | #define L_PTE_S2_RDWR (_AT(pteval_t, 3) << 6) /* HAP[2:1] */ | 127 | #define L_PTE_S2_RDWR (_AT(pteval_t, 3) << 6) /* HAP[2:1] */ |
| 128 | 128 | ||
| 129 | #define L_PMD_S2_RDWR (_AT(pmdval_t, 3) << 6) /* HAP[2:1] */ | ||
| 130 | |||
| 129 | /* | 131 | /* |
| 130 | * Hyp-mode PL2 PTE definitions for LPAE. | 132 | * Hyp-mode PL2 PTE definitions for LPAE. |
| 131 | */ | 133 | */ |
diff --git a/arch/arm/include/uapi/asm/kvm.h b/arch/arm/include/uapi/asm/kvm.h index c1ee007523d7..c498b60c0505 100644 --- a/arch/arm/include/uapi/asm/kvm.h +++ b/arch/arm/include/uapi/asm/kvm.h | |||
| @@ -63,7 +63,8 @@ struct kvm_regs { | |||
| 63 | 63 | ||
| 64 | /* Supported Processor Types */ | 64 | /* Supported Processor Types */ |
| 65 | #define KVM_ARM_TARGET_CORTEX_A15 0 | 65 | #define KVM_ARM_TARGET_CORTEX_A15 0 |
| 66 | #define KVM_ARM_NUM_TARGETS 1 | 66 | #define KVM_ARM_TARGET_CORTEX_A7 1 |
| 67 | #define KVM_ARM_NUM_TARGETS 2 | ||
| 67 | 68 | ||
| 68 | /* KVM_ARM_SET_DEVICE_ADDR ioctl id encoding */ | 69 | /* KVM_ARM_SET_DEVICE_ADDR ioctl id encoding */ |
| 69 | #define KVM_ARM_DEVICE_TYPE_SHIFT 0 | 70 | #define KVM_ARM_DEVICE_TYPE_SHIFT 0 |
diff --git a/arch/arm/kvm/Kconfig b/arch/arm/kvm/Kconfig index ebf5015508b5..466bd299b1a8 100644 --- a/arch/arm/kvm/Kconfig +++ b/arch/arm/kvm/Kconfig | |||
| @@ -20,6 +20,7 @@ config KVM | |||
| 20 | bool "Kernel-based Virtual Machine (KVM) support" | 20 | bool "Kernel-based Virtual Machine (KVM) support" |
| 21 | select PREEMPT_NOTIFIERS | 21 | select PREEMPT_NOTIFIERS |
| 22 | select ANON_INODES | 22 | select ANON_INODES |
| 23 | select HAVE_KVM_CPU_RELAX_INTERCEPT | ||
| 23 | select KVM_MMIO | 24 | select KVM_MMIO |
| 24 | select KVM_ARM_HOST | 25 | select KVM_ARM_HOST |
| 25 | depends on ARM_VIRT_EXT && ARM_LPAE | 26 | depends on ARM_VIRT_EXT && ARM_LPAE |
diff --git a/arch/arm/kvm/Makefile b/arch/arm/kvm/Makefile index d99bee4950e5..789bca9e64a7 100644 --- a/arch/arm/kvm/Makefile +++ b/arch/arm/kvm/Makefile | |||
| @@ -19,6 +19,6 @@ kvm-arm-y = $(KVM)/kvm_main.o $(KVM)/coalesced_mmio.o | |||
| 19 | 19 | ||
| 20 | obj-y += kvm-arm.o init.o interrupts.o | 20 | obj-y += kvm-arm.o init.o interrupts.o |
| 21 | obj-y += arm.o handle_exit.o guest.o mmu.o emulate.o reset.o | 21 | obj-y += arm.o handle_exit.o guest.o mmu.o emulate.o reset.o |
| 22 | obj-y += coproc.o coproc_a15.o mmio.o psci.o perf.o | 22 | obj-y += coproc.o coproc_a15.o coproc_a7.o mmio.o psci.o perf.o |
| 23 | obj-$(CONFIG_KVM_ARM_VGIC) += $(KVM)/arm/vgic.o | 23 | obj-$(CONFIG_KVM_ARM_VGIC) += $(KVM)/arm/vgic.o |
| 24 | obj-$(CONFIG_KVM_ARM_TIMER) += $(KVM)/arm/arch_timer.o | 24 | obj-$(CONFIG_KVM_ARM_TIMER) += $(KVM)/arm/arch_timer.o |
diff --git a/arch/arm/kvm/arm.c b/arch/arm/kvm/arm.c index aea7ccb8d397..2a700e00528d 100644 --- a/arch/arm/kvm/arm.c +++ b/arch/arm/kvm/arm.c | |||
| @@ -152,12 +152,13 @@ int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) | |||
| 152 | return VM_FAULT_SIGBUS; | 152 | return VM_FAULT_SIGBUS; |
| 153 | } | 153 | } |
| 154 | 154 | ||
| 155 | void kvm_arch_free_memslot(struct kvm_memory_slot *free, | 155 | void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free, |
| 156 | struct kvm_memory_slot *dont) | 156 | struct kvm_memory_slot *dont) |
| 157 | { | 157 | { |
| 158 | } | 158 | } |
| 159 | 159 | ||
| 160 | int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages) | 160 | int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, |
| 161 | unsigned long npages) | ||
| 161 | { | 162 | { |
| 162 | return 0; | 163 | return 0; |
| 163 | } | 164 | } |
| @@ -797,6 +798,19 @@ long kvm_arch_vm_ioctl(struct file *filp, | |||
| 797 | return -EFAULT; | 798 | return -EFAULT; |
| 798 | return kvm_vm_ioctl_set_device_addr(kvm, &dev_addr); | 799 | return kvm_vm_ioctl_set_device_addr(kvm, &dev_addr); |
| 799 | } | 800 | } |
| 801 | case KVM_ARM_PREFERRED_TARGET: { | ||
| 802 | int err; | ||
| 803 | struct kvm_vcpu_init init; | ||
| 804 | |||
| 805 | err = kvm_vcpu_preferred_target(&init); | ||
| 806 | if (err) | ||
| 807 | return err; | ||
| 808 | |||
| 809 | if (copy_to_user(argp, &init, sizeof(init))) | ||
| 810 | return -EFAULT; | ||
| 811 | |||
| 812 | return 0; | ||
| 813 | } | ||
| 800 | default: | 814 | default: |
| 801 | return -EINVAL; | 815 | return -EINVAL; |
| 802 | } | 816 | } |
diff --git a/arch/arm/kvm/coproc.c b/arch/arm/kvm/coproc.c index db9cf692d4dd..78c0885d6501 100644 --- a/arch/arm/kvm/coproc.c +++ b/arch/arm/kvm/coproc.c | |||
| @@ -71,6 +71,98 @@ int kvm_handle_cp14_access(struct kvm_vcpu *vcpu, struct kvm_run *run) | |||
| 71 | return 1; | 71 | return 1; |
| 72 | } | 72 | } |
| 73 | 73 | ||
| 74 | static void reset_mpidr(struct kvm_vcpu *vcpu, const struct coproc_reg *r) | ||
| 75 | { | ||
| 76 | /* | ||
| 77 | * Compute guest MPIDR. We build a virtual cluster out of the | ||
| 78 | * vcpu_id, but we read the 'U' bit from the underlying | ||
| 79 | * hardware directly. | ||
| 80 | */ | ||
| 81 | vcpu->arch.cp15[c0_MPIDR] = ((read_cpuid_mpidr() & MPIDR_SMP_BITMASK) | | ||
| 82 | ((vcpu->vcpu_id >> 2) << MPIDR_LEVEL_BITS) | | ||
| 83 | (vcpu->vcpu_id & 3)); | ||
| 84 | } | ||
| 85 | |||
| 86 | /* TRM entries A7:4.3.31 A15:4.3.28 - RO WI */ | ||
| 87 | static bool access_actlr(struct kvm_vcpu *vcpu, | ||
| 88 | const struct coproc_params *p, | ||
| 89 | const struct coproc_reg *r) | ||
| 90 | { | ||
| 91 | if (p->is_write) | ||
| 92 | return ignore_write(vcpu, p); | ||
| 93 | |||
| 94 | *vcpu_reg(vcpu, p->Rt1) = vcpu->arch.cp15[c1_ACTLR]; | ||
| 95 | return true; | ||
| 96 | } | ||
| 97 | |||
| 98 | /* TRM entries A7:4.3.56, A15:4.3.60 - R/O. */ | ||
| 99 | static bool access_cbar(struct kvm_vcpu *vcpu, | ||
| 100 | const struct coproc_params *p, | ||
| 101 | const struct coproc_reg *r) | ||
| 102 | { | ||
| 103 | if (p->is_write) | ||
| 104 | return write_to_read_only(vcpu, p); | ||
| 105 | return read_zero(vcpu, p); | ||
| 106 | } | ||
| 107 | |||
| 108 | /* TRM entries A7:4.3.49, A15:4.3.48 - R/O WI */ | ||
| 109 | static bool access_l2ctlr(struct kvm_vcpu *vcpu, | ||
| 110 | const struct coproc_params *p, | ||
| 111 | const struct coproc_reg *r) | ||
| 112 | { | ||
| 113 | if (p->is_write) | ||
| 114 | return ignore_write(vcpu, p); | ||
| 115 | |||
| 116 | *vcpu_reg(vcpu, p->Rt1) = vcpu->arch.cp15[c9_L2CTLR]; | ||
| 117 | return true; | ||
| 118 | } | ||
| 119 | |||
| 120 | static void reset_l2ctlr(struct kvm_vcpu *vcpu, const struct coproc_reg *r) | ||
| 121 | { | ||
| 122 | u32 l2ctlr, ncores; | ||
| 123 | |||
| 124 | asm volatile("mrc p15, 1, %0, c9, c0, 2\n" : "=r" (l2ctlr)); | ||
| 125 | l2ctlr &= ~(3 << 24); | ||
| 126 | ncores = atomic_read(&vcpu->kvm->online_vcpus) - 1; | ||
| 127 | /* How many cores in the current cluster and the next ones */ | ||
| 128 | ncores -= (vcpu->vcpu_id & ~3); | ||
| 129 | /* Cap it to the maximum number of cores in a single cluster */ | ||
| 130 | ncores = min(ncores, 3U); | ||
| 131 | l2ctlr |= (ncores & 3) << 24; | ||
| 132 | |||
| 133 | vcpu->arch.cp15[c9_L2CTLR] = l2ctlr; | ||
| 134 | } | ||
| 135 | |||
| 136 | static void reset_actlr(struct kvm_vcpu *vcpu, const struct coproc_reg *r) | ||
| 137 | { | ||
| 138 | u32 actlr; | ||
| 139 | |||
| 140 | /* ACTLR contains SMP bit: make sure you create all cpus first! */ | ||
| 141 | asm volatile("mrc p15, 0, %0, c1, c0, 1\n" : "=r" (actlr)); | ||
| 142 | /* Make the SMP bit consistent with the guest configuration */ | ||
| 143 | if (atomic_read(&vcpu->kvm->online_vcpus) > 1) | ||
| 144 | actlr |= 1U << 6; | ||
| 145 | else | ||
| 146 | actlr &= ~(1U << 6); | ||
| 147 | |||
| 148 | vcpu->arch.cp15[c1_ACTLR] = actlr; | ||
| 149 | } | ||
| 150 | |||
| 151 | /* | ||
| 152 | * TRM entries: A7:4.3.50, A15:4.3.49 | ||
| 153 | * R/O WI (even if NSACR.NS_L2ERR, a write of 1 is ignored). | ||
| 154 | */ | ||
| 155 | static bool access_l2ectlr(struct kvm_vcpu *vcpu, | ||
| 156 | const struct coproc_params *p, | ||
| 157 | const struct coproc_reg *r) | ||
| 158 | { | ||
| 159 | if (p->is_write) | ||
| 160 | return ignore_write(vcpu, p); | ||
| 161 | |||
| 162 | *vcpu_reg(vcpu, p->Rt1) = 0; | ||
| 163 | return true; | ||
| 164 | } | ||
| 165 | |||
| 74 | /* See note at ARM ARM B1.14.4 */ | 166 | /* See note at ARM ARM B1.14.4 */ |
| 75 | static bool access_dcsw(struct kvm_vcpu *vcpu, | 167 | static bool access_dcsw(struct kvm_vcpu *vcpu, |
| 76 | const struct coproc_params *p, | 168 | const struct coproc_params *p, |
| @@ -153,10 +245,22 @@ static bool pm_fake(struct kvm_vcpu *vcpu, | |||
| 153 | * registers preceding 32-bit ones. | 245 | * registers preceding 32-bit ones. |
| 154 | */ | 246 | */ |
| 155 | static const struct coproc_reg cp15_regs[] = { | 247 | static const struct coproc_reg cp15_regs[] = { |
| 248 | /* MPIDR: we use VMPIDR for guest access. */ | ||
| 249 | { CRn( 0), CRm( 0), Op1( 0), Op2( 5), is32, | ||
| 250 | NULL, reset_mpidr, c0_MPIDR }, | ||
| 251 | |||
| 156 | /* CSSELR: swapped by interrupt.S. */ | 252 | /* CSSELR: swapped by interrupt.S. */ |
| 157 | { CRn( 0), CRm( 0), Op1( 2), Op2( 0), is32, | 253 | { CRn( 0), CRm( 0), Op1( 2), Op2( 0), is32, |
| 158 | NULL, reset_unknown, c0_CSSELR }, | 254 | NULL, reset_unknown, c0_CSSELR }, |
| 159 | 255 | ||
| 256 | /* ACTLR: trapped by HCR.TAC bit. */ | ||
| 257 | { CRn( 1), CRm( 0), Op1( 0), Op2( 1), is32, | ||
| 258 | access_actlr, reset_actlr, c1_ACTLR }, | ||
| 259 | |||
| 260 | /* CPACR: swapped by interrupt.S. */ | ||
| 261 | { CRn( 1), CRm( 0), Op1( 0), Op2( 2), is32, | ||
| 262 | NULL, reset_val, c1_CPACR, 0x00000000 }, | ||
| 263 | |||
| 160 | /* TTBR0/TTBR1: swapped by interrupt.S. */ | 264 | /* TTBR0/TTBR1: swapped by interrupt.S. */ |
| 161 | { CRm64( 2), Op1( 0), is64, NULL, reset_unknown64, c2_TTBR0 }, | 265 | { CRm64( 2), Op1( 0), is64, NULL, reset_unknown64, c2_TTBR0 }, |
| 162 | { CRm64( 2), Op1( 1), is64, NULL, reset_unknown64, c2_TTBR1 }, | 266 | { CRm64( 2), Op1( 1), is64, NULL, reset_unknown64, c2_TTBR1 }, |
| @@ -195,6 +299,13 @@ static const struct coproc_reg cp15_regs[] = { | |||
| 195 | { CRn( 7), CRm(10), Op1( 0), Op2( 2), is32, access_dcsw}, | 299 | { CRn( 7), CRm(10), Op1( 0), Op2( 2), is32, access_dcsw}, |
| 196 | { CRn( 7), CRm(14), Op1( 0), Op2( 2), is32, access_dcsw}, | 300 | { CRn( 7), CRm(14), Op1( 0), Op2( 2), is32, access_dcsw}, |
| 197 | /* | 301 | /* |
| 302 | * L2CTLR access (guest wants to know #CPUs). | ||
| 303 | */ | ||
| 304 | { CRn( 9), CRm( 0), Op1( 1), Op2( 2), is32, | ||
| 305 | access_l2ctlr, reset_l2ctlr, c9_L2CTLR }, | ||
| 306 | { CRn( 9), CRm( 0), Op1( 1), Op2( 3), is32, access_l2ectlr}, | ||
| 307 | |||
| 308 | /* | ||
| 198 | * Dummy performance monitor implementation. | 309 | * Dummy performance monitor implementation. |
| 199 | */ | 310 | */ |
| 200 | { CRn( 9), CRm(12), Op1( 0), Op2( 0), is32, access_pmcr}, | 311 | { CRn( 9), CRm(12), Op1( 0), Op2( 0), is32, access_pmcr}, |
| @@ -234,6 +345,9 @@ static const struct coproc_reg cp15_regs[] = { | |||
| 234 | /* CNTKCTL: swapped by interrupt.S. */ | 345 | /* CNTKCTL: swapped by interrupt.S. */ |
| 235 | { CRn(14), CRm( 1), Op1( 0), Op2( 0), is32, | 346 | { CRn(14), CRm( 1), Op1( 0), Op2( 0), is32, |
| 236 | NULL, reset_val, c14_CNTKCTL, 0x00000000 }, | 347 | NULL, reset_val, c14_CNTKCTL, 0x00000000 }, |
| 348 | |||
| 349 | /* The Configuration Base Address Register. */ | ||
| 350 | { CRn(15), CRm( 0), Op1( 4), Op2( 0), is32, access_cbar}, | ||
| 237 | }; | 351 | }; |
| 238 | 352 | ||
| 239 | /* Target specific emulation tables */ | 353 | /* Target specific emulation tables */ |
| @@ -241,6 +355,12 @@ static struct kvm_coproc_target_table *target_tables[KVM_ARM_NUM_TARGETS]; | |||
| 241 | 355 | ||
| 242 | void kvm_register_target_coproc_table(struct kvm_coproc_target_table *table) | 356 | void kvm_register_target_coproc_table(struct kvm_coproc_target_table *table) |
| 243 | { | 357 | { |
| 358 | unsigned int i; | ||
| 359 | |||
| 360 | for (i = 1; i < table->num; i++) | ||
| 361 | BUG_ON(cmp_reg(&table->table[i-1], | ||
| 362 | &table->table[i]) >= 0); | ||
| 363 | |||
| 244 | target_tables[table->target] = table; | 364 | target_tables[table->target] = table; |
| 245 | } | 365 | } |
| 246 | 366 | ||
diff --git a/arch/arm/kvm/coproc_a15.c b/arch/arm/kvm/coproc_a15.c index cf93472b9dd6..bb0cac1410cc 100644 --- a/arch/arm/kvm/coproc_a15.c +++ b/arch/arm/kvm/coproc_a15.c | |||
| @@ -17,101 +17,12 @@ | |||
| 17 | * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. | 17 | * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
| 18 | */ | 18 | */ |
| 19 | #include <linux/kvm_host.h> | 19 | #include <linux/kvm_host.h> |
| 20 | #include <asm/cputype.h> | ||
| 21 | #include <asm/kvm_arm.h> | ||
| 22 | #include <asm/kvm_host.h> | ||
| 23 | #include <asm/kvm_emulate.h> | ||
| 24 | #include <asm/kvm_coproc.h> | 20 | #include <asm/kvm_coproc.h> |
| 21 | #include <asm/kvm_emulate.h> | ||
| 25 | #include <linux/init.h> | 22 | #include <linux/init.h> |
| 26 | 23 | ||
| 27 | static void reset_mpidr(struct kvm_vcpu *vcpu, const struct coproc_reg *r) | ||
| 28 | { | ||
| 29 | /* | ||
| 30 | * Compute guest MPIDR: | ||
| 31 | * (Even if we present only one VCPU to the guest on an SMP | ||
| 32 | * host we don't set the U bit in the MPIDR, or vice versa, as | ||
| 33 | * revealing the underlying hardware properties is likely to | ||
| 34 | * be the best choice). | ||
| 35 | */ | ||
| 36 | vcpu->arch.cp15[c0_MPIDR] = (read_cpuid_mpidr() & ~MPIDR_LEVEL_MASK) | ||
| 37 | | (vcpu->vcpu_id & MPIDR_LEVEL_MASK); | ||
| 38 | } | ||
| 39 | |||
| 40 | #include "coproc.h" | 24 | #include "coproc.h" |
| 41 | 25 | ||
| 42 | /* A15 TRM 4.3.28: RO WI */ | ||
| 43 | static bool access_actlr(struct kvm_vcpu *vcpu, | ||
| 44 | const struct coproc_params *p, | ||
| 45 | const struct coproc_reg *r) | ||
| 46 | { | ||
| 47 | if (p->is_write) | ||
| 48 | return ignore_write(vcpu, p); | ||
| 49 | |||
| 50 | *vcpu_reg(vcpu, p->Rt1) = vcpu->arch.cp15[c1_ACTLR]; | ||
| 51 | return true; | ||
| 52 | } | ||
| 53 | |||
| 54 | /* A15 TRM 4.3.60: R/O. */ | ||
| 55 | static bool access_cbar(struct kvm_vcpu *vcpu, | ||
| 56 | const struct coproc_params *p, | ||
| 57 | const struct coproc_reg *r) | ||
| 58 | { | ||
| 59 | if (p->is_write) | ||
| 60 | return write_to_read_only(vcpu, p); | ||
| 61 | return read_zero(vcpu, p); | ||
| 62 | } | ||
| 63 | |||
| 64 | /* A15 TRM 4.3.48: R/O WI. */ | ||
| 65 | static bool access_l2ctlr(struct kvm_vcpu *vcpu, | ||
| 66 | const struct coproc_params *p, | ||
| 67 | const struct coproc_reg *r) | ||
| 68 | { | ||
| 69 | if (p->is_write) | ||
| 70 | return ignore_write(vcpu, p); | ||
| 71 | |||
| 72 | *vcpu_reg(vcpu, p->Rt1) = vcpu->arch.cp15[c9_L2CTLR]; | ||
| 73 | return true; | ||
| 74 | } | ||
| 75 | |||
| 76 | static void reset_l2ctlr(struct kvm_vcpu *vcpu, const struct coproc_reg *r) | ||
| 77 | { | ||
| 78 | u32 l2ctlr, ncores; | ||
| 79 | |||
| 80 | asm volatile("mrc p15, 1, %0, c9, c0, 2\n" : "=r" (l2ctlr)); | ||
| 81 | l2ctlr &= ~(3 << 24); | ||
| 82 | ncores = atomic_read(&vcpu->kvm->online_vcpus) - 1; | ||
| 83 | l2ctlr |= (ncores & 3) << 24; | ||
| 84 | |||
| 85 | vcpu->arch.cp15[c9_L2CTLR] = l2ctlr; | ||
| 86 | } | ||
| 87 | |||
| 88 | static void reset_actlr(struct kvm_vcpu *vcpu, const struct coproc_reg *r) | ||
| 89 | { | ||
| 90 | u32 actlr; | ||
| 91 | |||
| 92 | /* ACTLR contains SMP bit: make sure you create all cpus first! */ | ||
| 93 | asm volatile("mrc p15, 0, %0, c1, c0, 1\n" : "=r" (actlr)); | ||
| 94 | /* Make the SMP bit consistent with the guest configuration */ | ||
| 95 | if (atomic_read(&vcpu->kvm->online_vcpus) > 1) | ||
| 96 | actlr |= 1U << 6; | ||
| 97 | else | ||
| 98 | actlr &= ~(1U << 6); | ||
| 99 | |||
| 100 | vcpu->arch.cp15[c1_ACTLR] = actlr; | ||
| 101 | } | ||
| 102 | |||
| 103 | /* A15 TRM 4.3.49: R/O WI (even if NSACR.NS_L2ERR, a write of 1 is ignored). */ | ||
| 104 | static bool access_l2ectlr(struct kvm_vcpu *vcpu, | ||
| 105 | const struct coproc_params *p, | ||
| 106 | const struct coproc_reg *r) | ||
| 107 | { | ||
| 108 | if (p->is_write) | ||
| 109 | return ignore_write(vcpu, p); | ||
| 110 | |||
| 111 | *vcpu_reg(vcpu, p->Rt1) = 0; | ||
| 112 | return true; | ||
| 113 | } | ||
| 114 | |||
| 115 | /* | 26 | /* |
| 116 | * A15-specific CP15 registers. | 27 | * A15-specific CP15 registers. |
| 117 | * CRn denotes the primary register number, but is copied to the CRm in the | 28 | * CRn denotes the primary register number, but is copied to the CRm in the |
| @@ -121,29 +32,9 @@ static bool access_l2ectlr(struct kvm_vcpu *vcpu, | |||
| 121 | * registers preceding 32-bit ones. | 32 | * registers preceding 32-bit ones. |
| 122 | */ | 33 | */ |
| 123 | static const struct coproc_reg a15_regs[] = { | 34 | static const struct coproc_reg a15_regs[] = { |
| 124 | /* MPIDR: we use VMPIDR for guest access. */ | ||
| 125 | { CRn( 0), CRm( 0), Op1( 0), Op2( 5), is32, | ||
| 126 | NULL, reset_mpidr, c0_MPIDR }, | ||
| 127 | |||
| 128 | /* SCTLR: swapped by interrupt.S. */ | 35 | /* SCTLR: swapped by interrupt.S. */ |
| 129 | { CRn( 1), CRm( 0), Op1( 0), Op2( 0), is32, | 36 | { CRn( 1), CRm( 0), Op1( 0), Op2( 0), is32, |
| 130 | NULL, reset_val, c1_SCTLR, 0x00C50078 }, | 37 | NULL, reset_val, c1_SCTLR, 0x00C50078 }, |
| 131 | /* ACTLR: trapped by HCR.TAC bit. */ | ||
| 132 | { CRn( 1), CRm( 0), Op1( 0), Op2( 1), is32, | ||
| 133 | access_actlr, reset_actlr, c1_ACTLR }, | ||
| 134 | /* CPACR: swapped by interrupt.S. */ | ||
| 135 | { CRn( 1), CRm( 0), Op1( 0), Op2( 2), is32, | ||
| 136 | NULL, reset_val, c1_CPACR, 0x00000000 }, | ||
| 137 | |||
| 138 | /* | ||
| 139 | * L2CTLR access (guest wants to know #CPUs). | ||
| 140 | */ | ||
| 141 | { CRn( 9), CRm( 0), Op1( 1), Op2( 2), is32, | ||
| 142 | access_l2ctlr, reset_l2ctlr, c9_L2CTLR }, | ||
| 143 | { CRn( 9), CRm( 0), Op1( 1), Op2( 3), is32, access_l2ectlr}, | ||
| 144 | |||
| 145 | /* The Configuration Base Address Register. */ | ||
| 146 | { CRn(15), CRm( 0), Op1( 4), Op2( 0), is32, access_cbar}, | ||
| 147 | }; | 38 | }; |
| 148 | 39 | ||
| 149 | static struct kvm_coproc_target_table a15_target_table = { | 40 | static struct kvm_coproc_target_table a15_target_table = { |
| @@ -154,12 +45,6 @@ static struct kvm_coproc_target_table a15_target_table = { | |||
| 154 | 45 | ||
| 155 | static int __init coproc_a15_init(void) | 46 | static int __init coproc_a15_init(void) |
| 156 | { | 47 | { |
| 157 | unsigned int i; | ||
| 158 | |||
| 159 | for (i = 1; i < ARRAY_SIZE(a15_regs); i++) | ||
| 160 | BUG_ON(cmp_reg(&a15_regs[i-1], | ||
| 161 | &a15_regs[i]) >= 0); | ||
| 162 | |||
| 163 | kvm_register_target_coproc_table(&a15_target_table); | 48 | kvm_register_target_coproc_table(&a15_target_table); |
| 164 | return 0; | 49 | return 0; |
| 165 | } | 50 | } |
diff --git a/arch/arm/kvm/coproc_a7.c b/arch/arm/kvm/coproc_a7.c new file mode 100644 index 000000000000..1df767331588 --- /dev/null +++ b/arch/arm/kvm/coproc_a7.c | |||
| @@ -0,0 +1,54 @@ | |||
| 1 | /* | ||
| 2 | * Copyright (C) 2012 - Virtual Open Systems and Columbia University | ||
| 3 | * Copyright (C) 2013 - ARM Ltd | ||
| 4 | * | ||
| 5 | * Authors: Rusty Russell <rusty@rustcorp.au> | ||
| 6 | * Christoffer Dall <c.dall@virtualopensystems.com> | ||
| 7 | * Jonathan Austin <jonathan.austin@arm.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, write to the Free Software | ||
| 20 | * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. | ||
| 21 | */ | ||
| 22 | #include <linux/kvm_host.h> | ||
| 23 | #include <asm/kvm_coproc.h> | ||
| 24 | #include <asm/kvm_emulate.h> | ||
| 25 | #include <linux/init.h> | ||
| 26 | |||
| 27 | #include "coproc.h" | ||
| 28 | |||
| 29 | /* | ||
| 30 | * Cortex-A7 specific CP15 registers. | ||
| 31 | * CRn denotes the primary register number, but is copied to the CRm in the | ||
| 32 | * user space API for 64-bit register access in line with the terminology used | ||
| 33 | * in the ARM ARM. | ||
| 34 | * Important: Must be sorted ascending by CRn, CRM, Op1, Op2 and with 64-bit | ||
| 35 | * registers preceding 32-bit ones. | ||
| 36 | */ | ||
| 37 | static const struct coproc_reg a7_regs[] = { | ||
| 38 | /* SCTLR: swapped by interrupt.S. */ | ||
| 39 | { CRn( 1), CRm( 0), Op1( 0), Op2( 0), is32, | ||
| 40 | NULL, reset_val, c1_SCTLR, 0x00C50878 }, | ||
| 41 | }; | ||
| 42 | |||
| 43 | static struct kvm_coproc_target_table a7_target_table = { | ||
| 44 | .target = KVM_ARM_TARGET_CORTEX_A7, | ||
| 45 | .table = a7_regs, | ||
| 46 | .num = ARRAY_SIZE(a7_regs), | ||
| 47 | }; | ||
| 48 | |||
| 49 | static int __init coproc_a7_init(void) | ||
| 50 | { | ||
| 51 | kvm_register_target_coproc_table(&a7_target_table); | ||
| 52 | return 0; | ||
| 53 | } | ||
| 54 | late_initcall(coproc_a7_init); | ||
diff --git a/arch/arm/kvm/emulate.c b/arch/arm/kvm/emulate.c index bdede9e7da51..d6c005283678 100644 --- a/arch/arm/kvm/emulate.c +++ b/arch/arm/kvm/emulate.c | |||
| @@ -354,7 +354,7 @@ static void inject_abt(struct kvm_vcpu *vcpu, bool is_pabt, unsigned long addr) | |||
| 354 | *vcpu_pc(vcpu) = exc_vector_base(vcpu) + vect_offset; | 354 | *vcpu_pc(vcpu) = exc_vector_base(vcpu) + vect_offset; |
| 355 | 355 | ||
| 356 | if (is_pabt) { | 356 | if (is_pabt) { |
| 357 | /* Set DFAR and DFSR */ | 357 | /* Set IFAR and IFSR */ |
| 358 | vcpu->arch.cp15[c6_IFAR] = addr; | 358 | vcpu->arch.cp15[c6_IFAR] = addr; |
| 359 | is_lpae = (vcpu->arch.cp15[c2_TTBCR] >> 31); | 359 | is_lpae = (vcpu->arch.cp15[c2_TTBCR] >> 31); |
| 360 | /* Always give debug fault for now - should give guest a clue */ | 360 | /* Always give debug fault for now - should give guest a clue */ |
diff --git a/arch/arm/kvm/guest.c b/arch/arm/kvm/guest.c index 152d03612181..20f8d97904af 100644 --- a/arch/arm/kvm/guest.c +++ b/arch/arm/kvm/guest.c | |||
| @@ -190,6 +190,8 @@ int __attribute_const__ kvm_target_cpu(void) | |||
| 190 | return -EINVAL; | 190 | return -EINVAL; |
| 191 | 191 | ||
| 192 | switch (part_number) { | 192 | switch (part_number) { |
| 193 | case ARM_CPU_PART_CORTEX_A7: | ||
| 194 | return KVM_ARM_TARGET_CORTEX_A7; | ||
| 193 | case ARM_CPU_PART_CORTEX_A15: | 195 | case ARM_CPU_PART_CORTEX_A15: |
| 194 | return KVM_ARM_TARGET_CORTEX_A15; | 196 | return KVM_ARM_TARGET_CORTEX_A15; |
| 195 | default: | 197 | default: |
| @@ -202,7 +204,7 @@ int kvm_vcpu_set_target(struct kvm_vcpu *vcpu, | |||
| 202 | { | 204 | { |
| 203 | unsigned int i; | 205 | unsigned int i; |
| 204 | 206 | ||
| 205 | /* We can only do a cortex A15 for now. */ | 207 | /* We can only cope with guest==host and only on A15/A7 (for now). */ |
| 206 | if (init->target != kvm_target_cpu()) | 208 | if (init->target != kvm_target_cpu()) |
| 207 | return -EINVAL; | 209 | return -EINVAL; |
| 208 | 210 | ||
| @@ -222,6 +224,26 @@ int kvm_vcpu_set_target(struct kvm_vcpu *vcpu, | |||
| 222 | return kvm_reset_vcpu(vcpu); | 224 | return kvm_reset_vcpu(vcpu); |
| 223 | } | 225 | } |
| 224 | 226 | ||
| 227 | int kvm_vcpu_preferred_target(struct kvm_vcpu_init *init) | ||
| 228 | { | ||
| 229 | int target = kvm_target_cpu(); | ||
| 230 | |||
| 231 | if (target < 0) | ||
| 232 | return -ENODEV; | ||
| 233 | |||
| 234 | memset(init, 0, sizeof(*init)); | ||
| 235 | |||
| 236 | /* | ||
| 237 | * For now, we don't return any features. | ||
| 238 | * In future, we might use features to return target | ||
| 239 | * specific features available for the preferred | ||
| 240 | * target type. | ||
| 241 | */ | ||
| 242 | init->target = (__u32)target; | ||
| 243 | |||
| 244 | return 0; | ||
| 245 | } | ||
| 246 | |||
| 225 | int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) | 247 | int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) |
| 226 | { | 248 | { |
| 227 | return -EINVAL; | 249 | return -EINVAL; |
diff --git a/arch/arm/kvm/handle_exit.c b/arch/arm/kvm/handle_exit.c index df4c82d47ad7..a92079011a83 100644 --- a/arch/arm/kvm/handle_exit.c +++ b/arch/arm/kvm/handle_exit.c | |||
| @@ -73,23 +73,29 @@ static int handle_dabt_hyp(struct kvm_vcpu *vcpu, struct kvm_run *run) | |||
| 73 | } | 73 | } |
| 74 | 74 | ||
| 75 | /** | 75 | /** |
| 76 | * kvm_handle_wfi - handle a wait-for-interrupts instruction executed by a guest | 76 | * kvm_handle_wfx - handle a WFI or WFE instructions trapped in guests |
| 77 | * @vcpu: the vcpu pointer | 77 | * @vcpu: the vcpu pointer |
| 78 | * @run: the kvm_run structure pointer | 78 | * @run: the kvm_run structure pointer |
| 79 | * | 79 | * |
| 80 | * Simply sets the wait_for_interrupts flag on the vcpu structure, which will | 80 | * WFE: Yield the CPU and come back to this vcpu when the scheduler |
| 81 | * halt execution of world-switches and schedule other host processes until | 81 | * decides to. |
| 82 | * there is an incoming IRQ or FIQ to the VM. | 82 | * WFI: Simply call kvm_vcpu_block(), which will halt execution of |
| 83 | * world-switches and schedule other host processes until there is an | ||
| 84 | * incoming IRQ or FIQ to the VM. | ||
| 83 | */ | 85 | */ |
| 84 | static int kvm_handle_wfi(struct kvm_vcpu *vcpu, struct kvm_run *run) | 86 | static int kvm_handle_wfx(struct kvm_vcpu *vcpu, struct kvm_run *run) |
| 85 | { | 87 | { |
| 86 | trace_kvm_wfi(*vcpu_pc(vcpu)); | 88 | trace_kvm_wfi(*vcpu_pc(vcpu)); |
| 87 | kvm_vcpu_block(vcpu); | 89 | if (kvm_vcpu_get_hsr(vcpu) & HSR_WFI_IS_WFE) |
| 90 | kvm_vcpu_on_spin(vcpu); | ||
| 91 | else | ||
| 92 | kvm_vcpu_block(vcpu); | ||
| 93 | |||
| 88 | return 1; | 94 | return 1; |
| 89 | } | 95 | } |
| 90 | 96 | ||
| 91 | static exit_handle_fn arm_exit_handlers[] = { | 97 | static exit_handle_fn arm_exit_handlers[] = { |
| 92 | [HSR_EC_WFI] = kvm_handle_wfi, | 98 | [HSR_EC_WFI] = kvm_handle_wfx, |
| 93 | [HSR_EC_CP15_32] = kvm_handle_cp15_32, | 99 | [HSR_EC_CP15_32] = kvm_handle_cp15_32, |
| 94 | [HSR_EC_CP15_64] = kvm_handle_cp15_64, | 100 | [HSR_EC_CP15_64] = kvm_handle_cp15_64, |
| 95 | [HSR_EC_CP14_MR] = kvm_handle_cp14_access, | 101 | [HSR_EC_CP14_MR] = kvm_handle_cp14_access, |
diff --git a/arch/arm/kvm/mmio.c b/arch/arm/kvm/mmio.c index 0c25d9487d53..4cb5a93182e9 100644 --- a/arch/arm/kvm/mmio.c +++ b/arch/arm/kvm/mmio.c | |||
| @@ -23,6 +23,68 @@ | |||
| 23 | 23 | ||
| 24 | #include "trace.h" | 24 | #include "trace.h" |
| 25 | 25 | ||
| 26 | static void mmio_write_buf(char *buf, unsigned int len, unsigned long data) | ||
| 27 | { | ||
| 28 | void *datap = NULL; | ||
| 29 | union { | ||
| 30 | u8 byte; | ||
| 31 | u16 hword; | ||
| 32 | u32 word; | ||
| 33 | u64 dword; | ||
| 34 | } tmp; | ||
| 35 | |||
| 36 | switch (len) { | ||
| 37 | case 1: | ||
| 38 | tmp.byte = data; | ||
| 39 | datap = &tmp.byte; | ||
| 40 | break; | ||
| 41 | case 2: | ||
| 42 | tmp.hword = data; | ||
| 43 | datap = &tmp.hword; | ||
| 44 | break; | ||
| 45 | case 4: | ||
| 46 | tmp.word = data; | ||
| 47 | datap = &tmp.word; | ||
| 48 | break; | ||
| 49 | case 8: | ||
| 50 | tmp.dword = data; | ||
| 51 | datap = &tmp.dword; | ||
| 52 | break; | ||
| 53 | } | ||
| 54 | |||
| 55 | memcpy(buf, datap, len); | ||
| 56 | } | ||
| 57 | |||
| 58 | static unsigned long mmio_read_buf(char *buf, unsigned int len) | ||
| 59 | { | ||
| 60 | unsigned long data = 0; | ||
| 61 | union { | ||
| 62 | u16 hword; | ||
| 63 | u32 word; | ||
| 64 | u64 dword; | ||
| 65 | } tmp; | ||
| 66 | |||
| 67 | switch (len) { | ||
| 68 | case 1: | ||
| 69 | data = buf[0]; | ||
| 70 | break; | ||
| 71 | case 2: | ||
| 72 | memcpy(&tmp.hword, buf, len); | ||
| 73 | data = tmp.hword; | ||
| 74 | break; | ||
| 75 | case 4: | ||
| 76 | memcpy(&tmp.word, buf, len); | ||
| 77 | data = tmp.word; | ||
| 78 | break; | ||
| 79 | case 8: | ||
| 80 | memcpy(&tmp.dword, buf, len); | ||
| 81 | data = tmp.dword; | ||
| 82 | break; | ||
| 83 | } | ||
| 84 | |||
| 85 | return data; | ||
| 86 | } | ||
| 87 | |||
| 26 | /** | 88 | /** |
| 27 | * kvm_handle_mmio_return -- Handle MMIO loads after user space emulation | 89 | * kvm_handle_mmio_return -- Handle MMIO loads after user space emulation |
| 28 | * @vcpu: The VCPU pointer | 90 | * @vcpu: The VCPU pointer |
| @@ -33,28 +95,27 @@ | |||
| 33 | */ | 95 | */ |
| 34 | int kvm_handle_mmio_return(struct kvm_vcpu *vcpu, struct kvm_run *run) | 96 | int kvm_handle_mmio_return(struct kvm_vcpu *vcpu, struct kvm_run *run) |
| 35 | { | 97 | { |
| 36 | unsigned long *dest; | 98 | unsigned long data; |
| 37 | unsigned int len; | 99 | unsigned int len; |
| 38 | int mask; | 100 | int mask; |
| 39 | 101 | ||
| 40 | if (!run->mmio.is_write) { | 102 | if (!run->mmio.is_write) { |
| 41 | dest = vcpu_reg(vcpu, vcpu->arch.mmio_decode.rt); | ||
| 42 | *dest = 0; | ||
| 43 | |||
| 44 | len = run->mmio.len; | 103 | len = run->mmio.len; |
| 45 | if (len > sizeof(unsigned long)) | 104 | if (len > sizeof(unsigned long)) |
| 46 | return -EINVAL; | 105 | return -EINVAL; |
| 47 | 106 | ||
| 48 | memcpy(dest, run->mmio.data, len); | 107 | data = mmio_read_buf(run->mmio.data, len); |
| 49 | |||
| 50 | trace_kvm_mmio(KVM_TRACE_MMIO_READ, len, run->mmio.phys_addr, | ||
| 51 | *((u64 *)run->mmio.data)); | ||
| 52 | 108 | ||
| 53 | if (vcpu->arch.mmio_decode.sign_extend && | 109 | if (vcpu->arch.mmio_decode.sign_extend && |
| 54 | len < sizeof(unsigned long)) { | 110 | len < sizeof(unsigned long)) { |
| 55 | mask = 1U << ((len * 8) - 1); | 111 | mask = 1U << ((len * 8) - 1); |
| 56 | *dest = (*dest ^ mask) - mask; | 112 | data = (data ^ mask) - mask; |
| 57 | } | 113 | } |
| 114 | |||
| 115 | trace_kvm_mmio(KVM_TRACE_MMIO_READ, len, run->mmio.phys_addr, | ||
| 116 | data); | ||
| 117 | data = vcpu_data_host_to_guest(vcpu, data, len); | ||
| 118 | *vcpu_reg(vcpu, vcpu->arch.mmio_decode.rt) = data; | ||
| 58 | } | 119 | } |
| 59 | 120 | ||
| 60 | return 0; | 121 | return 0; |
| @@ -105,6 +166,7 @@ int io_mem_abort(struct kvm_vcpu *vcpu, struct kvm_run *run, | |||
| 105 | phys_addr_t fault_ipa) | 166 | phys_addr_t fault_ipa) |
| 106 | { | 167 | { |
| 107 | struct kvm_exit_mmio mmio; | 168 | struct kvm_exit_mmio mmio; |
| 169 | unsigned long data; | ||
| 108 | unsigned long rt; | 170 | unsigned long rt; |
| 109 | int ret; | 171 | int ret; |
| 110 | 172 | ||
| @@ -125,13 +187,15 @@ int io_mem_abort(struct kvm_vcpu *vcpu, struct kvm_run *run, | |||
| 125 | } | 187 | } |
| 126 | 188 | ||
| 127 | rt = vcpu->arch.mmio_decode.rt; | 189 | rt = vcpu->arch.mmio_decode.rt; |
| 190 | data = vcpu_data_guest_to_host(vcpu, *vcpu_reg(vcpu, rt), mmio.len); | ||
| 191 | |||
| 128 | trace_kvm_mmio((mmio.is_write) ? KVM_TRACE_MMIO_WRITE : | 192 | trace_kvm_mmio((mmio.is_write) ? KVM_TRACE_MMIO_WRITE : |
| 129 | KVM_TRACE_MMIO_READ_UNSATISFIED, | 193 | KVM_TRACE_MMIO_READ_UNSATISFIED, |
| 130 | mmio.len, fault_ipa, | 194 | mmio.len, fault_ipa, |
| 131 | (mmio.is_write) ? *vcpu_reg(vcpu, rt) : 0); | 195 | (mmio.is_write) ? data : 0); |
| 132 | 196 | ||
| 133 | if (mmio.is_write) | 197 | if (mmio.is_write) |
| 134 | memcpy(mmio.data, vcpu_reg(vcpu, rt), mmio.len); | 198 | mmio_write_buf(mmio.data, mmio.len, data); |
| 135 | 199 | ||
| 136 | if (vgic_handle_mmio(vcpu, run, &mmio)) | 200 | if (vgic_handle_mmio(vcpu, run, &mmio)) |
| 137 | return 1; | 201 | return 1; |
diff --git a/arch/arm/kvm/mmu.c b/arch/arm/kvm/mmu.c index b0de86b56c13..371958370de4 100644 --- a/arch/arm/kvm/mmu.c +++ b/arch/arm/kvm/mmu.c | |||
| @@ -19,6 +19,7 @@ | |||
| 19 | #include <linux/mman.h> | 19 | #include <linux/mman.h> |
| 20 | #include <linux/kvm_host.h> | 20 | #include <linux/kvm_host.h> |
| 21 | #include <linux/io.h> | 21 | #include <linux/io.h> |
| 22 | #include <linux/hugetlb.h> | ||
| 22 | #include <trace/events/kvm.h> | 23 | #include <trace/events/kvm.h> |
| 23 | #include <asm/pgalloc.h> | 24 | #include <asm/pgalloc.h> |
| 24 | #include <asm/cacheflush.h> | 25 | #include <asm/cacheflush.h> |
| @@ -41,6 +42,8 @@ static unsigned long hyp_idmap_start; | |||
| 41 | static unsigned long hyp_idmap_end; | 42 | static unsigned long hyp_idmap_end; |
| 42 | static phys_addr_t hyp_idmap_vector; | 43 | static phys_addr_t hyp_idmap_vector; |
| 43 | 44 | ||
| 45 | #define kvm_pmd_huge(_x) (pmd_huge(_x) || pmd_trans_huge(_x)) | ||
| 46 | |||
| 44 | static void kvm_tlb_flush_vmid_ipa(struct kvm *kvm, phys_addr_t ipa) | 47 | static void kvm_tlb_flush_vmid_ipa(struct kvm *kvm, phys_addr_t ipa) |
| 45 | { | 48 | { |
| 46 | /* | 49 | /* |
| @@ -93,19 +96,29 @@ static bool page_empty(void *ptr) | |||
| 93 | 96 | ||
| 94 | static void clear_pud_entry(struct kvm *kvm, pud_t *pud, phys_addr_t addr) | 97 | static void clear_pud_entry(struct kvm *kvm, pud_t *pud, phys_addr_t addr) |
| 95 | { | 98 | { |
| 96 | pmd_t *pmd_table = pmd_offset(pud, 0); | 99 | if (pud_huge(*pud)) { |
| 97 | pud_clear(pud); | 100 | pud_clear(pud); |
| 98 | kvm_tlb_flush_vmid_ipa(kvm, addr); | 101 | kvm_tlb_flush_vmid_ipa(kvm, addr); |
| 99 | pmd_free(NULL, pmd_table); | 102 | } else { |
| 103 | pmd_t *pmd_table = pmd_offset(pud, 0); | ||
| 104 | pud_clear(pud); | ||
| 105 | kvm_tlb_flush_vmid_ipa(kvm, addr); | ||
| 106 | pmd_free(NULL, pmd_table); | ||
| 107 | } | ||
| 100 | put_page(virt_to_page(pud)); | 108 | put_page(virt_to_page(pud)); |
| 101 | } | 109 | } |
| 102 | 110 | ||
| 103 | static void clear_pmd_entry(struct kvm *kvm, pmd_t *pmd, phys_addr_t addr) | 111 | static void clear_pmd_entry(struct kvm *kvm, pmd_t *pmd, phys_addr_t addr) |
| 104 | { | 112 | { |
| 105 | pte_t *pte_table = pte_offset_kernel(pmd, 0); | 113 | if (kvm_pmd_huge(*pmd)) { |
| 106 | pmd_clear(pmd); | 114 | pmd_clear(pmd); |
| 107 | kvm_tlb_flush_vmid_ipa(kvm, addr); | 115 | kvm_tlb_flush_vmid_ipa(kvm, addr); |
| 108 | pte_free_kernel(NULL, pte_table); | 116 | } else { |
| 117 | pte_t *pte_table = pte_offset_kernel(pmd, 0); | ||
| 118 | pmd_clear(pmd); | ||
| 119 | kvm_tlb_flush_vmid_ipa(kvm, addr); | ||
| 120 | pte_free_kernel(NULL, pte_table); | ||
| 121 | } | ||
| 109 | put_page(virt_to_page(pmd)); | 122 | put_page(virt_to_page(pmd)); |
| 110 | } | 123 | } |
| 111 | 124 | ||
| @@ -136,18 +149,32 @@ static void unmap_range(struct kvm *kvm, pgd_t *pgdp, | |||
| 136 | continue; | 149 | continue; |
| 137 | } | 150 | } |
| 138 | 151 | ||
| 152 | if (pud_huge(*pud)) { | ||
| 153 | /* | ||
| 154 | * If we are dealing with a huge pud, just clear it and | ||
| 155 | * move on. | ||
| 156 | */ | ||
| 157 | clear_pud_entry(kvm, pud, addr); | ||
| 158 | addr = pud_addr_end(addr, end); | ||
| 159 | continue; | ||
| 160 | } | ||
| 161 | |||
| 139 | pmd = pmd_offset(pud, addr); | 162 | pmd = pmd_offset(pud, addr); |
| 140 | if (pmd_none(*pmd)) { | 163 | if (pmd_none(*pmd)) { |
| 141 | addr = pmd_addr_end(addr, end); | 164 | addr = pmd_addr_end(addr, end); |
| 142 | continue; | 165 | continue; |
| 143 | } | 166 | } |
| 144 | 167 | ||
| 145 | pte = pte_offset_kernel(pmd, addr); | 168 | if (!kvm_pmd_huge(*pmd)) { |
| 146 | clear_pte_entry(kvm, pte, addr); | 169 | pte = pte_offset_kernel(pmd, addr); |
| 147 | next = addr + PAGE_SIZE; | 170 | clear_pte_entry(kvm, pte, addr); |
| 171 | next = addr + PAGE_SIZE; | ||
| 172 | } | ||
| 148 | 173 | ||
| 149 | /* If we emptied the pte, walk back up the ladder */ | 174 | /* |
| 150 | if (page_empty(pte)) { | 175 | * If the pmd entry is to be cleared, walk back up the ladder |
| 176 | */ | ||
| 177 | if (kvm_pmd_huge(*pmd) || page_empty(pte)) { | ||
| 151 | clear_pmd_entry(kvm, pmd, addr); | 178 | clear_pmd_entry(kvm, pmd, addr); |
| 152 | next = pmd_addr_end(addr, end); | 179 | next = pmd_addr_end(addr, end); |
| 153 | if (page_empty(pmd) && !page_empty(pud)) { | 180 | if (page_empty(pmd) && !page_empty(pud)) { |
| @@ -420,29 +447,71 @@ void kvm_free_stage2_pgd(struct kvm *kvm) | |||
| 420 | kvm->arch.pgd = NULL; | 447 | kvm->arch.pgd = NULL; |
| 421 | } | 448 | } |
| 422 | 449 | ||
| 423 | 450 | static pmd_t *stage2_get_pmd(struct kvm *kvm, struct kvm_mmu_memory_cache *cache, | |
| 424 | static int stage2_set_pte(struct kvm *kvm, struct kvm_mmu_memory_cache *cache, | 451 | phys_addr_t addr) |
| 425 | phys_addr_t addr, const pte_t *new_pte, bool iomap) | ||
| 426 | { | 452 | { |
| 427 | pgd_t *pgd; | 453 | pgd_t *pgd; |
| 428 | pud_t *pud; | 454 | pud_t *pud; |
| 429 | pmd_t *pmd; | 455 | pmd_t *pmd; |
| 430 | pte_t *pte, old_pte; | ||
| 431 | 456 | ||
| 432 | /* Create 2nd stage page table mapping - Level 1 */ | ||
| 433 | pgd = kvm->arch.pgd + pgd_index(addr); | 457 | pgd = kvm->arch.pgd + pgd_index(addr); |
| 434 | pud = pud_offset(pgd, addr); | 458 | pud = pud_offset(pgd, addr); |
| 435 | if (pud_none(*pud)) { | 459 | if (pud_none(*pud)) { |
| 436 | if (!cache) | 460 | if (!cache) |
| 437 | return 0; /* ignore calls from kvm_set_spte_hva */ | 461 | return NULL; |
| 438 | pmd = mmu_memory_cache_alloc(cache); | 462 | pmd = mmu_memory_cache_alloc(cache); |
| 439 | pud_populate(NULL, pud, pmd); | 463 | pud_populate(NULL, pud, pmd); |
| 440 | get_page(virt_to_page(pud)); | 464 | get_page(virt_to_page(pud)); |
| 441 | } | 465 | } |
| 442 | 466 | ||
| 443 | pmd = pmd_offset(pud, addr); | 467 | return pmd_offset(pud, addr); |
| 468 | } | ||
| 469 | |||
| 470 | static int stage2_set_pmd_huge(struct kvm *kvm, struct kvm_mmu_memory_cache | ||
| 471 | *cache, phys_addr_t addr, const pmd_t *new_pmd) | ||
| 472 | { | ||
| 473 | pmd_t *pmd, old_pmd; | ||
| 474 | |||
| 475 | pmd = stage2_get_pmd(kvm, cache, addr); | ||
| 476 | VM_BUG_ON(!pmd); | ||
| 477 | |||
| 478 | /* | ||
| 479 | * Mapping in huge pages should only happen through a fault. If a | ||
| 480 | * page is merged into a transparent huge page, the individual | ||
| 481 | * subpages of that huge page should be unmapped through MMU | ||
| 482 | * notifiers before we get here. | ||
| 483 | * | ||
| 484 | * Merging of CompoundPages is not supported; they should become | ||
| 485 | * splitting first, unmapped, merged, and mapped back in on-demand. | ||
| 486 | */ | ||
| 487 | VM_BUG_ON(pmd_present(*pmd) && pmd_pfn(*pmd) != pmd_pfn(*new_pmd)); | ||
| 488 | |||
| 489 | old_pmd = *pmd; | ||
| 490 | kvm_set_pmd(pmd, *new_pmd); | ||
| 491 | if (pmd_present(old_pmd)) | ||
| 492 | kvm_tlb_flush_vmid_ipa(kvm, addr); | ||
| 493 | else | ||
| 494 | get_page(virt_to_page(pmd)); | ||
| 495 | return 0; | ||
| 496 | } | ||
| 497 | |||
| 498 | static int stage2_set_pte(struct kvm *kvm, struct kvm_mmu_memory_cache *cache, | ||
| 499 | phys_addr_t addr, const pte_t *new_pte, bool iomap) | ||
| 500 | { | ||
| 501 | pmd_t *pmd; | ||
| 502 | pte_t *pte, old_pte; | ||
| 444 | 503 | ||
| 445 | /* Create 2nd stage page table mapping - Level 2 */ | 504 | /* Create stage-2 page table mapping - Level 1 */ |
| 505 | pmd = stage2_get_pmd(kvm, cache, addr); | ||
| 506 | if (!pmd) { | ||
| 507 | /* | ||
| 508 | * Ignore calls from kvm_set_spte_hva for unallocated | ||
| 509 | * address ranges. | ||
| 510 | */ | ||
| 511 | return 0; | ||
| 512 | } | ||
| 513 | |||
| 514 | /* Create stage-2 page mappings - Level 2 */ | ||
| 446 | if (pmd_none(*pmd)) { | 515 | if (pmd_none(*pmd)) { |
| 447 | if (!cache) | 516 | if (!cache) |
| 448 | return 0; /* ignore calls from kvm_set_spte_hva */ | 517 | return 0; /* ignore calls from kvm_set_spte_hva */ |
| @@ -507,16 +576,60 @@ out: | |||
| 507 | return ret; | 576 | return ret; |
| 508 | } | 577 | } |
| 509 | 578 | ||
| 579 | static bool transparent_hugepage_adjust(pfn_t *pfnp, phys_addr_t *ipap) | ||
| 580 | { | ||
| 581 | pfn_t pfn = *pfnp; | ||
| 582 | gfn_t gfn = *ipap >> PAGE_SHIFT; | ||
| 583 | |||
| 584 | if (PageTransCompound(pfn_to_page(pfn))) { | ||
| 585 | unsigned long mask; | ||
| 586 | /* | ||
| 587 | * The address we faulted on is backed by a transparent huge | ||
| 588 | * page. However, because we map the compound huge page and | ||
| 589 | * not the individual tail page, we need to transfer the | ||
| 590 | * refcount to the head page. We have to be careful that the | ||
| 591 | * THP doesn't start to split while we are adjusting the | ||
| 592 | * refcounts. | ||
| 593 | * | ||
| 594 | * We are sure this doesn't happen, because mmu_notifier_retry | ||
| 595 | * was successful and we are holding the mmu_lock, so if this | ||
| 596 | * THP is trying to split, it will be blocked in the mmu | ||
| 597 | * notifier before touching any of the pages, specifically | ||
| 598 | * before being able to call __split_huge_page_refcount(). | ||
| 599 | * | ||
| 600 | * We can therefore safely transfer the refcount from PG_tail | ||
| 601 | * to PG_head and switch the pfn from a tail page to the head | ||
| 602 | * page accordingly. | ||
| 603 | */ | ||
| 604 | mask = PTRS_PER_PMD - 1; | ||
| 605 | VM_BUG_ON((gfn & mask) != (pfn & mask)); | ||
| 606 | if (pfn & mask) { | ||
| 607 | *ipap &= PMD_MASK; | ||
| 608 | kvm_release_pfn_clean(pfn); | ||
| 609 | pfn &= ~mask; | ||
| 610 | kvm_get_pfn(pfn); | ||
| 611 | *pfnp = pfn; | ||
| 612 | } | ||
| 613 | |||
| 614 | return true; | ||
| 615 | } | ||
| 616 | |||
| 617 | return false; | ||
| 618 | } | ||
| 619 | |||
| 510 | static int user_mem_abort(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa, | 620 | static int user_mem_abort(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa, |
| 511 | gfn_t gfn, struct kvm_memory_slot *memslot, | 621 | struct kvm_memory_slot *memslot, |
| 512 | unsigned long fault_status) | 622 | unsigned long fault_status) |
| 513 | { | 623 | { |
| 514 | pte_t new_pte; | ||
| 515 | pfn_t pfn; | ||
| 516 | int ret; | 624 | int ret; |
| 517 | bool write_fault, writable; | 625 | bool write_fault, writable, hugetlb = false, force_pte = false; |
| 518 | unsigned long mmu_seq; | 626 | unsigned long mmu_seq; |
| 627 | gfn_t gfn = fault_ipa >> PAGE_SHIFT; | ||
| 628 | unsigned long hva = gfn_to_hva(vcpu->kvm, gfn); | ||
| 629 | struct kvm *kvm = vcpu->kvm; | ||
| 519 | struct kvm_mmu_memory_cache *memcache = &vcpu->arch.mmu_page_cache; | 630 | struct kvm_mmu_memory_cache *memcache = &vcpu->arch.mmu_page_cache; |
| 631 | struct vm_area_struct *vma; | ||
| 632 | pfn_t pfn; | ||
| 520 | 633 | ||
| 521 | write_fault = kvm_is_write_fault(kvm_vcpu_get_hsr(vcpu)); | 634 | write_fault = kvm_is_write_fault(kvm_vcpu_get_hsr(vcpu)); |
| 522 | if (fault_status == FSC_PERM && !write_fault) { | 635 | if (fault_status == FSC_PERM && !write_fault) { |
| @@ -524,6 +637,26 @@ static int user_mem_abort(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa, | |||
| 524 | return -EFAULT; | 637 | return -EFAULT; |
| 525 | } | 638 | } |
| 526 | 639 | ||
| 640 | /* Let's check if we will get back a huge page backed by hugetlbfs */ | ||
| 641 | down_read(¤t->mm->mmap_sem); | ||
| 642 | vma = find_vma_intersection(current->mm, hva, hva + 1); | ||
| 643 | if (is_vm_hugetlb_page(vma)) { | ||
| 644 | hugetlb = true; | ||
| 645 | gfn = (fault_ipa & PMD_MASK) >> PAGE_SHIFT; | ||
| 646 | } else { | ||
| 647 | /* | ||
| 648 | * Pages belonging to VMAs not aligned to the PMD mapping | ||
| 649 | * granularity cannot be mapped using block descriptors even | ||
| 650 | * if the pages belong to a THP for the process, because the | ||
| 651 | * stage-2 block descriptor will cover more than a single THP | ||
| 652 | * and we loose atomicity for unmapping, updates, and splits | ||
| 653 | * of the THP or other pages in the stage-2 block range. | ||
| 654 | */ | ||
| 655 | if (vma->vm_start & ~PMD_MASK) | ||
| 656 | force_pte = true; | ||
| 657 | } | ||
| 658 | up_read(¤t->mm->mmap_sem); | ||
| 659 | |||
| 527 | /* We need minimum second+third level pages */ | 660 | /* We need minimum second+third level pages */ |
| 528 | ret = mmu_topup_memory_cache(memcache, 2, KVM_NR_MEM_OBJS); | 661 | ret = mmu_topup_memory_cache(memcache, 2, KVM_NR_MEM_OBJS); |
| 529 | if (ret) | 662 | if (ret) |
| @@ -541,26 +674,40 @@ static int user_mem_abort(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa, | |||
| 541 | */ | 674 | */ |
| 542 | smp_rmb(); | 675 | smp_rmb(); |
| 543 | 676 | ||
| 544 | pfn = gfn_to_pfn_prot(vcpu->kvm, gfn, write_fault, &writable); | 677 | pfn = gfn_to_pfn_prot(kvm, gfn, write_fault, &writable); |
| 545 | if (is_error_pfn(pfn)) | 678 | if (is_error_pfn(pfn)) |
| 546 | return -EFAULT; | 679 | return -EFAULT; |
| 547 | 680 | ||
| 548 | new_pte = pfn_pte(pfn, PAGE_S2); | 681 | spin_lock(&kvm->mmu_lock); |
| 549 | coherent_icache_guest_page(vcpu->kvm, gfn); | 682 | if (mmu_notifier_retry(kvm, mmu_seq)) |
| 550 | |||
| 551 | spin_lock(&vcpu->kvm->mmu_lock); | ||
| 552 | if (mmu_notifier_retry(vcpu->kvm, mmu_seq)) | ||
| 553 | goto out_unlock; | 683 | goto out_unlock; |
| 554 | if (writable) { | 684 | if (!hugetlb && !force_pte) |
| 555 | kvm_set_s2pte_writable(&new_pte); | 685 | hugetlb = transparent_hugepage_adjust(&pfn, &fault_ipa); |
| 556 | kvm_set_pfn_dirty(pfn); | 686 | |
| 687 | if (hugetlb) { | ||
| 688 | pmd_t new_pmd = pfn_pmd(pfn, PAGE_S2); | ||
| 689 | new_pmd = pmd_mkhuge(new_pmd); | ||
| 690 | if (writable) { | ||
| 691 | kvm_set_s2pmd_writable(&new_pmd); | ||
| 692 | kvm_set_pfn_dirty(pfn); | ||
| 693 | } | ||
| 694 | coherent_icache_guest_page(kvm, hva & PMD_MASK, PMD_SIZE); | ||
| 695 | ret = stage2_set_pmd_huge(kvm, memcache, fault_ipa, &new_pmd); | ||
| 696 | } else { | ||
| 697 | pte_t new_pte = pfn_pte(pfn, PAGE_S2); | ||
| 698 | if (writable) { | ||
| 699 | kvm_set_s2pte_writable(&new_pte); | ||
| 700 | kvm_set_pfn_dirty(pfn); | ||
| 701 | } | ||
| 702 | coherent_icache_guest_page(kvm, hva, PAGE_SIZE); | ||
| 703 | ret = stage2_set_pte(kvm, memcache, fault_ipa, &new_pte, false); | ||
| 557 | } | 704 | } |
| 558 | stage2_set_pte(vcpu->kvm, memcache, fault_ipa, &new_pte, false); | 705 | |
| 559 | 706 | ||
| 560 | out_unlock: | 707 | out_unlock: |
| 561 | spin_unlock(&vcpu->kvm->mmu_lock); | 708 | spin_unlock(&kvm->mmu_lock); |
| 562 | kvm_release_pfn_clean(pfn); | 709 | kvm_release_pfn_clean(pfn); |
| 563 | return 0; | 710 | return ret; |
| 564 | } | 711 | } |
| 565 | 712 | ||
| 566 | /** | 713 | /** |
| @@ -629,7 +776,7 @@ int kvm_handle_guest_abort(struct kvm_vcpu *vcpu, struct kvm_run *run) | |||
| 629 | 776 | ||
| 630 | memslot = gfn_to_memslot(vcpu->kvm, gfn); | 777 | memslot = gfn_to_memslot(vcpu->kvm, gfn); |
| 631 | 778 | ||
| 632 | ret = user_mem_abort(vcpu, fault_ipa, gfn, memslot, fault_status); | 779 | ret = user_mem_abort(vcpu, fault_ipa, memslot, fault_status); |
| 633 | if (ret == 0) | 780 | if (ret == 0) |
| 634 | ret = 1; | 781 | ret = 1; |
| 635 | out_unlock: | 782 | out_unlock: |
diff --git a/arch/arm/kvm/psci.c b/arch/arm/kvm/psci.c index 86a693a02ba3..0881bf169fbc 100644 --- a/arch/arm/kvm/psci.c +++ b/arch/arm/kvm/psci.c | |||
| @@ -18,6 +18,7 @@ | |||
| 18 | #include <linux/kvm_host.h> | 18 | #include <linux/kvm_host.h> |
| 19 | #include <linux/wait.h> | 19 | #include <linux/wait.h> |
| 20 | 20 | ||
| 21 | #include <asm/cputype.h> | ||
| 21 | #include <asm/kvm_emulate.h> | 22 | #include <asm/kvm_emulate.h> |
| 22 | #include <asm/kvm_psci.h> | 23 | #include <asm/kvm_psci.h> |
| 23 | 24 | ||
| @@ -34,22 +35,30 @@ static void kvm_psci_vcpu_off(struct kvm_vcpu *vcpu) | |||
| 34 | static unsigned long kvm_psci_vcpu_on(struct kvm_vcpu *source_vcpu) | 35 | static unsigned long kvm_psci_vcpu_on(struct kvm_vcpu *source_vcpu) |
| 35 | { | 36 | { |
| 36 | struct kvm *kvm = source_vcpu->kvm; | 37 | struct kvm *kvm = source_vcpu->kvm; |
| 37 | struct kvm_vcpu *vcpu; | 38 | struct kvm_vcpu *vcpu = NULL, *tmp; |
| 38 | wait_queue_head_t *wq; | 39 | wait_queue_head_t *wq; |
| 39 | unsigned long cpu_id; | 40 | unsigned long cpu_id; |
| 41 | unsigned long mpidr; | ||
| 40 | phys_addr_t target_pc; | 42 | phys_addr_t target_pc; |
| 43 | int i; | ||
| 41 | 44 | ||
| 42 | cpu_id = *vcpu_reg(source_vcpu, 1); | 45 | cpu_id = *vcpu_reg(source_vcpu, 1); |
| 43 | if (vcpu_mode_is_32bit(source_vcpu)) | 46 | if (vcpu_mode_is_32bit(source_vcpu)) |
| 44 | cpu_id &= ~((u32) 0); | 47 | cpu_id &= ~((u32) 0); |
| 45 | 48 | ||
| 46 | if (cpu_id >= atomic_read(&kvm->online_vcpus)) | 49 | kvm_for_each_vcpu(i, tmp, kvm) { |
| 50 | mpidr = kvm_vcpu_get_mpidr(tmp); | ||
| 51 | if ((mpidr & MPIDR_HWID_BITMASK) == (cpu_id & MPIDR_HWID_BITMASK)) { | ||
| 52 | vcpu = tmp; | ||
| 53 | break; | ||
| 54 | } | ||
| 55 | } | ||
| 56 | |||
| 57 | if (!vcpu) | ||
| 47 | return KVM_PSCI_RET_INVAL; | 58 | return KVM_PSCI_RET_INVAL; |
| 48 | 59 | ||
| 49 | target_pc = *vcpu_reg(source_vcpu, 2); | 60 | target_pc = *vcpu_reg(source_vcpu, 2); |
| 50 | 61 | ||
| 51 | vcpu = kvm_get_vcpu(kvm, cpu_id); | ||
| 52 | |||
| 53 | wq = kvm_arch_vcpu_wq(vcpu); | 62 | wq = kvm_arch_vcpu_wq(vcpu); |
| 54 | if (!waitqueue_active(wq)) | 63 | if (!waitqueue_active(wq)) |
| 55 | return KVM_PSCI_RET_INVAL; | 64 | return KVM_PSCI_RET_INVAL; |
| @@ -62,6 +71,10 @@ static unsigned long kvm_psci_vcpu_on(struct kvm_vcpu *source_vcpu) | |||
| 62 | vcpu_set_thumb(vcpu); | 71 | vcpu_set_thumb(vcpu); |
| 63 | } | 72 | } |
| 64 | 73 | ||
| 74 | /* Propagate caller endianness */ | ||
| 75 | if (kvm_vcpu_is_be(source_vcpu)) | ||
| 76 | kvm_vcpu_set_be(vcpu); | ||
| 77 | |||
| 65 | *vcpu_pc(vcpu) = target_pc; | 78 | *vcpu_pc(vcpu) = target_pc; |
| 66 | vcpu->arch.pause = false; | 79 | vcpu->arch.pause = false; |
| 67 | smp_mb(); /* Make sure the above is visible */ | 80 | smp_mb(); /* Make sure the above is visible */ |
diff --git a/arch/arm/kvm/reset.c b/arch/arm/kvm/reset.c index c02ba4af599f..f558c073c023 100644 --- a/arch/arm/kvm/reset.c +++ b/arch/arm/kvm/reset.c | |||
| @@ -30,16 +30,14 @@ | |||
| 30 | #include <kvm/arm_arch_timer.h> | 30 | #include <kvm/arm_arch_timer.h> |
| 31 | 31 | ||
| 32 | /****************************************************************************** | 32 | /****************************************************************************** |
| 33 | * Cortex-A15 Reset Values | 33 | * Cortex-A15 and Cortex-A7 Reset Values |
| 34 | */ | 34 | */ |
| 35 | 35 | ||
| 36 | static const int a15_max_cpu_idx = 3; | 36 | static struct kvm_regs cortexa_regs_reset = { |
| 37 | |||
| 38 | static struct kvm_regs a15_regs_reset = { | ||
| 39 | .usr_regs.ARM_cpsr = SVC_MODE | PSR_A_BIT | PSR_I_BIT | PSR_F_BIT, | 37 | .usr_regs.ARM_cpsr = SVC_MODE | PSR_A_BIT | PSR_I_BIT | PSR_F_BIT, |
| 40 | }; | 38 | }; |
| 41 | 39 | ||
| 42 | static const struct kvm_irq_level a15_vtimer_irq = { | 40 | static const struct kvm_irq_level cortexa_vtimer_irq = { |
| 43 | { .irq = 27 }, | 41 | { .irq = 27 }, |
| 44 | .level = 1, | 42 | .level = 1, |
| 45 | }; | 43 | }; |
| @@ -62,12 +60,11 @@ int kvm_reset_vcpu(struct kvm_vcpu *vcpu) | |||
| 62 | const struct kvm_irq_level *cpu_vtimer_irq; | 60 | const struct kvm_irq_level *cpu_vtimer_irq; |
| 63 | 61 | ||
| 64 | switch (vcpu->arch.target) { | 62 | switch (vcpu->arch.target) { |
| 63 | case KVM_ARM_TARGET_CORTEX_A7: | ||
| 65 | case KVM_ARM_TARGET_CORTEX_A15: | 64 | case KVM_ARM_TARGET_CORTEX_A15: |
| 66 | if (vcpu->vcpu_id > a15_max_cpu_idx) | 65 | reset_regs = &cortexa_regs_reset; |
| 67 | return -EINVAL; | ||
| 68 | reset_regs = &a15_regs_reset; | ||
| 69 | vcpu->arch.midr = read_cpuid_id(); | 66 | vcpu->arch.midr = read_cpuid_id(); |
| 70 | cpu_vtimer_irq = &a15_vtimer_irq; | 67 | cpu_vtimer_irq = &cortexa_vtimer_irq; |
| 71 | break; | 68 | break; |
| 72 | default: | 69 | default: |
| 73 | return -ENODEV; | 70 | return -ENODEV; |
diff --git a/arch/arm64/include/asm/kvm_arm.h b/arch/arm64/include/asm/kvm_arm.h index a5f28e2720c7..c98ef4771c73 100644 --- a/arch/arm64/include/asm/kvm_arm.h +++ b/arch/arm64/include/asm/kvm_arm.h | |||
| @@ -63,6 +63,7 @@ | |||
| 63 | * TAC: Trap ACTLR | 63 | * TAC: Trap ACTLR |
| 64 | * TSC: Trap SMC | 64 | * TSC: Trap SMC |
| 65 | * TSW: Trap cache operations by set/way | 65 | * TSW: Trap cache operations by set/way |
| 66 | * TWE: Trap WFE | ||
| 66 | * TWI: Trap WFI | 67 | * TWI: Trap WFI |
| 67 | * TIDCP: Trap L2CTLR/L2ECTLR | 68 | * TIDCP: Trap L2CTLR/L2ECTLR |
| 68 | * BSU_IS: Upgrade barriers to the inner shareable domain | 69 | * BSU_IS: Upgrade barriers to the inner shareable domain |
| @@ -72,8 +73,9 @@ | |||
| 72 | * FMO: Override CPSR.F and enable signaling with VF | 73 | * FMO: Override CPSR.F and enable signaling with VF |
| 73 | * SWIO: Turn set/way invalidates into set/way clean+invalidate | 74 | * SWIO: Turn set/way invalidates into set/way clean+invalidate |
| 74 | */ | 75 | */ |
| 75 | #define HCR_GUEST_FLAGS (HCR_TSC | HCR_TSW | HCR_TWI | HCR_VM | HCR_BSU_IS | \ | 76 | #define HCR_GUEST_FLAGS (HCR_TSC | HCR_TSW | HCR_TWE | HCR_TWI | HCR_VM | \ |
| 76 | HCR_FB | HCR_TAC | HCR_AMO | HCR_IMO | HCR_FMO | \ | 77 | HCR_BSU_IS | HCR_FB | HCR_TAC | \ |
| 78 | HCR_AMO | HCR_IMO | HCR_FMO | \ | ||
| 77 | HCR_SWIO | HCR_TIDCP | HCR_RW) | 79 | HCR_SWIO | HCR_TIDCP | HCR_RW) |
| 78 | #define HCR_VIRT_EXCP_MASK (HCR_VA | HCR_VI | HCR_VF) | 80 | #define HCR_VIRT_EXCP_MASK (HCR_VA | HCR_VI | HCR_VF) |
| 79 | 81 | ||
| @@ -242,4 +244,6 @@ | |||
| 242 | 244 | ||
| 243 | #define ESR_EL2_EC_xABT_xFSR_EXTABT 0x10 | 245 | #define ESR_EL2_EC_xABT_xFSR_EXTABT 0x10 |
| 244 | 246 | ||
| 247 | #define ESR_EL2_EC_WFI_ISS_WFE (1 << 0) | ||
| 248 | |||
| 245 | #endif /* __ARM64_KVM_ARM_H__ */ | 249 | #endif /* __ARM64_KVM_ARM_H__ */ |
diff --git a/arch/arm64/include/asm/kvm_emulate.h b/arch/arm64/include/asm/kvm_emulate.h index eec073875218..dd8ecfc3f995 100644 --- a/arch/arm64/include/asm/kvm_emulate.h +++ b/arch/arm64/include/asm/kvm_emulate.h | |||
| @@ -177,4 +177,65 @@ static inline u8 kvm_vcpu_trap_get_fault(const struct kvm_vcpu *vcpu) | |||
| 177 | return kvm_vcpu_get_hsr(vcpu) & ESR_EL2_FSC_TYPE; | 177 | return kvm_vcpu_get_hsr(vcpu) & ESR_EL2_FSC_TYPE; |
| 178 | } | 178 | } |
| 179 | 179 | ||
| 180 | static inline unsigned long kvm_vcpu_get_mpidr(struct kvm_vcpu *vcpu) | ||
| 181 | { | ||
| 182 | return vcpu_sys_reg(vcpu, MPIDR_EL1); | ||
| 183 | } | ||
| 184 | |||
| 185 | static inline void kvm_vcpu_set_be(struct kvm_vcpu *vcpu) | ||
| 186 | { | ||
| 187 | if (vcpu_mode_is_32bit(vcpu)) | ||
| 188 | *vcpu_cpsr(vcpu) |= COMPAT_PSR_E_BIT; | ||
| 189 | else | ||
| 190 | vcpu_sys_reg(vcpu, SCTLR_EL1) |= (1 << 25); | ||
| 191 | } | ||
| 192 | |||
| 193 | static inline bool kvm_vcpu_is_be(struct kvm_vcpu *vcpu) | ||
| 194 | { | ||
| 195 | if (vcpu_mode_is_32bit(vcpu)) | ||
| 196 | return !!(*vcpu_cpsr(vcpu) & COMPAT_PSR_E_BIT); | ||
| 197 | |||
| 198 | return !!(vcpu_sys_reg(vcpu, SCTLR_EL1) & (1 << 25)); | ||
| 199 | } | ||
| 200 | |||
| 201 | static inline unsigned long vcpu_data_guest_to_host(struct kvm_vcpu *vcpu, | ||
| 202 | unsigned long data, | ||
| 203 | unsigned int len) | ||
| 204 | { | ||
| 205 | if (kvm_vcpu_is_be(vcpu)) { | ||
| 206 | switch (len) { | ||
| 207 | case 1: | ||
| 208 | return data & 0xff; | ||
| 209 | case 2: | ||
| 210 | return be16_to_cpu(data & 0xffff); | ||
| 211 | case 4: | ||
| 212 | return be32_to_cpu(data & 0xffffffff); | ||
| 213 | default: | ||
| 214 | return be64_to_cpu(data); | ||
| 215 | } | ||
| 216 | } | ||
| 217 | |||
| 218 | return data; /* Leave LE untouched */ | ||
| 219 | } | ||
| 220 | |||
| 221 | static inline unsigned long vcpu_data_host_to_guest(struct kvm_vcpu *vcpu, | ||
| 222 | unsigned long data, | ||
| 223 | unsigned int len) | ||
| 224 | { | ||
| 225 | if (kvm_vcpu_is_be(vcpu)) { | ||
| 226 | switch (len) { | ||
| 227 | case 1: | ||
| 228 | return data & 0xff; | ||
| 229 | case 2: | ||
| 230 | return cpu_to_be16(data & 0xffff); | ||
| 231 | case 4: | ||
| 232 | return cpu_to_be32(data & 0xffffffff); | ||
| 233 | default: | ||
| 234 | return cpu_to_be64(data); | ||
| 235 | } | ||
| 236 | } | ||
| 237 | |||
| 238 | return data; /* Leave LE untouched */ | ||
| 239 | } | ||
| 240 | |||
| 180 | #endif /* __ARM64_KVM_EMULATE_H__ */ | 241 | #endif /* __ARM64_KVM_EMULATE_H__ */ |
diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h index 0859a4ddd1e7..5d85a02d1231 100644 --- a/arch/arm64/include/asm/kvm_host.h +++ b/arch/arm64/include/asm/kvm_host.h | |||
| @@ -36,11 +36,6 @@ | |||
| 36 | 36 | ||
| 37 | #define KVM_VCPU_MAX_FEATURES 2 | 37 | #define KVM_VCPU_MAX_FEATURES 2 |
| 38 | 38 | ||
| 39 | /* We don't currently support large pages. */ | ||
| 40 | #define KVM_HPAGE_GFN_SHIFT(x) 0 | ||
| 41 | #define KVM_NR_PAGE_SIZES 1 | ||
| 42 | #define KVM_PAGES_PER_HPAGE(x) (1UL<<31) | ||
| 43 | |||
| 44 | struct kvm_vcpu; | 39 | struct kvm_vcpu; |
| 45 | int kvm_target_cpu(void); | 40 | int kvm_target_cpu(void); |
| 46 | int kvm_reset_vcpu(struct kvm_vcpu *vcpu); | 41 | int kvm_reset_vcpu(struct kvm_vcpu *vcpu); |
| @@ -151,6 +146,7 @@ struct kvm_vcpu_stat { | |||
| 151 | struct kvm_vcpu_init; | 146 | struct kvm_vcpu_init; |
| 152 | int kvm_vcpu_set_target(struct kvm_vcpu *vcpu, | 147 | int kvm_vcpu_set_target(struct kvm_vcpu *vcpu, |
| 153 | const struct kvm_vcpu_init *init); | 148 | const struct kvm_vcpu_init *init); |
| 149 | int kvm_vcpu_preferred_target(struct kvm_vcpu_init *init); | ||
| 154 | unsigned long kvm_arm_num_regs(struct kvm_vcpu *vcpu); | 150 | unsigned long kvm_arm_num_regs(struct kvm_vcpu *vcpu); |
| 155 | int kvm_arm_copy_reg_indices(struct kvm_vcpu *vcpu, u64 __user *indices); | 151 | int kvm_arm_copy_reg_indices(struct kvm_vcpu *vcpu, u64 __user *indices); |
| 156 | struct kvm_one_reg; | 152 | struct kvm_one_reg; |
diff --git a/arch/arm64/include/asm/kvm_mmu.h b/arch/arm64/include/asm/kvm_mmu.h index efe609c6a3c9..680f74e67497 100644 --- a/arch/arm64/include/asm/kvm_mmu.h +++ b/arch/arm64/include/asm/kvm_mmu.h | |||
| @@ -91,6 +91,7 @@ int kvm_mmu_init(void); | |||
| 91 | void kvm_clear_hyp_idmap(void); | 91 | void kvm_clear_hyp_idmap(void); |
| 92 | 92 | ||
| 93 | #define kvm_set_pte(ptep, pte) set_pte(ptep, pte) | 93 | #define kvm_set_pte(ptep, pte) set_pte(ptep, pte) |
| 94 | #define kvm_set_pmd(pmdp, pmd) set_pmd(pmdp, pmd) | ||
| 94 | 95 | ||
| 95 | static inline bool kvm_is_write_fault(unsigned long esr) | 96 | static inline bool kvm_is_write_fault(unsigned long esr) |
| 96 | { | 97 | { |
| @@ -116,13 +117,18 @@ static inline void kvm_set_s2pte_writable(pte_t *pte) | |||
| 116 | pte_val(*pte) |= PTE_S2_RDWR; | 117 | pte_val(*pte) |= PTE_S2_RDWR; |
| 117 | } | 118 | } |
| 118 | 119 | ||
| 120 | static inline void kvm_set_s2pmd_writable(pmd_t *pmd) | ||
| 121 | { | ||
| 122 | pmd_val(*pmd) |= PMD_S2_RDWR; | ||
| 123 | } | ||
| 124 | |||
| 119 | struct kvm; | 125 | struct kvm; |
| 120 | 126 | ||
| 121 | static inline void coherent_icache_guest_page(struct kvm *kvm, gfn_t gfn) | 127 | static inline void coherent_icache_guest_page(struct kvm *kvm, hva_t hva, |
| 128 | unsigned long size) | ||
| 122 | { | 129 | { |
| 123 | if (!icache_is_aliasing()) { /* PIPT */ | 130 | if (!icache_is_aliasing()) { /* PIPT */ |
| 124 | unsigned long hva = gfn_to_hva(kvm, gfn); | 131 | flush_icache_range(hva, hva + size); |
| 125 | flush_icache_range(hva, hva + PAGE_SIZE); | ||
| 126 | } else if (!icache_is_aivivt()) { /* non ASID-tagged VIVT */ | 132 | } else if (!icache_is_aivivt()) { /* non ASID-tagged VIVT */ |
| 127 | /* any kind of VIPT cache */ | 133 | /* any kind of VIPT cache */ |
| 128 | __flush_icache_all(); | 134 | __flush_icache_all(); |
diff --git a/arch/arm64/include/asm/pgtable-hwdef.h b/arch/arm64/include/asm/pgtable-hwdef.h index d57e66845c86..755f86143320 100644 --- a/arch/arm64/include/asm/pgtable-hwdef.h +++ b/arch/arm64/include/asm/pgtable-hwdef.h | |||
| @@ -85,6 +85,8 @@ | |||
| 85 | #define PTE_S2_RDONLY (_AT(pteval_t, 1) << 6) /* HAP[2:1] */ | 85 | #define PTE_S2_RDONLY (_AT(pteval_t, 1) << 6) /* HAP[2:1] */ |
| 86 | #define PTE_S2_RDWR (_AT(pteval_t, 3) << 6) /* HAP[2:1] */ | 86 | #define PTE_S2_RDWR (_AT(pteval_t, 3) << 6) /* HAP[2:1] */ |
| 87 | 87 | ||
| 88 | #define PMD_S2_RDWR (_AT(pmdval_t, 3) << 6) /* HAP[2:1] */ | ||
| 89 | |||
| 88 | /* | 90 | /* |
| 89 | * Memory Attribute override for Stage-2 (MemAttr[3:0]) | 91 | * Memory Attribute override for Stage-2 (MemAttr[3:0]) |
| 90 | */ | 92 | */ |
diff --git a/arch/arm64/kvm/Kconfig b/arch/arm64/kvm/Kconfig index 21e90820bd23..4480ab339a00 100644 --- a/arch/arm64/kvm/Kconfig +++ b/arch/arm64/kvm/Kconfig | |||
| @@ -21,6 +21,7 @@ config KVM | |||
| 21 | select MMU_NOTIFIER | 21 | select MMU_NOTIFIER |
| 22 | select PREEMPT_NOTIFIERS | 22 | select PREEMPT_NOTIFIERS |
| 23 | select ANON_INODES | 23 | select ANON_INODES |
| 24 | select HAVE_KVM_CPU_RELAX_INTERCEPT | ||
| 24 | select KVM_MMIO | 25 | select KVM_MMIO |
| 25 | select KVM_ARM_HOST | 26 | select KVM_ARM_HOST |
| 26 | select KVM_ARM_VGIC | 27 | select KVM_ARM_VGIC |
diff --git a/arch/arm64/kvm/guest.c b/arch/arm64/kvm/guest.c index 2c3ff67a8ecb..3f0731e53274 100644 --- a/arch/arm64/kvm/guest.c +++ b/arch/arm64/kvm/guest.c | |||
| @@ -248,6 +248,26 @@ int kvm_vcpu_set_target(struct kvm_vcpu *vcpu, | |||
| 248 | return kvm_reset_vcpu(vcpu); | 248 | return kvm_reset_vcpu(vcpu); |
| 249 | } | 249 | } |
| 250 | 250 | ||
| 251 | int kvm_vcpu_preferred_target(struct kvm_vcpu_init *init) | ||
| 252 | { | ||
| 253 | int target = kvm_target_cpu(); | ||
| 254 | |||
| 255 | if (target < 0) | ||
| 256 | return -ENODEV; | ||
| 257 | |||
| 258 | memset(init, 0, sizeof(*init)); | ||
| 259 | |||
| 260 | /* | ||
| 261 | * For now, we don't return any features. | ||
| 262 | * In future, we might use features to return target | ||
| 263 | * specific features available for the preferred | ||
| 264 | * target type. | ||
| 265 | */ | ||
| 266 | init->target = (__u32)target; | ||
| 267 | |||
| 268 | return 0; | ||
| 269 | } | ||
| 270 | |||
| 251 | int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) | 271 | int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) |
| 252 | { | 272 | { |
| 253 | return -EINVAL; | 273 | return -EINVAL; |
diff --git a/arch/arm64/kvm/handle_exit.c b/arch/arm64/kvm/handle_exit.c index 9beaca033437..8da56067c304 100644 --- a/arch/arm64/kvm/handle_exit.c +++ b/arch/arm64/kvm/handle_exit.c | |||
| @@ -47,21 +47,29 @@ static int handle_smc(struct kvm_vcpu *vcpu, struct kvm_run *run) | |||
| 47 | } | 47 | } |
| 48 | 48 | ||
| 49 | /** | 49 | /** |
| 50 | * kvm_handle_wfi - handle a wait-for-interrupts instruction executed by a guest | 50 | * kvm_handle_wfx - handle a wait-for-interrupts or wait-for-event |
| 51 | * instruction executed by a guest | ||
| 52 | * | ||
| 51 | * @vcpu: the vcpu pointer | 53 | * @vcpu: the vcpu pointer |
| 52 | * | 54 | * |
| 53 | * Simply call kvm_vcpu_block(), which will halt execution of | 55 | * WFE: Yield the CPU and come back to this vcpu when the scheduler |
| 56 | * decides to. | ||
| 57 | * WFI: Simply call kvm_vcpu_block(), which will halt execution of | ||
| 54 | * world-switches and schedule other host processes until there is an | 58 | * world-switches and schedule other host processes until there is an |
| 55 | * incoming IRQ or FIQ to the VM. | 59 | * incoming IRQ or FIQ to the VM. |
| 56 | */ | 60 | */ |
| 57 | static int kvm_handle_wfi(struct kvm_vcpu *vcpu, struct kvm_run *run) | 61 | static int kvm_handle_wfx(struct kvm_vcpu *vcpu, struct kvm_run *run) |
| 58 | { | 62 | { |
| 59 | kvm_vcpu_block(vcpu); | 63 | if (kvm_vcpu_get_hsr(vcpu) & ESR_EL2_EC_WFI_ISS_WFE) |
| 64 | kvm_vcpu_on_spin(vcpu); | ||
| 65 | else | ||
| 66 | kvm_vcpu_block(vcpu); | ||
| 67 | |||
| 60 | return 1; | 68 | return 1; |
| 61 | } | 69 | } |
| 62 | 70 | ||
| 63 | static exit_handle_fn arm_exit_handlers[] = { | 71 | static exit_handle_fn arm_exit_handlers[] = { |
| 64 | [ESR_EL2_EC_WFI] = kvm_handle_wfi, | 72 | [ESR_EL2_EC_WFI] = kvm_handle_wfx, |
| 65 | [ESR_EL2_EC_CP15_32] = kvm_handle_cp15_32, | 73 | [ESR_EL2_EC_CP15_32] = kvm_handle_cp15_32, |
| 66 | [ESR_EL2_EC_CP15_64] = kvm_handle_cp15_64, | 74 | [ESR_EL2_EC_CP15_64] = kvm_handle_cp15_64, |
| 67 | [ESR_EL2_EC_CP14_MR] = kvm_handle_cp14_access, | 75 | [ESR_EL2_EC_CP14_MR] = kvm_handle_cp14_access, |
diff --git a/arch/ia64/include/asm/kvm_host.h b/arch/ia64/include/asm/kvm_host.h index 989dd3fe8de1..db95f570705f 100644 --- a/arch/ia64/include/asm/kvm_host.h +++ b/arch/ia64/include/asm/kvm_host.h | |||
| @@ -234,10 +234,6 @@ struct kvm_vm_data { | |||
| 234 | #define KVM_REQ_PTC_G 32 | 234 | #define KVM_REQ_PTC_G 32 |
| 235 | #define KVM_REQ_RESUME 33 | 235 | #define KVM_REQ_RESUME 33 |
| 236 | 236 | ||
| 237 | #define KVM_HPAGE_GFN_SHIFT(x) 0 | ||
| 238 | #define KVM_NR_PAGE_SIZES 1 | ||
| 239 | #define KVM_PAGES_PER_HPAGE(x) 1 | ||
| 240 | |||
| 241 | struct kvm; | 237 | struct kvm; |
| 242 | struct kvm_vcpu; | 238 | struct kvm_vcpu; |
| 243 | 239 | ||
| @@ -480,7 +476,7 @@ struct kvm_arch { | |||
| 480 | 476 | ||
| 481 | struct list_head assigned_dev_head; | 477 | struct list_head assigned_dev_head; |
| 482 | struct iommu_domain *iommu_domain; | 478 | struct iommu_domain *iommu_domain; |
| 483 | int iommu_flags; | 479 | bool iommu_noncoherent; |
| 484 | 480 | ||
| 485 | unsigned long irq_sources_bitmap; | 481 | unsigned long irq_sources_bitmap; |
| 486 | unsigned long irq_states[KVM_IOAPIC_NUM_PINS]; | 482 | unsigned long irq_states[KVM_IOAPIC_NUM_PINS]; |
diff --git a/arch/ia64/kvm/kvm-ia64.c b/arch/ia64/kvm/kvm-ia64.c index bdfd8789b376..985bf80c622e 100644 --- a/arch/ia64/kvm/kvm-ia64.c +++ b/arch/ia64/kvm/kvm-ia64.c | |||
| @@ -1550,12 +1550,13 @@ int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) | |||
| 1550 | return VM_FAULT_SIGBUS; | 1550 | return VM_FAULT_SIGBUS; |
| 1551 | } | 1551 | } |
| 1552 | 1552 | ||
| 1553 | void kvm_arch_free_memslot(struct kvm_memory_slot *free, | 1553 | void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free, |
| 1554 | struct kvm_memory_slot *dont) | 1554 | struct kvm_memory_slot *dont) |
| 1555 | { | 1555 | { |
| 1556 | } | 1556 | } |
| 1557 | 1557 | ||
| 1558 | int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages) | 1558 | int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, |
| 1559 | unsigned long npages) | ||
| 1559 | { | 1560 | { |
| 1560 | return 0; | 1561 | return 0; |
| 1561 | } | 1562 | } |
diff --git a/arch/mips/include/asm/kvm_host.h b/arch/mips/include/asm/kvm_host.h index 4d6fa0bf1305..32966969f2f9 100644 --- a/arch/mips/include/asm/kvm_host.h +++ b/arch/mips/include/asm/kvm_host.h | |||
| @@ -27,13 +27,6 @@ | |||
| 27 | 27 | ||
| 28 | #define KVM_COALESCED_MMIO_PAGE_OFFSET 1 | 28 | #define KVM_COALESCED_MMIO_PAGE_OFFSET 1 |
| 29 | 29 | ||
| 30 | /* Don't support huge pages */ | ||
| 31 | #define KVM_HPAGE_GFN_SHIFT(x) 0 | ||
| 32 | |||
| 33 | /* We don't currently support large pages. */ | ||
| 34 | #define KVM_NR_PAGE_SIZES 1 | ||
| 35 | #define KVM_PAGES_PER_HPAGE(x) 1 | ||
| 36 | |||
| 37 | 30 | ||
| 38 | 31 | ||
| 39 | /* Special address that contains the comm page, used for reducing # of traps */ | 32 | /* Special address that contains the comm page, used for reducing # of traps */ |
diff --git a/arch/mips/kvm/kvm_mips.c b/arch/mips/kvm/kvm_mips.c index a7b044536de4..73b34827826c 100644 --- a/arch/mips/kvm/kvm_mips.c +++ b/arch/mips/kvm/kvm_mips.c | |||
| @@ -198,12 +198,13 @@ kvm_arch_dev_ioctl(struct file *filp, unsigned int ioctl, unsigned long arg) | |||
| 198 | return -ENOIOCTLCMD; | 198 | return -ENOIOCTLCMD; |
| 199 | } | 199 | } |
| 200 | 200 | ||
| 201 | void kvm_arch_free_memslot(struct kvm_memory_slot *free, | 201 | void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free, |
| 202 | struct kvm_memory_slot *dont) | 202 | struct kvm_memory_slot *dont) |
| 203 | { | 203 | { |
| 204 | } | 204 | } |
| 205 | 205 | ||
| 206 | int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages) | 206 | int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, |
| 207 | unsigned long npages) | ||
| 207 | { | 208 | { |
| 208 | return 0; | 209 | return 0; |
| 209 | } | 210 | } |
diff --git a/arch/powerpc/include/asm/disassemble.h b/arch/powerpc/include/asm/disassemble.h index 9b198d1b3b2b..856f8deb557a 100644 --- a/arch/powerpc/include/asm/disassemble.h +++ b/arch/powerpc/include/asm/disassemble.h | |||
| @@ -77,4 +77,8 @@ static inline unsigned int get_d(u32 inst) | |||
| 77 | return inst & 0xffff; | 77 | return inst & 0xffff; |
| 78 | } | 78 | } |
| 79 | 79 | ||
| 80 | static inline unsigned int get_oc(u32 inst) | ||
| 81 | { | ||
| 82 | return (inst >> 11) & 0x7fff; | ||
| 83 | } | ||
| 80 | #endif /* __ASM_PPC_DISASSEMBLE_H__ */ | 84 | #endif /* __ASM_PPC_DISASSEMBLE_H__ */ |
diff --git a/arch/powerpc/include/asm/exception-64s.h b/arch/powerpc/include/asm/exception-64s.h index cca12f084842..894662a5d4d5 100644 --- a/arch/powerpc/include/asm/exception-64s.h +++ b/arch/powerpc/include/asm/exception-64s.h | |||
| @@ -198,12 +198,27 @@ END_FTR_SECTION_NESTED(ftr,ftr,943) | |||
| 198 | cmpwi r10,0; \ | 198 | cmpwi r10,0; \ |
| 199 | bne do_kvm_##n | 199 | bne do_kvm_##n |
| 200 | 200 | ||
| 201 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE | ||
| 202 | /* | ||
| 203 | * If hv is possible, interrupts come into to the hv version | ||
| 204 | * of the kvmppc_interrupt code, which then jumps to the PR handler, | ||
| 205 | * kvmppc_interrupt_pr, if the guest is a PR guest. | ||
| 206 | */ | ||
| 207 | #define kvmppc_interrupt kvmppc_interrupt_hv | ||
| 208 | #else | ||
| 209 | #define kvmppc_interrupt kvmppc_interrupt_pr | ||
| 210 | #endif | ||
| 211 | |||
| 201 | #define __KVM_HANDLER(area, h, n) \ | 212 | #define __KVM_HANDLER(area, h, n) \ |
| 202 | do_kvm_##n: \ | 213 | do_kvm_##n: \ |
| 203 | BEGIN_FTR_SECTION_NESTED(947) \ | 214 | BEGIN_FTR_SECTION_NESTED(947) \ |
| 204 | ld r10,area+EX_CFAR(r13); \ | 215 | ld r10,area+EX_CFAR(r13); \ |
| 205 | std r10,HSTATE_CFAR(r13); \ | 216 | std r10,HSTATE_CFAR(r13); \ |
| 206 | END_FTR_SECTION_NESTED(CPU_FTR_CFAR,CPU_FTR_CFAR,947); \ | 217 | END_FTR_SECTION_NESTED(CPU_FTR_CFAR,CPU_FTR_CFAR,947); \ |
| 218 | BEGIN_FTR_SECTION_NESTED(948) \ | ||
| 219 | ld r10,area+EX_PPR(r13); \ | ||
| 220 | std r10,HSTATE_PPR(r13); \ | ||
| 221 | END_FTR_SECTION_NESTED(CPU_FTR_HAS_PPR,CPU_FTR_HAS_PPR,948); \ | ||
| 207 | ld r10,area+EX_R10(r13); \ | 222 | ld r10,area+EX_R10(r13); \ |
| 208 | stw r9,HSTATE_SCRATCH1(r13); \ | 223 | stw r9,HSTATE_SCRATCH1(r13); \ |
| 209 | ld r9,area+EX_R9(r13); \ | 224 | ld r9,area+EX_R9(r13); \ |
| @@ -217,6 +232,10 @@ do_kvm_##n: \ | |||
| 217 | ld r10,area+EX_R10(r13); \ | 232 | ld r10,area+EX_R10(r13); \ |
| 218 | beq 89f; \ | 233 | beq 89f; \ |
| 219 | stw r9,HSTATE_SCRATCH1(r13); \ | 234 | stw r9,HSTATE_SCRATCH1(r13); \ |
| 235 | BEGIN_FTR_SECTION_NESTED(948) \ | ||
| 236 | ld r9,area+EX_PPR(r13); \ | ||
| 237 | std r9,HSTATE_PPR(r13); \ | ||
| 238 | END_FTR_SECTION_NESTED(CPU_FTR_HAS_PPR,CPU_FTR_HAS_PPR,948); \ | ||
| 220 | ld r9,area+EX_R9(r13); \ | 239 | ld r9,area+EX_R9(r13); \ |
| 221 | std r12,HSTATE_SCRATCH0(r13); \ | 240 | std r12,HSTATE_SCRATCH0(r13); \ |
| 222 | li r12,n; \ | 241 | li r12,n; \ |
| @@ -236,7 +255,7 @@ do_kvm_##n: \ | |||
| 236 | #define KVM_HANDLER_SKIP(area, h, n) | 255 | #define KVM_HANDLER_SKIP(area, h, n) |
| 237 | #endif | 256 | #endif |
| 238 | 257 | ||
| 239 | #ifdef CONFIG_KVM_BOOK3S_PR | 258 | #ifdef CONFIG_KVM_BOOK3S_PR_POSSIBLE |
| 240 | #define KVMTEST_PR(n) __KVMTEST(n) | 259 | #define KVMTEST_PR(n) __KVMTEST(n) |
| 241 | #define KVM_HANDLER_PR(area, h, n) __KVM_HANDLER(area, h, n) | 260 | #define KVM_HANDLER_PR(area, h, n) __KVM_HANDLER(area, h, n) |
| 242 | #define KVM_HANDLER_PR_SKIP(area, h, n) __KVM_HANDLER_SKIP(area, h, n) | 261 | #define KVM_HANDLER_PR_SKIP(area, h, n) __KVM_HANDLER_SKIP(area, h, n) |
diff --git a/arch/powerpc/include/asm/kvm_asm.h b/arch/powerpc/include/asm/kvm_asm.h index 851bac7afa4b..1bd92fd43cfb 100644 --- a/arch/powerpc/include/asm/kvm_asm.h +++ b/arch/powerpc/include/asm/kvm_asm.h | |||
| @@ -123,6 +123,8 @@ | |||
| 123 | #define BOOK3S_HFLAG_SLB 0x2 | 123 | #define BOOK3S_HFLAG_SLB 0x2 |
| 124 | #define BOOK3S_HFLAG_PAIRED_SINGLE 0x4 | 124 | #define BOOK3S_HFLAG_PAIRED_SINGLE 0x4 |
| 125 | #define BOOK3S_HFLAG_NATIVE_PS 0x8 | 125 | #define BOOK3S_HFLAG_NATIVE_PS 0x8 |
| 126 | #define BOOK3S_HFLAG_MULTI_PGSIZE 0x10 | ||
| 127 | #define BOOK3S_HFLAG_NEW_TLBIE 0x20 | ||
| 126 | 128 | ||
| 127 | #define RESUME_FLAG_NV (1<<0) /* Reload guest nonvolatile state? */ | 129 | #define RESUME_FLAG_NV (1<<0) /* Reload guest nonvolatile state? */ |
| 128 | #define RESUME_FLAG_HOST (1<<1) /* Resume host? */ | 130 | #define RESUME_FLAG_HOST (1<<1) /* Resume host? */ |
| @@ -136,6 +138,8 @@ | |||
| 136 | #define KVM_GUEST_MODE_NONE 0 | 138 | #define KVM_GUEST_MODE_NONE 0 |
| 137 | #define KVM_GUEST_MODE_GUEST 1 | 139 | #define KVM_GUEST_MODE_GUEST 1 |
| 138 | #define KVM_GUEST_MODE_SKIP 2 | 140 | #define KVM_GUEST_MODE_SKIP 2 |
| 141 | #define KVM_GUEST_MODE_GUEST_HV 3 | ||
| 142 | #define KVM_GUEST_MODE_HOST_HV 4 | ||
| 139 | 143 | ||
| 140 | #define KVM_INST_FETCH_FAILED -1 | 144 | #define KVM_INST_FETCH_FAILED -1 |
| 141 | 145 | ||
diff --git a/arch/powerpc/include/asm/kvm_book3s.h b/arch/powerpc/include/asm/kvm_book3s.h index fa19e2f1a874..4a594b76674d 100644 --- a/arch/powerpc/include/asm/kvm_book3s.h +++ b/arch/powerpc/include/asm/kvm_book3s.h | |||
| @@ -58,16 +58,18 @@ struct hpte_cache { | |||
| 58 | struct hlist_node list_pte_long; | 58 | struct hlist_node list_pte_long; |
| 59 | struct hlist_node list_vpte; | 59 | struct hlist_node list_vpte; |
| 60 | struct hlist_node list_vpte_long; | 60 | struct hlist_node list_vpte_long; |
| 61 | #ifdef CONFIG_PPC_BOOK3S_64 | ||
| 62 | struct hlist_node list_vpte_64k; | ||
| 63 | #endif | ||
| 61 | struct rcu_head rcu_head; | 64 | struct rcu_head rcu_head; |
| 62 | u64 host_vpn; | 65 | u64 host_vpn; |
| 63 | u64 pfn; | 66 | u64 pfn; |
| 64 | ulong slot; | 67 | ulong slot; |
| 65 | struct kvmppc_pte pte; | 68 | struct kvmppc_pte pte; |
| 69 | int pagesize; | ||
| 66 | }; | 70 | }; |
| 67 | 71 | ||
| 68 | struct kvmppc_vcpu_book3s { | 72 | struct kvmppc_vcpu_book3s { |
| 69 | struct kvm_vcpu vcpu; | ||
| 70 | struct kvmppc_book3s_shadow_vcpu *shadow_vcpu; | ||
| 71 | struct kvmppc_sid_map sid_map[SID_MAP_NUM]; | 73 | struct kvmppc_sid_map sid_map[SID_MAP_NUM]; |
| 72 | struct { | 74 | struct { |
| 73 | u64 esid; | 75 | u64 esid; |
| @@ -99,6 +101,9 @@ struct kvmppc_vcpu_book3s { | |||
| 99 | struct hlist_head hpte_hash_pte_long[HPTEG_HASH_NUM_PTE_LONG]; | 101 | struct hlist_head hpte_hash_pte_long[HPTEG_HASH_NUM_PTE_LONG]; |
| 100 | struct hlist_head hpte_hash_vpte[HPTEG_HASH_NUM_VPTE]; | 102 | struct hlist_head hpte_hash_vpte[HPTEG_HASH_NUM_VPTE]; |
| 101 | struct hlist_head hpte_hash_vpte_long[HPTEG_HASH_NUM_VPTE_LONG]; | 103 | struct hlist_head hpte_hash_vpte_long[HPTEG_HASH_NUM_VPTE_LONG]; |
| 104 | #ifdef CONFIG_PPC_BOOK3S_64 | ||
| 105 | struct hlist_head hpte_hash_vpte_64k[HPTEG_HASH_NUM_VPTE_64K]; | ||
| 106 | #endif | ||
| 102 | int hpte_cache_count; | 107 | int hpte_cache_count; |
| 103 | spinlock_t mmu_lock; | 108 | spinlock_t mmu_lock; |
| 104 | }; | 109 | }; |
| @@ -107,8 +112,9 @@ struct kvmppc_vcpu_book3s { | |||
| 107 | #define CONTEXT_GUEST 1 | 112 | #define CONTEXT_GUEST 1 |
| 108 | #define CONTEXT_GUEST_END 2 | 113 | #define CONTEXT_GUEST_END 2 |
| 109 | 114 | ||
| 110 | #define VSID_REAL 0x0fffffffffc00000ULL | 115 | #define VSID_REAL 0x07ffffffffc00000ULL |
| 111 | #define VSID_BAT 0x0fffffffffb00000ULL | 116 | #define VSID_BAT 0x07ffffffffb00000ULL |
| 117 | #define VSID_64K 0x0800000000000000ULL | ||
| 112 | #define VSID_1T 0x1000000000000000ULL | 118 | #define VSID_1T 0x1000000000000000ULL |
| 113 | #define VSID_REAL_DR 0x2000000000000000ULL | 119 | #define VSID_REAL_DR 0x2000000000000000ULL |
| 114 | #define VSID_REAL_IR 0x4000000000000000ULL | 120 | #define VSID_REAL_IR 0x4000000000000000ULL |
| @@ -118,11 +124,12 @@ extern void kvmppc_mmu_pte_flush(struct kvm_vcpu *vcpu, ulong ea, ulong ea_mask) | |||
| 118 | extern void kvmppc_mmu_pte_vflush(struct kvm_vcpu *vcpu, u64 vp, u64 vp_mask); | 124 | extern void kvmppc_mmu_pte_vflush(struct kvm_vcpu *vcpu, u64 vp, u64 vp_mask); |
| 119 | extern void kvmppc_mmu_pte_pflush(struct kvm_vcpu *vcpu, ulong pa_start, ulong pa_end); | 125 | extern void kvmppc_mmu_pte_pflush(struct kvm_vcpu *vcpu, ulong pa_start, ulong pa_end); |
| 120 | extern void kvmppc_set_msr(struct kvm_vcpu *vcpu, u64 new_msr); | 126 | extern void kvmppc_set_msr(struct kvm_vcpu *vcpu, u64 new_msr); |
| 121 | extern void kvmppc_set_pvr(struct kvm_vcpu *vcpu, u32 pvr); | ||
| 122 | extern void kvmppc_mmu_book3s_64_init(struct kvm_vcpu *vcpu); | 127 | extern void kvmppc_mmu_book3s_64_init(struct kvm_vcpu *vcpu); |
| 123 | extern void kvmppc_mmu_book3s_32_init(struct kvm_vcpu *vcpu); | 128 | extern void kvmppc_mmu_book3s_32_init(struct kvm_vcpu *vcpu); |
| 124 | extern void kvmppc_mmu_book3s_hv_init(struct kvm_vcpu *vcpu); | 129 | extern void kvmppc_mmu_book3s_hv_init(struct kvm_vcpu *vcpu); |
| 125 | extern int kvmppc_mmu_map_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *pte); | 130 | extern int kvmppc_mmu_map_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *pte, |
| 131 | bool iswrite); | ||
| 132 | extern void kvmppc_mmu_unmap_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *pte); | ||
| 126 | extern int kvmppc_mmu_map_segment(struct kvm_vcpu *vcpu, ulong eaddr); | 133 | extern int kvmppc_mmu_map_segment(struct kvm_vcpu *vcpu, ulong eaddr); |
| 127 | extern void kvmppc_mmu_flush_segment(struct kvm_vcpu *vcpu, ulong eaddr, ulong seg_size); | 134 | extern void kvmppc_mmu_flush_segment(struct kvm_vcpu *vcpu, ulong eaddr, ulong seg_size); |
| 128 | extern void kvmppc_mmu_flush_segments(struct kvm_vcpu *vcpu); | 135 | extern void kvmppc_mmu_flush_segments(struct kvm_vcpu *vcpu); |
| @@ -134,6 +141,7 @@ extern long kvmppc_hv_find_lock_hpte(struct kvm *kvm, gva_t eaddr, | |||
| 134 | 141 | ||
| 135 | extern void kvmppc_mmu_hpte_cache_map(struct kvm_vcpu *vcpu, struct hpte_cache *pte); | 142 | extern void kvmppc_mmu_hpte_cache_map(struct kvm_vcpu *vcpu, struct hpte_cache *pte); |
| 136 | extern struct hpte_cache *kvmppc_mmu_hpte_cache_next(struct kvm_vcpu *vcpu); | 143 | extern struct hpte_cache *kvmppc_mmu_hpte_cache_next(struct kvm_vcpu *vcpu); |
| 144 | extern void kvmppc_mmu_hpte_cache_free(struct hpte_cache *pte); | ||
| 137 | extern void kvmppc_mmu_hpte_destroy(struct kvm_vcpu *vcpu); | 145 | extern void kvmppc_mmu_hpte_destroy(struct kvm_vcpu *vcpu); |
| 138 | extern int kvmppc_mmu_hpte_init(struct kvm_vcpu *vcpu); | 146 | extern int kvmppc_mmu_hpte_init(struct kvm_vcpu *vcpu); |
| 139 | extern void kvmppc_mmu_invalidate_pte(struct kvm_vcpu *vcpu, struct hpte_cache *pte); | 147 | extern void kvmppc_mmu_invalidate_pte(struct kvm_vcpu *vcpu, struct hpte_cache *pte); |
| @@ -151,7 +159,8 @@ extern void kvmppc_set_bat(struct kvm_vcpu *vcpu, struct kvmppc_bat *bat, | |||
| 151 | bool upper, u32 val); | 159 | bool upper, u32 val); |
| 152 | extern void kvmppc_giveup_ext(struct kvm_vcpu *vcpu, ulong msr); | 160 | extern void kvmppc_giveup_ext(struct kvm_vcpu *vcpu, ulong msr); |
| 153 | extern int kvmppc_emulate_paired_single(struct kvm_run *run, struct kvm_vcpu *vcpu); | 161 | extern int kvmppc_emulate_paired_single(struct kvm_run *run, struct kvm_vcpu *vcpu); |
| 154 | extern pfn_t kvmppc_gfn_to_pfn(struct kvm_vcpu *vcpu, gfn_t gfn); | 162 | extern pfn_t kvmppc_gfn_to_pfn(struct kvm_vcpu *vcpu, gfn_t gfn, bool writing, |
| 163 | bool *writable); | ||
| 155 | extern void kvmppc_add_revmap_chain(struct kvm *kvm, struct revmap_entry *rev, | 164 | extern void kvmppc_add_revmap_chain(struct kvm *kvm, struct revmap_entry *rev, |
| 156 | unsigned long *rmap, long pte_index, int realmode); | 165 | unsigned long *rmap, long pte_index, int realmode); |
| 157 | extern void kvmppc_invalidate_hpte(struct kvm *kvm, unsigned long *hptep, | 166 | extern void kvmppc_invalidate_hpte(struct kvm *kvm, unsigned long *hptep, |
| @@ -172,6 +181,8 @@ extern long kvmppc_do_h_remove(struct kvm *kvm, unsigned long flags, | |||
| 172 | unsigned long *hpret); | 181 | unsigned long *hpret); |
| 173 | extern long kvmppc_hv_get_dirty_log(struct kvm *kvm, | 182 | extern long kvmppc_hv_get_dirty_log(struct kvm *kvm, |
| 174 | struct kvm_memory_slot *memslot, unsigned long *map); | 183 | struct kvm_memory_slot *memslot, unsigned long *map); |
| 184 | extern void kvmppc_update_lpcr(struct kvm *kvm, unsigned long lpcr, | ||
| 185 | unsigned long mask); | ||
| 175 | 186 | ||
| 176 | extern void kvmppc_entry_trampoline(void); | 187 | extern void kvmppc_entry_trampoline(void); |
| 177 | extern void kvmppc_hv_entry_trampoline(void); | 188 | extern void kvmppc_hv_entry_trampoline(void); |
| @@ -184,11 +195,9 @@ extern int kvmppc_h_pr(struct kvm_vcpu *vcpu, unsigned long cmd); | |||
| 184 | 195 | ||
| 185 | static inline struct kvmppc_vcpu_book3s *to_book3s(struct kvm_vcpu *vcpu) | 196 | static inline struct kvmppc_vcpu_book3s *to_book3s(struct kvm_vcpu *vcpu) |
| 186 | { | 197 | { |
| 187 | return container_of(vcpu, struct kvmppc_vcpu_book3s, vcpu); | 198 | return vcpu->arch.book3s; |
| 188 | } | 199 | } |
| 189 | 200 | ||
| 190 | extern void kvm_return_point(void); | ||
| 191 | |||
| 192 | /* Also add subarch specific defines */ | 201 | /* Also add subarch specific defines */ |
| 193 | 202 | ||
| 194 | #ifdef CONFIG_KVM_BOOK3S_32_HANDLER | 203 | #ifdef CONFIG_KVM_BOOK3S_32_HANDLER |
| @@ -198,203 +207,6 @@ extern void kvm_return_point(void); | |||
| 198 | #include <asm/kvm_book3s_64.h> | 207 | #include <asm/kvm_book3s_64.h> |
| 199 | #endif | 208 | #endif |
| 200 | 209 | ||
| 201 | #ifdef CONFIG_KVM_BOOK3S_PR | ||
| 202 | |||
| 203 | static inline unsigned long kvmppc_interrupt_offset(struct kvm_vcpu *vcpu) | ||
| 204 | { | ||
| 205 | return to_book3s(vcpu)->hior; | ||
| 206 | } | ||
| 207 | |||
| 208 | static inline void kvmppc_update_int_pending(struct kvm_vcpu *vcpu, | ||
| 209 | unsigned long pending_now, unsigned long old_pending) | ||
| 210 | { | ||
| 211 | if (pending_now) | ||
| 212 | vcpu->arch.shared->int_pending = 1; | ||
| 213 | else if (old_pending) | ||
| 214 | vcpu->arch.shared->int_pending = 0; | ||
| 215 | } | ||
| 216 | |||
| 217 | static inline void kvmppc_set_gpr(struct kvm_vcpu *vcpu, int num, ulong val) | ||
| 218 | { | ||
| 219 | if ( num < 14 ) { | ||
| 220 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 221 | svcpu->gpr[num] = val; | ||
| 222 | svcpu_put(svcpu); | ||
| 223 | to_book3s(vcpu)->shadow_vcpu->gpr[num] = val; | ||
| 224 | } else | ||
| 225 | vcpu->arch.gpr[num] = val; | ||
| 226 | } | ||
| 227 | |||
| 228 | static inline ulong kvmppc_get_gpr(struct kvm_vcpu *vcpu, int num) | ||
| 229 | { | ||
| 230 | if ( num < 14 ) { | ||
| 231 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 232 | ulong r = svcpu->gpr[num]; | ||
| 233 | svcpu_put(svcpu); | ||
| 234 | return r; | ||
| 235 | } else | ||
| 236 | return vcpu->arch.gpr[num]; | ||
| 237 | } | ||
| 238 | |||
| 239 | static inline void kvmppc_set_cr(struct kvm_vcpu *vcpu, u32 val) | ||
| 240 | { | ||
| 241 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 242 | svcpu->cr = val; | ||
| 243 | svcpu_put(svcpu); | ||
| 244 | to_book3s(vcpu)->shadow_vcpu->cr = val; | ||
| 245 | } | ||
| 246 | |||
| 247 | static inline u32 kvmppc_get_cr(struct kvm_vcpu *vcpu) | ||
| 248 | { | ||
| 249 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 250 | u32 r; | ||
| 251 | r = svcpu->cr; | ||
| 252 | svcpu_put(svcpu); | ||
| 253 | return r; | ||
| 254 | } | ||
| 255 | |||
| 256 | static inline void kvmppc_set_xer(struct kvm_vcpu *vcpu, u32 val) | ||
| 257 | { | ||
| 258 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 259 | svcpu->xer = val; | ||
| 260 | to_book3s(vcpu)->shadow_vcpu->xer = val; | ||
| 261 | svcpu_put(svcpu); | ||
| 262 | } | ||
| 263 | |||
| 264 | static inline u32 kvmppc_get_xer(struct kvm_vcpu *vcpu) | ||
| 265 | { | ||
| 266 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 267 | u32 r; | ||
| 268 | r = svcpu->xer; | ||
| 269 | svcpu_put(svcpu); | ||
| 270 | return r; | ||
| 271 | } | ||
| 272 | |||
| 273 | static inline void kvmppc_set_ctr(struct kvm_vcpu *vcpu, ulong val) | ||
| 274 | { | ||
| 275 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 276 | svcpu->ctr = val; | ||
| 277 | svcpu_put(svcpu); | ||
| 278 | } | ||
| 279 | |||
| 280 | static inline ulong kvmppc_get_ctr(struct kvm_vcpu *vcpu) | ||
| 281 | { | ||
| 282 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 283 | ulong r; | ||
| 284 | r = svcpu->ctr; | ||
| 285 | svcpu_put(svcpu); | ||
| 286 | return r; | ||
| 287 | } | ||
| 288 | |||
| 289 | static inline void kvmppc_set_lr(struct kvm_vcpu *vcpu, ulong val) | ||
| 290 | { | ||
| 291 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 292 | svcpu->lr = val; | ||
| 293 | svcpu_put(svcpu); | ||
| 294 | } | ||
| 295 | |||
| 296 | static inline ulong kvmppc_get_lr(struct kvm_vcpu *vcpu) | ||
| 297 | { | ||
| 298 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 299 | ulong r; | ||
| 300 | r = svcpu->lr; | ||
| 301 | svcpu_put(svcpu); | ||
| 302 | return r; | ||
| 303 | } | ||
| 304 | |||
| 305 | static inline void kvmppc_set_pc(struct kvm_vcpu *vcpu, ulong val) | ||
| 306 | { | ||
| 307 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 308 | svcpu->pc = val; | ||
| 309 | svcpu_put(svcpu); | ||
| 310 | } | ||
| 311 | |||
| 312 | static inline ulong kvmppc_get_pc(struct kvm_vcpu *vcpu) | ||
| 313 | { | ||
| 314 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 315 | ulong r; | ||
| 316 | r = svcpu->pc; | ||
| 317 | svcpu_put(svcpu); | ||
| 318 | return r; | ||
| 319 | } | ||
| 320 | |||
| 321 | static inline u32 kvmppc_get_last_inst(struct kvm_vcpu *vcpu) | ||
| 322 | { | ||
| 323 | ulong pc = kvmppc_get_pc(vcpu); | ||
| 324 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 325 | u32 r; | ||
| 326 | |||
| 327 | /* Load the instruction manually if it failed to do so in the | ||
| 328 | * exit path */ | ||
| 329 | if (svcpu->last_inst == KVM_INST_FETCH_FAILED) | ||
| 330 | kvmppc_ld(vcpu, &pc, sizeof(u32), &svcpu->last_inst, false); | ||
| 331 | |||
| 332 | r = svcpu->last_inst; | ||
| 333 | svcpu_put(svcpu); | ||
| 334 | return r; | ||
| 335 | } | ||
| 336 | |||
| 337 | /* | ||
| 338 | * Like kvmppc_get_last_inst(), but for fetching a sc instruction. | ||
| 339 | * Because the sc instruction sets SRR0 to point to the following | ||
| 340 | * instruction, we have to fetch from pc - 4. | ||
| 341 | */ | ||
| 342 | static inline u32 kvmppc_get_last_sc(struct kvm_vcpu *vcpu) | ||
| 343 | { | ||
| 344 | ulong pc = kvmppc_get_pc(vcpu) - 4; | ||
| 345 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 346 | u32 r; | ||
| 347 | |||
| 348 | /* Load the instruction manually if it failed to do so in the | ||
| 349 | * exit path */ | ||
| 350 | if (svcpu->last_inst == KVM_INST_FETCH_FAILED) | ||
| 351 | kvmppc_ld(vcpu, &pc, sizeof(u32), &svcpu->last_inst, false); | ||
| 352 | |||
| 353 | r = svcpu->last_inst; | ||
| 354 | svcpu_put(svcpu); | ||
| 355 | return r; | ||
| 356 | } | ||
| 357 | |||
| 358 | static inline ulong kvmppc_get_fault_dar(struct kvm_vcpu *vcpu) | ||
| 359 | { | ||
| 360 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 361 | ulong r; | ||
| 362 | r = svcpu->fault_dar; | ||
| 363 | svcpu_put(svcpu); | ||
| 364 | return r; | ||
| 365 | } | ||
| 366 | |||
| 367 | static inline bool kvmppc_critical_section(struct kvm_vcpu *vcpu) | ||
| 368 | { | ||
| 369 | ulong crit_raw = vcpu->arch.shared->critical; | ||
| 370 | ulong crit_r1 = kvmppc_get_gpr(vcpu, 1); | ||
| 371 | bool crit; | ||
| 372 | |||
| 373 | /* Truncate crit indicators in 32 bit mode */ | ||
| 374 | if (!(vcpu->arch.shared->msr & MSR_SF)) { | ||
| 375 | crit_raw &= 0xffffffff; | ||
| 376 | crit_r1 &= 0xffffffff; | ||
| 377 | } | ||
| 378 | |||
| 379 | /* Critical section when crit == r1 */ | ||
| 380 | crit = (crit_raw == crit_r1); | ||
| 381 | /* ... and we're in supervisor mode */ | ||
| 382 | crit = crit && !(vcpu->arch.shared->msr & MSR_PR); | ||
| 383 | |||
| 384 | return crit; | ||
| 385 | } | ||
| 386 | #else /* CONFIG_KVM_BOOK3S_PR */ | ||
| 387 | |||
| 388 | static inline unsigned long kvmppc_interrupt_offset(struct kvm_vcpu *vcpu) | ||
| 389 | { | ||
| 390 | return 0; | ||
| 391 | } | ||
| 392 | |||
| 393 | static inline void kvmppc_update_int_pending(struct kvm_vcpu *vcpu, | ||
| 394 | unsigned long pending_now, unsigned long old_pending) | ||
| 395 | { | ||
| 396 | } | ||
| 397 | |||
| 398 | static inline void kvmppc_set_gpr(struct kvm_vcpu *vcpu, int num, ulong val) | 210 | static inline void kvmppc_set_gpr(struct kvm_vcpu *vcpu, int num, ulong val) |
| 399 | { | 211 | { |
| 400 | vcpu->arch.gpr[num] = val; | 212 | vcpu->arch.gpr[num] = val; |
| @@ -489,12 +301,6 @@ static inline ulong kvmppc_get_fault_dar(struct kvm_vcpu *vcpu) | |||
| 489 | return vcpu->arch.fault_dar; | 301 | return vcpu->arch.fault_dar; |
| 490 | } | 302 | } |
| 491 | 303 | ||
| 492 | static inline bool kvmppc_critical_section(struct kvm_vcpu *vcpu) | ||
| 493 | { | ||
| 494 | return false; | ||
| 495 | } | ||
| 496 | #endif | ||
| 497 | |||
| 498 | /* Magic register values loaded into r3 and r4 before the 'sc' assembly | 304 | /* Magic register values loaded into r3 and r4 before the 'sc' assembly |
| 499 | * instruction for the OSI hypercalls */ | 305 | * instruction for the OSI hypercalls */ |
| 500 | #define OSI_SC_MAGIC_R3 0x113724FA | 306 | #define OSI_SC_MAGIC_R3 0x113724FA |
diff --git a/arch/powerpc/include/asm/kvm_book3s_32.h b/arch/powerpc/include/asm/kvm_book3s_32.h index ce0ef6ce8f86..c720e0b3238d 100644 --- a/arch/powerpc/include/asm/kvm_book3s_32.h +++ b/arch/powerpc/include/asm/kvm_book3s_32.h | |||
| @@ -22,7 +22,7 @@ | |||
| 22 | 22 | ||
| 23 | static inline struct kvmppc_book3s_shadow_vcpu *svcpu_get(struct kvm_vcpu *vcpu) | 23 | static inline struct kvmppc_book3s_shadow_vcpu *svcpu_get(struct kvm_vcpu *vcpu) |
| 24 | { | 24 | { |
| 25 | return to_book3s(vcpu)->shadow_vcpu; | 25 | return vcpu->arch.shadow_vcpu; |
| 26 | } | 26 | } |
| 27 | 27 | ||
| 28 | static inline void svcpu_put(struct kvmppc_book3s_shadow_vcpu *svcpu) | 28 | static inline void svcpu_put(struct kvmppc_book3s_shadow_vcpu *svcpu) |
diff --git a/arch/powerpc/include/asm/kvm_book3s_64.h b/arch/powerpc/include/asm/kvm_book3s_64.h index 86d638a3b359..bf0fa8b0a883 100644 --- a/arch/powerpc/include/asm/kvm_book3s_64.h +++ b/arch/powerpc/include/asm/kvm_book3s_64.h | |||
| @@ -20,7 +20,7 @@ | |||
| 20 | #ifndef __ASM_KVM_BOOK3S_64_H__ | 20 | #ifndef __ASM_KVM_BOOK3S_64_H__ |
| 21 | #define __ASM_KVM_BOOK3S_64_H__ | 21 | #define __ASM_KVM_BOOK3S_64_H__ |
| 22 | 22 | ||
| 23 | #ifdef CONFIG_KVM_BOOK3S_PR | 23 | #ifdef CONFIG_KVM_BOOK3S_PR_POSSIBLE |
| 24 | static inline struct kvmppc_book3s_shadow_vcpu *svcpu_get(struct kvm_vcpu *vcpu) | 24 | static inline struct kvmppc_book3s_shadow_vcpu *svcpu_get(struct kvm_vcpu *vcpu) |
| 25 | { | 25 | { |
| 26 | preempt_disable(); | 26 | preempt_disable(); |
| @@ -35,7 +35,7 @@ static inline void svcpu_put(struct kvmppc_book3s_shadow_vcpu *svcpu) | |||
| 35 | 35 | ||
| 36 | #define SPAPR_TCE_SHIFT 12 | 36 | #define SPAPR_TCE_SHIFT 12 |
| 37 | 37 | ||
| 38 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 38 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE |
| 39 | #define KVM_DEFAULT_HPT_ORDER 24 /* 16MB HPT by default */ | 39 | #define KVM_DEFAULT_HPT_ORDER 24 /* 16MB HPT by default */ |
| 40 | extern unsigned long kvm_rma_pages; | 40 | extern unsigned long kvm_rma_pages; |
| 41 | #endif | 41 | #endif |
| @@ -278,7 +278,7 @@ static inline int is_vrma_hpte(unsigned long hpte_v) | |||
| 278 | (HPTE_V_1TB_SEG | (VRMA_VSID << (40 - 16))); | 278 | (HPTE_V_1TB_SEG | (VRMA_VSID << (40 - 16))); |
| 279 | } | 279 | } |
| 280 | 280 | ||
| 281 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 281 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE |
| 282 | /* | 282 | /* |
| 283 | * Note modification of an HPTE; set the HPTE modified bit | 283 | * Note modification of an HPTE; set the HPTE modified bit |
| 284 | * if anyone is interested. | 284 | * if anyone is interested. |
| @@ -289,6 +289,6 @@ static inline void note_hpte_modification(struct kvm *kvm, | |||
| 289 | if (atomic_read(&kvm->arch.hpte_mod_interest)) | 289 | if (atomic_read(&kvm->arch.hpte_mod_interest)) |
| 290 | rev->guest_rpte |= HPTE_GR_MODIFIED; | 290 | rev->guest_rpte |= HPTE_GR_MODIFIED; |
| 291 | } | 291 | } |
| 292 | #endif /* CONFIG_KVM_BOOK3S_64_HV */ | 292 | #endif /* CONFIG_KVM_BOOK3S_HV_POSSIBLE */ |
| 293 | 293 | ||
| 294 | #endif /* __ASM_KVM_BOOK3S_64_H__ */ | 294 | #endif /* __ASM_KVM_BOOK3S_64_H__ */ |
diff --git a/arch/powerpc/include/asm/kvm_book3s_asm.h b/arch/powerpc/include/asm/kvm_book3s_asm.h index 9039d3c97eec..0bd9348a4db9 100644 --- a/arch/powerpc/include/asm/kvm_book3s_asm.h +++ b/arch/powerpc/include/asm/kvm_book3s_asm.h | |||
| @@ -83,7 +83,7 @@ struct kvmppc_host_state { | |||
| 83 | u8 restore_hid5; | 83 | u8 restore_hid5; |
| 84 | u8 napping; | 84 | u8 napping; |
| 85 | 85 | ||
| 86 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 86 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE |
| 87 | u8 hwthread_req; | 87 | u8 hwthread_req; |
| 88 | u8 hwthread_state; | 88 | u8 hwthread_state; |
| 89 | u8 host_ipi; | 89 | u8 host_ipi; |
| @@ -101,6 +101,7 @@ struct kvmppc_host_state { | |||
| 101 | #endif | 101 | #endif |
| 102 | #ifdef CONFIG_PPC_BOOK3S_64 | 102 | #ifdef CONFIG_PPC_BOOK3S_64 |
| 103 | u64 cfar; | 103 | u64 cfar; |
| 104 | u64 ppr; | ||
| 104 | #endif | 105 | #endif |
| 105 | }; | 106 | }; |
| 106 | 107 | ||
| @@ -108,14 +109,14 @@ struct kvmppc_book3s_shadow_vcpu { | |||
| 108 | ulong gpr[14]; | 109 | ulong gpr[14]; |
| 109 | u32 cr; | 110 | u32 cr; |
| 110 | u32 xer; | 111 | u32 xer; |
| 111 | |||
| 112 | u32 fault_dsisr; | ||
| 113 | u32 last_inst; | ||
| 114 | ulong ctr; | 112 | ulong ctr; |
| 115 | ulong lr; | 113 | ulong lr; |
| 116 | ulong pc; | 114 | ulong pc; |
| 115 | |||
| 117 | ulong shadow_srr1; | 116 | ulong shadow_srr1; |
| 118 | ulong fault_dar; | 117 | ulong fault_dar; |
| 118 | u32 fault_dsisr; | ||
| 119 | u32 last_inst; | ||
| 119 | 120 | ||
| 120 | #ifdef CONFIG_PPC_BOOK3S_32 | 121 | #ifdef CONFIG_PPC_BOOK3S_32 |
| 121 | u32 sr[16]; /* Guest SRs */ | 122 | u32 sr[16]; /* Guest SRs */ |
diff --git a/arch/powerpc/include/asm/kvm_booke.h b/arch/powerpc/include/asm/kvm_booke.h index d3c1eb34c986..dd8f61510dfd 100644 --- a/arch/powerpc/include/asm/kvm_booke.h +++ b/arch/powerpc/include/asm/kvm_booke.h | |||
| @@ -26,7 +26,12 @@ | |||
| 26 | /* LPIDs we support with this build -- runtime limit may be lower */ | 26 | /* LPIDs we support with this build -- runtime limit may be lower */ |
| 27 | #define KVMPPC_NR_LPIDS 64 | 27 | #define KVMPPC_NR_LPIDS 64 |
| 28 | 28 | ||
| 29 | #define KVMPPC_INST_EHPRIV 0x7c00021c | 29 | #define KVMPPC_INST_EHPRIV 0x7c00021c |
| 30 | #define EHPRIV_OC_SHIFT 11 | ||
| 31 | /* "ehpriv 1" : ehpriv with OC = 1 is used for debug emulation */ | ||
| 32 | #define EHPRIV_OC_DEBUG 1 | ||
| 33 | #define KVMPPC_INST_EHPRIV_DEBUG (KVMPPC_INST_EHPRIV | \ | ||
| 34 | (EHPRIV_OC_DEBUG << EHPRIV_OC_SHIFT)) | ||
| 30 | 35 | ||
| 31 | static inline void kvmppc_set_gpr(struct kvm_vcpu *vcpu, int num, ulong val) | 36 | static inline void kvmppc_set_gpr(struct kvm_vcpu *vcpu, int num, ulong val) |
| 32 | { | 37 | { |
diff --git a/arch/powerpc/include/asm/kvm_host.h b/arch/powerpc/include/asm/kvm_host.h index 33283532e9d8..237d1d25b448 100644 --- a/arch/powerpc/include/asm/kvm_host.h +++ b/arch/powerpc/include/asm/kvm_host.h | |||
| @@ -63,20 +63,17 @@ extern void kvm_set_spte_hva(struct kvm *kvm, unsigned long hva, pte_t pte); | |||
| 63 | 63 | ||
| 64 | #endif | 64 | #endif |
| 65 | 65 | ||
| 66 | /* We don't currently support large pages. */ | ||
| 67 | #define KVM_HPAGE_GFN_SHIFT(x) 0 | ||
| 68 | #define KVM_NR_PAGE_SIZES 1 | ||
| 69 | #define KVM_PAGES_PER_HPAGE(x) (1UL<<31) | ||
| 70 | |||
| 71 | #define HPTEG_CACHE_NUM (1 << 15) | 66 | #define HPTEG_CACHE_NUM (1 << 15) |
| 72 | #define HPTEG_HASH_BITS_PTE 13 | 67 | #define HPTEG_HASH_BITS_PTE 13 |
| 73 | #define HPTEG_HASH_BITS_PTE_LONG 12 | 68 | #define HPTEG_HASH_BITS_PTE_LONG 12 |
| 74 | #define HPTEG_HASH_BITS_VPTE 13 | 69 | #define HPTEG_HASH_BITS_VPTE 13 |
| 75 | #define HPTEG_HASH_BITS_VPTE_LONG 5 | 70 | #define HPTEG_HASH_BITS_VPTE_LONG 5 |
| 71 | #define HPTEG_HASH_BITS_VPTE_64K 11 | ||
| 76 | #define HPTEG_HASH_NUM_PTE (1 << HPTEG_HASH_BITS_PTE) | 72 | #define HPTEG_HASH_NUM_PTE (1 << HPTEG_HASH_BITS_PTE) |
| 77 | #define HPTEG_HASH_NUM_PTE_LONG (1 << HPTEG_HASH_BITS_PTE_LONG) | 73 | #define HPTEG_HASH_NUM_PTE_LONG (1 << HPTEG_HASH_BITS_PTE_LONG) |
| 78 | #define HPTEG_HASH_NUM_VPTE (1 << HPTEG_HASH_BITS_VPTE) | 74 | #define HPTEG_HASH_NUM_VPTE (1 << HPTEG_HASH_BITS_VPTE) |
| 79 | #define HPTEG_HASH_NUM_VPTE_LONG (1 << HPTEG_HASH_BITS_VPTE_LONG) | 75 | #define HPTEG_HASH_NUM_VPTE_LONG (1 << HPTEG_HASH_BITS_VPTE_LONG) |
| 76 | #define HPTEG_HASH_NUM_VPTE_64K (1 << HPTEG_HASH_BITS_VPTE_64K) | ||
| 80 | 77 | ||
| 81 | /* Physical Address Mask - allowed range of real mode RAM access */ | 78 | /* Physical Address Mask - allowed range of real mode RAM access */ |
| 82 | #define KVM_PAM 0x0fffffffffffffffULL | 79 | #define KVM_PAM 0x0fffffffffffffffULL |
| @@ -89,6 +86,9 @@ struct lppaca; | |||
| 89 | struct slb_shadow; | 86 | struct slb_shadow; |
| 90 | struct dtl_entry; | 87 | struct dtl_entry; |
| 91 | 88 | ||
| 89 | struct kvmppc_vcpu_book3s; | ||
| 90 | struct kvmppc_book3s_shadow_vcpu; | ||
| 91 | |||
| 92 | struct kvm_vm_stat { | 92 | struct kvm_vm_stat { |
| 93 | u32 remote_tlb_flush; | 93 | u32 remote_tlb_flush; |
| 94 | }; | 94 | }; |
| @@ -224,15 +224,15 @@ struct revmap_entry { | |||
| 224 | #define KVMPPC_GOT_PAGE 0x80 | 224 | #define KVMPPC_GOT_PAGE 0x80 |
| 225 | 225 | ||
| 226 | struct kvm_arch_memory_slot { | 226 | struct kvm_arch_memory_slot { |
| 227 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 227 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE |
| 228 | unsigned long *rmap; | 228 | unsigned long *rmap; |
| 229 | unsigned long *slot_phys; | 229 | unsigned long *slot_phys; |
| 230 | #endif /* CONFIG_KVM_BOOK3S_64_HV */ | 230 | #endif /* CONFIG_KVM_BOOK3S_HV_POSSIBLE */ |
| 231 | }; | 231 | }; |
| 232 | 232 | ||
| 233 | struct kvm_arch { | 233 | struct kvm_arch { |
| 234 | unsigned int lpid; | 234 | unsigned int lpid; |
| 235 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 235 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE |
| 236 | unsigned long hpt_virt; | 236 | unsigned long hpt_virt; |
| 237 | struct revmap_entry *revmap; | 237 | struct revmap_entry *revmap; |
| 238 | unsigned int host_lpid; | 238 | unsigned int host_lpid; |
| @@ -256,7 +256,10 @@ struct kvm_arch { | |||
| 256 | cpumask_t need_tlb_flush; | 256 | cpumask_t need_tlb_flush; |
| 257 | struct kvmppc_vcore *vcores[KVM_MAX_VCORES]; | 257 | struct kvmppc_vcore *vcores[KVM_MAX_VCORES]; |
| 258 | int hpt_cma_alloc; | 258 | int hpt_cma_alloc; |
| 259 | #endif /* CONFIG_KVM_BOOK3S_64_HV */ | 259 | #endif /* CONFIG_KVM_BOOK3S_HV_POSSIBLE */ |
| 260 | #ifdef CONFIG_KVM_BOOK3S_PR_POSSIBLE | ||
| 261 | struct mutex hpt_mutex; | ||
| 262 | #endif | ||
| 260 | #ifdef CONFIG_PPC_BOOK3S_64 | 263 | #ifdef CONFIG_PPC_BOOK3S_64 |
| 261 | struct list_head spapr_tce_tables; | 264 | struct list_head spapr_tce_tables; |
| 262 | struct list_head rtas_tokens; | 265 | struct list_head rtas_tokens; |
| @@ -267,6 +270,7 @@ struct kvm_arch { | |||
| 267 | #ifdef CONFIG_KVM_XICS | 270 | #ifdef CONFIG_KVM_XICS |
| 268 | struct kvmppc_xics *xics; | 271 | struct kvmppc_xics *xics; |
| 269 | #endif | 272 | #endif |
| 273 | struct kvmppc_ops *kvm_ops; | ||
| 270 | }; | 274 | }; |
| 271 | 275 | ||
| 272 | /* | 276 | /* |
| @@ -294,6 +298,10 @@ struct kvmppc_vcore { | |||
| 294 | u64 stolen_tb; | 298 | u64 stolen_tb; |
| 295 | u64 preempt_tb; | 299 | u64 preempt_tb; |
| 296 | struct kvm_vcpu *runner; | 300 | struct kvm_vcpu *runner; |
| 301 | u64 tb_offset; /* guest timebase - host timebase */ | ||
| 302 | ulong lpcr; | ||
| 303 | u32 arch_compat; | ||
| 304 | ulong pcr; | ||
| 297 | }; | 305 | }; |
| 298 | 306 | ||
| 299 | #define VCORE_ENTRY_COUNT(vc) ((vc)->entry_exit_count & 0xff) | 307 | #define VCORE_ENTRY_COUNT(vc) ((vc)->entry_exit_count & 0xff) |
| @@ -328,6 +336,7 @@ struct kvmppc_pte { | |||
| 328 | bool may_read : 1; | 336 | bool may_read : 1; |
| 329 | bool may_write : 1; | 337 | bool may_write : 1; |
| 330 | bool may_execute : 1; | 338 | bool may_execute : 1; |
| 339 | u8 page_size; /* MMU_PAGE_xxx */ | ||
| 331 | }; | 340 | }; |
| 332 | 341 | ||
| 333 | struct kvmppc_mmu { | 342 | struct kvmppc_mmu { |
| @@ -340,7 +349,8 @@ struct kvmppc_mmu { | |||
| 340 | /* book3s */ | 349 | /* book3s */ |
| 341 | void (*mtsrin)(struct kvm_vcpu *vcpu, u32 srnum, ulong value); | 350 | void (*mtsrin)(struct kvm_vcpu *vcpu, u32 srnum, ulong value); |
| 342 | u32 (*mfsrin)(struct kvm_vcpu *vcpu, u32 srnum); | 351 | u32 (*mfsrin)(struct kvm_vcpu *vcpu, u32 srnum); |
| 343 | int (*xlate)(struct kvm_vcpu *vcpu, gva_t eaddr, struct kvmppc_pte *pte, bool data); | 352 | int (*xlate)(struct kvm_vcpu *vcpu, gva_t eaddr, |
| 353 | struct kvmppc_pte *pte, bool data, bool iswrite); | ||
| 344 | void (*reset_msr)(struct kvm_vcpu *vcpu); | 354 | void (*reset_msr)(struct kvm_vcpu *vcpu); |
| 345 | void (*tlbie)(struct kvm_vcpu *vcpu, ulong addr, bool large); | 355 | void (*tlbie)(struct kvm_vcpu *vcpu, ulong addr, bool large); |
| 346 | int (*esid_to_vsid)(struct kvm_vcpu *vcpu, ulong esid, u64 *vsid); | 356 | int (*esid_to_vsid)(struct kvm_vcpu *vcpu, ulong esid, u64 *vsid); |
| @@ -360,6 +370,7 @@ struct kvmppc_slb { | |||
| 360 | bool large : 1; /* PTEs are 16MB */ | 370 | bool large : 1; /* PTEs are 16MB */ |
| 361 | bool tb : 1; /* 1TB segment */ | 371 | bool tb : 1; /* 1TB segment */ |
| 362 | bool class : 1; | 372 | bool class : 1; |
| 373 | u8 base_page_size; /* MMU_PAGE_xxx */ | ||
| 363 | }; | 374 | }; |
| 364 | 375 | ||
| 365 | # ifdef CONFIG_PPC_FSL_BOOK3E | 376 | # ifdef CONFIG_PPC_FSL_BOOK3E |
| @@ -377,17 +388,6 @@ struct kvmppc_slb { | |||
| 377 | #define KVMPPC_EPR_USER 1 /* exit to userspace to fill EPR */ | 388 | #define KVMPPC_EPR_USER 1 /* exit to userspace to fill EPR */ |
| 378 | #define KVMPPC_EPR_KERNEL 2 /* in-kernel irqchip */ | 389 | #define KVMPPC_EPR_KERNEL 2 /* in-kernel irqchip */ |
| 379 | 390 | ||
| 380 | struct kvmppc_booke_debug_reg { | ||
| 381 | u32 dbcr0; | ||
| 382 | u32 dbcr1; | ||
| 383 | u32 dbcr2; | ||
| 384 | #ifdef CONFIG_KVM_E500MC | ||
| 385 | u32 dbcr4; | ||
| 386 | #endif | ||
| 387 | u64 iac[KVMPPC_BOOKE_MAX_IAC]; | ||
| 388 | u64 dac[KVMPPC_BOOKE_MAX_DAC]; | ||
| 389 | }; | ||
| 390 | |||
| 391 | #define KVMPPC_IRQ_DEFAULT 0 | 391 | #define KVMPPC_IRQ_DEFAULT 0 |
| 392 | #define KVMPPC_IRQ_MPIC 1 | 392 | #define KVMPPC_IRQ_MPIC 1 |
| 393 | #define KVMPPC_IRQ_XICS 2 | 393 | #define KVMPPC_IRQ_XICS 2 |
| @@ -402,6 +402,10 @@ struct kvm_vcpu_arch { | |||
| 402 | int slb_max; /* 1 + index of last valid entry in slb[] */ | 402 | int slb_max; /* 1 + index of last valid entry in slb[] */ |
| 403 | int slb_nr; /* total number of entries in SLB */ | 403 | int slb_nr; /* total number of entries in SLB */ |
| 404 | struct kvmppc_mmu mmu; | 404 | struct kvmppc_mmu mmu; |
| 405 | struct kvmppc_vcpu_book3s *book3s; | ||
| 406 | #endif | ||
| 407 | #ifdef CONFIG_PPC_BOOK3S_32 | ||
| 408 | struct kvmppc_book3s_shadow_vcpu *shadow_vcpu; | ||
| 405 | #endif | 409 | #endif |
| 406 | 410 | ||
| 407 | ulong gpr[32]; | 411 | ulong gpr[32]; |
| @@ -463,6 +467,8 @@ struct kvm_vcpu_arch { | |||
| 463 | u32 ctrl; | 467 | u32 ctrl; |
| 464 | ulong dabr; | 468 | ulong dabr; |
| 465 | ulong cfar; | 469 | ulong cfar; |
| 470 | ulong ppr; | ||
| 471 | ulong shadow_srr1; | ||
| 466 | #endif | 472 | #endif |
| 467 | u32 vrsave; /* also USPRG0 */ | 473 | u32 vrsave; /* also USPRG0 */ |
| 468 | u32 mmucr; | 474 | u32 mmucr; |
| @@ -498,6 +504,8 @@ struct kvm_vcpu_arch { | |||
| 498 | 504 | ||
| 499 | u64 mmcr[3]; | 505 | u64 mmcr[3]; |
| 500 | u32 pmc[8]; | 506 | u32 pmc[8]; |
| 507 | u64 siar; | ||
| 508 | u64 sdar; | ||
| 501 | 509 | ||
| 502 | #ifdef CONFIG_KVM_EXIT_TIMING | 510 | #ifdef CONFIG_KVM_EXIT_TIMING |
| 503 | struct mutex exit_timing_lock; | 511 | struct mutex exit_timing_lock; |
| @@ -531,7 +539,10 @@ struct kvm_vcpu_arch { | |||
| 531 | u32 eptcfg; | 539 | u32 eptcfg; |
| 532 | u32 epr; | 540 | u32 epr; |
| 533 | u32 crit_save; | 541 | u32 crit_save; |
| 534 | struct kvmppc_booke_debug_reg dbg_reg; | 542 | /* guest debug registers*/ |
| 543 | struct debug_reg dbg_reg; | ||
| 544 | /* hardware visible debug registers when in guest state */ | ||
| 545 | struct debug_reg shadow_dbg_reg; | ||
| 535 | #endif | 546 | #endif |
| 536 | gpa_t paddr_accessed; | 547 | gpa_t paddr_accessed; |
| 537 | gva_t vaddr_accessed; | 548 | gva_t vaddr_accessed; |
| @@ -582,7 +593,7 @@ struct kvm_vcpu_arch { | |||
| 582 | struct kvmppc_icp *icp; /* XICS presentation controller */ | 593 | struct kvmppc_icp *icp; /* XICS presentation controller */ |
| 583 | #endif | 594 | #endif |
| 584 | 595 | ||
| 585 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 596 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE |
| 586 | struct kvm_vcpu_arch_shared shregs; | 597 | struct kvm_vcpu_arch_shared shregs; |
| 587 | 598 | ||
| 588 | unsigned long pgfault_addr; | 599 | unsigned long pgfault_addr; |
diff --git a/arch/powerpc/include/asm/kvm_ppc.h b/arch/powerpc/include/asm/kvm_ppc.h index b15554a26c20..c8317fbf92c4 100644 --- a/arch/powerpc/include/asm/kvm_ppc.h +++ b/arch/powerpc/include/asm/kvm_ppc.h | |||
| @@ -106,13 +106,6 @@ extern void kvmppc_core_queue_external(struct kvm_vcpu *vcpu, | |||
| 106 | struct kvm_interrupt *irq); | 106 | struct kvm_interrupt *irq); |
| 107 | extern void kvmppc_core_dequeue_external(struct kvm_vcpu *vcpu); | 107 | extern void kvmppc_core_dequeue_external(struct kvm_vcpu *vcpu); |
| 108 | extern void kvmppc_core_flush_tlb(struct kvm_vcpu *vcpu); | 108 | extern void kvmppc_core_flush_tlb(struct kvm_vcpu *vcpu); |
| 109 | |||
| 110 | extern int kvmppc_core_emulate_op(struct kvm_run *run, struct kvm_vcpu *vcpu, | ||
| 111 | unsigned int op, int *advance); | ||
| 112 | extern int kvmppc_core_emulate_mtspr(struct kvm_vcpu *vcpu, int sprn, | ||
| 113 | ulong val); | ||
| 114 | extern int kvmppc_core_emulate_mfspr(struct kvm_vcpu *vcpu, int sprn, | ||
| 115 | ulong *val); | ||
| 116 | extern int kvmppc_core_check_requests(struct kvm_vcpu *vcpu); | 109 | extern int kvmppc_core_check_requests(struct kvm_vcpu *vcpu); |
| 117 | 110 | ||
| 118 | extern int kvmppc_booke_init(void); | 111 | extern int kvmppc_booke_init(void); |
| @@ -135,17 +128,17 @@ extern long kvm_vm_ioctl_create_spapr_tce(struct kvm *kvm, | |||
| 135 | struct kvm_create_spapr_tce *args); | 128 | struct kvm_create_spapr_tce *args); |
| 136 | extern long kvmppc_h_put_tce(struct kvm_vcpu *vcpu, unsigned long liobn, | 129 | extern long kvmppc_h_put_tce(struct kvm_vcpu *vcpu, unsigned long liobn, |
| 137 | unsigned long ioba, unsigned long tce); | 130 | unsigned long ioba, unsigned long tce); |
| 138 | extern long kvm_vm_ioctl_allocate_rma(struct kvm *kvm, | ||
| 139 | struct kvm_allocate_rma *rma); | ||
| 140 | extern struct kvm_rma_info *kvm_alloc_rma(void); | 131 | extern struct kvm_rma_info *kvm_alloc_rma(void); |
| 141 | extern void kvm_release_rma(struct kvm_rma_info *ri); | 132 | extern void kvm_release_rma(struct kvm_rma_info *ri); |
| 142 | extern struct page *kvm_alloc_hpt(unsigned long nr_pages); | 133 | extern struct page *kvm_alloc_hpt(unsigned long nr_pages); |
| 143 | extern void kvm_release_hpt(struct page *page, unsigned long nr_pages); | 134 | extern void kvm_release_hpt(struct page *page, unsigned long nr_pages); |
| 144 | extern int kvmppc_core_init_vm(struct kvm *kvm); | 135 | extern int kvmppc_core_init_vm(struct kvm *kvm); |
| 145 | extern void kvmppc_core_destroy_vm(struct kvm *kvm); | 136 | extern void kvmppc_core_destroy_vm(struct kvm *kvm); |
| 146 | extern void kvmppc_core_free_memslot(struct kvm_memory_slot *free, | 137 | extern void kvmppc_core_free_memslot(struct kvm *kvm, |
| 138 | struct kvm_memory_slot *free, | ||
| 147 | struct kvm_memory_slot *dont); | 139 | struct kvm_memory_slot *dont); |
| 148 | extern int kvmppc_core_create_memslot(struct kvm_memory_slot *slot, | 140 | extern int kvmppc_core_create_memslot(struct kvm *kvm, |
| 141 | struct kvm_memory_slot *slot, | ||
| 149 | unsigned long npages); | 142 | unsigned long npages); |
| 150 | extern int kvmppc_core_prepare_memory_region(struct kvm *kvm, | 143 | extern int kvmppc_core_prepare_memory_region(struct kvm *kvm, |
| 151 | struct kvm_memory_slot *memslot, | 144 | struct kvm_memory_slot *memslot, |
| @@ -177,6 +170,72 @@ extern int kvmppc_xics_get_xive(struct kvm *kvm, u32 irq, u32 *server, | |||
| 177 | extern int kvmppc_xics_int_on(struct kvm *kvm, u32 irq); | 170 | extern int kvmppc_xics_int_on(struct kvm *kvm, u32 irq); |
| 178 | extern int kvmppc_xics_int_off(struct kvm *kvm, u32 irq); | 171 | extern int kvmppc_xics_int_off(struct kvm *kvm, u32 irq); |
| 179 | 172 | ||
| 173 | union kvmppc_one_reg { | ||
| 174 | u32 wval; | ||
| 175 | u64 dval; | ||
| 176 | vector128 vval; | ||
| 177 | u64 vsxval[2]; | ||
| 178 | struct { | ||
| 179 | u64 addr; | ||
| 180 | u64 length; | ||
| 181 | } vpaval; | ||
| 182 | }; | ||
| 183 | |||
| 184 | struct kvmppc_ops { | ||
| 185 | struct module *owner; | ||
| 186 | int (*get_sregs)(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs); | ||
| 187 | int (*set_sregs)(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs); | ||
| 188 | int (*get_one_reg)(struct kvm_vcpu *vcpu, u64 id, | ||
| 189 | union kvmppc_one_reg *val); | ||
| 190 | int (*set_one_reg)(struct kvm_vcpu *vcpu, u64 id, | ||
| 191 | union kvmppc_one_reg *val); | ||
| 192 | void (*vcpu_load)(struct kvm_vcpu *vcpu, int cpu); | ||
| 193 | void (*vcpu_put)(struct kvm_vcpu *vcpu); | ||
| 194 | void (*set_msr)(struct kvm_vcpu *vcpu, u64 msr); | ||
| 195 | int (*vcpu_run)(struct kvm_run *run, struct kvm_vcpu *vcpu); | ||
| 196 | struct kvm_vcpu *(*vcpu_create)(struct kvm *kvm, unsigned int id); | ||
| 197 | void (*vcpu_free)(struct kvm_vcpu *vcpu); | ||
| 198 | int (*check_requests)(struct kvm_vcpu *vcpu); | ||
| 199 | int (*get_dirty_log)(struct kvm *kvm, struct kvm_dirty_log *log); | ||
| 200 | void (*flush_memslot)(struct kvm *kvm, struct kvm_memory_slot *memslot); | ||
| 201 | int (*prepare_memory_region)(struct kvm *kvm, | ||
| 202 | struct kvm_memory_slot *memslot, | ||
| 203 | struct kvm_userspace_memory_region *mem); | ||
| 204 | void (*commit_memory_region)(struct kvm *kvm, | ||
| 205 | struct kvm_userspace_memory_region *mem, | ||
| 206 | const struct kvm_memory_slot *old); | ||
| 207 | int (*unmap_hva)(struct kvm *kvm, unsigned long hva); | ||
| 208 | int (*unmap_hva_range)(struct kvm *kvm, unsigned long start, | ||
| 209 | unsigned long end); | ||
| 210 | int (*age_hva)(struct kvm *kvm, unsigned long hva); | ||
| 211 | int (*test_age_hva)(struct kvm *kvm, unsigned long hva); | ||
| 212 | void (*set_spte_hva)(struct kvm *kvm, unsigned long hva, pte_t pte); | ||
| 213 | void (*mmu_destroy)(struct kvm_vcpu *vcpu); | ||
| 214 | void (*free_memslot)(struct kvm_memory_slot *free, | ||
| 215 | struct kvm_memory_slot *dont); | ||
| 216 | int (*create_memslot)(struct kvm_memory_slot *slot, | ||
| 217 | unsigned long npages); | ||
| 218 | int (*init_vm)(struct kvm *kvm); | ||
| 219 | void (*destroy_vm)(struct kvm *kvm); | ||
| 220 | int (*get_smmu_info)(struct kvm *kvm, struct kvm_ppc_smmu_info *info); | ||
| 221 | int (*emulate_op)(struct kvm_run *run, struct kvm_vcpu *vcpu, | ||
| 222 | unsigned int inst, int *advance); | ||
| 223 | int (*emulate_mtspr)(struct kvm_vcpu *vcpu, int sprn, ulong spr_val); | ||
| 224 | int (*emulate_mfspr)(struct kvm_vcpu *vcpu, int sprn, ulong *spr_val); | ||
| 225 | void (*fast_vcpu_kick)(struct kvm_vcpu *vcpu); | ||
| 226 | long (*arch_vm_ioctl)(struct file *filp, unsigned int ioctl, | ||
| 227 | unsigned long arg); | ||
| 228 | |||
| 229 | }; | ||
| 230 | |||
| 231 | extern struct kvmppc_ops *kvmppc_hv_ops; | ||
| 232 | extern struct kvmppc_ops *kvmppc_pr_ops; | ||
| 233 | |||
| 234 | static inline bool is_kvmppc_hv_enabled(struct kvm *kvm) | ||
| 235 | { | ||
| 236 | return kvm->arch.kvm_ops == kvmppc_hv_ops; | ||
| 237 | } | ||
| 238 | |||
| 180 | /* | 239 | /* |
| 181 | * Cuts out inst bits with ordering according to spec. | 240 | * Cuts out inst bits with ordering according to spec. |
| 182 | * That means the leftmost bit is zero. All given bits are included. | 241 | * That means the leftmost bit is zero. All given bits are included. |
| @@ -210,17 +269,6 @@ static inline u32 kvmppc_set_field(u64 inst, int msb, int lsb, int value) | |||
| 210 | return r; | 269 | return r; |
| 211 | } | 270 | } |
| 212 | 271 | ||
| 213 | union kvmppc_one_reg { | ||
| 214 | u32 wval; | ||
| 215 | u64 dval; | ||
| 216 | vector128 vval; | ||
| 217 | u64 vsxval[2]; | ||
| 218 | struct { | ||
| 219 | u64 addr; | ||
| 220 | u64 length; | ||
| 221 | } vpaval; | ||
| 222 | }; | ||
| 223 | |||
| 224 | #define one_reg_size(id) \ | 272 | #define one_reg_size(id) \ |
| 225 | (1ul << (((id) & KVM_REG_SIZE_MASK) >> KVM_REG_SIZE_SHIFT)) | 273 | (1ul << (((id) & KVM_REG_SIZE_MASK) >> KVM_REG_SIZE_SHIFT)) |
| 226 | 274 | ||
| @@ -245,10 +293,10 @@ union kvmppc_one_reg { | |||
| 245 | __v; \ | 293 | __v; \ |
| 246 | }) | 294 | }) |
| 247 | 295 | ||
| 248 | void kvmppc_core_get_sregs(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs); | 296 | int kvmppc_core_get_sregs(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs); |
| 249 | int kvmppc_core_set_sregs(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs); | 297 | int kvmppc_core_set_sregs(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs); |
| 250 | 298 | ||
| 251 | void kvmppc_get_sregs_ivor(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs); | 299 | int kvmppc_get_sregs_ivor(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs); |
| 252 | int kvmppc_set_sregs_ivor(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs); | 300 | int kvmppc_set_sregs_ivor(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs); |
| 253 | 301 | ||
| 254 | int kvm_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg); | 302 | int kvm_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg); |
| @@ -260,7 +308,7 @@ void kvmppc_set_pid(struct kvm_vcpu *vcpu, u32 pid); | |||
| 260 | 308 | ||
| 261 | struct openpic; | 309 | struct openpic; |
| 262 | 310 | ||
| 263 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 311 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE |
| 264 | extern void kvm_cma_reserve(void) __init; | 312 | extern void kvm_cma_reserve(void) __init; |
| 265 | static inline void kvmppc_set_xics_phys(int cpu, unsigned long addr) | 313 | static inline void kvmppc_set_xics_phys(int cpu, unsigned long addr) |
| 266 | { | 314 | { |
| @@ -269,10 +317,10 @@ static inline void kvmppc_set_xics_phys(int cpu, unsigned long addr) | |||
| 269 | 317 | ||
| 270 | static inline u32 kvmppc_get_xics_latch(void) | 318 | static inline u32 kvmppc_get_xics_latch(void) |
| 271 | { | 319 | { |
| 272 | u32 xirr = get_paca()->kvm_hstate.saved_xirr; | 320 | u32 xirr; |
| 273 | 321 | ||
| 322 | xirr = get_paca()->kvm_hstate.saved_xirr; | ||
| 274 | get_paca()->kvm_hstate.saved_xirr = 0; | 323 | get_paca()->kvm_hstate.saved_xirr = 0; |
| 275 | |||
| 276 | return xirr; | 324 | return xirr; |
| 277 | } | 325 | } |
| 278 | 326 | ||
| @@ -281,7 +329,10 @@ static inline void kvmppc_set_host_ipi(int cpu, u8 host_ipi) | |||
| 281 | paca[cpu].kvm_hstate.host_ipi = host_ipi; | 329 | paca[cpu].kvm_hstate.host_ipi = host_ipi; |
| 282 | } | 330 | } |
| 283 | 331 | ||
| 284 | extern void kvmppc_fast_vcpu_kick(struct kvm_vcpu *vcpu); | 332 | static inline void kvmppc_fast_vcpu_kick(struct kvm_vcpu *vcpu) |
| 333 | { | ||
| 334 | vcpu->kvm->arch.kvm_ops->fast_vcpu_kick(vcpu); | ||
| 335 | } | ||
| 285 | 336 | ||
| 286 | #else | 337 | #else |
| 287 | static inline void __init kvm_cma_reserve(void) | 338 | static inline void __init kvm_cma_reserve(void) |
diff --git a/arch/powerpc/include/asm/paca.h b/arch/powerpc/include/asm/paca.h index a5954cebbc55..b6ea9e068c13 100644 --- a/arch/powerpc/include/asm/paca.h +++ b/arch/powerpc/include/asm/paca.h | |||
| @@ -166,7 +166,7 @@ struct paca_struct { | |||
| 166 | struct dtl_entry *dtl_curr; /* pointer corresponding to dtl_ridx */ | 166 | struct dtl_entry *dtl_curr; /* pointer corresponding to dtl_ridx */ |
| 167 | 167 | ||
| 168 | #ifdef CONFIG_KVM_BOOK3S_HANDLER | 168 | #ifdef CONFIG_KVM_BOOK3S_HANDLER |
| 169 | #ifdef CONFIG_KVM_BOOK3S_PR | 169 | #ifdef CONFIG_KVM_BOOK3S_PR_POSSIBLE |
| 170 | /* We use this to store guest state in */ | 170 | /* We use this to store guest state in */ |
| 171 | struct kvmppc_book3s_shadow_vcpu shadow_vcpu; | 171 | struct kvmppc_book3s_shadow_vcpu shadow_vcpu; |
| 172 | #endif | 172 | #endif |
diff --git a/arch/powerpc/include/asm/processor.h b/arch/powerpc/include/asm/processor.h index 7794b2b04eb2..fc14a38c7ccf 100644 --- a/arch/powerpc/include/asm/processor.h +++ b/arch/powerpc/include/asm/processor.h | |||
| @@ -208,6 +208,7 @@ struct debug_reg { | |||
| 208 | 208 | ||
| 209 | struct thread_struct { | 209 | struct thread_struct { |
| 210 | unsigned long ksp; /* Kernel stack pointer */ | 210 | unsigned long ksp; /* Kernel stack pointer */ |
| 211 | |||
| 211 | #ifdef CONFIG_PPC64 | 212 | #ifdef CONFIG_PPC64 |
| 212 | unsigned long ksp_vsid; | 213 | unsigned long ksp_vsid; |
| 213 | #endif | 214 | #endif |
| @@ -221,6 +222,7 @@ struct thread_struct { | |||
| 221 | void *pgdir; /* root of page-table tree */ | 222 | void *pgdir; /* root of page-table tree */ |
| 222 | unsigned long ksp_limit; /* if ksp <= ksp_limit stack overflow */ | 223 | unsigned long ksp_limit; /* if ksp <= ksp_limit stack overflow */ |
| 223 | #endif | 224 | #endif |
| 225 | /* Debug Registers */ | ||
| 224 | struct debug_reg debug; | 226 | struct debug_reg debug; |
| 225 | struct thread_fp_state fp_state; | 227 | struct thread_fp_state fp_state; |
| 226 | struct thread_fp_state *fp_save_area; | 228 | struct thread_fp_state *fp_save_area; |
diff --git a/arch/powerpc/include/asm/pte-book3e.h b/arch/powerpc/include/asm/pte-book3e.h index 0156702ba24e..576ad88104cb 100644 --- a/arch/powerpc/include/asm/pte-book3e.h +++ b/arch/powerpc/include/asm/pte-book3e.h | |||
| @@ -40,7 +40,7 @@ | |||
| 40 | #define _PAGE_U1 0x010000 | 40 | #define _PAGE_U1 0x010000 |
| 41 | #define _PAGE_U0 0x020000 | 41 | #define _PAGE_U0 0x020000 |
| 42 | #define _PAGE_ACCESSED 0x040000 | 42 | #define _PAGE_ACCESSED 0x040000 |
| 43 | #define _PAGE_LENDIAN 0x080000 | 43 | #define _PAGE_ENDIAN 0x080000 |
| 44 | #define _PAGE_GUARDED 0x100000 | 44 | #define _PAGE_GUARDED 0x100000 |
| 45 | #define _PAGE_COHERENT 0x200000 /* M: enforce memory coherence */ | 45 | #define _PAGE_COHERENT 0x200000 /* M: enforce memory coherence */ |
| 46 | #define _PAGE_NO_CACHE 0x400000 /* I: cache inhibit */ | 46 | #define _PAGE_NO_CACHE 0x400000 /* I: cache inhibit */ |
diff --git a/arch/powerpc/include/asm/reg.h b/arch/powerpc/include/asm/reg.h index 126f6e98f84d..5c45787d551e 100644 --- a/arch/powerpc/include/asm/reg.h +++ b/arch/powerpc/include/asm/reg.h | |||
| @@ -248,6 +248,7 @@ | |||
| 248 | #define SPRN_TBRU 0x10D /* Time Base Read Upper Register (user, R/O) */ | 248 | #define SPRN_TBRU 0x10D /* Time Base Read Upper Register (user, R/O) */ |
| 249 | #define SPRN_TBWL 0x11C /* Time Base Lower Register (super, R/W) */ | 249 | #define SPRN_TBWL 0x11C /* Time Base Lower Register (super, R/W) */ |
| 250 | #define SPRN_TBWU 0x11D /* Time Base Upper Register (super, R/W) */ | 250 | #define SPRN_TBWU 0x11D /* Time Base Upper Register (super, R/W) */ |
| 251 | #define SPRN_TBU40 0x11E /* Timebase upper 40 bits (hyper, R/W) */ | ||
| 251 | #define SPRN_SPURR 0x134 /* Scaled PURR */ | 252 | #define SPRN_SPURR 0x134 /* Scaled PURR */ |
| 252 | #define SPRN_HSPRG0 0x130 /* Hypervisor Scratch 0 */ | 253 | #define SPRN_HSPRG0 0x130 /* Hypervisor Scratch 0 */ |
| 253 | #define SPRN_HSPRG1 0x131 /* Hypervisor Scratch 1 */ | 254 | #define SPRN_HSPRG1 0x131 /* Hypervisor Scratch 1 */ |
| @@ -288,6 +289,7 @@ | |||
| 288 | #define LPCR_ISL (1ul << (63-2)) | 289 | #define LPCR_ISL (1ul << (63-2)) |
| 289 | #define LPCR_VC_SH (63-2) | 290 | #define LPCR_VC_SH (63-2) |
| 290 | #define LPCR_DPFD_SH (63-11) | 291 | #define LPCR_DPFD_SH (63-11) |
| 292 | #define LPCR_DPFD (7ul << LPCR_DPFD_SH) | ||
| 291 | #define LPCR_VRMASD (0x1ful << (63-16)) | 293 | #define LPCR_VRMASD (0x1ful << (63-16)) |
| 292 | #define LPCR_VRMA_L (1ul << (63-12)) | 294 | #define LPCR_VRMA_L (1ul << (63-12)) |
| 293 | #define LPCR_VRMA_LP0 (1ul << (63-15)) | 295 | #define LPCR_VRMA_LP0 (1ul << (63-15)) |
| @@ -304,6 +306,7 @@ | |||
| 304 | #define LPCR_PECE2 0x00001000 /* machine check etc can cause exit */ | 306 | #define LPCR_PECE2 0x00001000 /* machine check etc can cause exit */ |
| 305 | #define LPCR_MER 0x00000800 /* Mediated External Exception */ | 307 | #define LPCR_MER 0x00000800 /* Mediated External Exception */ |
| 306 | #define LPCR_MER_SH 11 | 308 | #define LPCR_MER_SH 11 |
| 309 | #define LPCR_TC 0x00000200 /* Translation control */ | ||
| 307 | #define LPCR_LPES 0x0000000c | 310 | #define LPCR_LPES 0x0000000c |
| 308 | #define LPCR_LPES0 0x00000008 /* LPAR Env selector 0 */ | 311 | #define LPCR_LPES0 0x00000008 /* LPAR Env selector 0 */ |
| 309 | #define LPCR_LPES1 0x00000004 /* LPAR Env selector 1 */ | 312 | #define LPCR_LPES1 0x00000004 /* LPAR Env selector 1 */ |
| @@ -316,6 +319,10 @@ | |||
| 316 | #define LPID_RSVD 0x3ff /* Reserved LPID for partn switching */ | 319 | #define LPID_RSVD 0x3ff /* Reserved LPID for partn switching */ |
| 317 | #define SPRN_HMER 0x150 /* Hardware m? error recovery */ | 320 | #define SPRN_HMER 0x150 /* Hardware m? error recovery */ |
| 318 | #define SPRN_HMEER 0x151 /* Hardware m? enable error recovery */ | 321 | #define SPRN_HMEER 0x151 /* Hardware m? enable error recovery */ |
| 322 | #define SPRN_PCR 0x152 /* Processor compatibility register */ | ||
| 323 | #define PCR_VEC_DIS (1ul << (63-0)) /* Vec. disable (bit NA since POWER8) */ | ||
| 324 | #define PCR_VSX_DIS (1ul << (63-1)) /* VSX disable (bit NA since POWER8) */ | ||
| 325 | #define PCR_ARCH_205 0x2 /* Architecture 2.05 */ | ||
| 319 | #define SPRN_HEIR 0x153 /* Hypervisor Emulated Instruction Register */ | 326 | #define SPRN_HEIR 0x153 /* Hypervisor Emulated Instruction Register */ |
| 320 | #define SPRN_TLBINDEXR 0x154 /* P7 TLB control register */ | 327 | #define SPRN_TLBINDEXR 0x154 /* P7 TLB control register */ |
| 321 | #define SPRN_TLBVPNR 0x155 /* P7 TLB control register */ | 328 | #define SPRN_TLBVPNR 0x155 /* P7 TLB control register */ |
| @@ -425,6 +432,7 @@ | |||
| 425 | #define HID4_RMLS2_SH (63 - 2) /* Real mode limit bottom 2 bits */ | 432 | #define HID4_RMLS2_SH (63 - 2) /* Real mode limit bottom 2 bits */ |
| 426 | #define HID4_LPID5_SH (63 - 6) /* partition ID bottom 4 bits */ | 433 | #define HID4_LPID5_SH (63 - 6) /* partition ID bottom 4 bits */ |
| 427 | #define HID4_RMOR_SH (63 - 22) /* real mode offset (16 bits) */ | 434 | #define HID4_RMOR_SH (63 - 22) /* real mode offset (16 bits) */ |
| 435 | #define HID4_RMOR (0xFFFFul << HID4_RMOR_SH) | ||
| 428 | #define HID4_LPES1 (1 << (63-57)) /* LPAR env. sel. bit 1 */ | 436 | #define HID4_LPES1 (1 << (63-57)) /* LPAR env. sel. bit 1 */ |
| 429 | #define HID4_RMLS0_SH (63 - 58) /* Real mode limit top bit */ | 437 | #define HID4_RMLS0_SH (63 - 58) /* Real mode limit top bit */ |
| 430 | #define HID4_LPID1_SH 0 /* partition ID top 2 bits */ | 438 | #define HID4_LPID1_SH 0 /* partition ID top 2 bits */ |
| @@ -1107,6 +1115,13 @@ | |||
| 1107 | #define PVR_BE 0x0070 | 1115 | #define PVR_BE 0x0070 |
| 1108 | #define PVR_PA6T 0x0090 | 1116 | #define PVR_PA6T 0x0090 |
| 1109 | 1117 | ||
| 1118 | /* "Logical" PVR values defined in PAPR, representing architecture levels */ | ||
| 1119 | #define PVR_ARCH_204 0x0f000001 | ||
| 1120 | #define PVR_ARCH_205 0x0f000002 | ||
| 1121 | #define PVR_ARCH_206 0x0f000003 | ||
| 1122 | #define PVR_ARCH_206p 0x0f100003 | ||
| 1123 | #define PVR_ARCH_207 0x0f000004 | ||
| 1124 | |||
| 1110 | /* Macros for setting and retrieving special purpose registers */ | 1125 | /* Macros for setting and retrieving special purpose registers */ |
| 1111 | #ifndef __ASSEMBLY__ | 1126 | #ifndef __ASSEMBLY__ |
| 1112 | #define mfmsr() ({unsigned long rval; \ | 1127 | #define mfmsr() ({unsigned long rval; \ |
diff --git a/arch/powerpc/include/uapi/asm/kvm.h b/arch/powerpc/include/uapi/asm/kvm.h index 0fb1a6e9ff90..6836ec79a830 100644 --- a/arch/powerpc/include/uapi/asm/kvm.h +++ b/arch/powerpc/include/uapi/asm/kvm.h | |||
| @@ -27,6 +27,7 @@ | |||
| 27 | #define __KVM_HAVE_PPC_SMT | 27 | #define __KVM_HAVE_PPC_SMT |
| 28 | #define __KVM_HAVE_IRQCHIP | 28 | #define __KVM_HAVE_IRQCHIP |
| 29 | #define __KVM_HAVE_IRQ_LINE | 29 | #define __KVM_HAVE_IRQ_LINE |
| 30 | #define __KVM_HAVE_GUEST_DEBUG | ||
| 30 | 31 | ||
| 31 | struct kvm_regs { | 32 | struct kvm_regs { |
| 32 | __u64 pc; | 33 | __u64 pc; |
| @@ -269,7 +270,24 @@ struct kvm_fpu { | |||
| 269 | __u64 fpr[32]; | 270 | __u64 fpr[32]; |
| 270 | }; | 271 | }; |
| 271 | 272 | ||
| 273 | /* | ||
| 274 | * Defines for h/w breakpoint, watchpoint (read, write or both) and | ||
| 275 | * software breakpoint. | ||
| 276 | * These are used as "type" in KVM_SET_GUEST_DEBUG ioctl and "status" | ||
| 277 | * for KVM_DEBUG_EXIT. | ||
| 278 | */ | ||
| 279 | #define KVMPPC_DEBUG_NONE 0x0 | ||
| 280 | #define KVMPPC_DEBUG_BREAKPOINT (1UL << 1) | ||
| 281 | #define KVMPPC_DEBUG_WATCH_WRITE (1UL << 2) | ||
| 282 | #define KVMPPC_DEBUG_WATCH_READ (1UL << 3) | ||
| 272 | struct kvm_debug_exit_arch { | 283 | struct kvm_debug_exit_arch { |
| 284 | __u64 address; | ||
| 285 | /* | ||
| 286 | * exiting to userspace because of h/w breakpoint, watchpoint | ||
| 287 | * (read, write or both) and software breakpoint. | ||
| 288 | */ | ||
| 289 | __u32 status; | ||
| 290 | __u32 reserved; | ||
| 273 | }; | 291 | }; |
| 274 | 292 | ||
| 275 | /* for KVM_SET_GUEST_DEBUG */ | 293 | /* for KVM_SET_GUEST_DEBUG */ |
| @@ -281,10 +299,6 @@ struct kvm_guest_debug_arch { | |||
| 281 | * Type denotes h/w breakpoint, read watchpoint, write | 299 | * Type denotes h/w breakpoint, read watchpoint, write |
| 282 | * watchpoint or watchpoint (both read and write). | 300 | * watchpoint or watchpoint (both read and write). |
| 283 | */ | 301 | */ |
| 284 | #define KVMPPC_DEBUG_NONE 0x0 | ||
| 285 | #define KVMPPC_DEBUG_BREAKPOINT (1UL << 1) | ||
| 286 | #define KVMPPC_DEBUG_WATCH_WRITE (1UL << 2) | ||
| 287 | #define KVMPPC_DEBUG_WATCH_READ (1UL << 3) | ||
| 288 | __u32 type; | 302 | __u32 type; |
| 289 | __u32 reserved; | 303 | __u32 reserved; |
| 290 | } bp[16]; | 304 | } bp[16]; |
| @@ -429,6 +443,11 @@ struct kvm_get_htab_header { | |||
| 429 | #define KVM_REG_PPC_MMCR0 (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x10) | 443 | #define KVM_REG_PPC_MMCR0 (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x10) |
| 430 | #define KVM_REG_PPC_MMCR1 (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x11) | 444 | #define KVM_REG_PPC_MMCR1 (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x11) |
| 431 | #define KVM_REG_PPC_MMCRA (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x12) | 445 | #define KVM_REG_PPC_MMCRA (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x12) |
| 446 | #define KVM_REG_PPC_MMCR2 (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x13) | ||
| 447 | #define KVM_REG_PPC_MMCRS (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x14) | ||
| 448 | #define KVM_REG_PPC_SIAR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x15) | ||
| 449 | #define KVM_REG_PPC_SDAR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x16) | ||
| 450 | #define KVM_REG_PPC_SIER (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x17) | ||
| 432 | 451 | ||
| 433 | #define KVM_REG_PPC_PMC1 (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x18) | 452 | #define KVM_REG_PPC_PMC1 (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x18) |
| 434 | #define KVM_REG_PPC_PMC2 (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x19) | 453 | #define KVM_REG_PPC_PMC2 (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x19) |
| @@ -499,6 +518,65 @@ struct kvm_get_htab_header { | |||
| 499 | #define KVM_REG_PPC_TLB3PS (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x9a) | 518 | #define KVM_REG_PPC_TLB3PS (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x9a) |
| 500 | #define KVM_REG_PPC_EPTCFG (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x9b) | 519 | #define KVM_REG_PPC_EPTCFG (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x9b) |
| 501 | 520 | ||
| 521 | /* Timebase offset */ | ||
| 522 | #define KVM_REG_PPC_TB_OFFSET (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x9c) | ||
| 523 | |||
| 524 | /* POWER8 registers */ | ||
| 525 | #define KVM_REG_PPC_SPMC1 (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x9d) | ||
| 526 | #define KVM_REG_PPC_SPMC2 (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x9e) | ||
| 527 | #define KVM_REG_PPC_IAMR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x9f) | ||
| 528 | #define KVM_REG_PPC_TFHAR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa0) | ||
| 529 | #define KVM_REG_PPC_TFIAR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa1) | ||
| 530 | #define KVM_REG_PPC_TEXASR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa2) | ||
| 531 | #define KVM_REG_PPC_FSCR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa3) | ||
| 532 | #define KVM_REG_PPC_PSPB (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0xa4) | ||
| 533 | #define KVM_REG_PPC_EBBHR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa5) | ||
| 534 | #define KVM_REG_PPC_EBBRR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa6) | ||
| 535 | #define KVM_REG_PPC_BESCR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa7) | ||
| 536 | #define KVM_REG_PPC_TAR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa8) | ||
| 537 | #define KVM_REG_PPC_DPDES (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa9) | ||
| 538 | #define KVM_REG_PPC_DAWR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xaa) | ||
| 539 | #define KVM_REG_PPC_DAWRX (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xab) | ||
| 540 | #define KVM_REG_PPC_CIABR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xac) | ||
| 541 | #define KVM_REG_PPC_IC (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xad) | ||
| 542 | #define KVM_REG_PPC_VTB (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xae) | ||
| 543 | #define KVM_REG_PPC_CSIGR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xaf) | ||
| 544 | #define KVM_REG_PPC_TACR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xb0) | ||
| 545 | #define KVM_REG_PPC_TCSCR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xb1) | ||
| 546 | #define KVM_REG_PPC_PID (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xb2) | ||
| 547 | #define KVM_REG_PPC_ACOP (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xb3) | ||
| 548 | |||
| 549 | #define KVM_REG_PPC_VRSAVE (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0xb4) | ||
| 550 | #define KVM_REG_PPC_LPCR (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0xb5) | ||
| 551 | #define KVM_REG_PPC_PPR (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xb6) | ||
| 552 | |||
| 553 | /* Architecture compatibility level */ | ||
| 554 | #define KVM_REG_PPC_ARCH_COMPAT (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0xb7) | ||
| 555 | |||
| 556 | /* Transactional Memory checkpointed state: | ||
| 557 | * This is all GPRs, all VSX regs and a subset of SPRs | ||
| 558 | */ | ||
| 559 | #define KVM_REG_PPC_TM (KVM_REG_PPC | 0x80000000) | ||
| 560 | /* TM GPRs */ | ||
| 561 | #define KVM_REG_PPC_TM_GPR0 (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0) | ||
| 562 | #define KVM_REG_PPC_TM_GPR(n) (KVM_REG_PPC_TM_GPR0 + (n)) | ||
| 563 | #define KVM_REG_PPC_TM_GPR31 (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x1f) | ||
| 564 | /* TM VSX */ | ||
| 565 | #define KVM_REG_PPC_TM_VSR0 (KVM_REG_PPC_TM | KVM_REG_SIZE_U128 | 0x20) | ||
| 566 | #define KVM_REG_PPC_TM_VSR(n) (KVM_REG_PPC_TM_VSR0 + (n)) | ||
| 567 | #define KVM_REG_PPC_TM_VSR63 (KVM_REG_PPC_TM | KVM_REG_SIZE_U128 | 0x5f) | ||
| 568 | /* TM SPRS */ | ||
| 569 | #define KVM_REG_PPC_TM_CR (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x60) | ||
| 570 | #define KVM_REG_PPC_TM_LR (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x61) | ||
| 571 | #define KVM_REG_PPC_TM_CTR (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x62) | ||
| 572 | #define KVM_REG_PPC_TM_FPSCR (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x63) | ||
| 573 | #define KVM_REG_PPC_TM_AMR (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x64) | ||
| 574 | #define KVM_REG_PPC_TM_PPR (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x65) | ||
| 575 | #define KVM_REG_PPC_TM_VRSAVE (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x66) | ||
| 576 | #define KVM_REG_PPC_TM_VSCR (KVM_REG_PPC_TM | KVM_REG_SIZE_U32 | 0x67) | ||
| 577 | #define KVM_REG_PPC_TM_DSCR (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x68) | ||
| 578 | #define KVM_REG_PPC_TM_TAR (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x69) | ||
| 579 | |||
| 502 | /* PPC64 eXternal Interrupt Controller Specification */ | 580 | /* PPC64 eXternal Interrupt Controller Specification */ |
| 503 | #define KVM_DEV_XICS_GRP_SOURCES 1 /* 64-bit source attributes */ | 581 | #define KVM_DEV_XICS_GRP_SOURCES 1 /* 64-bit source attributes */ |
| 504 | 582 | ||
diff --git a/arch/powerpc/kernel/asm-offsets.c b/arch/powerpc/kernel/asm-offsets.c index e60a3697932c..2ea5cc033ec8 100644 --- a/arch/powerpc/kernel/asm-offsets.c +++ b/arch/powerpc/kernel/asm-offsets.c | |||
| @@ -439,7 +439,7 @@ int main(void) | |||
| 439 | DEFINE(VCPU_LR, offsetof(struct kvm_vcpu, arch.lr)); | 439 | DEFINE(VCPU_LR, offsetof(struct kvm_vcpu, arch.lr)); |
| 440 | DEFINE(VCPU_CR, offsetof(struct kvm_vcpu, arch.cr)); | 440 | DEFINE(VCPU_CR, offsetof(struct kvm_vcpu, arch.cr)); |
| 441 | DEFINE(VCPU_PC, offsetof(struct kvm_vcpu, arch.pc)); | 441 | DEFINE(VCPU_PC, offsetof(struct kvm_vcpu, arch.pc)); |
| 442 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 442 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE |
| 443 | DEFINE(VCPU_MSR, offsetof(struct kvm_vcpu, arch.shregs.msr)); | 443 | DEFINE(VCPU_MSR, offsetof(struct kvm_vcpu, arch.shregs.msr)); |
| 444 | DEFINE(VCPU_SRR0, offsetof(struct kvm_vcpu, arch.shregs.srr0)); | 444 | DEFINE(VCPU_SRR0, offsetof(struct kvm_vcpu, arch.shregs.srr0)); |
| 445 | DEFINE(VCPU_SRR1, offsetof(struct kvm_vcpu, arch.shregs.srr1)); | 445 | DEFINE(VCPU_SRR1, offsetof(struct kvm_vcpu, arch.shregs.srr1)); |
| @@ -470,7 +470,7 @@ int main(void) | |||
| 470 | DEFINE(KVM_LPID, offsetof(struct kvm, arch.lpid)); | 470 | DEFINE(KVM_LPID, offsetof(struct kvm, arch.lpid)); |
| 471 | 471 | ||
| 472 | /* book3s */ | 472 | /* book3s */ |
| 473 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 473 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE |
| 474 | DEFINE(KVM_SDR1, offsetof(struct kvm, arch.sdr1)); | 474 | DEFINE(KVM_SDR1, offsetof(struct kvm, arch.sdr1)); |
| 475 | DEFINE(KVM_HOST_LPID, offsetof(struct kvm, arch.host_lpid)); | 475 | DEFINE(KVM_HOST_LPID, offsetof(struct kvm, arch.host_lpid)); |
| 476 | DEFINE(KVM_HOST_LPCR, offsetof(struct kvm, arch.host_lpcr)); | 476 | DEFINE(KVM_HOST_LPCR, offsetof(struct kvm, arch.host_lpcr)); |
| @@ -502,6 +502,8 @@ int main(void) | |||
| 502 | DEFINE(VCPU_PRODDED, offsetof(struct kvm_vcpu, arch.prodded)); | 502 | DEFINE(VCPU_PRODDED, offsetof(struct kvm_vcpu, arch.prodded)); |
| 503 | DEFINE(VCPU_MMCR, offsetof(struct kvm_vcpu, arch.mmcr)); | 503 | DEFINE(VCPU_MMCR, offsetof(struct kvm_vcpu, arch.mmcr)); |
| 504 | DEFINE(VCPU_PMC, offsetof(struct kvm_vcpu, arch.pmc)); | 504 | DEFINE(VCPU_PMC, offsetof(struct kvm_vcpu, arch.pmc)); |
| 505 | DEFINE(VCPU_SIAR, offsetof(struct kvm_vcpu, arch.siar)); | ||
| 506 | DEFINE(VCPU_SDAR, offsetof(struct kvm_vcpu, arch.sdar)); | ||
| 505 | DEFINE(VCPU_SLB, offsetof(struct kvm_vcpu, arch.slb)); | 507 | DEFINE(VCPU_SLB, offsetof(struct kvm_vcpu, arch.slb)); |
| 506 | DEFINE(VCPU_SLB_MAX, offsetof(struct kvm_vcpu, arch.slb_max)); | 508 | DEFINE(VCPU_SLB_MAX, offsetof(struct kvm_vcpu, arch.slb_max)); |
| 507 | DEFINE(VCPU_SLB_NR, offsetof(struct kvm_vcpu, arch.slb_nr)); | 509 | DEFINE(VCPU_SLB_NR, offsetof(struct kvm_vcpu, arch.slb_nr)); |
| @@ -511,18 +513,22 @@ int main(void) | |||
| 511 | DEFINE(VCPU_TRAP, offsetof(struct kvm_vcpu, arch.trap)); | 513 | DEFINE(VCPU_TRAP, offsetof(struct kvm_vcpu, arch.trap)); |
| 512 | DEFINE(VCPU_PTID, offsetof(struct kvm_vcpu, arch.ptid)); | 514 | DEFINE(VCPU_PTID, offsetof(struct kvm_vcpu, arch.ptid)); |
| 513 | DEFINE(VCPU_CFAR, offsetof(struct kvm_vcpu, arch.cfar)); | 515 | DEFINE(VCPU_CFAR, offsetof(struct kvm_vcpu, arch.cfar)); |
| 516 | DEFINE(VCPU_PPR, offsetof(struct kvm_vcpu, arch.ppr)); | ||
| 517 | DEFINE(VCPU_SHADOW_SRR1, offsetof(struct kvm_vcpu, arch.shadow_srr1)); | ||
| 514 | DEFINE(VCORE_ENTRY_EXIT, offsetof(struct kvmppc_vcore, entry_exit_count)); | 518 | DEFINE(VCORE_ENTRY_EXIT, offsetof(struct kvmppc_vcore, entry_exit_count)); |
| 515 | DEFINE(VCORE_NAP_COUNT, offsetof(struct kvmppc_vcore, nap_count)); | 519 | DEFINE(VCORE_NAP_COUNT, offsetof(struct kvmppc_vcore, nap_count)); |
| 516 | DEFINE(VCORE_IN_GUEST, offsetof(struct kvmppc_vcore, in_guest)); | 520 | DEFINE(VCORE_IN_GUEST, offsetof(struct kvmppc_vcore, in_guest)); |
| 517 | DEFINE(VCORE_NAPPING_THREADS, offsetof(struct kvmppc_vcore, napping_threads)); | 521 | DEFINE(VCORE_NAPPING_THREADS, offsetof(struct kvmppc_vcore, napping_threads)); |
| 518 | DEFINE(VCPU_SVCPU, offsetof(struct kvmppc_vcpu_book3s, shadow_vcpu) - | 522 | DEFINE(VCORE_TB_OFFSET, offsetof(struct kvmppc_vcore, tb_offset)); |
| 519 | offsetof(struct kvmppc_vcpu_book3s, vcpu)); | 523 | DEFINE(VCORE_LPCR, offsetof(struct kvmppc_vcore, lpcr)); |
| 524 | DEFINE(VCORE_PCR, offsetof(struct kvmppc_vcore, pcr)); | ||
| 520 | DEFINE(VCPU_SLB_E, offsetof(struct kvmppc_slb, orige)); | 525 | DEFINE(VCPU_SLB_E, offsetof(struct kvmppc_slb, orige)); |
| 521 | DEFINE(VCPU_SLB_V, offsetof(struct kvmppc_slb, origv)); | 526 | DEFINE(VCPU_SLB_V, offsetof(struct kvmppc_slb, origv)); |
| 522 | DEFINE(VCPU_SLB_SIZE, sizeof(struct kvmppc_slb)); | 527 | DEFINE(VCPU_SLB_SIZE, sizeof(struct kvmppc_slb)); |
| 523 | 528 | ||
| 524 | #ifdef CONFIG_PPC_BOOK3S_64 | 529 | #ifdef CONFIG_PPC_BOOK3S_64 |
| 525 | #ifdef CONFIG_KVM_BOOK3S_PR | 530 | #ifdef CONFIG_KVM_BOOK3S_PR_POSSIBLE |
| 531 | DEFINE(PACA_SVCPU, offsetof(struct paca_struct, shadow_vcpu)); | ||
| 526 | # define SVCPU_FIELD(x, f) DEFINE(x, offsetof(struct paca_struct, shadow_vcpu.f)) | 532 | # define SVCPU_FIELD(x, f) DEFINE(x, offsetof(struct paca_struct, shadow_vcpu.f)) |
| 527 | #else | 533 | #else |
| 528 | # define SVCPU_FIELD(x, f) | 534 | # define SVCPU_FIELD(x, f) |
| @@ -574,7 +580,7 @@ int main(void) | |||
| 574 | HSTATE_FIELD(HSTATE_RESTORE_HID5, restore_hid5); | 580 | HSTATE_FIELD(HSTATE_RESTORE_HID5, restore_hid5); |
| 575 | HSTATE_FIELD(HSTATE_NAPPING, napping); | 581 | HSTATE_FIELD(HSTATE_NAPPING, napping); |
| 576 | 582 | ||
| 577 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 583 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE |
| 578 | HSTATE_FIELD(HSTATE_HWTHREAD_REQ, hwthread_req); | 584 | HSTATE_FIELD(HSTATE_HWTHREAD_REQ, hwthread_req); |
| 579 | HSTATE_FIELD(HSTATE_HWTHREAD_STATE, hwthread_state); | 585 | HSTATE_FIELD(HSTATE_HWTHREAD_STATE, hwthread_state); |
| 580 | HSTATE_FIELD(HSTATE_KVM_VCPU, kvm_vcpu); | 586 | HSTATE_FIELD(HSTATE_KVM_VCPU, kvm_vcpu); |
| @@ -590,10 +596,11 @@ int main(void) | |||
| 590 | HSTATE_FIELD(HSTATE_DABR, dabr); | 596 | HSTATE_FIELD(HSTATE_DABR, dabr); |
| 591 | HSTATE_FIELD(HSTATE_DECEXP, dec_expires); | 597 | HSTATE_FIELD(HSTATE_DECEXP, dec_expires); |
| 592 | DEFINE(IPI_PRIORITY, IPI_PRIORITY); | 598 | DEFINE(IPI_PRIORITY, IPI_PRIORITY); |
| 593 | #endif /* CONFIG_KVM_BOOK3S_64_HV */ | 599 | #endif /* CONFIG_KVM_BOOK3S_HV_POSSIBLE */ |
| 594 | 600 | ||
| 595 | #ifdef CONFIG_PPC_BOOK3S_64 | 601 | #ifdef CONFIG_PPC_BOOK3S_64 |
| 596 | HSTATE_FIELD(HSTATE_CFAR, cfar); | 602 | HSTATE_FIELD(HSTATE_CFAR, cfar); |
| 603 | HSTATE_FIELD(HSTATE_PPR, ppr); | ||
| 597 | #endif /* CONFIG_PPC_BOOK3S_64 */ | 604 | #endif /* CONFIG_PPC_BOOK3S_64 */ |
| 598 | 605 | ||
| 599 | #else /* CONFIG_PPC_BOOK3S */ | 606 | #else /* CONFIG_PPC_BOOK3S */ |
diff --git a/arch/powerpc/kernel/exceptions-64s.S b/arch/powerpc/kernel/exceptions-64s.S index 3a9ed6ac224b..9f905e40922e 100644 --- a/arch/powerpc/kernel/exceptions-64s.S +++ b/arch/powerpc/kernel/exceptions-64s.S | |||
| @@ -126,7 +126,7 @@ BEGIN_FTR_SECTION | |||
| 126 | bgt cr1,. | 126 | bgt cr1,. |
| 127 | GET_PACA(r13) | 127 | GET_PACA(r13) |
| 128 | 128 | ||
| 129 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 129 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE |
| 130 | li r0,KVM_HWTHREAD_IN_KERNEL | 130 | li r0,KVM_HWTHREAD_IN_KERNEL |
| 131 | stb r0,HSTATE_HWTHREAD_STATE(r13) | 131 | stb r0,HSTATE_HWTHREAD_STATE(r13) |
| 132 | /* Order setting hwthread_state vs. testing hwthread_req */ | 132 | /* Order setting hwthread_state vs. testing hwthread_req */ |
| @@ -425,7 +425,7 @@ data_access_check_stab: | |||
| 425 | mfspr r9,SPRN_DSISR | 425 | mfspr r9,SPRN_DSISR |
| 426 | srdi r10,r10,60 | 426 | srdi r10,r10,60 |
| 427 | rlwimi r10,r9,16,0x20 | 427 | rlwimi r10,r9,16,0x20 |
| 428 | #ifdef CONFIG_KVM_BOOK3S_PR | 428 | #ifdef CONFIG_KVM_BOOK3S_PR_POSSIBLE |
| 429 | lbz r9,HSTATE_IN_GUEST(r13) | 429 | lbz r9,HSTATE_IN_GUEST(r13) |
| 430 | rlwimi r10,r9,8,0x300 | 430 | rlwimi r10,r9,8,0x300 |
| 431 | #endif | 431 | #endif |
| @@ -650,6 +650,32 @@ slb_miss_user_pseries: | |||
| 650 | b . /* prevent spec. execution */ | 650 | b . /* prevent spec. execution */ |
| 651 | #endif /* __DISABLED__ */ | 651 | #endif /* __DISABLED__ */ |
| 652 | 652 | ||
| 653 | #ifdef CONFIG_KVM_BOOK3S_64_HANDLER | ||
| 654 | kvmppc_skip_interrupt: | ||
| 655 | /* | ||
| 656 | * Here all GPRs are unchanged from when the interrupt happened | ||
| 657 | * except for r13, which is saved in SPRG_SCRATCH0. | ||
| 658 | */ | ||
| 659 | mfspr r13, SPRN_SRR0 | ||
| 660 | addi r13, r13, 4 | ||
| 661 | mtspr SPRN_SRR0, r13 | ||
| 662 | GET_SCRATCH0(r13) | ||
| 663 | rfid | ||
| 664 | b . | ||
| 665 | |||
| 666 | kvmppc_skip_Hinterrupt: | ||
| 667 | /* | ||
| 668 | * Here all GPRs are unchanged from when the interrupt happened | ||
| 669 | * except for r13, which is saved in SPRG_SCRATCH0. | ||
| 670 | */ | ||
| 671 | mfspr r13, SPRN_HSRR0 | ||
| 672 | addi r13, r13, 4 | ||
| 673 | mtspr SPRN_HSRR0, r13 | ||
| 674 | GET_SCRATCH0(r13) | ||
| 675 | hrfid | ||
| 676 | b . | ||
| 677 | #endif | ||
| 678 | |||
| 653 | /* | 679 | /* |
| 654 | * Code from here down to __end_handlers is invoked from the | 680 | * Code from here down to __end_handlers is invoked from the |
| 655 | * exception prologs above. Because the prologs assemble the | 681 | * exception prologs above. Because the prologs assemble the |
diff --git a/arch/powerpc/kernel/idle_power7.S b/arch/powerpc/kernel/idle_power7.S index e11863f4e595..847e40e62fce 100644 --- a/arch/powerpc/kernel/idle_power7.S +++ b/arch/powerpc/kernel/idle_power7.S | |||
| @@ -84,7 +84,7 @@ _GLOBAL(power7_nap) | |||
| 84 | std r9,_MSR(r1) | 84 | std r9,_MSR(r1) |
| 85 | std r1,PACAR1(r13) | 85 | std r1,PACAR1(r13) |
| 86 | 86 | ||
| 87 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 87 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE |
| 88 | /* Tell KVM we're napping */ | 88 | /* Tell KVM we're napping */ |
| 89 | li r4,KVM_HWTHREAD_IN_NAP | 89 | li r4,KVM_HWTHREAD_IN_NAP |
| 90 | stb r4,HSTATE_HWTHREAD_STATE(r13) | 90 | stb r4,HSTATE_HWTHREAD_STATE(r13) |
diff --git a/arch/powerpc/kernel/traps.c b/arch/powerpc/kernel/traps.c index 62c3dd8c69f2..907a472f9a9e 100644 --- a/arch/powerpc/kernel/traps.c +++ b/arch/powerpc/kernel/traps.c | |||
| @@ -1529,7 +1529,7 @@ static void handle_debug(struct pt_regs *regs, unsigned long debug_status) | |||
| 1529 | * back on or not. | 1529 | * back on or not. |
| 1530 | */ | 1530 | */ |
| 1531 | if (DBCR_ACTIVE_EVENTS(current->thread.debug.dbcr0, | 1531 | if (DBCR_ACTIVE_EVENTS(current->thread.debug.dbcr0, |
| 1532 | current->thread.debug.dbcr1)) | 1532 | current->thread.debug.dbcr1)) |
| 1533 | regs->msr |= MSR_DE; | 1533 | regs->msr |= MSR_DE; |
| 1534 | else | 1534 | else |
| 1535 | /* Make sure the IDM flag is off */ | 1535 | /* Make sure the IDM flag is off */ |
diff --git a/arch/powerpc/kvm/44x.c b/arch/powerpc/kvm/44x.c index 2f5c6b6d6877..93221e87b911 100644 --- a/arch/powerpc/kvm/44x.c +++ b/arch/powerpc/kvm/44x.c | |||
| @@ -31,13 +31,13 @@ | |||
| 31 | #include "44x_tlb.h" | 31 | #include "44x_tlb.h" |
| 32 | #include "booke.h" | 32 | #include "booke.h" |
| 33 | 33 | ||
| 34 | void kvmppc_core_vcpu_load(struct kvm_vcpu *vcpu, int cpu) | 34 | static void kvmppc_core_vcpu_load_44x(struct kvm_vcpu *vcpu, int cpu) |
| 35 | { | 35 | { |
| 36 | kvmppc_booke_vcpu_load(vcpu, cpu); | 36 | kvmppc_booke_vcpu_load(vcpu, cpu); |
| 37 | kvmppc_44x_tlb_load(vcpu); | 37 | kvmppc_44x_tlb_load(vcpu); |
| 38 | } | 38 | } |
| 39 | 39 | ||
| 40 | void kvmppc_core_vcpu_put(struct kvm_vcpu *vcpu) | 40 | static void kvmppc_core_vcpu_put_44x(struct kvm_vcpu *vcpu) |
| 41 | { | 41 | { |
| 42 | kvmppc_44x_tlb_put(vcpu); | 42 | kvmppc_44x_tlb_put(vcpu); |
| 43 | kvmppc_booke_vcpu_put(vcpu); | 43 | kvmppc_booke_vcpu_put(vcpu); |
| @@ -114,29 +114,32 @@ int kvmppc_core_vcpu_translate(struct kvm_vcpu *vcpu, | |||
| 114 | return 0; | 114 | return 0; |
| 115 | } | 115 | } |
| 116 | 116 | ||
| 117 | void kvmppc_core_get_sregs(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) | 117 | static int kvmppc_core_get_sregs_44x(struct kvm_vcpu *vcpu, |
| 118 | struct kvm_sregs *sregs) | ||
| 118 | { | 119 | { |
| 119 | kvmppc_get_sregs_ivor(vcpu, sregs); | 120 | return kvmppc_get_sregs_ivor(vcpu, sregs); |
| 120 | } | 121 | } |
| 121 | 122 | ||
| 122 | int kvmppc_core_set_sregs(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) | 123 | static int kvmppc_core_set_sregs_44x(struct kvm_vcpu *vcpu, |
| 124 | struct kvm_sregs *sregs) | ||
| 123 | { | 125 | { |
| 124 | return kvmppc_set_sregs_ivor(vcpu, sregs); | 126 | return kvmppc_set_sregs_ivor(vcpu, sregs); |
| 125 | } | 127 | } |
| 126 | 128 | ||
| 127 | int kvmppc_get_one_reg(struct kvm_vcpu *vcpu, u64 id, | 129 | static int kvmppc_get_one_reg_44x(struct kvm_vcpu *vcpu, u64 id, |
| 128 | union kvmppc_one_reg *val) | 130 | union kvmppc_one_reg *val) |
| 129 | { | 131 | { |
| 130 | return -EINVAL; | 132 | return -EINVAL; |
| 131 | } | 133 | } |
| 132 | 134 | ||
| 133 | int kvmppc_set_one_reg(struct kvm_vcpu *vcpu, u64 id, | 135 | static int kvmppc_set_one_reg_44x(struct kvm_vcpu *vcpu, u64 id, |
| 134 | union kvmppc_one_reg *val) | 136 | union kvmppc_one_reg *val) |
| 135 | { | 137 | { |
| 136 | return -EINVAL; | 138 | return -EINVAL; |
| 137 | } | 139 | } |
| 138 | 140 | ||
| 139 | struct kvm_vcpu *kvmppc_core_vcpu_create(struct kvm *kvm, unsigned int id) | 141 | static struct kvm_vcpu *kvmppc_core_vcpu_create_44x(struct kvm *kvm, |
| 142 | unsigned int id) | ||
| 140 | { | 143 | { |
| 141 | struct kvmppc_vcpu_44x *vcpu_44x; | 144 | struct kvmppc_vcpu_44x *vcpu_44x; |
| 142 | struct kvm_vcpu *vcpu; | 145 | struct kvm_vcpu *vcpu; |
| @@ -167,7 +170,7 @@ out: | |||
| 167 | return ERR_PTR(err); | 170 | return ERR_PTR(err); |
| 168 | } | 171 | } |
| 169 | 172 | ||
| 170 | void kvmppc_core_vcpu_free(struct kvm_vcpu *vcpu) | 173 | static void kvmppc_core_vcpu_free_44x(struct kvm_vcpu *vcpu) |
| 171 | { | 174 | { |
| 172 | struct kvmppc_vcpu_44x *vcpu_44x = to_44x(vcpu); | 175 | struct kvmppc_vcpu_44x *vcpu_44x = to_44x(vcpu); |
| 173 | 176 | ||
| @@ -176,28 +179,53 @@ void kvmppc_core_vcpu_free(struct kvm_vcpu *vcpu) | |||
| 176 | kmem_cache_free(kvm_vcpu_cache, vcpu_44x); | 179 | kmem_cache_free(kvm_vcpu_cache, vcpu_44x); |
| 177 | } | 180 | } |
| 178 | 181 | ||
| 179 | int kvmppc_core_init_vm(struct kvm *kvm) | 182 | static int kvmppc_core_init_vm_44x(struct kvm *kvm) |
| 180 | { | 183 | { |
| 181 | return 0; | 184 | return 0; |
| 182 | } | 185 | } |
| 183 | 186 | ||
| 184 | void kvmppc_core_destroy_vm(struct kvm *kvm) | 187 | static void kvmppc_core_destroy_vm_44x(struct kvm *kvm) |
| 185 | { | 188 | { |
| 186 | } | 189 | } |
| 187 | 190 | ||
| 191 | static struct kvmppc_ops kvm_ops_44x = { | ||
| 192 | .get_sregs = kvmppc_core_get_sregs_44x, | ||
| 193 | .set_sregs = kvmppc_core_set_sregs_44x, | ||
| 194 | .get_one_reg = kvmppc_get_one_reg_44x, | ||
| 195 | .set_one_reg = kvmppc_set_one_reg_44x, | ||
| 196 | .vcpu_load = kvmppc_core_vcpu_load_44x, | ||
| 197 | .vcpu_put = kvmppc_core_vcpu_put_44x, | ||
| 198 | .vcpu_create = kvmppc_core_vcpu_create_44x, | ||
| 199 | .vcpu_free = kvmppc_core_vcpu_free_44x, | ||
| 200 | .mmu_destroy = kvmppc_mmu_destroy_44x, | ||
| 201 | .init_vm = kvmppc_core_init_vm_44x, | ||
| 202 | .destroy_vm = kvmppc_core_destroy_vm_44x, | ||
| 203 | .emulate_op = kvmppc_core_emulate_op_44x, | ||
| 204 | .emulate_mtspr = kvmppc_core_emulate_mtspr_44x, | ||
| 205 | .emulate_mfspr = kvmppc_core_emulate_mfspr_44x, | ||
| 206 | }; | ||
| 207 | |||
| 188 | static int __init kvmppc_44x_init(void) | 208 | static int __init kvmppc_44x_init(void) |
| 189 | { | 209 | { |
| 190 | int r; | 210 | int r; |
| 191 | 211 | ||
| 192 | r = kvmppc_booke_init(); | 212 | r = kvmppc_booke_init(); |
| 193 | if (r) | 213 | if (r) |
| 194 | return r; | 214 | goto err_out; |
| 215 | |||
| 216 | r = kvm_init(NULL, sizeof(struct kvmppc_vcpu_44x), 0, THIS_MODULE); | ||
| 217 | if (r) | ||
| 218 | goto err_out; | ||
| 219 | kvm_ops_44x.owner = THIS_MODULE; | ||
| 220 | kvmppc_pr_ops = &kvm_ops_44x; | ||
| 195 | 221 | ||
| 196 | return kvm_init(NULL, sizeof(struct kvmppc_vcpu_44x), 0, THIS_MODULE); | 222 | err_out: |
| 223 | return r; | ||
| 197 | } | 224 | } |
| 198 | 225 | ||
| 199 | static void __exit kvmppc_44x_exit(void) | 226 | static void __exit kvmppc_44x_exit(void) |
| 200 | { | 227 | { |
| 228 | kvmppc_pr_ops = NULL; | ||
| 201 | kvmppc_booke_exit(); | 229 | kvmppc_booke_exit(); |
| 202 | } | 230 | } |
| 203 | 231 | ||
diff --git a/arch/powerpc/kvm/44x_emulate.c b/arch/powerpc/kvm/44x_emulate.c index 35ec0a8547da..92c9ab4bcfec 100644 --- a/arch/powerpc/kvm/44x_emulate.c +++ b/arch/powerpc/kvm/44x_emulate.c | |||
| @@ -91,8 +91,8 @@ static int emulate_mfdcr(struct kvm_vcpu *vcpu, int rt, int dcrn) | |||
| 91 | return EMULATE_DONE; | 91 | return EMULATE_DONE; |
| 92 | } | 92 | } |
| 93 | 93 | ||
| 94 | int kvmppc_core_emulate_op(struct kvm_run *run, struct kvm_vcpu *vcpu, | 94 | int kvmppc_core_emulate_op_44x(struct kvm_run *run, struct kvm_vcpu *vcpu, |
| 95 | unsigned int inst, int *advance) | 95 | unsigned int inst, int *advance) |
| 96 | { | 96 | { |
| 97 | int emulated = EMULATE_DONE; | 97 | int emulated = EMULATE_DONE; |
| 98 | int dcrn = get_dcrn(inst); | 98 | int dcrn = get_dcrn(inst); |
| @@ -152,7 +152,7 @@ int kvmppc_core_emulate_op(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 152 | return emulated; | 152 | return emulated; |
| 153 | } | 153 | } |
| 154 | 154 | ||
| 155 | int kvmppc_core_emulate_mtspr(struct kvm_vcpu *vcpu, int sprn, ulong spr_val) | 155 | int kvmppc_core_emulate_mtspr_44x(struct kvm_vcpu *vcpu, int sprn, ulong spr_val) |
| 156 | { | 156 | { |
| 157 | int emulated = EMULATE_DONE; | 157 | int emulated = EMULATE_DONE; |
| 158 | 158 | ||
| @@ -172,7 +172,7 @@ int kvmppc_core_emulate_mtspr(struct kvm_vcpu *vcpu, int sprn, ulong spr_val) | |||
| 172 | return emulated; | 172 | return emulated; |
| 173 | } | 173 | } |
| 174 | 174 | ||
| 175 | int kvmppc_core_emulate_mfspr(struct kvm_vcpu *vcpu, int sprn, ulong *spr_val) | 175 | int kvmppc_core_emulate_mfspr_44x(struct kvm_vcpu *vcpu, int sprn, ulong *spr_val) |
| 176 | { | 176 | { |
| 177 | int emulated = EMULATE_DONE; | 177 | int emulated = EMULATE_DONE; |
| 178 | 178 | ||
diff --git a/arch/powerpc/kvm/44x_tlb.c b/arch/powerpc/kvm/44x_tlb.c index ed0385448148..0deef1082e02 100644 --- a/arch/powerpc/kvm/44x_tlb.c +++ b/arch/powerpc/kvm/44x_tlb.c | |||
| @@ -268,7 +268,7 @@ static void kvmppc_44x_shadow_release(struct kvmppc_vcpu_44x *vcpu_44x, | |||
| 268 | trace_kvm_stlb_inval(stlb_index); | 268 | trace_kvm_stlb_inval(stlb_index); |
| 269 | } | 269 | } |
| 270 | 270 | ||
| 271 | void kvmppc_mmu_destroy(struct kvm_vcpu *vcpu) | 271 | void kvmppc_mmu_destroy_44x(struct kvm_vcpu *vcpu) |
| 272 | { | 272 | { |
| 273 | struct kvmppc_vcpu_44x *vcpu_44x = to_44x(vcpu); | 273 | struct kvmppc_vcpu_44x *vcpu_44x = to_44x(vcpu); |
| 274 | int i; | 274 | int i; |
diff --git a/arch/powerpc/kvm/Kconfig b/arch/powerpc/kvm/Kconfig index e593ff257bd3..141b2027189a 100644 --- a/arch/powerpc/kvm/Kconfig +++ b/arch/powerpc/kvm/Kconfig | |||
| @@ -35,17 +35,20 @@ config KVM_BOOK3S_64_HANDLER | |||
| 35 | bool | 35 | bool |
| 36 | select KVM_BOOK3S_HANDLER | 36 | select KVM_BOOK3S_HANDLER |
| 37 | 37 | ||
| 38 | config KVM_BOOK3S_PR | 38 | config KVM_BOOK3S_PR_POSSIBLE |
| 39 | bool | 39 | bool |
| 40 | select KVM_MMIO | 40 | select KVM_MMIO |
| 41 | select MMU_NOTIFIER | 41 | select MMU_NOTIFIER |
| 42 | 42 | ||
| 43 | config KVM_BOOK3S_HV_POSSIBLE | ||
| 44 | bool | ||
| 45 | |||
| 43 | config KVM_BOOK3S_32 | 46 | config KVM_BOOK3S_32 |
| 44 | tristate "KVM support for PowerPC book3s_32 processors" | 47 | tristate "KVM support for PowerPC book3s_32 processors" |
| 45 | depends on PPC_BOOK3S_32 && !SMP && !PTE_64BIT | 48 | depends on PPC_BOOK3S_32 && !SMP && !PTE_64BIT |
| 46 | select KVM | 49 | select KVM |
| 47 | select KVM_BOOK3S_32_HANDLER | 50 | select KVM_BOOK3S_32_HANDLER |
| 48 | select KVM_BOOK3S_PR | 51 | select KVM_BOOK3S_PR_POSSIBLE |
| 49 | ---help--- | 52 | ---help--- |
| 50 | Support running unmodified book3s_32 guest kernels | 53 | Support running unmodified book3s_32 guest kernels |
| 51 | in virtual machines on book3s_32 host processors. | 54 | in virtual machines on book3s_32 host processors. |
| @@ -60,6 +63,7 @@ config KVM_BOOK3S_64 | |||
| 60 | depends on PPC_BOOK3S_64 | 63 | depends on PPC_BOOK3S_64 |
| 61 | select KVM_BOOK3S_64_HANDLER | 64 | select KVM_BOOK3S_64_HANDLER |
| 62 | select KVM | 65 | select KVM |
| 66 | select KVM_BOOK3S_PR_POSSIBLE if !KVM_BOOK3S_HV_POSSIBLE | ||
| 63 | ---help--- | 67 | ---help--- |
| 64 | Support running unmodified book3s_64 and book3s_32 guest kernels | 68 | Support running unmodified book3s_64 and book3s_32 guest kernels |
| 65 | in virtual machines on book3s_64 host processors. | 69 | in virtual machines on book3s_64 host processors. |
| @@ -70,8 +74,9 @@ config KVM_BOOK3S_64 | |||
| 70 | If unsure, say N. | 74 | If unsure, say N. |
| 71 | 75 | ||
| 72 | config KVM_BOOK3S_64_HV | 76 | config KVM_BOOK3S_64_HV |
| 73 | bool "KVM support for POWER7 and PPC970 using hypervisor mode in host" | 77 | tristate "KVM support for POWER7 and PPC970 using hypervisor mode in host" |
| 74 | depends on KVM_BOOK3S_64 | 78 | depends on KVM_BOOK3S_64 |
| 79 | select KVM_BOOK3S_HV_POSSIBLE | ||
| 75 | select MMU_NOTIFIER | 80 | select MMU_NOTIFIER |
| 76 | select CMA | 81 | select CMA |
| 77 | ---help--- | 82 | ---help--- |
| @@ -90,9 +95,20 @@ config KVM_BOOK3S_64_HV | |||
| 90 | If unsure, say N. | 95 | If unsure, say N. |
| 91 | 96 | ||
| 92 | config KVM_BOOK3S_64_PR | 97 | config KVM_BOOK3S_64_PR |
| 93 | def_bool y | 98 | tristate "KVM support without using hypervisor mode in host" |
| 94 | depends on KVM_BOOK3S_64 && !KVM_BOOK3S_64_HV | 99 | depends on KVM_BOOK3S_64 |
| 95 | select KVM_BOOK3S_PR | 100 | select KVM_BOOK3S_PR_POSSIBLE |
| 101 | ---help--- | ||
| 102 | Support running guest kernels in virtual machines on processors | ||
| 103 | without using hypervisor mode in the host, by running the | ||
| 104 | guest in user mode (problem state) and emulating all | ||
| 105 | privileged instructions and registers. | ||
| 106 | |||
| 107 | This is not as fast as using hypervisor mode, but works on | ||
| 108 | machines where hypervisor mode is not available or not usable, | ||
| 109 | and can emulate processors that are different from the host | ||
| 110 | processor, including emulating 32-bit processors on a 64-bit | ||
| 111 | host. | ||
| 96 | 112 | ||
| 97 | config KVM_BOOKE_HV | 113 | config KVM_BOOKE_HV |
| 98 | bool | 114 | bool |
diff --git a/arch/powerpc/kvm/Makefile b/arch/powerpc/kvm/Makefile index 6646c952c5e3..ce569b6bf4d8 100644 --- a/arch/powerpc/kvm/Makefile +++ b/arch/powerpc/kvm/Makefile | |||
| @@ -53,41 +53,51 @@ kvm-e500mc-objs := \ | |||
| 53 | e500_emulate.o | 53 | e500_emulate.o |
| 54 | kvm-objs-$(CONFIG_KVM_E500MC) := $(kvm-e500mc-objs) | 54 | kvm-objs-$(CONFIG_KVM_E500MC) := $(kvm-e500mc-objs) |
| 55 | 55 | ||
| 56 | kvm-book3s_64-objs-$(CONFIG_KVM_BOOK3S_64_PR) := \ | 56 | kvm-book3s_64-builtin-objs-$(CONFIG_KVM_BOOK3S_64_HANDLER) := \ |
| 57 | $(KVM)/coalesced_mmio.o \ | 57 | book3s_64_vio_hv.o |
| 58 | |||
| 59 | kvm-pr-y := \ | ||
| 58 | fpu.o \ | 60 | fpu.o \ |
| 59 | book3s_paired_singles.o \ | 61 | book3s_paired_singles.o \ |
| 60 | book3s_pr.o \ | 62 | book3s_pr.o \ |
| 61 | book3s_pr_papr.o \ | 63 | book3s_pr_papr.o \ |
| 62 | book3s_64_vio_hv.o \ | ||
| 63 | book3s_emulate.o \ | 64 | book3s_emulate.o \ |
| 64 | book3s_interrupts.o \ | 65 | book3s_interrupts.o \ |
| 65 | book3s_mmu_hpte.o \ | 66 | book3s_mmu_hpte.o \ |
| 66 | book3s_64_mmu_host.o \ | 67 | book3s_64_mmu_host.o \ |
| 67 | book3s_64_mmu.o \ | 68 | book3s_64_mmu.o \ |
| 68 | book3s_32_mmu.o | 69 | book3s_32_mmu.o |
| 69 | kvm-book3s_64-builtin-objs-$(CONFIG_KVM_BOOK3S_64_PR) := \ | 70 | |
| 71 | ifdef CONFIG_KVM_BOOK3S_PR_POSSIBLE | ||
| 72 | kvm-book3s_64-module-objs := \ | ||
| 73 | $(KVM)/coalesced_mmio.o | ||
| 74 | |||
| 75 | kvm-book3s_64-builtin-objs-$(CONFIG_KVM_BOOK3S_64_HANDLER) += \ | ||
| 70 | book3s_rmhandlers.o | 76 | book3s_rmhandlers.o |
| 77 | endif | ||
| 71 | 78 | ||
| 72 | kvm-book3s_64-objs-$(CONFIG_KVM_BOOK3S_64_HV) := \ | 79 | kvm-hv-y += \ |
| 73 | book3s_hv.o \ | 80 | book3s_hv.o \ |
| 74 | book3s_hv_interrupts.o \ | 81 | book3s_hv_interrupts.o \ |
| 75 | book3s_64_mmu_hv.o | 82 | book3s_64_mmu_hv.o |
| 83 | |||
| 76 | kvm-book3s_64-builtin-xics-objs-$(CONFIG_KVM_XICS) := \ | 84 | kvm-book3s_64-builtin-xics-objs-$(CONFIG_KVM_XICS) := \ |
| 77 | book3s_hv_rm_xics.o | 85 | book3s_hv_rm_xics.o |
| 78 | kvm-book3s_64-builtin-objs-$(CONFIG_KVM_BOOK3S_64_HV) := \ | 86 | |
| 87 | ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE | ||
| 88 | kvm-book3s_64-builtin-objs-$(CONFIG_KVM_BOOK3S_64_HANDLER) += \ | ||
| 79 | book3s_hv_rmhandlers.o \ | 89 | book3s_hv_rmhandlers.o \ |
| 80 | book3s_hv_rm_mmu.o \ | 90 | book3s_hv_rm_mmu.o \ |
| 81 | book3s_64_vio_hv.o \ | ||
| 82 | book3s_hv_ras.o \ | 91 | book3s_hv_ras.o \ |
| 83 | book3s_hv_builtin.o \ | 92 | book3s_hv_builtin.o \ |
| 84 | book3s_hv_cma.o \ | 93 | book3s_hv_cma.o \ |
| 85 | $(kvm-book3s_64-builtin-xics-objs-y) | 94 | $(kvm-book3s_64-builtin-xics-objs-y) |
| 95 | endif | ||
| 86 | 96 | ||
| 87 | kvm-book3s_64-objs-$(CONFIG_KVM_XICS) += \ | 97 | kvm-book3s_64-objs-$(CONFIG_KVM_XICS) += \ |
| 88 | book3s_xics.o | 98 | book3s_xics.o |
| 89 | 99 | ||
| 90 | kvm-book3s_64-module-objs := \ | 100 | kvm-book3s_64-module-objs += \ |
| 91 | $(KVM)/kvm_main.o \ | 101 | $(KVM)/kvm_main.o \ |
| 92 | $(KVM)/eventfd.o \ | 102 | $(KVM)/eventfd.o \ |
| 93 | powerpc.o \ | 103 | powerpc.o \ |
| @@ -123,4 +133,7 @@ obj-$(CONFIG_KVM_E500MC) += kvm.o | |||
| 123 | obj-$(CONFIG_KVM_BOOK3S_64) += kvm.o | 133 | obj-$(CONFIG_KVM_BOOK3S_64) += kvm.o |
| 124 | obj-$(CONFIG_KVM_BOOK3S_32) += kvm.o | 134 | obj-$(CONFIG_KVM_BOOK3S_32) += kvm.o |
| 125 | 135 | ||
| 136 | obj-$(CONFIG_KVM_BOOK3S_64_PR) += kvm-pr.o | ||
| 137 | obj-$(CONFIG_KVM_BOOK3S_64_HV) += kvm-hv.o | ||
| 138 | |||
| 126 | obj-y += $(kvm-book3s_64-builtin-objs-y) | 139 | obj-y += $(kvm-book3s_64-builtin-objs-y) |
diff --git a/arch/powerpc/kvm/book3s.c b/arch/powerpc/kvm/book3s.c index 700df6f1d32c..8912608b7e1b 100644 --- a/arch/powerpc/kvm/book3s.c +++ b/arch/powerpc/kvm/book3s.c | |||
| @@ -34,6 +34,7 @@ | |||
| 34 | #include <linux/vmalloc.h> | 34 | #include <linux/vmalloc.h> |
| 35 | #include <linux/highmem.h> | 35 | #include <linux/highmem.h> |
| 36 | 36 | ||
| 37 | #include "book3s.h" | ||
| 37 | #include "trace.h" | 38 | #include "trace.h" |
| 38 | 39 | ||
| 39 | #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU | 40 | #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU |
| @@ -69,6 +70,50 @@ void kvmppc_core_load_guest_debugstate(struct kvm_vcpu *vcpu) | |||
| 69 | { | 70 | { |
| 70 | } | 71 | } |
| 71 | 72 | ||
| 73 | static inline unsigned long kvmppc_interrupt_offset(struct kvm_vcpu *vcpu) | ||
| 74 | { | ||
| 75 | if (!is_kvmppc_hv_enabled(vcpu->kvm)) | ||
| 76 | return to_book3s(vcpu)->hior; | ||
| 77 | return 0; | ||
| 78 | } | ||
| 79 | |||
| 80 | static inline void kvmppc_update_int_pending(struct kvm_vcpu *vcpu, | ||
| 81 | unsigned long pending_now, unsigned long old_pending) | ||
| 82 | { | ||
| 83 | if (is_kvmppc_hv_enabled(vcpu->kvm)) | ||
| 84 | return; | ||
| 85 | if (pending_now) | ||
| 86 | vcpu->arch.shared->int_pending = 1; | ||
| 87 | else if (old_pending) | ||
| 88 | vcpu->arch.shared->int_pending = 0; | ||
| 89 | } | ||
| 90 | |||
| 91 | static inline bool kvmppc_critical_section(struct kvm_vcpu *vcpu) | ||
| 92 | { | ||
| 93 | ulong crit_raw; | ||
| 94 | ulong crit_r1; | ||
| 95 | bool crit; | ||
| 96 | |||
| 97 | if (is_kvmppc_hv_enabled(vcpu->kvm)) | ||
| 98 | return false; | ||
| 99 | |||
| 100 | crit_raw = vcpu->arch.shared->critical; | ||
| 101 | crit_r1 = kvmppc_get_gpr(vcpu, 1); | ||
| 102 | |||
| 103 | /* Truncate crit indicators in 32 bit mode */ | ||
| 104 | if (!(vcpu->arch.shared->msr & MSR_SF)) { | ||
| 105 | crit_raw &= 0xffffffff; | ||
| 106 | crit_r1 &= 0xffffffff; | ||
| 107 | } | ||
| 108 | |||
| 109 | /* Critical section when crit == r1 */ | ||
| 110 | crit = (crit_raw == crit_r1); | ||
| 111 | /* ... and we're in supervisor mode */ | ||
| 112 | crit = crit && !(vcpu->arch.shared->msr & MSR_PR); | ||
| 113 | |||
| 114 | return crit; | ||
| 115 | } | ||
| 116 | |||
| 72 | void kvmppc_inject_interrupt(struct kvm_vcpu *vcpu, int vec, u64 flags) | 117 | void kvmppc_inject_interrupt(struct kvm_vcpu *vcpu, int vec, u64 flags) |
| 73 | { | 118 | { |
| 74 | vcpu->arch.shared->srr0 = kvmppc_get_pc(vcpu); | 119 | vcpu->arch.shared->srr0 = kvmppc_get_pc(vcpu); |
| @@ -126,28 +171,32 @@ void kvmppc_book3s_queue_irqprio(struct kvm_vcpu *vcpu, unsigned int vec) | |||
| 126 | printk(KERN_INFO "Queueing interrupt %x\n", vec); | 171 | printk(KERN_INFO "Queueing interrupt %x\n", vec); |
| 127 | #endif | 172 | #endif |
| 128 | } | 173 | } |
| 129 | 174 | EXPORT_SYMBOL_GPL(kvmppc_book3s_queue_irqprio); | |
| 130 | 175 | ||
| 131 | void kvmppc_core_queue_program(struct kvm_vcpu *vcpu, ulong flags) | 176 | void kvmppc_core_queue_program(struct kvm_vcpu *vcpu, ulong flags) |
| 132 | { | 177 | { |
| 133 | /* might as well deliver this straight away */ | 178 | /* might as well deliver this straight away */ |
| 134 | kvmppc_inject_interrupt(vcpu, BOOK3S_INTERRUPT_PROGRAM, flags); | 179 | kvmppc_inject_interrupt(vcpu, BOOK3S_INTERRUPT_PROGRAM, flags); |
| 135 | } | 180 | } |
| 181 | EXPORT_SYMBOL_GPL(kvmppc_core_queue_program); | ||
| 136 | 182 | ||
| 137 | void kvmppc_core_queue_dec(struct kvm_vcpu *vcpu) | 183 | void kvmppc_core_queue_dec(struct kvm_vcpu *vcpu) |
| 138 | { | 184 | { |
| 139 | kvmppc_book3s_queue_irqprio(vcpu, BOOK3S_INTERRUPT_DECREMENTER); | 185 | kvmppc_book3s_queue_irqprio(vcpu, BOOK3S_INTERRUPT_DECREMENTER); |
| 140 | } | 186 | } |
| 187 | EXPORT_SYMBOL_GPL(kvmppc_core_queue_dec); | ||
| 141 | 188 | ||
| 142 | int kvmppc_core_pending_dec(struct kvm_vcpu *vcpu) | 189 | int kvmppc_core_pending_dec(struct kvm_vcpu *vcpu) |
| 143 | { | 190 | { |
| 144 | return test_bit(BOOK3S_IRQPRIO_DECREMENTER, &vcpu->arch.pending_exceptions); | 191 | return test_bit(BOOK3S_IRQPRIO_DECREMENTER, &vcpu->arch.pending_exceptions); |
| 145 | } | 192 | } |
| 193 | EXPORT_SYMBOL_GPL(kvmppc_core_pending_dec); | ||
| 146 | 194 | ||
| 147 | void kvmppc_core_dequeue_dec(struct kvm_vcpu *vcpu) | 195 | void kvmppc_core_dequeue_dec(struct kvm_vcpu *vcpu) |
| 148 | { | 196 | { |
| 149 | kvmppc_book3s_dequeue_irqprio(vcpu, BOOK3S_INTERRUPT_DECREMENTER); | 197 | kvmppc_book3s_dequeue_irqprio(vcpu, BOOK3S_INTERRUPT_DECREMENTER); |
| 150 | } | 198 | } |
| 199 | EXPORT_SYMBOL_GPL(kvmppc_core_dequeue_dec); | ||
| 151 | 200 | ||
| 152 | void kvmppc_core_queue_external(struct kvm_vcpu *vcpu, | 201 | void kvmppc_core_queue_external(struct kvm_vcpu *vcpu, |
| 153 | struct kvm_interrupt *irq) | 202 | struct kvm_interrupt *irq) |
| @@ -285,8 +334,10 @@ int kvmppc_core_prepare_to_enter(struct kvm_vcpu *vcpu) | |||
| 285 | 334 | ||
| 286 | return 0; | 335 | return 0; |
| 287 | } | 336 | } |
| 337 | EXPORT_SYMBOL_GPL(kvmppc_core_prepare_to_enter); | ||
| 288 | 338 | ||
| 289 | pfn_t kvmppc_gfn_to_pfn(struct kvm_vcpu *vcpu, gfn_t gfn) | 339 | pfn_t kvmppc_gfn_to_pfn(struct kvm_vcpu *vcpu, gfn_t gfn, bool writing, |
| 340 | bool *writable) | ||
| 290 | { | 341 | { |
| 291 | ulong mp_pa = vcpu->arch.magic_page_pa; | 342 | ulong mp_pa = vcpu->arch.magic_page_pa; |
| 292 | 343 | ||
| @@ -302,20 +353,23 @@ pfn_t kvmppc_gfn_to_pfn(struct kvm_vcpu *vcpu, gfn_t gfn) | |||
| 302 | 353 | ||
| 303 | pfn = (pfn_t)virt_to_phys((void*)shared_page) >> PAGE_SHIFT; | 354 | pfn = (pfn_t)virt_to_phys((void*)shared_page) >> PAGE_SHIFT; |
| 304 | get_page(pfn_to_page(pfn)); | 355 | get_page(pfn_to_page(pfn)); |
| 356 | if (writable) | ||
| 357 | *writable = true; | ||
| 305 | return pfn; | 358 | return pfn; |
| 306 | } | 359 | } |
| 307 | 360 | ||
| 308 | return gfn_to_pfn(vcpu->kvm, gfn); | 361 | return gfn_to_pfn_prot(vcpu->kvm, gfn, writing, writable); |
| 309 | } | 362 | } |
| 363 | EXPORT_SYMBOL_GPL(kvmppc_gfn_to_pfn); | ||
| 310 | 364 | ||
| 311 | static int kvmppc_xlate(struct kvm_vcpu *vcpu, ulong eaddr, bool data, | 365 | static int kvmppc_xlate(struct kvm_vcpu *vcpu, ulong eaddr, bool data, |
| 312 | struct kvmppc_pte *pte) | 366 | bool iswrite, struct kvmppc_pte *pte) |
| 313 | { | 367 | { |
| 314 | int relocated = (vcpu->arch.shared->msr & (data ? MSR_DR : MSR_IR)); | 368 | int relocated = (vcpu->arch.shared->msr & (data ? MSR_DR : MSR_IR)); |
| 315 | int r; | 369 | int r; |
| 316 | 370 | ||
| 317 | if (relocated) { | 371 | if (relocated) { |
| 318 | r = vcpu->arch.mmu.xlate(vcpu, eaddr, pte, data); | 372 | r = vcpu->arch.mmu.xlate(vcpu, eaddr, pte, data, iswrite); |
| 319 | } else { | 373 | } else { |
| 320 | pte->eaddr = eaddr; | 374 | pte->eaddr = eaddr; |
| 321 | pte->raddr = eaddr & KVM_PAM; | 375 | pte->raddr = eaddr & KVM_PAM; |
| @@ -361,7 +415,7 @@ int kvmppc_st(struct kvm_vcpu *vcpu, ulong *eaddr, int size, void *ptr, | |||
| 361 | 415 | ||
| 362 | vcpu->stat.st++; | 416 | vcpu->stat.st++; |
| 363 | 417 | ||
| 364 | if (kvmppc_xlate(vcpu, *eaddr, data, &pte)) | 418 | if (kvmppc_xlate(vcpu, *eaddr, data, true, &pte)) |
| 365 | return -ENOENT; | 419 | return -ENOENT; |
| 366 | 420 | ||
| 367 | *eaddr = pte.raddr; | 421 | *eaddr = pte.raddr; |
| @@ -374,6 +428,7 @@ int kvmppc_st(struct kvm_vcpu *vcpu, ulong *eaddr, int size, void *ptr, | |||
| 374 | 428 | ||
| 375 | return EMULATE_DONE; | 429 | return EMULATE_DONE; |
| 376 | } | 430 | } |
| 431 | EXPORT_SYMBOL_GPL(kvmppc_st); | ||
| 377 | 432 | ||
| 378 | int kvmppc_ld(struct kvm_vcpu *vcpu, ulong *eaddr, int size, void *ptr, | 433 | int kvmppc_ld(struct kvm_vcpu *vcpu, ulong *eaddr, int size, void *ptr, |
| 379 | bool data) | 434 | bool data) |
| @@ -383,7 +438,7 @@ int kvmppc_ld(struct kvm_vcpu *vcpu, ulong *eaddr, int size, void *ptr, | |||
| 383 | 438 | ||
| 384 | vcpu->stat.ld++; | 439 | vcpu->stat.ld++; |
| 385 | 440 | ||
| 386 | if (kvmppc_xlate(vcpu, *eaddr, data, &pte)) | 441 | if (kvmppc_xlate(vcpu, *eaddr, data, false, &pte)) |
| 387 | goto nopte; | 442 | goto nopte; |
| 388 | 443 | ||
| 389 | *eaddr = pte.raddr; | 444 | *eaddr = pte.raddr; |
| @@ -404,6 +459,7 @@ nopte: | |||
| 404 | mmio: | 459 | mmio: |
| 405 | return EMULATE_DO_MMIO; | 460 | return EMULATE_DO_MMIO; |
| 406 | } | 461 | } |
| 462 | EXPORT_SYMBOL_GPL(kvmppc_ld); | ||
| 407 | 463 | ||
| 408 | int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) | 464 | int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) |
| 409 | { | 465 | { |
| @@ -419,6 +475,18 @@ void kvmppc_subarch_vcpu_uninit(struct kvm_vcpu *vcpu) | |||
| 419 | { | 475 | { |
| 420 | } | 476 | } |
| 421 | 477 | ||
| 478 | int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, | ||
| 479 | struct kvm_sregs *sregs) | ||
| 480 | { | ||
| 481 | return vcpu->kvm->arch.kvm_ops->get_sregs(vcpu, sregs); | ||
| 482 | } | ||
| 483 | |||
| 484 | int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, | ||
| 485 | struct kvm_sregs *sregs) | ||
| 486 | { | ||
| 487 | return vcpu->kvm->arch.kvm_ops->set_sregs(vcpu, sregs); | ||
| 488 | } | ||
| 489 | |||
| 422 | int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) | 490 | int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) |
| 423 | { | 491 | { |
| 424 | int i; | 492 | int i; |
| @@ -495,8 +563,7 @@ int kvm_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg) | |||
| 495 | if (size > sizeof(val)) | 563 | if (size > sizeof(val)) |
| 496 | return -EINVAL; | 564 | return -EINVAL; |
| 497 | 565 | ||
| 498 | r = kvmppc_get_one_reg(vcpu, reg->id, &val); | 566 | r = vcpu->kvm->arch.kvm_ops->get_one_reg(vcpu, reg->id, &val); |
| 499 | |||
| 500 | if (r == -EINVAL) { | 567 | if (r == -EINVAL) { |
| 501 | r = 0; | 568 | r = 0; |
| 502 | switch (reg->id) { | 569 | switch (reg->id) { |
| @@ -528,6 +595,9 @@ int kvm_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg) | |||
| 528 | } | 595 | } |
| 529 | val = get_reg_val(reg->id, vcpu->arch.vscr.u[3]); | 596 | val = get_reg_val(reg->id, vcpu->arch.vscr.u[3]); |
| 530 | break; | 597 | break; |
| 598 | case KVM_REG_PPC_VRSAVE: | ||
| 599 | val = get_reg_val(reg->id, vcpu->arch.vrsave); | ||
| 600 | break; | ||
| 531 | #endif /* CONFIG_ALTIVEC */ | 601 | #endif /* CONFIG_ALTIVEC */ |
| 532 | case KVM_REG_PPC_DEBUG_INST: { | 602 | case KVM_REG_PPC_DEBUG_INST: { |
| 533 | u32 opcode = INS_TW; | 603 | u32 opcode = INS_TW; |
| @@ -572,8 +642,7 @@ int kvm_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg) | |||
| 572 | if (copy_from_user(&val, (char __user *)(unsigned long)reg->addr, size)) | 642 | if (copy_from_user(&val, (char __user *)(unsigned long)reg->addr, size)) |
| 573 | return -EFAULT; | 643 | return -EFAULT; |
| 574 | 644 | ||
| 575 | r = kvmppc_set_one_reg(vcpu, reg->id, &val); | 645 | r = vcpu->kvm->arch.kvm_ops->set_one_reg(vcpu, reg->id, &val); |
| 576 | |||
| 577 | if (r == -EINVAL) { | 646 | if (r == -EINVAL) { |
| 578 | r = 0; | 647 | r = 0; |
| 579 | switch (reg->id) { | 648 | switch (reg->id) { |
| @@ -605,6 +674,13 @@ int kvm_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg) | |||
| 605 | } | 674 | } |
| 606 | vcpu->arch.vscr.u[3] = set_reg_val(reg->id, val); | 675 | vcpu->arch.vscr.u[3] = set_reg_val(reg->id, val); |
| 607 | break; | 676 | break; |
| 677 | case KVM_REG_PPC_VRSAVE: | ||
| 678 | if (!cpu_has_feature(CPU_FTR_ALTIVEC)) { | ||
| 679 | r = -ENXIO; | ||
| 680 | break; | ||
| 681 | } | ||
| 682 | vcpu->arch.vrsave = set_reg_val(reg->id, val); | ||
| 683 | break; | ||
| 608 | #endif /* CONFIG_ALTIVEC */ | 684 | #endif /* CONFIG_ALTIVEC */ |
| 609 | #ifdef CONFIG_KVM_XICS | 685 | #ifdef CONFIG_KVM_XICS |
| 610 | case KVM_REG_PPC_ICP_STATE: | 686 | case KVM_REG_PPC_ICP_STATE: |
| @@ -625,6 +701,27 @@ int kvm_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg) | |||
| 625 | return r; | 701 | return r; |
| 626 | } | 702 | } |
| 627 | 703 | ||
| 704 | void kvmppc_core_vcpu_load(struct kvm_vcpu *vcpu, int cpu) | ||
| 705 | { | ||
| 706 | vcpu->kvm->arch.kvm_ops->vcpu_load(vcpu, cpu); | ||
| 707 | } | ||
| 708 | |||
| 709 | void kvmppc_core_vcpu_put(struct kvm_vcpu *vcpu) | ||
| 710 | { | ||
| 711 | vcpu->kvm->arch.kvm_ops->vcpu_put(vcpu); | ||
| 712 | } | ||
| 713 | |||
| 714 | void kvmppc_set_msr(struct kvm_vcpu *vcpu, u64 msr) | ||
| 715 | { | ||
| 716 | vcpu->kvm->arch.kvm_ops->set_msr(vcpu, msr); | ||
| 717 | } | ||
| 718 | EXPORT_SYMBOL_GPL(kvmppc_set_msr); | ||
| 719 | |||
| 720 | int kvmppc_vcpu_run(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu) | ||
| 721 | { | ||
| 722 | return vcpu->kvm->arch.kvm_ops->vcpu_run(kvm_run, vcpu); | ||
| 723 | } | ||
| 724 | |||
| 628 | int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, | 725 | int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, |
| 629 | struct kvm_translation *tr) | 726 | struct kvm_translation *tr) |
| 630 | { | 727 | { |
| @@ -644,3 +741,141 @@ void kvmppc_decrementer_func(unsigned long data) | |||
| 644 | kvmppc_core_queue_dec(vcpu); | 741 | kvmppc_core_queue_dec(vcpu); |
| 645 | kvm_vcpu_kick(vcpu); | 742 | kvm_vcpu_kick(vcpu); |
| 646 | } | 743 | } |
| 744 | |||
| 745 | struct kvm_vcpu *kvmppc_core_vcpu_create(struct kvm *kvm, unsigned int id) | ||
| 746 | { | ||
| 747 | return kvm->arch.kvm_ops->vcpu_create(kvm, id); | ||
| 748 | } | ||
| 749 | |||
| 750 | void kvmppc_core_vcpu_free(struct kvm_vcpu *vcpu) | ||
| 751 | { | ||
| 752 | vcpu->kvm->arch.kvm_ops->vcpu_free(vcpu); | ||
| 753 | } | ||
| 754 | |||
| 755 | int kvmppc_core_check_requests(struct kvm_vcpu *vcpu) | ||
| 756 | { | ||
| 757 | return vcpu->kvm->arch.kvm_ops->check_requests(vcpu); | ||
| 758 | } | ||
| 759 | |||
| 760 | int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, struct kvm_dirty_log *log) | ||
| 761 | { | ||
| 762 | return kvm->arch.kvm_ops->get_dirty_log(kvm, log); | ||
| 763 | } | ||
| 764 | |||
| 765 | void kvmppc_core_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free, | ||
| 766 | struct kvm_memory_slot *dont) | ||
| 767 | { | ||
| 768 | kvm->arch.kvm_ops->free_memslot(free, dont); | ||
| 769 | } | ||
| 770 | |||
| 771 | int kvmppc_core_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, | ||
| 772 | unsigned long npages) | ||
| 773 | { | ||
| 774 | return kvm->arch.kvm_ops->create_memslot(slot, npages); | ||
| 775 | } | ||
| 776 | |||
| 777 | void kvmppc_core_flush_memslot(struct kvm *kvm, struct kvm_memory_slot *memslot) | ||
| 778 | { | ||
| 779 | kvm->arch.kvm_ops->flush_memslot(kvm, memslot); | ||
| 780 | } | ||
| 781 | |||
| 782 | int kvmppc_core_prepare_memory_region(struct kvm *kvm, | ||
| 783 | struct kvm_memory_slot *memslot, | ||
| 784 | struct kvm_userspace_memory_region *mem) | ||
| 785 | { | ||
| 786 | return kvm->arch.kvm_ops->prepare_memory_region(kvm, memslot, mem); | ||
| 787 | } | ||
| 788 | |||
| 789 | void kvmppc_core_commit_memory_region(struct kvm *kvm, | ||
| 790 | struct kvm_userspace_memory_region *mem, | ||
| 791 | const struct kvm_memory_slot *old) | ||
| 792 | { | ||
| 793 | kvm->arch.kvm_ops->commit_memory_region(kvm, mem, old); | ||
| 794 | } | ||
| 795 | |||
| 796 | int kvm_unmap_hva(struct kvm *kvm, unsigned long hva) | ||
| 797 | { | ||
| 798 | return kvm->arch.kvm_ops->unmap_hva(kvm, hva); | ||
| 799 | } | ||
| 800 | EXPORT_SYMBOL_GPL(kvm_unmap_hva); | ||
| 801 | |||
| 802 | int kvm_unmap_hva_range(struct kvm *kvm, unsigned long start, unsigned long end) | ||
| 803 | { | ||
| 804 | return kvm->arch.kvm_ops->unmap_hva_range(kvm, start, end); | ||
| 805 | } | ||
| 806 | |||
| 807 | int kvm_age_hva(struct kvm *kvm, unsigned long hva) | ||
| 808 | { | ||
| 809 | return kvm->arch.kvm_ops->age_hva(kvm, hva); | ||
| 810 | } | ||
| 811 | |||
| 812 | int kvm_test_age_hva(struct kvm *kvm, unsigned long hva) | ||
| 813 | { | ||
| 814 | return kvm->arch.kvm_ops->test_age_hva(kvm, hva); | ||
| 815 | } | ||
| 816 | |||
| 817 | void kvm_set_spte_hva(struct kvm *kvm, unsigned long hva, pte_t pte) | ||
| 818 | { | ||
| 819 | kvm->arch.kvm_ops->set_spte_hva(kvm, hva, pte); | ||
| 820 | } | ||
| 821 | |||
| 822 | void kvmppc_mmu_destroy(struct kvm_vcpu *vcpu) | ||
| 823 | { | ||
| 824 | vcpu->kvm->arch.kvm_ops->mmu_destroy(vcpu); | ||
| 825 | } | ||
| 826 | |||
| 827 | int kvmppc_core_init_vm(struct kvm *kvm) | ||
| 828 | { | ||
| 829 | |||
| 830 | #ifdef CONFIG_PPC64 | ||
| 831 | INIT_LIST_HEAD(&kvm->arch.spapr_tce_tables); | ||
| 832 | INIT_LIST_HEAD(&kvm->arch.rtas_tokens); | ||
| 833 | #endif | ||
| 834 | |||
| 835 | return kvm->arch.kvm_ops->init_vm(kvm); | ||
| 836 | } | ||
| 837 | |||
| 838 | void kvmppc_core_destroy_vm(struct kvm *kvm) | ||
| 839 | { | ||
| 840 | kvm->arch.kvm_ops->destroy_vm(kvm); | ||
| 841 | |||
| 842 | #ifdef CONFIG_PPC64 | ||
| 843 | kvmppc_rtas_tokens_free(kvm); | ||
| 844 | WARN_ON(!list_empty(&kvm->arch.spapr_tce_tables)); | ||
| 845 | #endif | ||
| 846 | } | ||
| 847 | |||
| 848 | int kvmppc_core_check_processor_compat(void) | ||
| 849 | { | ||
| 850 | /* | ||
| 851 | * We always return 0 for book3s. We check | ||
| 852 | * for compatability while loading the HV | ||
| 853 | * or PR module | ||
| 854 | */ | ||
| 855 | return 0; | ||
| 856 | } | ||
| 857 | |||
| 858 | static int kvmppc_book3s_init(void) | ||
| 859 | { | ||
| 860 | int r; | ||
| 861 | |||
| 862 | r = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); | ||
| 863 | if (r) | ||
| 864 | return r; | ||
| 865 | #ifdef CONFIG_KVM_BOOK3S_32 | ||
| 866 | r = kvmppc_book3s_init_pr(); | ||
| 867 | #endif | ||
| 868 | return r; | ||
| 869 | |||
| 870 | } | ||
| 871 | |||
| 872 | static void kvmppc_book3s_exit(void) | ||
| 873 | { | ||
| 874 | #ifdef CONFIG_KVM_BOOK3S_32 | ||
| 875 | kvmppc_book3s_exit_pr(); | ||
| 876 | #endif | ||
| 877 | kvm_exit(); | ||
| 878 | } | ||
| 879 | |||
| 880 | module_init(kvmppc_book3s_init); | ||
| 881 | module_exit(kvmppc_book3s_exit); | ||
diff --git a/arch/powerpc/kvm/book3s.h b/arch/powerpc/kvm/book3s.h new file mode 100644 index 000000000000..4bf956cf94d6 --- /dev/null +++ b/arch/powerpc/kvm/book3s.h | |||
| @@ -0,0 +1,34 @@ | |||
| 1 | /* | ||
| 2 | * Copyright IBM Corporation, 2013 | ||
| 3 | * Author Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com> | ||
| 4 | * | ||
| 5 | * This program is free software; you can redistribute it and/or | ||
| 6 | * modify it under the terms of the GNU General Public License as | ||
| 7 | * published by the Free Software Foundation; either version 2 of the | ||
| 8 | * License or (at your optional) any later version of the license. | ||
| 9 | * | ||
| 10 | */ | ||
| 11 | |||
| 12 | #ifndef __POWERPC_KVM_BOOK3S_H__ | ||
| 13 | #define __POWERPC_KVM_BOOK3S_H__ | ||
| 14 | |||
| 15 | extern void kvmppc_core_flush_memslot_hv(struct kvm *kvm, | ||
| 16 | struct kvm_memory_slot *memslot); | ||
| 17 | extern int kvm_unmap_hva_hv(struct kvm *kvm, unsigned long hva); | ||
| 18 | extern int kvm_unmap_hva_range_hv(struct kvm *kvm, unsigned long start, | ||
| 19 | unsigned long end); | ||
| 20 | extern int kvm_age_hva_hv(struct kvm *kvm, unsigned long hva); | ||
| 21 | extern int kvm_test_age_hva_hv(struct kvm *kvm, unsigned long hva); | ||
| 22 | extern void kvm_set_spte_hva_hv(struct kvm *kvm, unsigned long hva, pte_t pte); | ||
| 23 | |||
| 24 | extern void kvmppc_mmu_destroy_pr(struct kvm_vcpu *vcpu); | ||
| 25 | extern int kvmppc_core_emulate_op_pr(struct kvm_run *run, struct kvm_vcpu *vcpu, | ||
| 26 | unsigned int inst, int *advance); | ||
| 27 | extern int kvmppc_core_emulate_mtspr_pr(struct kvm_vcpu *vcpu, | ||
| 28 | int sprn, ulong spr_val); | ||
| 29 | extern int kvmppc_core_emulate_mfspr_pr(struct kvm_vcpu *vcpu, | ||
| 30 | int sprn, ulong *spr_val); | ||
| 31 | extern int kvmppc_book3s_init_pr(void); | ||
| 32 | extern void kvmppc_book3s_exit_pr(void); | ||
| 33 | |||
| 34 | #endif | ||
diff --git a/arch/powerpc/kvm/book3s_32_mmu.c b/arch/powerpc/kvm/book3s_32_mmu.c index c8cefdd15fd8..76a64ce6a5b6 100644 --- a/arch/powerpc/kvm/book3s_32_mmu.c +++ b/arch/powerpc/kvm/book3s_32_mmu.c | |||
| @@ -84,7 +84,8 @@ static inline bool sr_nx(u32 sr_raw) | |||
| 84 | } | 84 | } |
| 85 | 85 | ||
| 86 | static int kvmppc_mmu_book3s_32_xlate_bat(struct kvm_vcpu *vcpu, gva_t eaddr, | 86 | static int kvmppc_mmu_book3s_32_xlate_bat(struct kvm_vcpu *vcpu, gva_t eaddr, |
| 87 | struct kvmppc_pte *pte, bool data); | 87 | struct kvmppc_pte *pte, bool data, |
| 88 | bool iswrite); | ||
| 88 | static int kvmppc_mmu_book3s_32_esid_to_vsid(struct kvm_vcpu *vcpu, ulong esid, | 89 | static int kvmppc_mmu_book3s_32_esid_to_vsid(struct kvm_vcpu *vcpu, ulong esid, |
| 89 | u64 *vsid); | 90 | u64 *vsid); |
| 90 | 91 | ||
| @@ -99,7 +100,7 @@ static u64 kvmppc_mmu_book3s_32_ea_to_vp(struct kvm_vcpu *vcpu, gva_t eaddr, | |||
| 99 | u64 vsid; | 100 | u64 vsid; |
| 100 | struct kvmppc_pte pte; | 101 | struct kvmppc_pte pte; |
| 101 | 102 | ||
| 102 | if (!kvmppc_mmu_book3s_32_xlate_bat(vcpu, eaddr, &pte, data)) | 103 | if (!kvmppc_mmu_book3s_32_xlate_bat(vcpu, eaddr, &pte, data, false)) |
| 103 | return pte.vpage; | 104 | return pte.vpage; |
| 104 | 105 | ||
| 105 | kvmppc_mmu_book3s_32_esid_to_vsid(vcpu, eaddr >> SID_SHIFT, &vsid); | 106 | kvmppc_mmu_book3s_32_esid_to_vsid(vcpu, eaddr >> SID_SHIFT, &vsid); |
| @@ -111,10 +112,11 @@ static void kvmppc_mmu_book3s_32_reset_msr(struct kvm_vcpu *vcpu) | |||
| 111 | kvmppc_set_msr(vcpu, 0); | 112 | kvmppc_set_msr(vcpu, 0); |
| 112 | } | 113 | } |
| 113 | 114 | ||
| 114 | static hva_t kvmppc_mmu_book3s_32_get_pteg(struct kvmppc_vcpu_book3s *vcpu_book3s, | 115 | static hva_t kvmppc_mmu_book3s_32_get_pteg(struct kvm_vcpu *vcpu, |
| 115 | u32 sre, gva_t eaddr, | 116 | u32 sre, gva_t eaddr, |
| 116 | bool primary) | 117 | bool primary) |
| 117 | { | 118 | { |
| 119 | struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu); | ||
| 118 | u32 page, hash, pteg, htabmask; | 120 | u32 page, hash, pteg, htabmask; |
| 119 | hva_t r; | 121 | hva_t r; |
| 120 | 122 | ||
| @@ -132,7 +134,7 @@ static hva_t kvmppc_mmu_book3s_32_get_pteg(struct kvmppc_vcpu_book3s *vcpu_book3 | |||
| 132 | kvmppc_get_pc(&vcpu_book3s->vcpu), eaddr, vcpu_book3s->sdr1, pteg, | 134 | kvmppc_get_pc(&vcpu_book3s->vcpu), eaddr, vcpu_book3s->sdr1, pteg, |
| 133 | sr_vsid(sre)); | 135 | sr_vsid(sre)); |
| 134 | 136 | ||
| 135 | r = gfn_to_hva(vcpu_book3s->vcpu.kvm, pteg >> PAGE_SHIFT); | 137 | r = gfn_to_hva(vcpu->kvm, pteg >> PAGE_SHIFT); |
| 136 | if (kvm_is_error_hva(r)) | 138 | if (kvm_is_error_hva(r)) |
| 137 | return r; | 139 | return r; |
| 138 | return r | (pteg & ~PAGE_MASK); | 140 | return r | (pteg & ~PAGE_MASK); |
| @@ -145,7 +147,8 @@ static u32 kvmppc_mmu_book3s_32_get_ptem(u32 sre, gva_t eaddr, bool primary) | |||
| 145 | } | 147 | } |
| 146 | 148 | ||
| 147 | static int kvmppc_mmu_book3s_32_xlate_bat(struct kvm_vcpu *vcpu, gva_t eaddr, | 149 | static int kvmppc_mmu_book3s_32_xlate_bat(struct kvm_vcpu *vcpu, gva_t eaddr, |
| 148 | struct kvmppc_pte *pte, bool data) | 150 | struct kvmppc_pte *pte, bool data, |
| 151 | bool iswrite) | ||
| 149 | { | 152 | { |
| 150 | struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu); | 153 | struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu); |
| 151 | struct kvmppc_bat *bat; | 154 | struct kvmppc_bat *bat; |
| @@ -186,8 +189,7 @@ static int kvmppc_mmu_book3s_32_xlate_bat(struct kvm_vcpu *vcpu, gva_t eaddr, | |||
| 186 | printk(KERN_INFO "BAT is not readable!\n"); | 189 | printk(KERN_INFO "BAT is not readable!\n"); |
| 187 | continue; | 190 | continue; |
| 188 | } | 191 | } |
| 189 | if (!pte->may_write) { | 192 | if (iswrite && !pte->may_write) { |
| 190 | /* let's treat r/o BATs as not-readable for now */ | ||
| 191 | dprintk_pte("BAT is read-only!\n"); | 193 | dprintk_pte("BAT is read-only!\n"); |
| 192 | continue; | 194 | continue; |
| 193 | } | 195 | } |
| @@ -201,9 +203,8 @@ static int kvmppc_mmu_book3s_32_xlate_bat(struct kvm_vcpu *vcpu, gva_t eaddr, | |||
| 201 | 203 | ||
| 202 | static int kvmppc_mmu_book3s_32_xlate_pte(struct kvm_vcpu *vcpu, gva_t eaddr, | 204 | static int kvmppc_mmu_book3s_32_xlate_pte(struct kvm_vcpu *vcpu, gva_t eaddr, |
| 203 | struct kvmppc_pte *pte, bool data, | 205 | struct kvmppc_pte *pte, bool data, |
| 204 | bool primary) | 206 | bool iswrite, bool primary) |
| 205 | { | 207 | { |
| 206 | struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu); | ||
| 207 | u32 sre; | 208 | u32 sre; |
| 208 | hva_t ptegp; | 209 | hva_t ptegp; |
| 209 | u32 pteg[16]; | 210 | u32 pteg[16]; |
| @@ -218,7 +219,7 @@ static int kvmppc_mmu_book3s_32_xlate_pte(struct kvm_vcpu *vcpu, gva_t eaddr, | |||
| 218 | 219 | ||
| 219 | pte->vpage = kvmppc_mmu_book3s_32_ea_to_vp(vcpu, eaddr, data); | 220 | pte->vpage = kvmppc_mmu_book3s_32_ea_to_vp(vcpu, eaddr, data); |
| 220 | 221 | ||
| 221 | ptegp = kvmppc_mmu_book3s_32_get_pteg(vcpu_book3s, sre, eaddr, primary); | 222 | ptegp = kvmppc_mmu_book3s_32_get_pteg(vcpu, sre, eaddr, primary); |
| 222 | if (kvm_is_error_hva(ptegp)) { | 223 | if (kvm_is_error_hva(ptegp)) { |
| 223 | printk(KERN_INFO "KVM: Invalid PTEG!\n"); | 224 | printk(KERN_INFO "KVM: Invalid PTEG!\n"); |
| 224 | goto no_page_found; | 225 | goto no_page_found; |
| @@ -258,9 +259,6 @@ static int kvmppc_mmu_book3s_32_xlate_pte(struct kvm_vcpu *vcpu, gva_t eaddr, | |||
| 258 | break; | 259 | break; |
| 259 | } | 260 | } |
| 260 | 261 | ||
| 261 | if ( !pte->may_read ) | ||
| 262 | continue; | ||
| 263 | |||
| 264 | dprintk_pte("MMU: Found PTE -> %x %x - %x\n", | 262 | dprintk_pte("MMU: Found PTE -> %x %x - %x\n", |
| 265 | pteg[i], pteg[i+1], pp); | 263 | pteg[i], pteg[i+1], pp); |
| 266 | found = 1; | 264 | found = 1; |
| @@ -271,19 +269,23 @@ static int kvmppc_mmu_book3s_32_xlate_pte(struct kvm_vcpu *vcpu, gva_t eaddr, | |||
| 271 | /* Update PTE C and A bits, so the guest's swapper knows we used the | 269 | /* Update PTE C and A bits, so the guest's swapper knows we used the |
| 272 | page */ | 270 | page */ |
| 273 | if (found) { | 271 | if (found) { |
| 274 | u32 oldpte = pteg[i+1]; | 272 | u32 pte_r = pteg[i+1]; |
| 275 | 273 | char __user *addr = (char __user *) &pteg[i+1]; | |
| 276 | if (pte->may_read) | 274 | |
| 277 | pteg[i+1] |= PTEG_FLAG_ACCESSED; | 275 | /* |
| 278 | if (pte->may_write) | 276 | * Use single-byte writes to update the HPTE, to |
| 279 | pteg[i+1] |= PTEG_FLAG_DIRTY; | 277 | * conform to what real hardware does. |
| 280 | else | 278 | */ |
| 281 | dprintk_pte("KVM: Mapping read-only page!\n"); | 279 | if (pte->may_read && !(pte_r & PTEG_FLAG_ACCESSED)) { |
| 282 | 280 | pte_r |= PTEG_FLAG_ACCESSED; | |
| 283 | /* Write back into the PTEG */ | 281 | put_user(pte_r >> 8, addr + 2); |
| 284 | if (pteg[i+1] != oldpte) | 282 | } |
| 285 | copy_to_user((void __user *)ptegp, pteg, sizeof(pteg)); | 283 | if (iswrite && pte->may_write && !(pte_r & PTEG_FLAG_DIRTY)) { |
| 286 | 284 | pte_r |= PTEG_FLAG_DIRTY; | |
| 285 | put_user(pte_r, addr + 3); | ||
| 286 | } | ||
| 287 | if (!pte->may_read || (iswrite && !pte->may_write)) | ||
| 288 | return -EPERM; | ||
| 287 | return 0; | 289 | return 0; |
| 288 | } | 290 | } |
| 289 | 291 | ||
| @@ -302,12 +304,14 @@ no_page_found: | |||
| 302 | } | 304 | } |
| 303 | 305 | ||
| 304 | static int kvmppc_mmu_book3s_32_xlate(struct kvm_vcpu *vcpu, gva_t eaddr, | 306 | static int kvmppc_mmu_book3s_32_xlate(struct kvm_vcpu *vcpu, gva_t eaddr, |
| 305 | struct kvmppc_pte *pte, bool data) | 307 | struct kvmppc_pte *pte, bool data, |
| 308 | bool iswrite) | ||
| 306 | { | 309 | { |
| 307 | int r; | 310 | int r; |
| 308 | ulong mp_ea = vcpu->arch.magic_page_ea; | 311 | ulong mp_ea = vcpu->arch.magic_page_ea; |
| 309 | 312 | ||
| 310 | pte->eaddr = eaddr; | 313 | pte->eaddr = eaddr; |
| 314 | pte->page_size = MMU_PAGE_4K; | ||
| 311 | 315 | ||
| 312 | /* Magic page override */ | 316 | /* Magic page override */ |
| 313 | if (unlikely(mp_ea) && | 317 | if (unlikely(mp_ea) && |
| @@ -323,11 +327,13 @@ static int kvmppc_mmu_book3s_32_xlate(struct kvm_vcpu *vcpu, gva_t eaddr, | |||
| 323 | return 0; | 327 | return 0; |
| 324 | } | 328 | } |
| 325 | 329 | ||
| 326 | r = kvmppc_mmu_book3s_32_xlate_bat(vcpu, eaddr, pte, data); | 330 | r = kvmppc_mmu_book3s_32_xlate_bat(vcpu, eaddr, pte, data, iswrite); |
| 327 | if (r < 0) | 331 | if (r < 0) |
| 328 | r = kvmppc_mmu_book3s_32_xlate_pte(vcpu, eaddr, pte, data, true); | 332 | r = kvmppc_mmu_book3s_32_xlate_pte(vcpu, eaddr, pte, |
| 333 | data, iswrite, true); | ||
| 329 | if (r < 0) | 334 | if (r < 0) |
| 330 | r = kvmppc_mmu_book3s_32_xlate_pte(vcpu, eaddr, pte, data, false); | 335 | r = kvmppc_mmu_book3s_32_xlate_pte(vcpu, eaddr, pte, |
| 336 | data, iswrite, false); | ||
| 331 | 337 | ||
| 332 | return r; | 338 | return r; |
| 333 | } | 339 | } |
| @@ -347,7 +353,12 @@ static void kvmppc_mmu_book3s_32_mtsrin(struct kvm_vcpu *vcpu, u32 srnum, | |||
| 347 | 353 | ||
| 348 | static void kvmppc_mmu_book3s_32_tlbie(struct kvm_vcpu *vcpu, ulong ea, bool large) | 354 | static void kvmppc_mmu_book3s_32_tlbie(struct kvm_vcpu *vcpu, ulong ea, bool large) |
| 349 | { | 355 | { |
| 350 | kvmppc_mmu_pte_flush(vcpu, ea, 0x0FFFF000); | 356 | int i; |
| 357 | struct kvm_vcpu *v; | ||
| 358 | |||
| 359 | /* flush this VA on all cpus */ | ||
| 360 | kvm_for_each_vcpu(i, v, vcpu->kvm) | ||
| 361 | kvmppc_mmu_pte_flush(v, ea, 0x0FFFF000); | ||
| 351 | } | 362 | } |
| 352 | 363 | ||
| 353 | static int kvmppc_mmu_book3s_32_esid_to_vsid(struct kvm_vcpu *vcpu, ulong esid, | 364 | static int kvmppc_mmu_book3s_32_esid_to_vsid(struct kvm_vcpu *vcpu, ulong esid, |
diff --git a/arch/powerpc/kvm/book3s_32_mmu_host.c b/arch/powerpc/kvm/book3s_32_mmu_host.c index 00e619bf608e..3a0abd2e5a15 100644 --- a/arch/powerpc/kvm/book3s_32_mmu_host.c +++ b/arch/powerpc/kvm/book3s_32_mmu_host.c | |||
| @@ -138,7 +138,8 @@ static u32 *kvmppc_mmu_get_pteg(struct kvm_vcpu *vcpu, u32 vsid, u32 eaddr, | |||
| 138 | 138 | ||
| 139 | extern char etext[]; | 139 | extern char etext[]; |
| 140 | 140 | ||
| 141 | int kvmppc_mmu_map_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *orig_pte) | 141 | int kvmppc_mmu_map_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *orig_pte, |
| 142 | bool iswrite) | ||
| 142 | { | 143 | { |
| 143 | pfn_t hpaddr; | 144 | pfn_t hpaddr; |
| 144 | u64 vpn; | 145 | u64 vpn; |
| @@ -152,9 +153,11 @@ int kvmppc_mmu_map_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *orig_pte) | |||
| 152 | bool evict = false; | 153 | bool evict = false; |
| 153 | struct hpte_cache *pte; | 154 | struct hpte_cache *pte; |
| 154 | int r = 0; | 155 | int r = 0; |
| 156 | bool writable; | ||
| 155 | 157 | ||
| 156 | /* Get host physical address for gpa */ | 158 | /* Get host physical address for gpa */ |
| 157 | hpaddr = kvmppc_gfn_to_pfn(vcpu, orig_pte->raddr >> PAGE_SHIFT); | 159 | hpaddr = kvmppc_gfn_to_pfn(vcpu, orig_pte->raddr >> PAGE_SHIFT, |
| 160 | iswrite, &writable); | ||
| 158 | if (is_error_noslot_pfn(hpaddr)) { | 161 | if (is_error_noslot_pfn(hpaddr)) { |
| 159 | printk(KERN_INFO "Couldn't get guest page for gfn %lx!\n", | 162 | printk(KERN_INFO "Couldn't get guest page for gfn %lx!\n", |
| 160 | orig_pte->eaddr); | 163 | orig_pte->eaddr); |
| @@ -204,7 +207,7 @@ next_pteg: | |||
| 204 | (primary ? 0 : PTE_SEC); | 207 | (primary ? 0 : PTE_SEC); |
| 205 | pteg1 = hpaddr | PTE_M | PTE_R | PTE_C; | 208 | pteg1 = hpaddr | PTE_M | PTE_R | PTE_C; |
| 206 | 209 | ||
| 207 | if (orig_pte->may_write) { | 210 | if (orig_pte->may_write && writable) { |
| 208 | pteg1 |= PP_RWRW; | 211 | pteg1 |= PP_RWRW; |
| 209 | mark_page_dirty(vcpu->kvm, orig_pte->raddr >> PAGE_SHIFT); | 212 | mark_page_dirty(vcpu->kvm, orig_pte->raddr >> PAGE_SHIFT); |
| 210 | } else { | 213 | } else { |
| @@ -259,6 +262,11 @@ out: | |||
| 259 | return r; | 262 | return r; |
| 260 | } | 263 | } |
| 261 | 264 | ||
| 265 | void kvmppc_mmu_unmap_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *pte) | ||
| 266 | { | ||
| 267 | kvmppc_mmu_pte_vflush(vcpu, pte->vpage, 0xfffffffffULL); | ||
| 268 | } | ||
| 269 | |||
| 262 | static struct kvmppc_sid_map *create_sid_map(struct kvm_vcpu *vcpu, u64 gvsid) | 270 | static struct kvmppc_sid_map *create_sid_map(struct kvm_vcpu *vcpu, u64 gvsid) |
| 263 | { | 271 | { |
| 264 | struct kvmppc_sid_map *map; | 272 | struct kvmppc_sid_map *map; |
| @@ -341,7 +349,7 @@ void kvmppc_mmu_flush_segments(struct kvm_vcpu *vcpu) | |||
| 341 | svcpu_put(svcpu); | 349 | svcpu_put(svcpu); |
| 342 | } | 350 | } |
| 343 | 351 | ||
| 344 | void kvmppc_mmu_destroy(struct kvm_vcpu *vcpu) | 352 | void kvmppc_mmu_destroy_pr(struct kvm_vcpu *vcpu) |
| 345 | { | 353 | { |
| 346 | int i; | 354 | int i; |
| 347 | 355 | ||
diff --git a/arch/powerpc/kvm/book3s_64_mmu.c b/arch/powerpc/kvm/book3s_64_mmu.c index 7e345e00661a..83da1f868fd5 100644 --- a/arch/powerpc/kvm/book3s_64_mmu.c +++ b/arch/powerpc/kvm/book3s_64_mmu.c | |||
| @@ -107,9 +107,20 @@ static u64 kvmppc_mmu_book3s_64_ea_to_vp(struct kvm_vcpu *vcpu, gva_t eaddr, | |||
| 107 | return kvmppc_slb_calc_vpn(slb, eaddr); | 107 | return kvmppc_slb_calc_vpn(slb, eaddr); |
| 108 | } | 108 | } |
| 109 | 109 | ||
| 110 | static int mmu_pagesize(int mmu_pg) | ||
| 111 | { | ||
| 112 | switch (mmu_pg) { | ||
| 113 | case MMU_PAGE_64K: | ||
| 114 | return 16; | ||
| 115 | case MMU_PAGE_16M: | ||
| 116 | return 24; | ||
| 117 | } | ||
| 118 | return 12; | ||
| 119 | } | ||
| 120 | |||
| 110 | static int kvmppc_mmu_book3s_64_get_pagesize(struct kvmppc_slb *slbe) | 121 | static int kvmppc_mmu_book3s_64_get_pagesize(struct kvmppc_slb *slbe) |
| 111 | { | 122 | { |
| 112 | return slbe->large ? 24 : 12; | 123 | return mmu_pagesize(slbe->base_page_size); |
| 113 | } | 124 | } |
| 114 | 125 | ||
| 115 | static u32 kvmppc_mmu_book3s_64_get_page(struct kvmppc_slb *slbe, gva_t eaddr) | 126 | static u32 kvmppc_mmu_book3s_64_get_page(struct kvmppc_slb *slbe, gva_t eaddr) |
| @@ -119,11 +130,11 @@ static u32 kvmppc_mmu_book3s_64_get_page(struct kvmppc_slb *slbe, gva_t eaddr) | |||
| 119 | return ((eaddr & kvmppc_slb_offset_mask(slbe)) >> p); | 130 | return ((eaddr & kvmppc_slb_offset_mask(slbe)) >> p); |
| 120 | } | 131 | } |
| 121 | 132 | ||
| 122 | static hva_t kvmppc_mmu_book3s_64_get_pteg( | 133 | static hva_t kvmppc_mmu_book3s_64_get_pteg(struct kvm_vcpu *vcpu, |
| 123 | struct kvmppc_vcpu_book3s *vcpu_book3s, | ||
| 124 | struct kvmppc_slb *slbe, gva_t eaddr, | 134 | struct kvmppc_slb *slbe, gva_t eaddr, |
| 125 | bool second) | 135 | bool second) |
| 126 | { | 136 | { |
| 137 | struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu); | ||
| 127 | u64 hash, pteg, htabsize; | 138 | u64 hash, pteg, htabsize; |
| 128 | u32 ssize; | 139 | u32 ssize; |
| 129 | hva_t r; | 140 | hva_t r; |
| @@ -148,10 +159,10 @@ static hva_t kvmppc_mmu_book3s_64_get_pteg( | |||
| 148 | 159 | ||
| 149 | /* When running a PAPR guest, SDR1 contains a HVA address instead | 160 | /* When running a PAPR guest, SDR1 contains a HVA address instead |
| 150 | of a GPA */ | 161 | of a GPA */ |
| 151 | if (vcpu_book3s->vcpu.arch.papr_enabled) | 162 | if (vcpu->arch.papr_enabled) |
| 152 | r = pteg; | 163 | r = pteg; |
| 153 | else | 164 | else |
| 154 | r = gfn_to_hva(vcpu_book3s->vcpu.kvm, pteg >> PAGE_SHIFT); | 165 | r = gfn_to_hva(vcpu->kvm, pteg >> PAGE_SHIFT); |
| 155 | 166 | ||
| 156 | if (kvm_is_error_hva(r)) | 167 | if (kvm_is_error_hva(r)) |
| 157 | return r; | 168 | return r; |
| @@ -166,18 +177,38 @@ static u64 kvmppc_mmu_book3s_64_get_avpn(struct kvmppc_slb *slbe, gva_t eaddr) | |||
| 166 | avpn = kvmppc_mmu_book3s_64_get_page(slbe, eaddr); | 177 | avpn = kvmppc_mmu_book3s_64_get_page(slbe, eaddr); |
| 167 | avpn |= slbe->vsid << (kvmppc_slb_sid_shift(slbe) - p); | 178 | avpn |= slbe->vsid << (kvmppc_slb_sid_shift(slbe) - p); |
| 168 | 179 | ||
| 169 | if (p < 24) | 180 | if (p < 16) |
| 170 | avpn >>= ((80 - p) - 56) - 8; | 181 | avpn >>= ((80 - p) - 56) - 8; /* 16 - p */ |
| 171 | else | 182 | else |
| 172 | avpn <<= 8; | 183 | avpn <<= p - 16; |
| 173 | 184 | ||
| 174 | return avpn; | 185 | return avpn; |
| 175 | } | 186 | } |
| 176 | 187 | ||
| 188 | /* | ||
| 189 | * Return page size encoded in the second word of a HPTE, or | ||
| 190 | * -1 for an invalid encoding for the base page size indicated by | ||
| 191 | * the SLB entry. This doesn't handle mixed pagesize segments yet. | ||
| 192 | */ | ||
| 193 | static int decode_pagesize(struct kvmppc_slb *slbe, u64 r) | ||
| 194 | { | ||
| 195 | switch (slbe->base_page_size) { | ||
| 196 | case MMU_PAGE_64K: | ||
| 197 | if ((r & 0xf000) == 0x1000) | ||
| 198 | return MMU_PAGE_64K; | ||
| 199 | break; | ||
| 200 | case MMU_PAGE_16M: | ||
| 201 | if ((r & 0xff000) == 0) | ||
| 202 | return MMU_PAGE_16M; | ||
| 203 | break; | ||
| 204 | } | ||
| 205 | return -1; | ||
| 206 | } | ||
| 207 | |||
| 177 | static int kvmppc_mmu_book3s_64_xlate(struct kvm_vcpu *vcpu, gva_t eaddr, | 208 | static int kvmppc_mmu_book3s_64_xlate(struct kvm_vcpu *vcpu, gva_t eaddr, |
| 178 | struct kvmppc_pte *gpte, bool data) | 209 | struct kvmppc_pte *gpte, bool data, |
| 210 | bool iswrite) | ||
| 179 | { | 211 | { |
| 180 | struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu); | ||
| 181 | struct kvmppc_slb *slbe; | 212 | struct kvmppc_slb *slbe; |
| 182 | hva_t ptegp; | 213 | hva_t ptegp; |
| 183 | u64 pteg[16]; | 214 | u64 pteg[16]; |
| @@ -189,6 +220,7 @@ static int kvmppc_mmu_book3s_64_xlate(struct kvm_vcpu *vcpu, gva_t eaddr, | |||
| 189 | u8 pp, key = 0; | 220 | u8 pp, key = 0; |
| 190 | bool found = false; | 221 | bool found = false; |
| 191 | bool second = false; | 222 | bool second = false; |
| 223 | int pgsize; | ||
| 192 | ulong mp_ea = vcpu->arch.magic_page_ea; | 224 | ulong mp_ea = vcpu->arch.magic_page_ea; |
| 193 | 225 | ||
| 194 | /* Magic page override */ | 226 | /* Magic page override */ |
| @@ -202,6 +234,7 @@ static int kvmppc_mmu_book3s_64_xlate(struct kvm_vcpu *vcpu, gva_t eaddr, | |||
| 202 | gpte->may_execute = true; | 234 | gpte->may_execute = true; |
| 203 | gpte->may_read = true; | 235 | gpte->may_read = true; |
| 204 | gpte->may_write = true; | 236 | gpte->may_write = true; |
| 237 | gpte->page_size = MMU_PAGE_4K; | ||
| 205 | 238 | ||
| 206 | return 0; | 239 | return 0; |
| 207 | } | 240 | } |
| @@ -222,8 +255,12 @@ static int kvmppc_mmu_book3s_64_xlate(struct kvm_vcpu *vcpu, gva_t eaddr, | |||
| 222 | v_mask = SLB_VSID_B | HPTE_V_AVPN | HPTE_V_LARGE | HPTE_V_VALID | | 255 | v_mask = SLB_VSID_B | HPTE_V_AVPN | HPTE_V_LARGE | HPTE_V_VALID | |
| 223 | HPTE_V_SECONDARY; | 256 | HPTE_V_SECONDARY; |
| 224 | 257 | ||
| 258 | pgsize = slbe->large ? MMU_PAGE_16M : MMU_PAGE_4K; | ||
| 259 | |||
| 260 | mutex_lock(&vcpu->kvm->arch.hpt_mutex); | ||
| 261 | |||
| 225 | do_second: | 262 | do_second: |
| 226 | ptegp = kvmppc_mmu_book3s_64_get_pteg(vcpu_book3s, slbe, eaddr, second); | 263 | ptegp = kvmppc_mmu_book3s_64_get_pteg(vcpu, slbe, eaddr, second); |
| 227 | if (kvm_is_error_hva(ptegp)) | 264 | if (kvm_is_error_hva(ptegp)) |
| 228 | goto no_page_found; | 265 | goto no_page_found; |
| 229 | 266 | ||
| @@ -240,6 +277,13 @@ do_second: | |||
| 240 | for (i=0; i<16; i+=2) { | 277 | for (i=0; i<16; i+=2) { |
| 241 | /* Check all relevant fields of 1st dword */ | 278 | /* Check all relevant fields of 1st dword */ |
| 242 | if ((pteg[i] & v_mask) == v_val) { | 279 | if ((pteg[i] & v_mask) == v_val) { |
| 280 | /* If large page bit is set, check pgsize encoding */ | ||
| 281 | if (slbe->large && | ||
| 282 | (vcpu->arch.hflags & BOOK3S_HFLAG_MULTI_PGSIZE)) { | ||
| 283 | pgsize = decode_pagesize(slbe, pteg[i+1]); | ||
| 284 | if (pgsize < 0) | ||
| 285 | continue; | ||
| 286 | } | ||
| 243 | found = true; | 287 | found = true; |
| 244 | break; | 288 | break; |
| 245 | } | 289 | } |
| @@ -256,13 +300,15 @@ do_second: | |||
| 256 | v = pteg[i]; | 300 | v = pteg[i]; |
| 257 | r = pteg[i+1]; | 301 | r = pteg[i+1]; |
| 258 | pp = (r & HPTE_R_PP) | key; | 302 | pp = (r & HPTE_R_PP) | key; |
| 259 | eaddr_mask = 0xFFF; | 303 | if (r & HPTE_R_PP0) |
| 304 | pp |= 8; | ||
| 260 | 305 | ||
| 261 | gpte->eaddr = eaddr; | 306 | gpte->eaddr = eaddr; |
| 262 | gpte->vpage = kvmppc_mmu_book3s_64_ea_to_vp(vcpu, eaddr, data); | 307 | gpte->vpage = kvmppc_mmu_book3s_64_ea_to_vp(vcpu, eaddr, data); |
| 263 | if (slbe->large) | 308 | |
| 264 | eaddr_mask = 0xFFFFFF; | 309 | eaddr_mask = (1ull << mmu_pagesize(pgsize)) - 1; |
| 265 | gpte->raddr = (r & HPTE_R_RPN & ~eaddr_mask) | (eaddr & eaddr_mask); | 310 | gpte->raddr = (r & HPTE_R_RPN & ~eaddr_mask) | (eaddr & eaddr_mask); |
| 311 | gpte->page_size = pgsize; | ||
| 266 | gpte->may_execute = ((r & HPTE_R_N) ? false : true); | 312 | gpte->may_execute = ((r & HPTE_R_N) ? false : true); |
| 267 | gpte->may_read = false; | 313 | gpte->may_read = false; |
| 268 | gpte->may_write = false; | 314 | gpte->may_write = false; |
| @@ -277,6 +323,7 @@ do_second: | |||
| 277 | case 3: | 323 | case 3: |
| 278 | case 5: | 324 | case 5: |
| 279 | case 7: | 325 | case 7: |
| 326 | case 10: | ||
| 280 | gpte->may_read = true; | 327 | gpte->may_read = true; |
| 281 | break; | 328 | break; |
| 282 | } | 329 | } |
| @@ -287,30 +334,37 @@ do_second: | |||
| 287 | 334 | ||
| 288 | /* Update PTE R and C bits, so the guest's swapper knows we used the | 335 | /* Update PTE R and C bits, so the guest's swapper knows we used the |
| 289 | * page */ | 336 | * page */ |
| 290 | if (gpte->may_read) { | 337 | if (gpte->may_read && !(r & HPTE_R_R)) { |
| 291 | /* Set the accessed flag */ | 338 | /* |
| 339 | * Set the accessed flag. | ||
| 340 | * We have to write this back with a single byte write | ||
| 341 | * because another vcpu may be accessing this on | ||
| 342 | * non-PAPR platforms such as mac99, and this is | ||
| 343 | * what real hardware does. | ||
| 344 | */ | ||
| 345 | char __user *addr = (char __user *) &pteg[i+1]; | ||
| 292 | r |= HPTE_R_R; | 346 | r |= HPTE_R_R; |
| 347 | put_user(r >> 8, addr + 6); | ||
| 293 | } | 348 | } |
| 294 | if (data && gpte->may_write) { | 349 | if (iswrite && gpte->may_write && !(r & HPTE_R_C)) { |
| 295 | /* Set the dirty flag -- XXX even if not writing */ | 350 | /* Set the dirty flag */ |
| 351 | /* Use a single byte write */ | ||
| 352 | char __user *addr = (char __user *) &pteg[i+1]; | ||
| 296 | r |= HPTE_R_C; | 353 | r |= HPTE_R_C; |
| 354 | put_user(r, addr + 7); | ||
| 297 | } | 355 | } |
| 298 | 356 | ||
| 299 | /* Write back into the PTEG */ | 357 | mutex_unlock(&vcpu->kvm->arch.hpt_mutex); |
| 300 | if (pteg[i+1] != r) { | ||
| 301 | pteg[i+1] = r; | ||
| 302 | copy_to_user((void __user *)ptegp, pteg, sizeof(pteg)); | ||
| 303 | } | ||
| 304 | 358 | ||
| 305 | if (!gpte->may_read) | 359 | if (!gpte->may_read || (iswrite && !gpte->may_write)) |
| 306 | return -EPERM; | 360 | return -EPERM; |
| 307 | return 0; | 361 | return 0; |
| 308 | 362 | ||
| 309 | no_page_found: | 363 | no_page_found: |
| 364 | mutex_unlock(&vcpu->kvm->arch.hpt_mutex); | ||
| 310 | return -ENOENT; | 365 | return -ENOENT; |
| 311 | 366 | ||
| 312 | no_seg_found: | 367 | no_seg_found: |
| 313 | |||
| 314 | dprintk("KVM MMU: Trigger segment fault\n"); | 368 | dprintk("KVM MMU: Trigger segment fault\n"); |
| 315 | return -EINVAL; | 369 | return -EINVAL; |
| 316 | } | 370 | } |
| @@ -345,6 +399,21 @@ static void kvmppc_mmu_book3s_64_slbmte(struct kvm_vcpu *vcpu, u64 rs, u64 rb) | |||
| 345 | slbe->nx = (rs & SLB_VSID_N) ? 1 : 0; | 399 | slbe->nx = (rs & SLB_VSID_N) ? 1 : 0; |
| 346 | slbe->class = (rs & SLB_VSID_C) ? 1 : 0; | 400 | slbe->class = (rs & SLB_VSID_C) ? 1 : 0; |
| 347 | 401 | ||
| 402 | slbe->base_page_size = MMU_PAGE_4K; | ||
| 403 | if (slbe->large) { | ||
| 404 | if (vcpu->arch.hflags & BOOK3S_HFLAG_MULTI_PGSIZE) { | ||
| 405 | switch (rs & SLB_VSID_LP) { | ||
| 406 | case SLB_VSID_LP_00: | ||
| 407 | slbe->base_page_size = MMU_PAGE_16M; | ||
| 408 | break; | ||
| 409 | case SLB_VSID_LP_01: | ||
| 410 | slbe->base_page_size = MMU_PAGE_64K; | ||
| 411 | break; | ||
| 412 | } | ||
| 413 | } else | ||
| 414 | slbe->base_page_size = MMU_PAGE_16M; | ||
| 415 | } | ||
| 416 | |||
| 348 | slbe->orige = rb & (ESID_MASK | SLB_ESID_V); | 417 | slbe->orige = rb & (ESID_MASK | SLB_ESID_V); |
| 349 | slbe->origv = rs; | 418 | slbe->origv = rs; |
| 350 | 419 | ||
| @@ -460,14 +529,45 @@ static void kvmppc_mmu_book3s_64_tlbie(struct kvm_vcpu *vcpu, ulong va, | |||
| 460 | bool large) | 529 | bool large) |
| 461 | { | 530 | { |
| 462 | u64 mask = 0xFFFFFFFFFULL; | 531 | u64 mask = 0xFFFFFFFFFULL; |
| 532 | long i; | ||
| 533 | struct kvm_vcpu *v; | ||
| 463 | 534 | ||
| 464 | dprintk("KVM MMU: tlbie(0x%lx)\n", va); | 535 | dprintk("KVM MMU: tlbie(0x%lx)\n", va); |
| 465 | 536 | ||
| 466 | if (large) | 537 | /* |
| 467 | mask = 0xFFFFFF000ULL; | 538 | * The tlbie instruction changed behaviour starting with |
| 468 | kvmppc_mmu_pte_vflush(vcpu, va >> 12, mask); | 539 | * POWER6. POWER6 and later don't have the large page flag |
| 540 | * in the instruction but in the RB value, along with bits | ||
| 541 | * indicating page and segment sizes. | ||
| 542 | */ | ||
| 543 | if (vcpu->arch.hflags & BOOK3S_HFLAG_NEW_TLBIE) { | ||
| 544 | /* POWER6 or later */ | ||
| 545 | if (va & 1) { /* L bit */ | ||
| 546 | if ((va & 0xf000) == 0x1000) | ||
| 547 | mask = 0xFFFFFFFF0ULL; /* 64k page */ | ||
| 548 | else | ||
| 549 | mask = 0xFFFFFF000ULL; /* 16M page */ | ||
| 550 | } | ||
| 551 | } else { | ||
| 552 | /* older processors, e.g. PPC970 */ | ||
| 553 | if (large) | ||
| 554 | mask = 0xFFFFFF000ULL; | ||
| 555 | } | ||
| 556 | /* flush this VA on all vcpus */ | ||
| 557 | kvm_for_each_vcpu(i, v, vcpu->kvm) | ||
| 558 | kvmppc_mmu_pte_vflush(v, va >> 12, mask); | ||
| 469 | } | 559 | } |
| 470 | 560 | ||
| 561 | #ifdef CONFIG_PPC_64K_PAGES | ||
| 562 | static int segment_contains_magic_page(struct kvm_vcpu *vcpu, ulong esid) | ||
| 563 | { | ||
| 564 | ulong mp_ea = vcpu->arch.magic_page_ea; | ||
| 565 | |||
| 566 | return mp_ea && !(vcpu->arch.shared->msr & MSR_PR) && | ||
| 567 | (mp_ea >> SID_SHIFT) == esid; | ||
| 568 | } | ||
| 569 | #endif | ||
| 570 | |||
| 471 | static int kvmppc_mmu_book3s_64_esid_to_vsid(struct kvm_vcpu *vcpu, ulong esid, | 571 | static int kvmppc_mmu_book3s_64_esid_to_vsid(struct kvm_vcpu *vcpu, ulong esid, |
| 472 | u64 *vsid) | 572 | u64 *vsid) |
| 473 | { | 573 | { |
| @@ -475,11 +575,13 @@ static int kvmppc_mmu_book3s_64_esid_to_vsid(struct kvm_vcpu *vcpu, ulong esid, | |||
| 475 | struct kvmppc_slb *slb; | 575 | struct kvmppc_slb *slb; |
| 476 | u64 gvsid = esid; | 576 | u64 gvsid = esid; |
| 477 | ulong mp_ea = vcpu->arch.magic_page_ea; | 577 | ulong mp_ea = vcpu->arch.magic_page_ea; |
| 578 | int pagesize = MMU_PAGE_64K; | ||
| 478 | 579 | ||
| 479 | if (vcpu->arch.shared->msr & (MSR_DR|MSR_IR)) { | 580 | if (vcpu->arch.shared->msr & (MSR_DR|MSR_IR)) { |
| 480 | slb = kvmppc_mmu_book3s_64_find_slbe(vcpu, ea); | 581 | slb = kvmppc_mmu_book3s_64_find_slbe(vcpu, ea); |
| 481 | if (slb) { | 582 | if (slb) { |
| 482 | gvsid = slb->vsid; | 583 | gvsid = slb->vsid; |
| 584 | pagesize = slb->base_page_size; | ||
| 483 | if (slb->tb) { | 585 | if (slb->tb) { |
| 484 | gvsid <<= SID_SHIFT_1T - SID_SHIFT; | 586 | gvsid <<= SID_SHIFT_1T - SID_SHIFT; |
| 485 | gvsid |= esid & ((1ul << (SID_SHIFT_1T - SID_SHIFT)) - 1); | 587 | gvsid |= esid & ((1ul << (SID_SHIFT_1T - SID_SHIFT)) - 1); |
| @@ -490,28 +592,41 @@ static int kvmppc_mmu_book3s_64_esid_to_vsid(struct kvm_vcpu *vcpu, ulong esid, | |||
| 490 | 592 | ||
| 491 | switch (vcpu->arch.shared->msr & (MSR_DR|MSR_IR)) { | 593 | switch (vcpu->arch.shared->msr & (MSR_DR|MSR_IR)) { |
| 492 | case 0: | 594 | case 0: |
| 493 | *vsid = VSID_REAL | esid; | 595 | gvsid = VSID_REAL | esid; |
| 494 | break; | 596 | break; |
| 495 | case MSR_IR: | 597 | case MSR_IR: |
| 496 | *vsid = VSID_REAL_IR | gvsid; | 598 | gvsid |= VSID_REAL_IR; |
| 497 | break; | 599 | break; |
| 498 | case MSR_DR: | 600 | case MSR_DR: |
| 499 | *vsid = VSID_REAL_DR | gvsid; | 601 | gvsid |= VSID_REAL_DR; |
| 500 | break; | 602 | break; |
| 501 | case MSR_DR|MSR_IR: | 603 | case MSR_DR|MSR_IR: |
| 502 | if (!slb) | 604 | if (!slb) |
| 503 | goto no_slb; | 605 | goto no_slb; |
| 504 | 606 | ||
| 505 | *vsid = gvsid; | ||
| 506 | break; | 607 | break; |
| 507 | default: | 608 | default: |
| 508 | BUG(); | 609 | BUG(); |
| 509 | break; | 610 | break; |
| 510 | } | 611 | } |
| 511 | 612 | ||
| 613 | #ifdef CONFIG_PPC_64K_PAGES | ||
| 614 | /* | ||
| 615 | * Mark this as a 64k segment if the host is using | ||
| 616 | * 64k pages, the host MMU supports 64k pages and | ||
| 617 | * the guest segment page size is >= 64k, | ||
| 618 | * but not if this segment contains the magic page. | ||
| 619 | */ | ||
| 620 | if (pagesize >= MMU_PAGE_64K && | ||
| 621 | mmu_psize_defs[MMU_PAGE_64K].shift && | ||
| 622 | !segment_contains_magic_page(vcpu, esid)) | ||
| 623 | gvsid |= VSID_64K; | ||
| 624 | #endif | ||
| 625 | |||
| 512 | if (vcpu->arch.shared->msr & MSR_PR) | 626 | if (vcpu->arch.shared->msr & MSR_PR) |
| 513 | *vsid |= VSID_PR; | 627 | gvsid |= VSID_PR; |
| 514 | 628 | ||
| 629 | *vsid = gvsid; | ||
| 515 | return 0; | 630 | return 0; |
| 516 | 631 | ||
| 517 | no_slb: | 632 | no_slb: |
diff --git a/arch/powerpc/kvm/book3s_64_mmu_host.c b/arch/powerpc/kvm/book3s_64_mmu_host.c index e5240524bf6c..0d513af62bba 100644 --- a/arch/powerpc/kvm/book3s_64_mmu_host.c +++ b/arch/powerpc/kvm/book3s_64_mmu_host.c | |||
| @@ -27,14 +27,14 @@ | |||
| 27 | #include <asm/machdep.h> | 27 | #include <asm/machdep.h> |
| 28 | #include <asm/mmu_context.h> | 28 | #include <asm/mmu_context.h> |
| 29 | #include <asm/hw_irq.h> | 29 | #include <asm/hw_irq.h> |
| 30 | #include "trace.h" | 30 | #include "trace_pr.h" |
| 31 | 31 | ||
| 32 | #define PTE_SIZE 12 | 32 | #define PTE_SIZE 12 |
| 33 | 33 | ||
| 34 | void kvmppc_mmu_invalidate_pte(struct kvm_vcpu *vcpu, struct hpte_cache *pte) | 34 | void kvmppc_mmu_invalidate_pte(struct kvm_vcpu *vcpu, struct hpte_cache *pte) |
| 35 | { | 35 | { |
| 36 | ppc_md.hpte_invalidate(pte->slot, pte->host_vpn, | 36 | ppc_md.hpte_invalidate(pte->slot, pte->host_vpn, |
| 37 | MMU_PAGE_4K, MMU_PAGE_4K, MMU_SEGSIZE_256M, | 37 | pte->pagesize, pte->pagesize, MMU_SEGSIZE_256M, |
| 38 | false); | 38 | false); |
| 39 | } | 39 | } |
| 40 | 40 | ||
| @@ -78,7 +78,8 @@ static struct kvmppc_sid_map *find_sid_vsid(struct kvm_vcpu *vcpu, u64 gvsid) | |||
| 78 | return NULL; | 78 | return NULL; |
| 79 | } | 79 | } |
| 80 | 80 | ||
| 81 | int kvmppc_mmu_map_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *orig_pte) | 81 | int kvmppc_mmu_map_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *orig_pte, |
| 82 | bool iswrite) | ||
| 82 | { | 83 | { |
| 83 | unsigned long vpn; | 84 | unsigned long vpn; |
| 84 | pfn_t hpaddr; | 85 | pfn_t hpaddr; |
| @@ -90,16 +91,26 @@ int kvmppc_mmu_map_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *orig_pte) | |||
| 90 | int attempt = 0; | 91 | int attempt = 0; |
| 91 | struct kvmppc_sid_map *map; | 92 | struct kvmppc_sid_map *map; |
| 92 | int r = 0; | 93 | int r = 0; |
| 94 | int hpsize = MMU_PAGE_4K; | ||
| 95 | bool writable; | ||
| 96 | unsigned long mmu_seq; | ||
| 97 | struct kvm *kvm = vcpu->kvm; | ||
| 98 | struct hpte_cache *cpte; | ||
| 99 | unsigned long gfn = orig_pte->raddr >> PAGE_SHIFT; | ||
| 100 | unsigned long pfn; | ||
| 101 | |||
| 102 | /* used to check for invalidations in progress */ | ||
| 103 | mmu_seq = kvm->mmu_notifier_seq; | ||
| 104 | smp_rmb(); | ||
| 93 | 105 | ||
| 94 | /* Get host physical address for gpa */ | 106 | /* Get host physical address for gpa */ |
| 95 | hpaddr = kvmppc_gfn_to_pfn(vcpu, orig_pte->raddr >> PAGE_SHIFT); | 107 | pfn = kvmppc_gfn_to_pfn(vcpu, gfn, iswrite, &writable); |
| 96 | if (is_error_noslot_pfn(hpaddr)) { | 108 | if (is_error_noslot_pfn(pfn)) { |
| 97 | printk(KERN_INFO "Couldn't get guest page for gfn %lx!\n", orig_pte->eaddr); | 109 | printk(KERN_INFO "Couldn't get guest page for gfn %lx!\n", gfn); |
| 98 | r = -EINVAL; | 110 | r = -EINVAL; |
| 99 | goto out; | 111 | goto out; |
| 100 | } | 112 | } |
| 101 | hpaddr <<= PAGE_SHIFT; | 113 | hpaddr = pfn << PAGE_SHIFT; |
| 102 | hpaddr |= orig_pte->raddr & (~0xfffULL & ~PAGE_MASK); | ||
| 103 | 114 | ||
| 104 | /* and write the mapping ea -> hpa into the pt */ | 115 | /* and write the mapping ea -> hpa into the pt */ |
| 105 | vcpu->arch.mmu.esid_to_vsid(vcpu, orig_pte->eaddr >> SID_SHIFT, &vsid); | 116 | vcpu->arch.mmu.esid_to_vsid(vcpu, orig_pte->eaddr >> SID_SHIFT, &vsid); |
| @@ -117,20 +128,39 @@ int kvmppc_mmu_map_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *orig_pte) | |||
| 117 | goto out; | 128 | goto out; |
| 118 | } | 129 | } |
| 119 | 130 | ||
| 120 | vsid = map->host_vsid; | 131 | vpn = hpt_vpn(orig_pte->eaddr, map->host_vsid, MMU_SEGSIZE_256M); |
| 121 | vpn = hpt_vpn(orig_pte->eaddr, vsid, MMU_SEGSIZE_256M); | ||
| 122 | 132 | ||
| 123 | if (!orig_pte->may_write) | 133 | kvm_set_pfn_accessed(pfn); |
| 124 | rflags |= HPTE_R_PP; | 134 | if (!orig_pte->may_write || !writable) |
| 125 | else | 135 | rflags |= PP_RXRX; |
| 126 | mark_page_dirty(vcpu->kvm, orig_pte->raddr >> PAGE_SHIFT); | 136 | else { |
| 137 | mark_page_dirty(vcpu->kvm, gfn); | ||
| 138 | kvm_set_pfn_dirty(pfn); | ||
| 139 | } | ||
| 127 | 140 | ||
| 128 | if (!orig_pte->may_execute) | 141 | if (!orig_pte->may_execute) |
| 129 | rflags |= HPTE_R_N; | 142 | rflags |= HPTE_R_N; |
| 130 | else | 143 | else |
| 131 | kvmppc_mmu_flush_icache(hpaddr >> PAGE_SHIFT); | 144 | kvmppc_mmu_flush_icache(pfn); |
| 145 | |||
| 146 | /* | ||
| 147 | * Use 64K pages if possible; otherwise, on 64K page kernels, | ||
| 148 | * we need to transfer 4 more bits from guest real to host real addr. | ||
| 149 | */ | ||
| 150 | if (vsid & VSID_64K) | ||
| 151 | hpsize = MMU_PAGE_64K; | ||
| 152 | else | ||
| 153 | hpaddr |= orig_pte->raddr & (~0xfffULL & ~PAGE_MASK); | ||
| 154 | |||
| 155 | hash = hpt_hash(vpn, mmu_psize_defs[hpsize].shift, MMU_SEGSIZE_256M); | ||
| 132 | 156 | ||
| 133 | hash = hpt_hash(vpn, PTE_SIZE, MMU_SEGSIZE_256M); | 157 | cpte = kvmppc_mmu_hpte_cache_next(vcpu); |
| 158 | |||
| 159 | spin_lock(&kvm->mmu_lock); | ||
| 160 | if (!cpte || mmu_notifier_retry(kvm, mmu_seq)) { | ||
| 161 | r = -EAGAIN; | ||
| 162 | goto out_unlock; | ||
| 163 | } | ||
| 134 | 164 | ||
| 135 | map_again: | 165 | map_again: |
| 136 | hpteg = ((hash & htab_hash_mask) * HPTES_PER_GROUP); | 166 | hpteg = ((hash & htab_hash_mask) * HPTES_PER_GROUP); |
| @@ -139,11 +169,11 @@ map_again: | |||
| 139 | if (attempt > 1) | 169 | if (attempt > 1) |
| 140 | if (ppc_md.hpte_remove(hpteg) < 0) { | 170 | if (ppc_md.hpte_remove(hpteg) < 0) { |
| 141 | r = -1; | 171 | r = -1; |
| 142 | goto out; | 172 | goto out_unlock; |
| 143 | } | 173 | } |
| 144 | 174 | ||
| 145 | ret = ppc_md.hpte_insert(hpteg, vpn, hpaddr, rflags, vflags, | 175 | ret = ppc_md.hpte_insert(hpteg, vpn, hpaddr, rflags, vflags, |
| 146 | MMU_PAGE_4K, MMU_PAGE_4K, MMU_SEGSIZE_256M); | 176 | hpsize, hpsize, MMU_SEGSIZE_256M); |
| 147 | 177 | ||
| 148 | if (ret < 0) { | 178 | if (ret < 0) { |
| 149 | /* If we couldn't map a primary PTE, try a secondary */ | 179 | /* If we couldn't map a primary PTE, try a secondary */ |
| @@ -152,8 +182,6 @@ map_again: | |||
| 152 | attempt++; | 182 | attempt++; |
| 153 | goto map_again; | 183 | goto map_again; |
| 154 | } else { | 184 | } else { |
| 155 | struct hpte_cache *pte = kvmppc_mmu_hpte_cache_next(vcpu); | ||
| 156 | |||
| 157 | trace_kvm_book3s_64_mmu_map(rflags, hpteg, | 185 | trace_kvm_book3s_64_mmu_map(rflags, hpteg, |
| 158 | vpn, hpaddr, orig_pte); | 186 | vpn, hpaddr, orig_pte); |
| 159 | 187 | ||
| @@ -164,19 +192,37 @@ map_again: | |||
| 164 | hpteg = ((hash & htab_hash_mask) * HPTES_PER_GROUP); | 192 | hpteg = ((hash & htab_hash_mask) * HPTES_PER_GROUP); |
| 165 | } | 193 | } |
| 166 | 194 | ||
| 167 | pte->slot = hpteg + (ret & 7); | 195 | cpte->slot = hpteg + (ret & 7); |
| 168 | pte->host_vpn = vpn; | 196 | cpte->host_vpn = vpn; |
| 169 | pte->pte = *orig_pte; | 197 | cpte->pte = *orig_pte; |
| 170 | pte->pfn = hpaddr >> PAGE_SHIFT; | 198 | cpte->pfn = pfn; |
| 199 | cpte->pagesize = hpsize; | ||
| 171 | 200 | ||
| 172 | kvmppc_mmu_hpte_cache_map(vcpu, pte); | 201 | kvmppc_mmu_hpte_cache_map(vcpu, cpte); |
| 202 | cpte = NULL; | ||
| 173 | } | 203 | } |
| 174 | kvm_release_pfn_clean(hpaddr >> PAGE_SHIFT); | 204 | |
| 205 | out_unlock: | ||
| 206 | spin_unlock(&kvm->mmu_lock); | ||
| 207 | kvm_release_pfn_clean(pfn); | ||
| 208 | if (cpte) | ||
| 209 | kvmppc_mmu_hpte_cache_free(cpte); | ||
| 175 | 210 | ||
| 176 | out: | 211 | out: |
| 177 | return r; | 212 | return r; |
| 178 | } | 213 | } |
| 179 | 214 | ||
| 215 | void kvmppc_mmu_unmap_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *pte) | ||
| 216 | { | ||
| 217 | u64 mask = 0xfffffffffULL; | ||
| 218 | u64 vsid; | ||
| 219 | |||
| 220 | vcpu->arch.mmu.esid_to_vsid(vcpu, pte->eaddr >> SID_SHIFT, &vsid); | ||
| 221 | if (vsid & VSID_64K) | ||
| 222 | mask = 0xffffffff0ULL; | ||
| 223 | kvmppc_mmu_pte_vflush(vcpu, pte->vpage, mask); | ||
| 224 | } | ||
| 225 | |||
| 180 | static struct kvmppc_sid_map *create_sid_map(struct kvm_vcpu *vcpu, u64 gvsid) | 226 | static struct kvmppc_sid_map *create_sid_map(struct kvm_vcpu *vcpu, u64 gvsid) |
| 181 | { | 227 | { |
| 182 | struct kvmppc_sid_map *map; | 228 | struct kvmppc_sid_map *map; |
| @@ -291,6 +337,12 @@ int kvmppc_mmu_map_segment(struct kvm_vcpu *vcpu, ulong eaddr) | |||
| 291 | slb_vsid &= ~SLB_VSID_KP; | 337 | slb_vsid &= ~SLB_VSID_KP; |
| 292 | slb_esid |= slb_index; | 338 | slb_esid |= slb_index; |
| 293 | 339 | ||
| 340 | #ifdef CONFIG_PPC_64K_PAGES | ||
| 341 | /* Set host segment base page size to 64K if possible */ | ||
| 342 | if (gvsid & VSID_64K) | ||
| 343 | slb_vsid |= mmu_psize_defs[MMU_PAGE_64K].sllp; | ||
| 344 | #endif | ||
| 345 | |||
| 294 | svcpu->slb[slb_index].esid = slb_esid; | 346 | svcpu->slb[slb_index].esid = slb_esid; |
| 295 | svcpu->slb[slb_index].vsid = slb_vsid; | 347 | svcpu->slb[slb_index].vsid = slb_vsid; |
| 296 | 348 | ||
| @@ -326,7 +378,7 @@ void kvmppc_mmu_flush_segments(struct kvm_vcpu *vcpu) | |||
| 326 | svcpu_put(svcpu); | 378 | svcpu_put(svcpu); |
| 327 | } | 379 | } |
| 328 | 380 | ||
| 329 | void kvmppc_mmu_destroy(struct kvm_vcpu *vcpu) | 381 | void kvmppc_mmu_destroy_pr(struct kvm_vcpu *vcpu) |
| 330 | { | 382 | { |
| 331 | kvmppc_mmu_hpte_destroy(vcpu); | 383 | kvmppc_mmu_hpte_destroy(vcpu); |
| 332 | __destroy_context(to_book3s(vcpu)->context_id[0]); | 384 | __destroy_context(to_book3s(vcpu)->context_id[0]); |
diff --git a/arch/powerpc/kvm/book3s_64_mmu_hv.c b/arch/powerpc/kvm/book3s_64_mmu_hv.c index 043eec8461e7..f3ff587a8b7d 100644 --- a/arch/powerpc/kvm/book3s_64_mmu_hv.c +++ b/arch/powerpc/kvm/book3s_64_mmu_hv.c | |||
| @@ -260,10 +260,6 @@ int kvmppc_mmu_hv_init(void) | |||
| 260 | return 0; | 260 | return 0; |
| 261 | } | 261 | } |
| 262 | 262 | ||
| 263 | void kvmppc_mmu_destroy(struct kvm_vcpu *vcpu) | ||
| 264 | { | ||
| 265 | } | ||
| 266 | |||
| 267 | static void kvmppc_mmu_book3s_64_hv_reset_msr(struct kvm_vcpu *vcpu) | 263 | static void kvmppc_mmu_book3s_64_hv_reset_msr(struct kvm_vcpu *vcpu) |
| 268 | { | 264 | { |
| 269 | kvmppc_set_msr(vcpu, MSR_SF | MSR_ME); | 265 | kvmppc_set_msr(vcpu, MSR_SF | MSR_ME); |
| @@ -451,7 +447,7 @@ static unsigned long kvmppc_mmu_get_real_addr(unsigned long v, unsigned long r, | |||
| 451 | } | 447 | } |
| 452 | 448 | ||
| 453 | static int kvmppc_mmu_book3s_64_hv_xlate(struct kvm_vcpu *vcpu, gva_t eaddr, | 449 | static int kvmppc_mmu_book3s_64_hv_xlate(struct kvm_vcpu *vcpu, gva_t eaddr, |
| 454 | struct kvmppc_pte *gpte, bool data) | 450 | struct kvmppc_pte *gpte, bool data, bool iswrite) |
| 455 | { | 451 | { |
| 456 | struct kvm *kvm = vcpu->kvm; | 452 | struct kvm *kvm = vcpu->kvm; |
| 457 | struct kvmppc_slb *slbe; | 453 | struct kvmppc_slb *slbe; |
| @@ -906,21 +902,22 @@ static int kvm_unmap_rmapp(struct kvm *kvm, unsigned long *rmapp, | |||
| 906 | return 0; | 902 | return 0; |
| 907 | } | 903 | } |
| 908 | 904 | ||
| 909 | int kvm_unmap_hva(struct kvm *kvm, unsigned long hva) | 905 | int kvm_unmap_hva_hv(struct kvm *kvm, unsigned long hva) |
| 910 | { | 906 | { |
| 911 | if (kvm->arch.using_mmu_notifiers) | 907 | if (kvm->arch.using_mmu_notifiers) |
| 912 | kvm_handle_hva(kvm, hva, kvm_unmap_rmapp); | 908 | kvm_handle_hva(kvm, hva, kvm_unmap_rmapp); |
| 913 | return 0; | 909 | return 0; |
| 914 | } | 910 | } |
| 915 | 911 | ||
| 916 | int kvm_unmap_hva_range(struct kvm *kvm, unsigned long start, unsigned long end) | 912 | int kvm_unmap_hva_range_hv(struct kvm *kvm, unsigned long start, unsigned long end) |
| 917 | { | 913 | { |
| 918 | if (kvm->arch.using_mmu_notifiers) | 914 | if (kvm->arch.using_mmu_notifiers) |
| 919 | kvm_handle_hva_range(kvm, start, end, kvm_unmap_rmapp); | 915 | kvm_handle_hva_range(kvm, start, end, kvm_unmap_rmapp); |
| 920 | return 0; | 916 | return 0; |
| 921 | } | 917 | } |
| 922 | 918 | ||
| 923 | void kvmppc_core_flush_memslot(struct kvm *kvm, struct kvm_memory_slot *memslot) | 919 | void kvmppc_core_flush_memslot_hv(struct kvm *kvm, |
| 920 | struct kvm_memory_slot *memslot) | ||
| 924 | { | 921 | { |
| 925 | unsigned long *rmapp; | 922 | unsigned long *rmapp; |
| 926 | unsigned long gfn; | 923 | unsigned long gfn; |
| @@ -994,7 +991,7 @@ static int kvm_age_rmapp(struct kvm *kvm, unsigned long *rmapp, | |||
| 994 | return ret; | 991 | return ret; |
| 995 | } | 992 | } |
| 996 | 993 | ||
| 997 | int kvm_age_hva(struct kvm *kvm, unsigned long hva) | 994 | int kvm_age_hva_hv(struct kvm *kvm, unsigned long hva) |
| 998 | { | 995 | { |
| 999 | if (!kvm->arch.using_mmu_notifiers) | 996 | if (!kvm->arch.using_mmu_notifiers) |
| 1000 | return 0; | 997 | return 0; |
| @@ -1032,14 +1029,14 @@ static int kvm_test_age_rmapp(struct kvm *kvm, unsigned long *rmapp, | |||
| 1032 | return ret; | 1029 | return ret; |
| 1033 | } | 1030 | } |
| 1034 | 1031 | ||
| 1035 | int kvm_test_age_hva(struct kvm *kvm, unsigned long hva) | 1032 | int kvm_test_age_hva_hv(struct kvm *kvm, unsigned long hva) |
| 1036 | { | 1033 | { |
| 1037 | if (!kvm->arch.using_mmu_notifiers) | 1034 | if (!kvm->arch.using_mmu_notifiers) |
| 1038 | return 0; | 1035 | return 0; |
| 1039 | return kvm_handle_hva(kvm, hva, kvm_test_age_rmapp); | 1036 | return kvm_handle_hva(kvm, hva, kvm_test_age_rmapp); |
| 1040 | } | 1037 | } |
| 1041 | 1038 | ||
| 1042 | void kvm_set_spte_hva(struct kvm *kvm, unsigned long hva, pte_t pte) | 1039 | void kvm_set_spte_hva_hv(struct kvm *kvm, unsigned long hva, pte_t pte) |
| 1043 | { | 1040 | { |
| 1044 | if (!kvm->arch.using_mmu_notifiers) | 1041 | if (!kvm->arch.using_mmu_notifiers) |
| 1045 | return; | 1042 | return; |
| @@ -1512,9 +1509,8 @@ static ssize_t kvm_htab_write(struct file *file, const char __user *buf, | |||
| 1512 | 1509 | ||
| 1513 | kvm->arch.vrma_slb_v = senc | SLB_VSID_B_1T | | 1510 | kvm->arch.vrma_slb_v = senc | SLB_VSID_B_1T | |
| 1514 | (VRMA_VSID << SLB_VSID_SHIFT_1T); | 1511 | (VRMA_VSID << SLB_VSID_SHIFT_1T); |
| 1515 | lpcr = kvm->arch.lpcr & ~LPCR_VRMASD; | 1512 | lpcr = senc << (LPCR_VRMASD_SH - 4); |
| 1516 | lpcr |= senc << (LPCR_VRMASD_SH - 4); | 1513 | kvmppc_update_lpcr(kvm, lpcr, LPCR_VRMASD); |
| 1517 | kvm->arch.lpcr = lpcr; | ||
| 1518 | rma_setup = 1; | 1514 | rma_setup = 1; |
| 1519 | } | 1515 | } |
| 1520 | ++i; | 1516 | ++i; |
diff --git a/arch/powerpc/kvm/book3s_64_vio_hv.c b/arch/powerpc/kvm/book3s_64_vio_hv.c index 30c2f3b134c6..2c25f5412bdb 100644 --- a/arch/powerpc/kvm/book3s_64_vio_hv.c +++ b/arch/powerpc/kvm/book3s_64_vio_hv.c | |||
| @@ -74,3 +74,4 @@ long kvmppc_h_put_tce(struct kvm_vcpu *vcpu, unsigned long liobn, | |||
| 74 | /* Didn't find the liobn, punt it to userspace */ | 74 | /* Didn't find the liobn, punt it to userspace */ |
| 75 | return H_TOO_HARD; | 75 | return H_TOO_HARD; |
| 76 | } | 76 | } |
| 77 | EXPORT_SYMBOL_GPL(kvmppc_h_put_tce); | ||
diff --git a/arch/powerpc/kvm/book3s_emulate.c b/arch/powerpc/kvm/book3s_emulate.c index 360ce68c9809..99d40f8977e8 100644 --- a/arch/powerpc/kvm/book3s_emulate.c +++ b/arch/powerpc/kvm/book3s_emulate.c | |||
| @@ -86,8 +86,8 @@ static bool spr_allowed(struct kvm_vcpu *vcpu, enum priv_level level) | |||
| 86 | return true; | 86 | return true; |
| 87 | } | 87 | } |
| 88 | 88 | ||
| 89 | int kvmppc_core_emulate_op(struct kvm_run *run, struct kvm_vcpu *vcpu, | 89 | int kvmppc_core_emulate_op_pr(struct kvm_run *run, struct kvm_vcpu *vcpu, |
| 90 | unsigned int inst, int *advance) | 90 | unsigned int inst, int *advance) |
| 91 | { | 91 | { |
| 92 | int emulated = EMULATE_DONE; | 92 | int emulated = EMULATE_DONE; |
| 93 | int rt = get_rt(inst); | 93 | int rt = get_rt(inst); |
| @@ -172,7 +172,7 @@ int kvmppc_core_emulate_op(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 172 | vcpu->arch.mmu.tlbie(vcpu, addr, large); | 172 | vcpu->arch.mmu.tlbie(vcpu, addr, large); |
| 173 | break; | 173 | break; |
| 174 | } | 174 | } |
| 175 | #ifdef CONFIG_KVM_BOOK3S_64_PR | 175 | #ifdef CONFIG_PPC_BOOK3S_64 |
| 176 | case OP_31_XOP_FAKE_SC1: | 176 | case OP_31_XOP_FAKE_SC1: |
| 177 | { | 177 | { |
| 178 | /* SC 1 papr hypercalls */ | 178 | /* SC 1 papr hypercalls */ |
| @@ -267,12 +267,9 @@ int kvmppc_core_emulate_op(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 267 | 267 | ||
| 268 | r = kvmppc_st(vcpu, &addr, 32, zeros, true); | 268 | r = kvmppc_st(vcpu, &addr, 32, zeros, true); |
| 269 | if ((r == -ENOENT) || (r == -EPERM)) { | 269 | if ((r == -ENOENT) || (r == -EPERM)) { |
| 270 | struct kvmppc_book3s_shadow_vcpu *svcpu; | ||
| 271 | |||
| 272 | svcpu = svcpu_get(vcpu); | ||
| 273 | *advance = 0; | 270 | *advance = 0; |
| 274 | vcpu->arch.shared->dar = vaddr; | 271 | vcpu->arch.shared->dar = vaddr; |
| 275 | svcpu->fault_dar = vaddr; | 272 | vcpu->arch.fault_dar = vaddr; |
| 276 | 273 | ||
| 277 | dsisr = DSISR_ISSTORE; | 274 | dsisr = DSISR_ISSTORE; |
| 278 | if (r == -ENOENT) | 275 | if (r == -ENOENT) |
| @@ -281,8 +278,7 @@ int kvmppc_core_emulate_op(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 281 | dsisr |= DSISR_PROTFAULT; | 278 | dsisr |= DSISR_PROTFAULT; |
| 282 | 279 | ||
| 283 | vcpu->arch.shared->dsisr = dsisr; | 280 | vcpu->arch.shared->dsisr = dsisr; |
| 284 | svcpu->fault_dsisr = dsisr; | 281 | vcpu->arch.fault_dsisr = dsisr; |
| 285 | svcpu_put(svcpu); | ||
| 286 | 282 | ||
| 287 | kvmppc_book3s_queue_irqprio(vcpu, | 283 | kvmppc_book3s_queue_irqprio(vcpu, |
| 288 | BOOK3S_INTERRUPT_DATA_STORAGE); | 284 | BOOK3S_INTERRUPT_DATA_STORAGE); |
| @@ -349,7 +345,7 @@ static struct kvmppc_bat *kvmppc_find_bat(struct kvm_vcpu *vcpu, int sprn) | |||
| 349 | return bat; | 345 | return bat; |
| 350 | } | 346 | } |
| 351 | 347 | ||
| 352 | int kvmppc_core_emulate_mtspr(struct kvm_vcpu *vcpu, int sprn, ulong spr_val) | 348 | int kvmppc_core_emulate_mtspr_pr(struct kvm_vcpu *vcpu, int sprn, ulong spr_val) |
| 353 | { | 349 | { |
| 354 | int emulated = EMULATE_DONE; | 350 | int emulated = EMULATE_DONE; |
| 355 | 351 | ||
| @@ -472,7 +468,7 @@ unprivileged: | |||
| 472 | return emulated; | 468 | return emulated; |
| 473 | } | 469 | } |
| 474 | 470 | ||
| 475 | int kvmppc_core_emulate_mfspr(struct kvm_vcpu *vcpu, int sprn, ulong *spr_val) | 471 | int kvmppc_core_emulate_mfspr_pr(struct kvm_vcpu *vcpu, int sprn, ulong *spr_val) |
| 476 | { | 472 | { |
| 477 | int emulated = EMULATE_DONE; | 473 | int emulated = EMULATE_DONE; |
| 478 | 474 | ||
diff --git a/arch/powerpc/kvm/book3s_exports.c b/arch/powerpc/kvm/book3s_exports.c index 7057a02f0906..852989a9bad3 100644 --- a/arch/powerpc/kvm/book3s_exports.c +++ b/arch/powerpc/kvm/book3s_exports.c | |||
| @@ -20,9 +20,10 @@ | |||
| 20 | #include <linux/export.h> | 20 | #include <linux/export.h> |
| 21 | #include <asm/kvm_book3s.h> | 21 | #include <asm/kvm_book3s.h> |
| 22 | 22 | ||
| 23 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 23 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE |
| 24 | EXPORT_SYMBOL_GPL(kvmppc_hv_entry_trampoline); | 24 | EXPORT_SYMBOL_GPL(kvmppc_hv_entry_trampoline); |
| 25 | #else | 25 | #endif |
| 26 | #ifdef CONFIG_KVM_BOOK3S_PR_POSSIBLE | ||
| 26 | EXPORT_SYMBOL_GPL(kvmppc_entry_trampoline); | 27 | EXPORT_SYMBOL_GPL(kvmppc_entry_trampoline); |
| 27 | EXPORT_SYMBOL_GPL(kvmppc_load_up_fpu); | 28 | EXPORT_SYMBOL_GPL(kvmppc_load_up_fpu); |
| 28 | #ifdef CONFIG_ALTIVEC | 29 | #ifdef CONFIG_ALTIVEC |
diff --git a/arch/powerpc/kvm/book3s_hv.c b/arch/powerpc/kvm/book3s_hv.c index 62a2b5ab08ed..072287f1c3bc 100644 --- a/arch/powerpc/kvm/book3s_hv.c +++ b/arch/powerpc/kvm/book3s_hv.c | |||
| @@ -52,6 +52,9 @@ | |||
| 52 | #include <linux/vmalloc.h> | 52 | #include <linux/vmalloc.h> |
| 53 | #include <linux/highmem.h> | 53 | #include <linux/highmem.h> |
| 54 | #include <linux/hugetlb.h> | 54 | #include <linux/hugetlb.h> |
| 55 | #include <linux/module.h> | ||
| 56 | |||
| 57 | #include "book3s.h" | ||
| 55 | 58 | ||
| 56 | /* #define EXIT_DEBUG */ | 59 | /* #define EXIT_DEBUG */ |
| 57 | /* #define EXIT_DEBUG_SIMPLE */ | 60 | /* #define EXIT_DEBUG_SIMPLE */ |
| @@ -66,7 +69,7 @@ | |||
| 66 | static void kvmppc_end_cede(struct kvm_vcpu *vcpu); | 69 | static void kvmppc_end_cede(struct kvm_vcpu *vcpu); |
| 67 | static int kvmppc_hv_setup_htab_rma(struct kvm_vcpu *vcpu); | 70 | static int kvmppc_hv_setup_htab_rma(struct kvm_vcpu *vcpu); |
| 68 | 71 | ||
| 69 | void kvmppc_fast_vcpu_kick(struct kvm_vcpu *vcpu) | 72 | static void kvmppc_fast_vcpu_kick_hv(struct kvm_vcpu *vcpu) |
| 70 | { | 73 | { |
| 71 | int me; | 74 | int me; |
| 72 | int cpu = vcpu->cpu; | 75 | int cpu = vcpu->cpu; |
| @@ -125,7 +128,7 @@ void kvmppc_fast_vcpu_kick(struct kvm_vcpu *vcpu) | |||
| 125 | * purely defensive; they should never fail.) | 128 | * purely defensive; they should never fail.) |
| 126 | */ | 129 | */ |
| 127 | 130 | ||
| 128 | void kvmppc_core_vcpu_load(struct kvm_vcpu *vcpu, int cpu) | 131 | static void kvmppc_core_vcpu_load_hv(struct kvm_vcpu *vcpu, int cpu) |
| 129 | { | 132 | { |
| 130 | struct kvmppc_vcore *vc = vcpu->arch.vcore; | 133 | struct kvmppc_vcore *vc = vcpu->arch.vcore; |
| 131 | 134 | ||
| @@ -143,7 +146,7 @@ void kvmppc_core_vcpu_load(struct kvm_vcpu *vcpu, int cpu) | |||
| 143 | spin_unlock(&vcpu->arch.tbacct_lock); | 146 | spin_unlock(&vcpu->arch.tbacct_lock); |
| 144 | } | 147 | } |
| 145 | 148 | ||
| 146 | void kvmppc_core_vcpu_put(struct kvm_vcpu *vcpu) | 149 | static void kvmppc_core_vcpu_put_hv(struct kvm_vcpu *vcpu) |
| 147 | { | 150 | { |
| 148 | struct kvmppc_vcore *vc = vcpu->arch.vcore; | 151 | struct kvmppc_vcore *vc = vcpu->arch.vcore; |
| 149 | 152 | ||
| @@ -155,17 +158,46 @@ void kvmppc_core_vcpu_put(struct kvm_vcpu *vcpu) | |||
| 155 | spin_unlock(&vcpu->arch.tbacct_lock); | 158 | spin_unlock(&vcpu->arch.tbacct_lock); |
| 156 | } | 159 | } |
| 157 | 160 | ||
| 158 | void kvmppc_set_msr(struct kvm_vcpu *vcpu, u64 msr) | 161 | static void kvmppc_set_msr_hv(struct kvm_vcpu *vcpu, u64 msr) |
| 159 | { | 162 | { |
| 160 | vcpu->arch.shregs.msr = msr; | 163 | vcpu->arch.shregs.msr = msr; |
| 161 | kvmppc_end_cede(vcpu); | 164 | kvmppc_end_cede(vcpu); |
| 162 | } | 165 | } |
| 163 | 166 | ||
| 164 | void kvmppc_set_pvr(struct kvm_vcpu *vcpu, u32 pvr) | 167 | void kvmppc_set_pvr_hv(struct kvm_vcpu *vcpu, u32 pvr) |
| 165 | { | 168 | { |
| 166 | vcpu->arch.pvr = pvr; | 169 | vcpu->arch.pvr = pvr; |
| 167 | } | 170 | } |
| 168 | 171 | ||
| 172 | int kvmppc_set_arch_compat(struct kvm_vcpu *vcpu, u32 arch_compat) | ||
| 173 | { | ||
| 174 | unsigned long pcr = 0; | ||
| 175 | struct kvmppc_vcore *vc = vcpu->arch.vcore; | ||
| 176 | |||
| 177 | if (arch_compat) { | ||
| 178 | if (!cpu_has_feature(CPU_FTR_ARCH_206)) | ||
| 179 | return -EINVAL; /* 970 has no compat mode support */ | ||
| 180 | |||
| 181 | switch (arch_compat) { | ||
| 182 | case PVR_ARCH_205: | ||
| 183 | pcr = PCR_ARCH_205; | ||
| 184 | break; | ||
| 185 | case PVR_ARCH_206: | ||
| 186 | case PVR_ARCH_206p: | ||
| 187 | break; | ||
| 188 | default: | ||
| 189 | return -EINVAL; | ||
| 190 | } | ||
| 191 | } | ||
| 192 | |||
| 193 | spin_lock(&vc->lock); | ||
| 194 | vc->arch_compat = arch_compat; | ||
| 195 | vc->pcr = pcr; | ||
| 196 | spin_unlock(&vc->lock); | ||
| 197 | |||
| 198 | return 0; | ||
| 199 | } | ||
| 200 | |||
| 169 | void kvmppc_dump_regs(struct kvm_vcpu *vcpu) | 201 | void kvmppc_dump_regs(struct kvm_vcpu *vcpu) |
| 170 | { | 202 | { |
| 171 | int r; | 203 | int r; |
| @@ -195,7 +227,7 @@ void kvmppc_dump_regs(struct kvm_vcpu *vcpu) | |||
| 195 | pr_err(" ESID = %.16llx VSID = %.16llx\n", | 227 | pr_err(" ESID = %.16llx VSID = %.16llx\n", |
| 196 | vcpu->arch.slb[r].orige, vcpu->arch.slb[r].origv); | 228 | vcpu->arch.slb[r].orige, vcpu->arch.slb[r].origv); |
| 197 | pr_err("lpcr = %.16lx sdr1 = %.16lx last_inst = %.8x\n", | 229 | pr_err("lpcr = %.16lx sdr1 = %.16lx last_inst = %.8x\n", |
| 198 | vcpu->kvm->arch.lpcr, vcpu->kvm->arch.sdr1, | 230 | vcpu->arch.vcore->lpcr, vcpu->kvm->arch.sdr1, |
| 199 | vcpu->arch.last_inst); | 231 | vcpu->arch.last_inst); |
| 200 | } | 232 | } |
| 201 | 233 | ||
| @@ -489,7 +521,7 @@ static void kvmppc_create_dtl_entry(struct kvm_vcpu *vcpu, | |||
| 489 | memset(dt, 0, sizeof(struct dtl_entry)); | 521 | memset(dt, 0, sizeof(struct dtl_entry)); |
| 490 | dt->dispatch_reason = 7; | 522 | dt->dispatch_reason = 7; |
| 491 | dt->processor_id = vc->pcpu + vcpu->arch.ptid; | 523 | dt->processor_id = vc->pcpu + vcpu->arch.ptid; |
| 492 | dt->timebase = now; | 524 | dt->timebase = now + vc->tb_offset; |
| 493 | dt->enqueue_to_dispatch_time = stolen; | 525 | dt->enqueue_to_dispatch_time = stolen; |
| 494 | dt->srr0 = kvmppc_get_pc(vcpu); | 526 | dt->srr0 = kvmppc_get_pc(vcpu); |
| 495 | dt->srr1 = vcpu->arch.shregs.msr; | 527 | dt->srr1 = vcpu->arch.shregs.msr; |
| @@ -538,6 +570,15 @@ int kvmppc_pseries_do_hcall(struct kvm_vcpu *vcpu) | |||
| 538 | } | 570 | } |
| 539 | break; | 571 | break; |
| 540 | case H_CONFER: | 572 | case H_CONFER: |
| 573 | target = kvmppc_get_gpr(vcpu, 4); | ||
| 574 | if (target == -1) | ||
| 575 | break; | ||
| 576 | tvcpu = kvmppc_find_vcpu(vcpu->kvm, target); | ||
| 577 | if (!tvcpu) { | ||
| 578 | ret = H_PARAMETER; | ||
| 579 | break; | ||
| 580 | } | ||
| 581 | kvm_vcpu_yield_to(tvcpu); | ||
| 541 | break; | 582 | break; |
| 542 | case H_REGISTER_VPA: | 583 | case H_REGISTER_VPA: |
| 543 | ret = do_h_register_vpa(vcpu, kvmppc_get_gpr(vcpu, 4), | 584 | ret = do_h_register_vpa(vcpu, kvmppc_get_gpr(vcpu, 4), |
| @@ -576,8 +617,8 @@ int kvmppc_pseries_do_hcall(struct kvm_vcpu *vcpu) | |||
| 576 | return RESUME_GUEST; | 617 | return RESUME_GUEST; |
| 577 | } | 618 | } |
| 578 | 619 | ||
| 579 | static int kvmppc_handle_exit(struct kvm_run *run, struct kvm_vcpu *vcpu, | 620 | static int kvmppc_handle_exit_hv(struct kvm_run *run, struct kvm_vcpu *vcpu, |
| 580 | struct task_struct *tsk) | 621 | struct task_struct *tsk) |
| 581 | { | 622 | { |
| 582 | int r = RESUME_HOST; | 623 | int r = RESUME_HOST; |
| 583 | 624 | ||
| @@ -671,16 +712,16 @@ static int kvmppc_handle_exit(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 671 | printk(KERN_EMERG "trap=0x%x | pc=0x%lx | msr=0x%llx\n", | 712 | printk(KERN_EMERG "trap=0x%x | pc=0x%lx | msr=0x%llx\n", |
| 672 | vcpu->arch.trap, kvmppc_get_pc(vcpu), | 713 | vcpu->arch.trap, kvmppc_get_pc(vcpu), |
| 673 | vcpu->arch.shregs.msr); | 714 | vcpu->arch.shregs.msr); |
| 715 | run->hw.hardware_exit_reason = vcpu->arch.trap; | ||
| 674 | r = RESUME_HOST; | 716 | r = RESUME_HOST; |
| 675 | BUG(); | ||
| 676 | break; | 717 | break; |
| 677 | } | 718 | } |
| 678 | 719 | ||
| 679 | return r; | 720 | return r; |
| 680 | } | 721 | } |
| 681 | 722 | ||
| 682 | int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, | 723 | static int kvm_arch_vcpu_ioctl_get_sregs_hv(struct kvm_vcpu *vcpu, |
| 683 | struct kvm_sregs *sregs) | 724 | struct kvm_sregs *sregs) |
| 684 | { | 725 | { |
| 685 | int i; | 726 | int i; |
| 686 | 727 | ||
| @@ -694,12 +735,12 @@ int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, | |||
| 694 | return 0; | 735 | return 0; |
| 695 | } | 736 | } |
| 696 | 737 | ||
| 697 | int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, | 738 | static int kvm_arch_vcpu_ioctl_set_sregs_hv(struct kvm_vcpu *vcpu, |
| 698 | struct kvm_sregs *sregs) | 739 | struct kvm_sregs *sregs) |
| 699 | { | 740 | { |
| 700 | int i, j; | 741 | int i, j; |
| 701 | 742 | ||
| 702 | kvmppc_set_pvr(vcpu, sregs->pvr); | 743 | kvmppc_set_pvr_hv(vcpu, sregs->pvr); |
| 703 | 744 | ||
| 704 | j = 0; | 745 | j = 0; |
| 705 | for (i = 0; i < vcpu->arch.slb_nr; i++) { | 746 | for (i = 0; i < vcpu->arch.slb_nr; i++) { |
| @@ -714,7 +755,23 @@ int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, | |||
| 714 | return 0; | 755 | return 0; |
| 715 | } | 756 | } |
| 716 | 757 | ||
| 717 | int kvmppc_get_one_reg(struct kvm_vcpu *vcpu, u64 id, union kvmppc_one_reg *val) | 758 | static void kvmppc_set_lpcr(struct kvm_vcpu *vcpu, u64 new_lpcr) |
| 759 | { | ||
| 760 | struct kvmppc_vcore *vc = vcpu->arch.vcore; | ||
| 761 | u64 mask; | ||
| 762 | |||
| 763 | spin_lock(&vc->lock); | ||
| 764 | /* | ||
| 765 | * Userspace can only modify DPFD (default prefetch depth), | ||
| 766 | * ILE (interrupt little-endian) and TC (translation control). | ||
| 767 | */ | ||
| 768 | mask = LPCR_DPFD | LPCR_ILE | LPCR_TC; | ||
| 769 | vc->lpcr = (vc->lpcr & ~mask) | (new_lpcr & mask); | ||
| 770 | spin_unlock(&vc->lock); | ||
| 771 | } | ||
| 772 | |||
| 773 | static int kvmppc_get_one_reg_hv(struct kvm_vcpu *vcpu, u64 id, | ||
| 774 | union kvmppc_one_reg *val) | ||
| 718 | { | 775 | { |
| 719 | int r = 0; | 776 | int r = 0; |
| 720 | long int i; | 777 | long int i; |
| @@ -749,6 +806,12 @@ int kvmppc_get_one_reg(struct kvm_vcpu *vcpu, u64 id, union kvmppc_one_reg *val) | |||
| 749 | i = id - KVM_REG_PPC_PMC1; | 806 | i = id - KVM_REG_PPC_PMC1; |
| 750 | *val = get_reg_val(id, vcpu->arch.pmc[i]); | 807 | *val = get_reg_val(id, vcpu->arch.pmc[i]); |
| 751 | break; | 808 | break; |
| 809 | case KVM_REG_PPC_SIAR: | ||
| 810 | *val = get_reg_val(id, vcpu->arch.siar); | ||
| 811 | break; | ||
| 812 | case KVM_REG_PPC_SDAR: | ||
| 813 | *val = get_reg_val(id, vcpu->arch.sdar); | ||
| 814 | break; | ||
| 752 | #ifdef CONFIG_VSX | 815 | #ifdef CONFIG_VSX |
| 753 | case KVM_REG_PPC_FPR0 ... KVM_REG_PPC_FPR31: | 816 | case KVM_REG_PPC_FPR0 ... KVM_REG_PPC_FPR31: |
| 754 | if (cpu_has_feature(CPU_FTR_VSX)) { | 817 | if (cpu_has_feature(CPU_FTR_VSX)) { |
| @@ -787,6 +850,18 @@ int kvmppc_get_one_reg(struct kvm_vcpu *vcpu, u64 id, union kvmppc_one_reg *val) | |||
| 787 | val->vpaval.length = vcpu->arch.dtl.len; | 850 | val->vpaval.length = vcpu->arch.dtl.len; |
| 788 | spin_unlock(&vcpu->arch.vpa_update_lock); | 851 | spin_unlock(&vcpu->arch.vpa_update_lock); |
| 789 | break; | 852 | break; |
| 853 | case KVM_REG_PPC_TB_OFFSET: | ||
| 854 | *val = get_reg_val(id, vcpu->arch.vcore->tb_offset); | ||
| 855 | break; | ||
| 856 | case KVM_REG_PPC_LPCR: | ||
| 857 | *val = get_reg_val(id, vcpu->arch.vcore->lpcr); | ||
| 858 | break; | ||
| 859 | case KVM_REG_PPC_PPR: | ||
| 860 | *val = get_reg_val(id, vcpu->arch.ppr); | ||
| 861 | break; | ||
| 862 | case KVM_REG_PPC_ARCH_COMPAT: | ||
| 863 | *val = get_reg_val(id, vcpu->arch.vcore->arch_compat); | ||
| 864 | break; | ||
| 790 | default: | 865 | default: |
| 791 | r = -EINVAL; | 866 | r = -EINVAL; |
| 792 | break; | 867 | break; |
| @@ -795,7 +870,8 @@ int kvmppc_get_one_reg(struct kvm_vcpu *vcpu, u64 id, union kvmppc_one_reg *val) | |||
| 795 | return r; | 870 | return r; |
| 796 | } | 871 | } |
| 797 | 872 | ||
| 798 | int kvmppc_set_one_reg(struct kvm_vcpu *vcpu, u64 id, union kvmppc_one_reg *val) | 873 | static int kvmppc_set_one_reg_hv(struct kvm_vcpu *vcpu, u64 id, |
| 874 | union kvmppc_one_reg *val) | ||
| 799 | { | 875 | { |
| 800 | int r = 0; | 876 | int r = 0; |
| 801 | long int i; | 877 | long int i; |
| @@ -833,6 +909,12 @@ int kvmppc_set_one_reg(struct kvm_vcpu *vcpu, u64 id, union kvmppc_one_reg *val) | |||
| 833 | i = id - KVM_REG_PPC_PMC1; | 909 | i = id - KVM_REG_PPC_PMC1; |
| 834 | vcpu->arch.pmc[i] = set_reg_val(id, *val); | 910 | vcpu->arch.pmc[i] = set_reg_val(id, *val); |
| 835 | break; | 911 | break; |
| 912 | case KVM_REG_PPC_SIAR: | ||
| 913 | vcpu->arch.siar = set_reg_val(id, *val); | ||
| 914 | break; | ||
| 915 | case KVM_REG_PPC_SDAR: | ||
| 916 | vcpu->arch.sdar = set_reg_val(id, *val); | ||
| 917 | break; | ||
| 836 | #ifdef CONFIG_VSX | 918 | #ifdef CONFIG_VSX |
| 837 | case KVM_REG_PPC_FPR0 ... KVM_REG_PPC_FPR31: | 919 | case KVM_REG_PPC_FPR0 ... KVM_REG_PPC_FPR31: |
| 838 | if (cpu_has_feature(CPU_FTR_VSX)) { | 920 | if (cpu_has_feature(CPU_FTR_VSX)) { |
| @@ -880,6 +962,20 @@ int kvmppc_set_one_reg(struct kvm_vcpu *vcpu, u64 id, union kvmppc_one_reg *val) | |||
| 880 | len -= len % sizeof(struct dtl_entry); | 962 | len -= len % sizeof(struct dtl_entry); |
| 881 | r = set_vpa(vcpu, &vcpu->arch.dtl, addr, len); | 963 | r = set_vpa(vcpu, &vcpu->arch.dtl, addr, len); |
| 882 | break; | 964 | break; |
| 965 | case KVM_REG_PPC_TB_OFFSET: | ||
| 966 | /* round up to multiple of 2^24 */ | ||
| 967 | vcpu->arch.vcore->tb_offset = | ||
| 968 | ALIGN(set_reg_val(id, *val), 1UL << 24); | ||
| 969 | break; | ||
| 970 | case KVM_REG_PPC_LPCR: | ||
| 971 | kvmppc_set_lpcr(vcpu, set_reg_val(id, *val)); | ||
| 972 | break; | ||
| 973 | case KVM_REG_PPC_PPR: | ||
| 974 | vcpu->arch.ppr = set_reg_val(id, *val); | ||
| 975 | break; | ||
| 976 | case KVM_REG_PPC_ARCH_COMPAT: | ||
| 977 | r = kvmppc_set_arch_compat(vcpu, set_reg_val(id, *val)); | ||
| 978 | break; | ||
| 883 | default: | 979 | default: |
| 884 | r = -EINVAL; | 980 | r = -EINVAL; |
| 885 | break; | 981 | break; |
| @@ -888,14 +984,8 @@ int kvmppc_set_one_reg(struct kvm_vcpu *vcpu, u64 id, union kvmppc_one_reg *val) | |||
| 888 | return r; | 984 | return r; |
| 889 | } | 985 | } |
| 890 | 986 | ||
| 891 | int kvmppc_core_check_processor_compat(void) | 987 | static struct kvm_vcpu *kvmppc_core_vcpu_create_hv(struct kvm *kvm, |
| 892 | { | 988 | unsigned int id) |
| 893 | if (cpu_has_feature(CPU_FTR_HVMODE)) | ||
| 894 | return 0; | ||
| 895 | return -EIO; | ||
| 896 | } | ||
| 897 | |||
| 898 | struct kvm_vcpu *kvmppc_core_vcpu_create(struct kvm *kvm, unsigned int id) | ||
| 899 | { | 989 | { |
| 900 | struct kvm_vcpu *vcpu; | 990 | struct kvm_vcpu *vcpu; |
| 901 | int err = -EINVAL; | 991 | int err = -EINVAL; |
| @@ -919,8 +1009,7 @@ struct kvm_vcpu *kvmppc_core_vcpu_create(struct kvm *kvm, unsigned int id) | |||
| 919 | vcpu->arch.mmcr[0] = MMCR0_FC; | 1009 | vcpu->arch.mmcr[0] = MMCR0_FC; |
| 920 | vcpu->arch.ctrl = CTRL_RUNLATCH; | 1010 | vcpu->arch.ctrl = CTRL_RUNLATCH; |
| 921 | /* default to host PVR, since we can't spoof it */ | 1011 | /* default to host PVR, since we can't spoof it */ |
| 922 | vcpu->arch.pvr = mfspr(SPRN_PVR); | 1012 | kvmppc_set_pvr_hv(vcpu, mfspr(SPRN_PVR)); |
| 923 | kvmppc_set_pvr(vcpu, vcpu->arch.pvr); | ||
| 924 | spin_lock_init(&vcpu->arch.vpa_update_lock); | 1013 | spin_lock_init(&vcpu->arch.vpa_update_lock); |
| 925 | spin_lock_init(&vcpu->arch.tbacct_lock); | 1014 | spin_lock_init(&vcpu->arch.tbacct_lock); |
| 926 | vcpu->arch.busy_preempt = TB_NIL; | 1015 | vcpu->arch.busy_preempt = TB_NIL; |
| @@ -940,6 +1029,7 @@ struct kvm_vcpu *kvmppc_core_vcpu_create(struct kvm *kvm, unsigned int id) | |||
| 940 | spin_lock_init(&vcore->lock); | 1029 | spin_lock_init(&vcore->lock); |
| 941 | init_waitqueue_head(&vcore->wq); | 1030 | init_waitqueue_head(&vcore->wq); |
| 942 | vcore->preempt_tb = TB_NIL; | 1031 | vcore->preempt_tb = TB_NIL; |
| 1032 | vcore->lpcr = kvm->arch.lpcr; | ||
| 943 | } | 1033 | } |
| 944 | kvm->arch.vcores[core] = vcore; | 1034 | kvm->arch.vcores[core] = vcore; |
| 945 | kvm->arch.online_vcores++; | 1035 | kvm->arch.online_vcores++; |
| @@ -972,7 +1062,7 @@ static void unpin_vpa(struct kvm *kvm, struct kvmppc_vpa *vpa) | |||
| 972 | vpa->dirty); | 1062 | vpa->dirty); |
| 973 | } | 1063 | } |
| 974 | 1064 | ||
| 975 | void kvmppc_core_vcpu_free(struct kvm_vcpu *vcpu) | 1065 | static void kvmppc_core_vcpu_free_hv(struct kvm_vcpu *vcpu) |
| 976 | { | 1066 | { |
| 977 | spin_lock(&vcpu->arch.vpa_update_lock); | 1067 | spin_lock(&vcpu->arch.vpa_update_lock); |
| 978 | unpin_vpa(vcpu->kvm, &vcpu->arch.dtl); | 1068 | unpin_vpa(vcpu->kvm, &vcpu->arch.dtl); |
| @@ -983,6 +1073,12 @@ void kvmppc_core_vcpu_free(struct kvm_vcpu *vcpu) | |||
| 983 | kmem_cache_free(kvm_vcpu_cache, vcpu); | 1073 | kmem_cache_free(kvm_vcpu_cache, vcpu); |
| 984 | } | 1074 | } |
| 985 | 1075 | ||
| 1076 | static int kvmppc_core_check_requests_hv(struct kvm_vcpu *vcpu) | ||
| 1077 | { | ||
| 1078 | /* Indicate we want to get back into the guest */ | ||
| 1079 | return 1; | ||
| 1080 | } | ||
| 1081 | |||
| 986 | static void kvmppc_set_timer(struct kvm_vcpu *vcpu) | 1082 | static void kvmppc_set_timer(struct kvm_vcpu *vcpu) |
| 987 | { | 1083 | { |
| 988 | unsigned long dec_nsec, now; | 1084 | unsigned long dec_nsec, now; |
| @@ -1264,8 +1360,8 @@ static void kvmppc_run_core(struct kvmppc_vcore *vc) | |||
| 1264 | 1360 | ||
| 1265 | ret = RESUME_GUEST; | 1361 | ret = RESUME_GUEST; |
| 1266 | if (vcpu->arch.trap) | 1362 | if (vcpu->arch.trap) |
| 1267 | ret = kvmppc_handle_exit(vcpu->arch.kvm_run, vcpu, | 1363 | ret = kvmppc_handle_exit_hv(vcpu->arch.kvm_run, vcpu, |
| 1268 | vcpu->arch.run_task); | 1364 | vcpu->arch.run_task); |
| 1269 | 1365 | ||
| 1270 | vcpu->arch.ret = ret; | 1366 | vcpu->arch.ret = ret; |
| 1271 | vcpu->arch.trap = 0; | 1367 | vcpu->arch.trap = 0; |
| @@ -1424,7 +1520,7 @@ static int kvmppc_run_vcpu(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu) | |||
| 1424 | return vcpu->arch.ret; | 1520 | return vcpu->arch.ret; |
| 1425 | } | 1521 | } |
| 1426 | 1522 | ||
| 1427 | int kvmppc_vcpu_run(struct kvm_run *run, struct kvm_vcpu *vcpu) | 1523 | static int kvmppc_vcpu_run_hv(struct kvm_run *run, struct kvm_vcpu *vcpu) |
| 1428 | { | 1524 | { |
| 1429 | int r; | 1525 | int r; |
| 1430 | int srcu_idx; | 1526 | int srcu_idx; |
| @@ -1546,7 +1642,8 @@ static const struct file_operations kvm_rma_fops = { | |||
| 1546 | .release = kvm_rma_release, | 1642 | .release = kvm_rma_release, |
| 1547 | }; | 1643 | }; |
| 1548 | 1644 | ||
| 1549 | long kvm_vm_ioctl_allocate_rma(struct kvm *kvm, struct kvm_allocate_rma *ret) | 1645 | static long kvm_vm_ioctl_allocate_rma(struct kvm *kvm, |
| 1646 | struct kvm_allocate_rma *ret) | ||
| 1550 | { | 1647 | { |
| 1551 | long fd; | 1648 | long fd; |
| 1552 | struct kvm_rma_info *ri; | 1649 | struct kvm_rma_info *ri; |
| @@ -1592,7 +1689,8 @@ static void kvmppc_add_seg_page_size(struct kvm_ppc_one_seg_page_size **sps, | |||
| 1592 | (*sps)++; | 1689 | (*sps)++; |
| 1593 | } | 1690 | } |
| 1594 | 1691 | ||
| 1595 | int kvm_vm_ioctl_get_smmu_info(struct kvm *kvm, struct kvm_ppc_smmu_info *info) | 1692 | static int kvm_vm_ioctl_get_smmu_info_hv(struct kvm *kvm, |
| 1693 | struct kvm_ppc_smmu_info *info) | ||
| 1596 | { | 1694 | { |
| 1597 | struct kvm_ppc_one_seg_page_size *sps; | 1695 | struct kvm_ppc_one_seg_page_size *sps; |
| 1598 | 1696 | ||
| @@ -1613,7 +1711,8 @@ int kvm_vm_ioctl_get_smmu_info(struct kvm *kvm, struct kvm_ppc_smmu_info *info) | |||
| 1613 | /* | 1711 | /* |
| 1614 | * Get (and clear) the dirty memory log for a memory slot. | 1712 | * Get (and clear) the dirty memory log for a memory slot. |
| 1615 | */ | 1713 | */ |
| 1616 | int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, struct kvm_dirty_log *log) | 1714 | static int kvm_vm_ioctl_get_dirty_log_hv(struct kvm *kvm, |
| 1715 | struct kvm_dirty_log *log) | ||
| 1617 | { | 1716 | { |
| 1618 | struct kvm_memory_slot *memslot; | 1717 | struct kvm_memory_slot *memslot; |
| 1619 | int r; | 1718 | int r; |
| @@ -1667,8 +1766,8 @@ static void unpin_slot(struct kvm_memory_slot *memslot) | |||
| 1667 | } | 1766 | } |
| 1668 | } | 1767 | } |
| 1669 | 1768 | ||
| 1670 | void kvmppc_core_free_memslot(struct kvm_memory_slot *free, | 1769 | static void kvmppc_core_free_memslot_hv(struct kvm_memory_slot *free, |
| 1671 | struct kvm_memory_slot *dont) | 1770 | struct kvm_memory_slot *dont) |
| 1672 | { | 1771 | { |
| 1673 | if (!dont || free->arch.rmap != dont->arch.rmap) { | 1772 | if (!dont || free->arch.rmap != dont->arch.rmap) { |
| 1674 | vfree(free->arch.rmap); | 1773 | vfree(free->arch.rmap); |
| @@ -1681,8 +1780,8 @@ void kvmppc_core_free_memslot(struct kvm_memory_slot *free, | |||
| 1681 | } | 1780 | } |
| 1682 | } | 1781 | } |
| 1683 | 1782 | ||
| 1684 | int kvmppc_core_create_memslot(struct kvm_memory_slot *slot, | 1783 | static int kvmppc_core_create_memslot_hv(struct kvm_memory_slot *slot, |
| 1685 | unsigned long npages) | 1784 | unsigned long npages) |
| 1686 | { | 1785 | { |
| 1687 | slot->arch.rmap = vzalloc(npages * sizeof(*slot->arch.rmap)); | 1786 | slot->arch.rmap = vzalloc(npages * sizeof(*slot->arch.rmap)); |
| 1688 | if (!slot->arch.rmap) | 1787 | if (!slot->arch.rmap) |
| @@ -1692,9 +1791,9 @@ int kvmppc_core_create_memslot(struct kvm_memory_slot *slot, | |||
| 1692 | return 0; | 1791 | return 0; |
| 1693 | } | 1792 | } |
| 1694 | 1793 | ||
| 1695 | int kvmppc_core_prepare_memory_region(struct kvm *kvm, | 1794 | static int kvmppc_core_prepare_memory_region_hv(struct kvm *kvm, |
| 1696 | struct kvm_memory_slot *memslot, | 1795 | struct kvm_memory_slot *memslot, |
| 1697 | struct kvm_userspace_memory_region *mem) | 1796 | struct kvm_userspace_memory_region *mem) |
| 1698 | { | 1797 | { |
| 1699 | unsigned long *phys; | 1798 | unsigned long *phys; |
| 1700 | 1799 | ||
| @@ -1710,9 +1809,9 @@ int kvmppc_core_prepare_memory_region(struct kvm *kvm, | |||
| 1710 | return 0; | 1809 | return 0; |
| 1711 | } | 1810 | } |
| 1712 | 1811 | ||
| 1713 | void kvmppc_core_commit_memory_region(struct kvm *kvm, | 1812 | static void kvmppc_core_commit_memory_region_hv(struct kvm *kvm, |
| 1714 | struct kvm_userspace_memory_region *mem, | 1813 | struct kvm_userspace_memory_region *mem, |
| 1715 | const struct kvm_memory_slot *old) | 1814 | const struct kvm_memory_slot *old) |
| 1716 | { | 1815 | { |
| 1717 | unsigned long npages = mem->memory_size >> PAGE_SHIFT; | 1816 | unsigned long npages = mem->memory_size >> PAGE_SHIFT; |
| 1718 | struct kvm_memory_slot *memslot; | 1817 | struct kvm_memory_slot *memslot; |
| @@ -1729,6 +1828,37 @@ void kvmppc_core_commit_memory_region(struct kvm *kvm, | |||
| 1729 | } | 1828 | } |
| 1730 | } | 1829 | } |
| 1731 | 1830 | ||
| 1831 | /* | ||
| 1832 | * Update LPCR values in kvm->arch and in vcores. | ||
| 1833 | * Caller must hold kvm->lock. | ||
| 1834 | */ | ||
| 1835 | void kvmppc_update_lpcr(struct kvm *kvm, unsigned long lpcr, unsigned long mask) | ||
| 1836 | { | ||
| 1837 | long int i; | ||
| 1838 | u32 cores_done = 0; | ||
| 1839 | |||
| 1840 | if ((kvm->arch.lpcr & mask) == lpcr) | ||
| 1841 | return; | ||
| 1842 | |||
| 1843 | kvm->arch.lpcr = (kvm->arch.lpcr & ~mask) | lpcr; | ||
| 1844 | |||
| 1845 | for (i = 0; i < KVM_MAX_VCORES; ++i) { | ||
| 1846 | struct kvmppc_vcore *vc = kvm->arch.vcores[i]; | ||
| 1847 | if (!vc) | ||
| 1848 | continue; | ||
| 1849 | spin_lock(&vc->lock); | ||
| 1850 | vc->lpcr = (vc->lpcr & ~mask) | lpcr; | ||
| 1851 | spin_unlock(&vc->lock); | ||
| 1852 | if (++cores_done >= kvm->arch.online_vcores) | ||
| 1853 | break; | ||
| 1854 | } | ||
| 1855 | } | ||
| 1856 | |||
| 1857 | static void kvmppc_mmu_destroy_hv(struct kvm_vcpu *vcpu) | ||
| 1858 | { | ||
| 1859 | return; | ||
| 1860 | } | ||
| 1861 | |||
| 1732 | static int kvmppc_hv_setup_htab_rma(struct kvm_vcpu *vcpu) | 1862 | static int kvmppc_hv_setup_htab_rma(struct kvm_vcpu *vcpu) |
| 1733 | { | 1863 | { |
| 1734 | int err = 0; | 1864 | int err = 0; |
| @@ -1737,7 +1867,8 @@ static int kvmppc_hv_setup_htab_rma(struct kvm_vcpu *vcpu) | |||
| 1737 | unsigned long hva; | 1867 | unsigned long hva; |
| 1738 | struct kvm_memory_slot *memslot; | 1868 | struct kvm_memory_slot *memslot; |
| 1739 | struct vm_area_struct *vma; | 1869 | struct vm_area_struct *vma; |
| 1740 | unsigned long lpcr, senc; | 1870 | unsigned long lpcr = 0, senc; |
| 1871 | unsigned long lpcr_mask = 0; | ||
| 1741 | unsigned long psize, porder; | 1872 | unsigned long psize, porder; |
| 1742 | unsigned long rma_size; | 1873 | unsigned long rma_size; |
| 1743 | unsigned long rmls; | 1874 | unsigned long rmls; |
| @@ -1802,9 +1933,9 @@ static int kvmppc_hv_setup_htab_rma(struct kvm_vcpu *vcpu) | |||
| 1802 | senc = slb_pgsize_encoding(psize); | 1933 | senc = slb_pgsize_encoding(psize); |
| 1803 | kvm->arch.vrma_slb_v = senc | SLB_VSID_B_1T | | 1934 | kvm->arch.vrma_slb_v = senc | SLB_VSID_B_1T | |
| 1804 | (VRMA_VSID << SLB_VSID_SHIFT_1T); | 1935 | (VRMA_VSID << SLB_VSID_SHIFT_1T); |
| 1805 | lpcr = kvm->arch.lpcr & ~LPCR_VRMASD; | 1936 | lpcr_mask = LPCR_VRMASD; |
| 1806 | lpcr |= senc << (LPCR_VRMASD_SH - 4); | 1937 | /* the -4 is to account for senc values starting at 0x10 */ |
| 1807 | kvm->arch.lpcr = lpcr; | 1938 | lpcr = senc << (LPCR_VRMASD_SH - 4); |
| 1808 | 1939 | ||
| 1809 | /* Create HPTEs in the hash page table for the VRMA */ | 1940 | /* Create HPTEs in the hash page table for the VRMA */ |
| 1810 | kvmppc_map_vrma(vcpu, memslot, porder); | 1941 | kvmppc_map_vrma(vcpu, memslot, porder); |
| @@ -1825,23 +1956,21 @@ static int kvmppc_hv_setup_htab_rma(struct kvm_vcpu *vcpu) | |||
| 1825 | kvm->arch.rma = ri; | 1956 | kvm->arch.rma = ri; |
| 1826 | 1957 | ||
| 1827 | /* Update LPCR and RMOR */ | 1958 | /* Update LPCR and RMOR */ |
| 1828 | lpcr = kvm->arch.lpcr; | ||
| 1829 | if (cpu_has_feature(CPU_FTR_ARCH_201)) { | 1959 | if (cpu_has_feature(CPU_FTR_ARCH_201)) { |
| 1830 | /* PPC970; insert RMLS value (split field) in HID4 */ | 1960 | /* PPC970; insert RMLS value (split field) in HID4 */ |
| 1831 | lpcr &= ~((1ul << HID4_RMLS0_SH) | | 1961 | lpcr_mask = (1ul << HID4_RMLS0_SH) | |
| 1832 | (3ul << HID4_RMLS2_SH)); | 1962 | (3ul << HID4_RMLS2_SH) | HID4_RMOR; |
| 1833 | lpcr |= ((rmls >> 2) << HID4_RMLS0_SH) | | 1963 | lpcr = ((rmls >> 2) << HID4_RMLS0_SH) | |
| 1834 | ((rmls & 3) << HID4_RMLS2_SH); | 1964 | ((rmls & 3) << HID4_RMLS2_SH); |
| 1835 | /* RMOR is also in HID4 */ | 1965 | /* RMOR is also in HID4 */ |
| 1836 | lpcr |= ((ri->base_pfn >> (26 - PAGE_SHIFT)) & 0xffff) | 1966 | lpcr |= ((ri->base_pfn >> (26 - PAGE_SHIFT)) & 0xffff) |
| 1837 | << HID4_RMOR_SH; | 1967 | << HID4_RMOR_SH; |
| 1838 | } else { | 1968 | } else { |
| 1839 | /* POWER7 */ | 1969 | /* POWER7 */ |
| 1840 | lpcr &= ~(LPCR_VPM0 | LPCR_VRMA_L); | 1970 | lpcr_mask = LPCR_VPM0 | LPCR_VRMA_L | LPCR_RMLS; |
| 1841 | lpcr |= rmls << LPCR_RMLS_SH; | 1971 | lpcr = rmls << LPCR_RMLS_SH; |
| 1842 | kvm->arch.rmor = ri->base_pfn << PAGE_SHIFT; | 1972 | kvm->arch.rmor = ri->base_pfn << PAGE_SHIFT; |
| 1843 | } | 1973 | } |
| 1844 | kvm->arch.lpcr = lpcr; | ||
| 1845 | pr_info("KVM: Using RMO at %lx size %lx (LPCR = %lx)\n", | 1974 | pr_info("KVM: Using RMO at %lx size %lx (LPCR = %lx)\n", |
| 1846 | ri->base_pfn << PAGE_SHIFT, rma_size, lpcr); | 1975 | ri->base_pfn << PAGE_SHIFT, rma_size, lpcr); |
| 1847 | 1976 | ||
| @@ -1860,6 +1989,8 @@ static int kvmppc_hv_setup_htab_rma(struct kvm_vcpu *vcpu) | |||
| 1860 | } | 1989 | } |
| 1861 | } | 1990 | } |
| 1862 | 1991 | ||
| 1992 | kvmppc_update_lpcr(kvm, lpcr, lpcr_mask); | ||
| 1993 | |||
| 1863 | /* Order updates to kvm->arch.lpcr etc. vs. rma_setup_done */ | 1994 | /* Order updates to kvm->arch.lpcr etc. vs. rma_setup_done */ |
| 1864 | smp_wmb(); | 1995 | smp_wmb(); |
| 1865 | kvm->arch.rma_setup_done = 1; | 1996 | kvm->arch.rma_setup_done = 1; |
| @@ -1875,7 +2006,7 @@ static int kvmppc_hv_setup_htab_rma(struct kvm_vcpu *vcpu) | |||
| 1875 | goto out_srcu; | 2006 | goto out_srcu; |
| 1876 | } | 2007 | } |
| 1877 | 2008 | ||
| 1878 | int kvmppc_core_init_vm(struct kvm *kvm) | 2009 | static int kvmppc_core_init_vm_hv(struct kvm *kvm) |
| 1879 | { | 2010 | { |
| 1880 | unsigned long lpcr, lpid; | 2011 | unsigned long lpcr, lpid; |
| 1881 | 2012 | ||
| @@ -1893,9 +2024,6 @@ int kvmppc_core_init_vm(struct kvm *kvm) | |||
| 1893 | */ | 2024 | */ |
| 1894 | cpumask_setall(&kvm->arch.need_tlb_flush); | 2025 | cpumask_setall(&kvm->arch.need_tlb_flush); |
| 1895 | 2026 | ||
| 1896 | INIT_LIST_HEAD(&kvm->arch.spapr_tce_tables); | ||
| 1897 | INIT_LIST_HEAD(&kvm->arch.rtas_tokens); | ||
| 1898 | |||
| 1899 | kvm->arch.rma = NULL; | 2027 | kvm->arch.rma = NULL; |
| 1900 | 2028 | ||
| 1901 | kvm->arch.host_sdr1 = mfspr(SPRN_SDR1); | 2029 | kvm->arch.host_sdr1 = mfspr(SPRN_SDR1); |
| @@ -1931,61 +2059,162 @@ int kvmppc_core_init_vm(struct kvm *kvm) | |||
| 1931 | return 0; | 2059 | return 0; |
| 1932 | } | 2060 | } |
| 1933 | 2061 | ||
| 1934 | void kvmppc_core_destroy_vm(struct kvm *kvm) | 2062 | static void kvmppc_free_vcores(struct kvm *kvm) |
| 2063 | { | ||
| 2064 | long int i; | ||
| 2065 | |||
| 2066 | for (i = 0; i < KVM_MAX_VCORES; ++i) | ||
| 2067 | kfree(kvm->arch.vcores[i]); | ||
| 2068 | kvm->arch.online_vcores = 0; | ||
| 2069 | } | ||
| 2070 | |||
| 2071 | static void kvmppc_core_destroy_vm_hv(struct kvm *kvm) | ||
| 1935 | { | 2072 | { |
| 1936 | uninhibit_secondary_onlining(); | 2073 | uninhibit_secondary_onlining(); |
| 1937 | 2074 | ||
| 2075 | kvmppc_free_vcores(kvm); | ||
| 1938 | if (kvm->arch.rma) { | 2076 | if (kvm->arch.rma) { |
| 1939 | kvm_release_rma(kvm->arch.rma); | 2077 | kvm_release_rma(kvm->arch.rma); |
| 1940 | kvm->arch.rma = NULL; | 2078 | kvm->arch.rma = NULL; |
| 1941 | } | 2079 | } |
| 1942 | 2080 | ||
| 1943 | kvmppc_rtas_tokens_free(kvm); | ||
| 1944 | |||
| 1945 | kvmppc_free_hpt(kvm); | 2081 | kvmppc_free_hpt(kvm); |
| 1946 | WARN_ON(!list_empty(&kvm->arch.spapr_tce_tables)); | ||
| 1947 | } | 2082 | } |
| 1948 | 2083 | ||
| 1949 | /* These are stubs for now */ | 2084 | /* We don't need to emulate any privileged instructions or dcbz */ |
| 1950 | void kvmppc_mmu_pte_pflush(struct kvm_vcpu *vcpu, ulong pa_start, ulong pa_end) | 2085 | static int kvmppc_core_emulate_op_hv(struct kvm_run *run, struct kvm_vcpu *vcpu, |
| 2086 | unsigned int inst, int *advance) | ||
| 1951 | { | 2087 | { |
| 2088 | return EMULATE_FAIL; | ||
| 1952 | } | 2089 | } |
| 1953 | 2090 | ||
| 1954 | /* We don't need to emulate any privileged instructions or dcbz */ | 2091 | static int kvmppc_core_emulate_mtspr_hv(struct kvm_vcpu *vcpu, int sprn, |
| 1955 | int kvmppc_core_emulate_op(struct kvm_run *run, struct kvm_vcpu *vcpu, | 2092 | ulong spr_val) |
| 1956 | unsigned int inst, int *advance) | ||
| 1957 | { | 2093 | { |
| 1958 | return EMULATE_FAIL; | 2094 | return EMULATE_FAIL; |
| 1959 | } | 2095 | } |
| 1960 | 2096 | ||
| 1961 | int kvmppc_core_emulate_mtspr(struct kvm_vcpu *vcpu, int sprn, ulong spr_val) | 2097 | static int kvmppc_core_emulate_mfspr_hv(struct kvm_vcpu *vcpu, int sprn, |
| 2098 | ulong *spr_val) | ||
| 1962 | { | 2099 | { |
| 1963 | return EMULATE_FAIL; | 2100 | return EMULATE_FAIL; |
| 1964 | } | 2101 | } |
| 1965 | 2102 | ||
| 1966 | int kvmppc_core_emulate_mfspr(struct kvm_vcpu *vcpu, int sprn, ulong *spr_val) | 2103 | static int kvmppc_core_check_processor_compat_hv(void) |
| 1967 | { | 2104 | { |
| 1968 | return EMULATE_FAIL; | 2105 | if (!cpu_has_feature(CPU_FTR_HVMODE)) |
| 2106 | return -EIO; | ||
| 2107 | return 0; | ||
| 1969 | } | 2108 | } |
| 1970 | 2109 | ||
| 1971 | static int kvmppc_book3s_hv_init(void) | 2110 | static long kvm_arch_vm_ioctl_hv(struct file *filp, |
| 2111 | unsigned int ioctl, unsigned long arg) | ||
| 1972 | { | 2112 | { |
| 1973 | int r; | 2113 | struct kvm *kvm __maybe_unused = filp->private_data; |
| 2114 | void __user *argp = (void __user *)arg; | ||
| 2115 | long r; | ||
| 1974 | 2116 | ||
| 1975 | r = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); | 2117 | switch (ioctl) { |
| 1976 | 2118 | ||
| 1977 | if (r) | 2119 | case KVM_ALLOCATE_RMA: { |
| 2120 | struct kvm_allocate_rma rma; | ||
| 2121 | struct kvm *kvm = filp->private_data; | ||
| 2122 | |||
| 2123 | r = kvm_vm_ioctl_allocate_rma(kvm, &rma); | ||
| 2124 | if (r >= 0 && copy_to_user(argp, &rma, sizeof(rma))) | ||
| 2125 | r = -EFAULT; | ||
| 2126 | break; | ||
| 2127 | } | ||
| 2128 | |||
| 2129 | case KVM_PPC_ALLOCATE_HTAB: { | ||
| 2130 | u32 htab_order; | ||
| 2131 | |||
| 2132 | r = -EFAULT; | ||
| 2133 | if (get_user(htab_order, (u32 __user *)argp)) | ||
| 2134 | break; | ||
| 2135 | r = kvmppc_alloc_reset_hpt(kvm, &htab_order); | ||
| 2136 | if (r) | ||
| 2137 | break; | ||
| 2138 | r = -EFAULT; | ||
| 2139 | if (put_user(htab_order, (u32 __user *)argp)) | ||
| 2140 | break; | ||
| 2141 | r = 0; | ||
| 2142 | break; | ||
| 2143 | } | ||
| 2144 | |||
| 2145 | case KVM_PPC_GET_HTAB_FD: { | ||
| 2146 | struct kvm_get_htab_fd ghf; | ||
| 2147 | |||
| 2148 | r = -EFAULT; | ||
| 2149 | if (copy_from_user(&ghf, argp, sizeof(ghf))) | ||
| 2150 | break; | ||
| 2151 | r = kvm_vm_ioctl_get_htab_fd(kvm, &ghf); | ||
| 2152 | break; | ||
| 2153 | } | ||
| 2154 | |||
| 2155 | default: | ||
| 2156 | r = -ENOTTY; | ||
| 2157 | } | ||
| 2158 | |||
| 2159 | return r; | ||
| 2160 | } | ||
| 2161 | |||
| 2162 | static struct kvmppc_ops kvm_ops_hv = { | ||
| 2163 | .get_sregs = kvm_arch_vcpu_ioctl_get_sregs_hv, | ||
| 2164 | .set_sregs = kvm_arch_vcpu_ioctl_set_sregs_hv, | ||
| 2165 | .get_one_reg = kvmppc_get_one_reg_hv, | ||
| 2166 | .set_one_reg = kvmppc_set_one_reg_hv, | ||
| 2167 | .vcpu_load = kvmppc_core_vcpu_load_hv, | ||
| 2168 | .vcpu_put = kvmppc_core_vcpu_put_hv, | ||
| 2169 | .set_msr = kvmppc_set_msr_hv, | ||
| 2170 | .vcpu_run = kvmppc_vcpu_run_hv, | ||
| 2171 | .vcpu_create = kvmppc_core_vcpu_create_hv, | ||
| 2172 | .vcpu_free = kvmppc_core_vcpu_free_hv, | ||
| 2173 | .check_requests = kvmppc_core_check_requests_hv, | ||
| 2174 | .get_dirty_log = kvm_vm_ioctl_get_dirty_log_hv, | ||
| 2175 | .flush_memslot = kvmppc_core_flush_memslot_hv, | ||
| 2176 | .prepare_memory_region = kvmppc_core_prepare_memory_region_hv, | ||
| 2177 | .commit_memory_region = kvmppc_core_commit_memory_region_hv, | ||
| 2178 | .unmap_hva = kvm_unmap_hva_hv, | ||
| 2179 | .unmap_hva_range = kvm_unmap_hva_range_hv, | ||
| 2180 | .age_hva = kvm_age_hva_hv, | ||
| 2181 | .test_age_hva = kvm_test_age_hva_hv, | ||
| 2182 | .set_spte_hva = kvm_set_spte_hva_hv, | ||
| 2183 | .mmu_destroy = kvmppc_mmu_destroy_hv, | ||
| 2184 | .free_memslot = kvmppc_core_free_memslot_hv, | ||
| 2185 | .create_memslot = kvmppc_core_create_memslot_hv, | ||
| 2186 | .init_vm = kvmppc_core_init_vm_hv, | ||
| 2187 | .destroy_vm = kvmppc_core_destroy_vm_hv, | ||
| 2188 | .get_smmu_info = kvm_vm_ioctl_get_smmu_info_hv, | ||
| 2189 | .emulate_op = kvmppc_core_emulate_op_hv, | ||
| 2190 | .emulate_mtspr = kvmppc_core_emulate_mtspr_hv, | ||
| 2191 | .emulate_mfspr = kvmppc_core_emulate_mfspr_hv, | ||
| 2192 | .fast_vcpu_kick = kvmppc_fast_vcpu_kick_hv, | ||
| 2193 | .arch_vm_ioctl = kvm_arch_vm_ioctl_hv, | ||
| 2194 | }; | ||
| 2195 | |||
| 2196 | static int kvmppc_book3s_init_hv(void) | ||
| 2197 | { | ||
| 2198 | int r; | ||
| 2199 | /* | ||
| 2200 | * FIXME!! Do we need to check on all cpus ? | ||
| 2201 | */ | ||
| 2202 | r = kvmppc_core_check_processor_compat_hv(); | ||
| 2203 | if (r < 0) | ||
| 1978 | return r; | 2204 | return r; |
| 1979 | 2205 | ||
| 1980 | r = kvmppc_mmu_hv_init(); | 2206 | kvm_ops_hv.owner = THIS_MODULE; |
| 2207 | kvmppc_hv_ops = &kvm_ops_hv; | ||
| 1981 | 2208 | ||
| 2209 | r = kvmppc_mmu_hv_init(); | ||
| 1982 | return r; | 2210 | return r; |
| 1983 | } | 2211 | } |
| 1984 | 2212 | ||
| 1985 | static void kvmppc_book3s_hv_exit(void) | 2213 | static void kvmppc_book3s_exit_hv(void) |
| 1986 | { | 2214 | { |
| 1987 | kvm_exit(); | 2215 | kvmppc_hv_ops = NULL; |
| 1988 | } | 2216 | } |
| 1989 | 2217 | ||
| 1990 | module_init(kvmppc_book3s_hv_init); | 2218 | module_init(kvmppc_book3s_init_hv); |
| 1991 | module_exit(kvmppc_book3s_hv_exit); | 2219 | module_exit(kvmppc_book3s_exit_hv); |
| 2220 | MODULE_LICENSE("GPL"); | ||
diff --git a/arch/powerpc/kvm/book3s_hv_interrupts.S b/arch/powerpc/kvm/book3s_hv_interrupts.S index 37f1cc417ca0..928142c64cb0 100644 --- a/arch/powerpc/kvm/book3s_hv_interrupts.S +++ b/arch/powerpc/kvm/book3s_hv_interrupts.S | |||
| @@ -158,9 +158,6 @@ END_FTR_SECTION_IFSET(CPU_FTR_ARCH_201) | |||
| 158 | * Interrupts are enabled again at this point. | 158 | * Interrupts are enabled again at this point. |
| 159 | */ | 159 | */ |
| 160 | 160 | ||
| 161 | .global kvmppc_handler_highmem | ||
| 162 | kvmppc_handler_highmem: | ||
| 163 | |||
| 164 | /* | 161 | /* |
| 165 | * Register usage at this point: | 162 | * Register usage at this point: |
| 166 | * | 163 | * |
diff --git a/arch/powerpc/kvm/book3s_hv_rmhandlers.S b/arch/powerpc/kvm/book3s_hv_rmhandlers.S index c71103b8a748..bc8de75b1925 100644 --- a/arch/powerpc/kvm/book3s_hv_rmhandlers.S +++ b/arch/powerpc/kvm/book3s_hv_rmhandlers.S | |||
| @@ -33,30 +33,6 @@ | |||
| 33 | #error Need to fix lppaca and SLB shadow accesses in little endian mode | 33 | #error Need to fix lppaca and SLB shadow accesses in little endian mode |
| 34 | #endif | 34 | #endif |
| 35 | 35 | ||
| 36 | /***************************************************************************** | ||
| 37 | * * | ||
| 38 | * Real Mode handlers that need to be in the linear mapping * | ||
| 39 | * * | ||
| 40 | ****************************************************************************/ | ||
| 41 | |||
| 42 | .globl kvmppc_skip_interrupt | ||
| 43 | kvmppc_skip_interrupt: | ||
| 44 | mfspr r13,SPRN_SRR0 | ||
| 45 | addi r13,r13,4 | ||
| 46 | mtspr SPRN_SRR0,r13 | ||
| 47 | GET_SCRATCH0(r13) | ||
| 48 | rfid | ||
| 49 | b . | ||
| 50 | |||
| 51 | .globl kvmppc_skip_Hinterrupt | ||
| 52 | kvmppc_skip_Hinterrupt: | ||
| 53 | mfspr r13,SPRN_HSRR0 | ||
| 54 | addi r13,r13,4 | ||
| 55 | mtspr SPRN_HSRR0,r13 | ||
| 56 | GET_SCRATCH0(r13) | ||
| 57 | hrfid | ||
| 58 | b . | ||
| 59 | |||
| 60 | /* | 36 | /* |
| 61 | * Call kvmppc_hv_entry in real mode. | 37 | * Call kvmppc_hv_entry in real mode. |
| 62 | * Must be called with interrupts hard-disabled. | 38 | * Must be called with interrupts hard-disabled. |
| @@ -66,8 +42,11 @@ kvmppc_skip_Hinterrupt: | |||
| 66 | * LR = return address to continue at after eventually re-enabling MMU | 42 | * LR = return address to continue at after eventually re-enabling MMU |
| 67 | */ | 43 | */ |
| 68 | _GLOBAL(kvmppc_hv_entry_trampoline) | 44 | _GLOBAL(kvmppc_hv_entry_trampoline) |
| 45 | mflr r0 | ||
| 46 | std r0, PPC_LR_STKOFF(r1) | ||
| 47 | stdu r1, -112(r1) | ||
| 69 | mfmsr r10 | 48 | mfmsr r10 |
| 70 | LOAD_REG_ADDR(r5, kvmppc_hv_entry) | 49 | LOAD_REG_ADDR(r5, kvmppc_call_hv_entry) |
| 71 | li r0,MSR_RI | 50 | li r0,MSR_RI |
| 72 | andc r0,r10,r0 | 51 | andc r0,r10,r0 |
| 73 | li r6,MSR_IR | MSR_DR | 52 | li r6,MSR_IR | MSR_DR |
| @@ -77,11 +56,103 @@ _GLOBAL(kvmppc_hv_entry_trampoline) | |||
| 77 | mtsrr1 r6 | 56 | mtsrr1 r6 |
| 78 | RFI | 57 | RFI |
| 79 | 58 | ||
| 80 | /****************************************************************************** | 59 | kvmppc_call_hv_entry: |
| 81 | * * | 60 | bl kvmppc_hv_entry |
| 82 | * Entry code * | 61 | |
| 83 | * * | 62 | /* Back from guest - restore host state and return to caller */ |
| 84 | *****************************************************************************/ | 63 | |
| 64 | /* Restore host DABR and DABRX */ | ||
| 65 | ld r5,HSTATE_DABR(r13) | ||
| 66 | li r6,7 | ||
| 67 | mtspr SPRN_DABR,r5 | ||
| 68 | mtspr SPRN_DABRX,r6 | ||
| 69 | |||
| 70 | /* Restore SPRG3 */ | ||
| 71 | ld r3,PACA_SPRG3(r13) | ||
| 72 | mtspr SPRN_SPRG3,r3 | ||
| 73 | |||
| 74 | /* | ||
| 75 | * Reload DEC. HDEC interrupts were disabled when | ||
| 76 | * we reloaded the host's LPCR value. | ||
| 77 | */ | ||
| 78 | ld r3, HSTATE_DECEXP(r13) | ||
| 79 | mftb r4 | ||
| 80 | subf r4, r4, r3 | ||
| 81 | mtspr SPRN_DEC, r4 | ||
| 82 | |||
| 83 | /* Reload the host's PMU registers */ | ||
| 84 | ld r3, PACALPPACAPTR(r13) /* is the host using the PMU? */ | ||
| 85 | lbz r4, LPPACA_PMCINUSE(r3) | ||
| 86 | cmpwi r4, 0 | ||
| 87 | beq 23f /* skip if not */ | ||
| 88 | lwz r3, HSTATE_PMC(r13) | ||
| 89 | lwz r4, HSTATE_PMC + 4(r13) | ||
| 90 | lwz r5, HSTATE_PMC + 8(r13) | ||
| 91 | lwz r6, HSTATE_PMC + 12(r13) | ||
| 92 | lwz r8, HSTATE_PMC + 16(r13) | ||
| 93 | lwz r9, HSTATE_PMC + 20(r13) | ||
| 94 | BEGIN_FTR_SECTION | ||
| 95 | lwz r10, HSTATE_PMC + 24(r13) | ||
| 96 | lwz r11, HSTATE_PMC + 28(r13) | ||
| 97 | END_FTR_SECTION_IFSET(CPU_FTR_ARCH_201) | ||
| 98 | mtspr SPRN_PMC1, r3 | ||
| 99 | mtspr SPRN_PMC2, r4 | ||
| 100 | mtspr SPRN_PMC3, r5 | ||
| 101 | mtspr SPRN_PMC4, r6 | ||
| 102 | mtspr SPRN_PMC5, r8 | ||
| 103 | mtspr SPRN_PMC6, r9 | ||
| 104 | BEGIN_FTR_SECTION | ||
| 105 | mtspr SPRN_PMC7, r10 | ||
| 106 | mtspr SPRN_PMC8, r11 | ||
| 107 | END_FTR_SECTION_IFSET(CPU_FTR_ARCH_201) | ||
| 108 | ld r3, HSTATE_MMCR(r13) | ||
| 109 | ld r4, HSTATE_MMCR + 8(r13) | ||
| 110 | ld r5, HSTATE_MMCR + 16(r13) | ||
| 111 | mtspr SPRN_MMCR1, r4 | ||
| 112 | mtspr SPRN_MMCRA, r5 | ||
| 113 | mtspr SPRN_MMCR0, r3 | ||
| 114 | isync | ||
| 115 | 23: | ||
| 116 | |||
| 117 | /* | ||
| 118 | * For external and machine check interrupts, we need | ||
| 119 | * to call the Linux handler to process the interrupt. | ||
| 120 | * We do that by jumping to absolute address 0x500 for | ||
| 121 | * external interrupts, or the machine_check_fwnmi label | ||
| 122 | * for machine checks (since firmware might have patched | ||
| 123 | * the vector area at 0x200). The [h]rfid at the end of the | ||
| 124 | * handler will return to the book3s_hv_interrupts.S code. | ||
| 125 | * For other interrupts we do the rfid to get back | ||
| 126 | * to the book3s_hv_interrupts.S code here. | ||
| 127 | */ | ||
| 128 | ld r8, 112+PPC_LR_STKOFF(r1) | ||
| 129 | addi r1, r1, 112 | ||
| 130 | ld r7, HSTATE_HOST_MSR(r13) | ||
| 131 | |||
| 132 | cmpwi cr1, r12, BOOK3S_INTERRUPT_MACHINE_CHECK | ||
| 133 | cmpwi r12, BOOK3S_INTERRUPT_EXTERNAL | ||
| 134 | BEGIN_FTR_SECTION | ||
| 135 | beq 11f | ||
| 136 | END_FTR_SECTION_IFSET(CPU_FTR_ARCH_206) | ||
| 137 | |||
| 138 | /* RFI into the highmem handler, or branch to interrupt handler */ | ||
| 139 | mfmsr r6 | ||
| 140 | li r0, MSR_RI | ||
| 141 | andc r6, r6, r0 | ||
| 142 | mtmsrd r6, 1 /* Clear RI in MSR */ | ||
| 143 | mtsrr0 r8 | ||
| 144 | mtsrr1 r7 | ||
| 145 | beqa 0x500 /* external interrupt (PPC970) */ | ||
| 146 | beq cr1, 13f /* machine check */ | ||
| 147 | RFI | ||
| 148 | |||
| 149 | /* On POWER7, we have external interrupts set to use HSRR0/1 */ | ||
| 150 | 11: mtspr SPRN_HSRR0, r8 | ||
| 151 | mtspr SPRN_HSRR1, r7 | ||
| 152 | ba 0x500 | ||
| 153 | |||
| 154 | 13: b machine_check_fwnmi | ||
| 155 | |||
| 85 | 156 | ||
| 86 | /* | 157 | /* |
| 87 | * We come in here when wakened from nap mode on a secondary hw thread. | 158 | * We come in here when wakened from nap mode on a secondary hw thread. |
| @@ -137,7 +208,7 @@ kvm_start_guest: | |||
| 137 | cmpdi r4,0 | 208 | cmpdi r4,0 |
| 138 | /* if we have no vcpu to run, go back to sleep */ | 209 | /* if we have no vcpu to run, go back to sleep */ |
| 139 | beq kvm_no_guest | 210 | beq kvm_no_guest |
| 140 | b kvmppc_hv_entry | 211 | b 30f |
| 141 | 212 | ||
| 142 | 27: /* XXX should handle hypervisor maintenance interrupts etc. here */ | 213 | 27: /* XXX should handle hypervisor maintenance interrupts etc. here */ |
| 143 | b kvm_no_guest | 214 | b kvm_no_guest |
| @@ -147,6 +218,57 @@ kvm_start_guest: | |||
| 147 | stw r8,HSTATE_SAVED_XIRR(r13) | 218 | stw r8,HSTATE_SAVED_XIRR(r13) |
| 148 | b kvm_no_guest | 219 | b kvm_no_guest |
| 149 | 220 | ||
| 221 | 30: bl kvmppc_hv_entry | ||
| 222 | |||
| 223 | /* Back from the guest, go back to nap */ | ||
| 224 | /* Clear our vcpu pointer so we don't come back in early */ | ||
| 225 | li r0, 0 | ||
| 226 | std r0, HSTATE_KVM_VCPU(r13) | ||
| 227 | lwsync | ||
| 228 | /* Clear any pending IPI - we're an offline thread */ | ||
| 229 | ld r5, HSTATE_XICS_PHYS(r13) | ||
| 230 | li r7, XICS_XIRR | ||
| 231 | lwzcix r3, r5, r7 /* ack any pending interrupt */ | ||
| 232 | rlwinm. r0, r3, 0, 0xffffff /* any pending? */ | ||
| 233 | beq 37f | ||
| 234 | sync | ||
| 235 | li r0, 0xff | ||
| 236 | li r6, XICS_MFRR | ||
| 237 | stbcix r0, r5, r6 /* clear the IPI */ | ||
| 238 | stwcix r3, r5, r7 /* EOI it */ | ||
| 239 | 37: sync | ||
| 240 | |||
| 241 | /* increment the nap count and then go to nap mode */ | ||
| 242 | ld r4, HSTATE_KVM_VCORE(r13) | ||
| 243 | addi r4, r4, VCORE_NAP_COUNT | ||
| 244 | lwsync /* make previous updates visible */ | ||
| 245 | 51: lwarx r3, 0, r4 | ||
| 246 | addi r3, r3, 1 | ||
| 247 | stwcx. r3, 0, r4 | ||
| 248 | bne 51b | ||
| 249 | |||
| 250 | kvm_no_guest: | ||
| 251 | li r0, KVM_HWTHREAD_IN_NAP | ||
| 252 | stb r0, HSTATE_HWTHREAD_STATE(r13) | ||
| 253 | li r3, LPCR_PECE0 | ||
| 254 | mfspr r4, SPRN_LPCR | ||
| 255 | rlwimi r4, r3, 0, LPCR_PECE0 | LPCR_PECE1 | ||
| 256 | mtspr SPRN_LPCR, r4 | ||
| 257 | isync | ||
| 258 | std r0, HSTATE_SCRATCH0(r13) | ||
| 259 | ptesync | ||
| 260 | ld r0, HSTATE_SCRATCH0(r13) | ||
| 261 | 1: cmpd r0, r0 | ||
| 262 | bne 1b | ||
| 263 | nap | ||
| 264 | b . | ||
| 265 | |||
| 266 | /****************************************************************************** | ||
| 267 | * * | ||
| 268 | * Entry code * | ||
| 269 | * * | ||
| 270 | *****************************************************************************/ | ||
| 271 | |||
| 150 | .global kvmppc_hv_entry | 272 | .global kvmppc_hv_entry |
| 151 | kvmppc_hv_entry: | 273 | kvmppc_hv_entry: |
| 152 | 274 | ||
| @@ -159,7 +281,8 @@ kvmppc_hv_entry: | |||
| 159 | * all other volatile GPRS = free | 281 | * all other volatile GPRS = free |
| 160 | */ | 282 | */ |
| 161 | mflr r0 | 283 | mflr r0 |
| 162 | std r0, HSTATE_VMHANDLER(r13) | 284 | std r0, PPC_LR_STKOFF(r1) |
| 285 | stdu r1, -112(r1) | ||
| 163 | 286 | ||
| 164 | /* Set partition DABR */ | 287 | /* Set partition DABR */ |
| 165 | /* Do this before re-enabling PMU to avoid P7 DABR corruption bug */ | 288 | /* Do this before re-enabling PMU to avoid P7 DABR corruption bug */ |
| @@ -200,8 +323,12 @@ END_FTR_SECTION_IFSET(CPU_FTR_ARCH_201) | |||
| 200 | ld r3, VCPU_MMCR(r4) | 323 | ld r3, VCPU_MMCR(r4) |
| 201 | ld r5, VCPU_MMCR + 8(r4) | 324 | ld r5, VCPU_MMCR + 8(r4) |
| 202 | ld r6, VCPU_MMCR + 16(r4) | 325 | ld r6, VCPU_MMCR + 16(r4) |
| 326 | ld r7, VCPU_SIAR(r4) | ||
| 327 | ld r8, VCPU_SDAR(r4) | ||
| 203 | mtspr SPRN_MMCR1, r5 | 328 | mtspr SPRN_MMCR1, r5 |
| 204 | mtspr SPRN_MMCRA, r6 | 329 | mtspr SPRN_MMCRA, r6 |
| 330 | mtspr SPRN_SIAR, r7 | ||
| 331 | mtspr SPRN_SDAR, r8 | ||
| 205 | mtspr SPRN_MMCR0, r3 | 332 | mtspr SPRN_MMCR0, r3 |
| 206 | isync | 333 | isync |
| 207 | 334 | ||
| @@ -254,22 +381,15 @@ END_FTR_SECTION_IFSET(CPU_FTR_ARCH_206) | |||
| 254 | /* Save R1 in the PACA */ | 381 | /* Save R1 in the PACA */ |
| 255 | std r1, HSTATE_HOST_R1(r13) | 382 | std r1, HSTATE_HOST_R1(r13) |
| 256 | 383 | ||
| 257 | /* Increment yield count if they have a VPA */ | ||
| 258 | ld r3, VCPU_VPA(r4) | ||
| 259 | cmpdi r3, 0 | ||
| 260 | beq 25f | ||
| 261 | lwz r5, LPPACA_YIELDCOUNT(r3) | ||
| 262 | addi r5, r5, 1 | ||
| 263 | stw r5, LPPACA_YIELDCOUNT(r3) | ||
| 264 | li r6, 1 | ||
| 265 | stb r6, VCPU_VPA_DIRTY(r4) | ||
| 266 | 25: | ||
| 267 | /* Load up DAR and DSISR */ | 384 | /* Load up DAR and DSISR */ |
| 268 | ld r5, VCPU_DAR(r4) | 385 | ld r5, VCPU_DAR(r4) |
| 269 | lwz r6, VCPU_DSISR(r4) | 386 | lwz r6, VCPU_DSISR(r4) |
| 270 | mtspr SPRN_DAR, r5 | 387 | mtspr SPRN_DAR, r5 |
| 271 | mtspr SPRN_DSISR, r6 | 388 | mtspr SPRN_DSISR, r6 |
| 272 | 389 | ||
| 390 | li r6, KVM_GUEST_MODE_HOST_HV | ||
| 391 | stb r6, HSTATE_IN_GUEST(r13) | ||
| 392 | |||
| 273 | BEGIN_FTR_SECTION | 393 | BEGIN_FTR_SECTION |
| 274 | /* Restore AMR and UAMOR, set AMOR to all 1s */ | 394 | /* Restore AMR and UAMOR, set AMOR to all 1s */ |
| 275 | ld r5,VCPU_AMR(r4) | 395 | ld r5,VCPU_AMR(r4) |
| @@ -343,7 +463,28 @@ END_FTR_SECTION_IFSET(CPU_FTR_ARCH_201) | |||
| 343 | bdnz 28b | 463 | bdnz 28b |
| 344 | ptesync | 464 | ptesync |
| 345 | 465 | ||
| 346 | 22: li r0,1 | 466 | /* Add timebase offset onto timebase */ |
| 467 | 22: ld r8,VCORE_TB_OFFSET(r5) | ||
| 468 | cmpdi r8,0 | ||
| 469 | beq 37f | ||
| 470 | mftb r6 /* current host timebase */ | ||
| 471 | add r8,r8,r6 | ||
| 472 | mtspr SPRN_TBU40,r8 /* update upper 40 bits */ | ||
| 473 | mftb r7 /* check if lower 24 bits overflowed */ | ||
| 474 | clrldi r6,r6,40 | ||
| 475 | clrldi r7,r7,40 | ||
| 476 | cmpld r7,r6 | ||
| 477 | bge 37f | ||
| 478 | addis r8,r8,0x100 /* if so, increment upper 40 bits */ | ||
| 479 | mtspr SPRN_TBU40,r8 | ||
| 480 | |||
| 481 | /* Load guest PCR value to select appropriate compat mode */ | ||
| 482 | 37: ld r7, VCORE_PCR(r5) | ||
| 483 | cmpdi r7, 0 | ||
| 484 | beq 38f | ||
| 485 | mtspr SPRN_PCR, r7 | ||
| 486 | 38: | ||
| 487 | li r0,1 | ||
| 347 | stb r0,VCORE_IN_GUEST(r5) /* signal secondaries to continue */ | 488 | stb r0,VCORE_IN_GUEST(r5) /* signal secondaries to continue */ |
| 348 | b 10f | 489 | b 10f |
| 349 | 490 | ||
| @@ -353,12 +494,22 @@ END_FTR_SECTION_IFSET(CPU_FTR_ARCH_201) | |||
| 353 | beq 20b | 494 | beq 20b |
| 354 | 495 | ||
| 355 | /* Set LPCR and RMOR. */ | 496 | /* Set LPCR and RMOR. */ |
| 356 | 10: ld r8,KVM_LPCR(r9) | 497 | 10: ld r8,VCORE_LPCR(r5) |
| 357 | mtspr SPRN_LPCR,r8 | 498 | mtspr SPRN_LPCR,r8 |
| 358 | ld r8,KVM_RMOR(r9) | 499 | ld r8,KVM_RMOR(r9) |
| 359 | mtspr SPRN_RMOR,r8 | 500 | mtspr SPRN_RMOR,r8 |
| 360 | isync | 501 | isync |
| 361 | 502 | ||
| 503 | /* Increment yield count if they have a VPA */ | ||
| 504 | ld r3, VCPU_VPA(r4) | ||
| 505 | cmpdi r3, 0 | ||
| 506 | beq 25f | ||
| 507 | lwz r5, LPPACA_YIELDCOUNT(r3) | ||
| 508 | addi r5, r5, 1 | ||
| 509 | stw r5, LPPACA_YIELDCOUNT(r3) | ||
| 510 | li r6, 1 | ||
| 511 | stb r6, VCPU_VPA_DIRTY(r4) | ||
| 512 | 25: | ||
| 362 | /* Check if HDEC expires soon */ | 513 | /* Check if HDEC expires soon */ |
| 363 | mfspr r3,SPRN_HDEC | 514 | mfspr r3,SPRN_HDEC |
| 364 | cmpwi r3,10 | 515 | cmpwi r3,10 |
| @@ -405,7 +556,8 @@ toc_tlbie_lock: | |||
| 405 | bne 24b | 556 | bne 24b |
| 406 | isync | 557 | isync |
| 407 | 558 | ||
| 408 | ld r7,KVM_LPCR(r9) /* use kvm->arch.lpcr to store HID4 */ | 559 | ld r5,HSTATE_KVM_VCORE(r13) |
| 560 | ld r7,VCORE_LPCR(r5) /* use vcore->lpcr to store HID4 */ | ||
| 409 | li r0,0x18f | 561 | li r0,0x18f |
| 410 | rotldi r0,r0,HID4_LPID5_SH /* all lpid bits in HID4 = 1 */ | 562 | rotldi r0,r0,HID4_LPID5_SH /* all lpid bits in HID4 = 1 */ |
| 411 | or r0,r7,r0 | 563 | or r0,r7,r0 |
| @@ -541,7 +693,7 @@ fast_guest_return: | |||
| 541 | mtspr SPRN_HSRR1,r11 | 693 | mtspr SPRN_HSRR1,r11 |
| 542 | 694 | ||
| 543 | /* Activate guest mode, so faults get handled by KVM */ | 695 | /* Activate guest mode, so faults get handled by KVM */ |
| 544 | li r9, KVM_GUEST_MODE_GUEST | 696 | li r9, KVM_GUEST_MODE_GUEST_HV |
| 545 | stb r9, HSTATE_IN_GUEST(r13) | 697 | stb r9, HSTATE_IN_GUEST(r13) |
| 546 | 698 | ||
| 547 | /* Enter guest */ | 699 | /* Enter guest */ |
| @@ -550,13 +702,15 @@ BEGIN_FTR_SECTION | |||
| 550 | ld r5, VCPU_CFAR(r4) | 702 | ld r5, VCPU_CFAR(r4) |
| 551 | mtspr SPRN_CFAR, r5 | 703 | mtspr SPRN_CFAR, r5 |
| 552 | END_FTR_SECTION_IFSET(CPU_FTR_CFAR) | 704 | END_FTR_SECTION_IFSET(CPU_FTR_CFAR) |
| 705 | BEGIN_FTR_SECTION | ||
| 706 | ld r0, VCPU_PPR(r4) | ||
| 707 | END_FTR_SECTION_IFSET(CPU_FTR_HAS_PPR) | ||
| 553 | 708 | ||
| 554 | ld r5, VCPU_LR(r4) | 709 | ld r5, VCPU_LR(r4) |
| 555 | lwz r6, VCPU_CR(r4) | 710 | lwz r6, VCPU_CR(r4) |
| 556 | mtlr r5 | 711 | mtlr r5 |
| 557 | mtcr r6 | 712 | mtcr r6 |
| 558 | 713 | ||
| 559 | ld r0, VCPU_GPR(R0)(r4) | ||
| 560 | ld r1, VCPU_GPR(R1)(r4) | 714 | ld r1, VCPU_GPR(R1)(r4) |
| 561 | ld r2, VCPU_GPR(R2)(r4) | 715 | ld r2, VCPU_GPR(R2)(r4) |
| 562 | ld r3, VCPU_GPR(R3)(r4) | 716 | ld r3, VCPU_GPR(R3)(r4) |
| @@ -570,6 +724,10 @@ END_FTR_SECTION_IFSET(CPU_FTR_CFAR) | |||
| 570 | ld r12, VCPU_GPR(R12)(r4) | 724 | ld r12, VCPU_GPR(R12)(r4) |
| 571 | ld r13, VCPU_GPR(R13)(r4) | 725 | ld r13, VCPU_GPR(R13)(r4) |
| 572 | 726 | ||
| 727 | BEGIN_FTR_SECTION | ||
| 728 | mtspr SPRN_PPR, r0 | ||
| 729 | END_FTR_SECTION_IFSET(CPU_FTR_HAS_PPR) | ||
| 730 | ld r0, VCPU_GPR(R0)(r4) | ||
| 573 | ld r4, VCPU_GPR(R4)(r4) | 731 | ld r4, VCPU_GPR(R4)(r4) |
| 574 | 732 | ||
| 575 | hrfid | 733 | hrfid |
| @@ -584,8 +742,8 @@ END_FTR_SECTION_IFSET(CPU_FTR_CFAR) | |||
| 584 | /* | 742 | /* |
| 585 | * We come here from the first-level interrupt handlers. | 743 | * We come here from the first-level interrupt handlers. |
| 586 | */ | 744 | */ |
| 587 | .globl kvmppc_interrupt | 745 | .globl kvmppc_interrupt_hv |
| 588 | kvmppc_interrupt: | 746 | kvmppc_interrupt_hv: |
| 589 | /* | 747 | /* |
| 590 | * Register contents: | 748 | * Register contents: |
| 591 | * R12 = interrupt vector | 749 | * R12 = interrupt vector |
| @@ -595,6 +753,19 @@ kvmppc_interrupt: | |||
| 595 | */ | 753 | */ |
| 596 | /* abuse host_r2 as third scratch area; we get r2 from PACATOC(r13) */ | 754 | /* abuse host_r2 as third scratch area; we get r2 from PACATOC(r13) */ |
| 597 | std r9, HSTATE_HOST_R2(r13) | 755 | std r9, HSTATE_HOST_R2(r13) |
| 756 | |||
| 757 | lbz r9, HSTATE_IN_GUEST(r13) | ||
| 758 | cmpwi r9, KVM_GUEST_MODE_HOST_HV | ||
| 759 | beq kvmppc_bad_host_intr | ||
| 760 | #ifdef CONFIG_KVM_BOOK3S_PR_POSSIBLE | ||
| 761 | cmpwi r9, KVM_GUEST_MODE_GUEST | ||
| 762 | ld r9, HSTATE_HOST_R2(r13) | ||
| 763 | beq kvmppc_interrupt_pr | ||
| 764 | #endif | ||
| 765 | /* We're now back in the host but in guest MMU context */ | ||
| 766 | li r9, KVM_GUEST_MODE_HOST_HV | ||
| 767 | stb r9, HSTATE_IN_GUEST(r13) | ||
| 768 | |||
| 598 | ld r9, HSTATE_KVM_VCPU(r13) | 769 | ld r9, HSTATE_KVM_VCPU(r13) |
| 599 | 770 | ||
| 600 | /* Save registers */ | 771 | /* Save registers */ |
| @@ -620,6 +791,10 @@ BEGIN_FTR_SECTION | |||
| 620 | ld r3, HSTATE_CFAR(r13) | 791 | ld r3, HSTATE_CFAR(r13) |
| 621 | std r3, VCPU_CFAR(r9) | 792 | std r3, VCPU_CFAR(r9) |
| 622 | END_FTR_SECTION_IFSET(CPU_FTR_CFAR) | 793 | END_FTR_SECTION_IFSET(CPU_FTR_CFAR) |
| 794 | BEGIN_FTR_SECTION | ||
| 795 | ld r4, HSTATE_PPR(r13) | ||
| 796 | std r4, VCPU_PPR(r9) | ||
| 797 | END_FTR_SECTION_IFSET(CPU_FTR_HAS_PPR) | ||
| 623 | 798 | ||
| 624 | /* Restore R1/R2 so we can handle faults */ | 799 | /* Restore R1/R2 so we can handle faults */ |
| 625 | ld r1, HSTATE_HOST_R1(r13) | 800 | ld r1, HSTATE_HOST_R1(r13) |
| @@ -642,10 +817,6 @@ END_FTR_SECTION_IFSET(CPU_FTR_CFAR) | |||
| 642 | std r3, VCPU_GPR(R13)(r9) | 817 | std r3, VCPU_GPR(R13)(r9) |
| 643 | std r4, VCPU_LR(r9) | 818 | std r4, VCPU_LR(r9) |
| 644 | 819 | ||
| 645 | /* Unset guest mode */ | ||
| 646 | li r0, KVM_GUEST_MODE_NONE | ||
| 647 | stb r0, HSTATE_IN_GUEST(r13) | ||
| 648 | |||
| 649 | stw r12,VCPU_TRAP(r9) | 820 | stw r12,VCPU_TRAP(r9) |
| 650 | 821 | ||
| 651 | /* Save HEIR (HV emulation assist reg) in last_inst | 822 | /* Save HEIR (HV emulation assist reg) in last_inst |
| @@ -696,46 +867,11 @@ END_FTR_SECTION_IFCLR(CPU_FTR_ARCH_206) | |||
| 696 | * set, we know the host wants us out so let's do it now | 867 | * set, we know the host wants us out so let's do it now |
| 697 | */ | 868 | */ |
| 698 | do_ext_interrupt: | 869 | do_ext_interrupt: |
| 699 | lbz r0, HSTATE_HOST_IPI(r13) | 870 | bl kvmppc_read_intr |
| 700 | cmpwi r0, 0 | 871 | cmpdi r3, 0 |
| 701 | bne ext_interrupt_to_host | 872 | bgt ext_interrupt_to_host |
| 702 | |||
| 703 | /* Now read the interrupt from the ICP */ | ||
| 704 | ld r5, HSTATE_XICS_PHYS(r13) | ||
| 705 | li r7, XICS_XIRR | ||
| 706 | cmpdi r5, 0 | ||
| 707 | beq- ext_interrupt_to_host | ||
| 708 | lwzcix r3, r5, r7 | ||
| 709 | rlwinm. r0, r3, 0, 0xffffff | ||
| 710 | sync | ||
| 711 | beq 3f /* if nothing pending in the ICP */ | ||
| 712 | |||
| 713 | /* We found something in the ICP... | ||
| 714 | * | ||
| 715 | * If it's not an IPI, stash it in the PACA and return to | ||
| 716 | * the host, we don't (yet) handle directing real external | ||
| 717 | * interrupts directly to the guest | ||
| 718 | */ | ||
| 719 | cmpwi r0, XICS_IPI | ||
| 720 | bne ext_stash_for_host | ||
| 721 | |||
| 722 | /* It's an IPI, clear the MFRR and EOI it */ | ||
| 723 | li r0, 0xff | ||
| 724 | li r6, XICS_MFRR | ||
| 725 | stbcix r0, r5, r6 /* clear the IPI */ | ||
| 726 | stwcix r3, r5, r7 /* EOI it */ | ||
| 727 | sync | ||
| 728 | |||
| 729 | /* We need to re-check host IPI now in case it got set in the | ||
| 730 | * meantime. If it's clear, we bounce the interrupt to the | ||
| 731 | * guest | ||
| 732 | */ | ||
| 733 | lbz r0, HSTATE_HOST_IPI(r13) | ||
| 734 | cmpwi r0, 0 | ||
| 735 | bne- 1f | ||
| 736 | 873 | ||
| 737 | /* Allright, looks like an IPI for the guest, we need to set MER */ | 874 | /* Allright, looks like an IPI for the guest, we need to set MER */ |
| 738 | 3: | ||
| 739 | /* Check if any CPU is heading out to the host, if so head out too */ | 875 | /* Check if any CPU is heading out to the host, if so head out too */ |
| 740 | ld r5, HSTATE_KVM_VCORE(r13) | 876 | ld r5, HSTATE_KVM_VCORE(r13) |
| 741 | lwz r0, VCORE_ENTRY_EXIT(r5) | 877 | lwz r0, VCORE_ENTRY_EXIT(r5) |
| @@ -764,27 +900,9 @@ do_ext_interrupt: | |||
| 764 | mtspr SPRN_LPCR, r8 | 900 | mtspr SPRN_LPCR, r8 |
| 765 | b fast_guest_return | 901 | b fast_guest_return |
| 766 | 902 | ||
| 767 | /* We raced with the host, we need to resend that IPI, bummer */ | ||
| 768 | 1: li r0, IPI_PRIORITY | ||
| 769 | stbcix r0, r5, r6 /* set the IPI */ | ||
| 770 | sync | ||
| 771 | b ext_interrupt_to_host | ||
| 772 | |||
| 773 | ext_stash_for_host: | ||
| 774 | /* It's not an IPI and it's for the host, stash it in the PACA | ||
| 775 | * before exit, it will be picked up by the host ICP driver | ||
| 776 | */ | ||
| 777 | stw r3, HSTATE_SAVED_XIRR(r13) | ||
| 778 | ext_interrupt_to_host: | 903 | ext_interrupt_to_host: |
| 779 | 904 | ||
| 780 | guest_exit_cont: /* r9 = vcpu, r12 = trap, r13 = paca */ | 905 | guest_exit_cont: /* r9 = vcpu, r12 = trap, r13 = paca */ |
| 781 | /* Save DEC */ | ||
| 782 | mfspr r5,SPRN_DEC | ||
| 783 | mftb r6 | ||
| 784 | extsw r5,r5 | ||
| 785 | add r5,r5,r6 | ||
| 786 | std r5,VCPU_DEC_EXPIRES(r9) | ||
| 787 | |||
| 788 | /* Save more register state */ | 906 | /* Save more register state */ |
| 789 | mfdar r6 | 907 | mfdar r6 |
| 790 | mfdsisr r7 | 908 | mfdsisr r7 |
| @@ -954,7 +1072,30 @@ END_FTR_SECTION_IFSET(CPU_FTR_ARCH_201) | |||
| 954 | mtspr SPRN_SDR1,r6 /* switch to partition page table */ | 1072 | mtspr SPRN_SDR1,r6 /* switch to partition page table */ |
| 955 | mtspr SPRN_LPID,r7 | 1073 | mtspr SPRN_LPID,r7 |
| 956 | isync | 1074 | isync |
| 957 | li r0,0 | 1075 | |
| 1076 | /* Subtract timebase offset from timebase */ | ||
| 1077 | ld r8,VCORE_TB_OFFSET(r5) | ||
| 1078 | cmpdi r8,0 | ||
| 1079 | beq 17f | ||
| 1080 | mftb r6 /* current host timebase */ | ||
| 1081 | subf r8,r8,r6 | ||
| 1082 | mtspr SPRN_TBU40,r8 /* update upper 40 bits */ | ||
| 1083 | mftb r7 /* check if lower 24 bits overflowed */ | ||
| 1084 | clrldi r6,r6,40 | ||
| 1085 | clrldi r7,r7,40 | ||
| 1086 | cmpld r7,r6 | ||
| 1087 | bge 17f | ||
| 1088 | addis r8,r8,0x100 /* if so, increment upper 40 bits */ | ||
| 1089 | mtspr SPRN_TBU40,r8 | ||
| 1090 | |||
| 1091 | /* Reset PCR */ | ||
| 1092 | 17: ld r0, VCORE_PCR(r5) | ||
| 1093 | cmpdi r0, 0 | ||
| 1094 | beq 18f | ||
| 1095 | li r0, 0 | ||
| 1096 | mtspr SPRN_PCR, r0 | ||
| 1097 | 18: | ||
| 1098 | /* Signal secondary CPUs to continue */ | ||
| 958 | stb r0,VCORE_IN_GUEST(r5) | 1099 | stb r0,VCORE_IN_GUEST(r5) |
| 959 | lis r8,0x7fff /* MAX_INT@h */ | 1100 | lis r8,0x7fff /* MAX_INT@h */ |
| 960 | mtspr SPRN_HDEC,r8 | 1101 | mtspr SPRN_HDEC,r8 |
| @@ -1052,6 +1193,13 @@ END_FTR_SECTION_IFSET(CPU_FTR_ARCH_201) | |||
| 1052 | 1: addi r8,r8,16 | 1193 | 1: addi r8,r8,16 |
| 1053 | .endr | 1194 | .endr |
| 1054 | 1195 | ||
| 1196 | /* Save DEC */ | ||
| 1197 | mfspr r5,SPRN_DEC | ||
| 1198 | mftb r6 | ||
| 1199 | extsw r5,r5 | ||
| 1200 | add r5,r5,r6 | ||
| 1201 | std r5,VCPU_DEC_EXPIRES(r9) | ||
| 1202 | |||
| 1055 | /* Save and reset AMR and UAMOR before turning on the MMU */ | 1203 | /* Save and reset AMR and UAMOR before turning on the MMU */ |
| 1056 | BEGIN_FTR_SECTION | 1204 | BEGIN_FTR_SECTION |
| 1057 | mfspr r5,SPRN_AMR | 1205 | mfspr r5,SPRN_AMR |
| @@ -1062,6 +1210,10 @@ BEGIN_FTR_SECTION | |||
| 1062 | mtspr SPRN_AMR,r6 | 1210 | mtspr SPRN_AMR,r6 |
| 1063 | END_FTR_SECTION_IFSET(CPU_FTR_ARCH_206) | 1211 | END_FTR_SECTION_IFSET(CPU_FTR_ARCH_206) |
| 1064 | 1212 | ||
| 1213 | /* Unset guest mode */ | ||
| 1214 | li r0, KVM_GUEST_MODE_NONE | ||
| 1215 | stb r0, HSTATE_IN_GUEST(r13) | ||
| 1216 | |||
| 1065 | /* Switch DSCR back to host value */ | 1217 | /* Switch DSCR back to host value */ |
| 1066 | BEGIN_FTR_SECTION | 1218 | BEGIN_FTR_SECTION |
| 1067 | mfspr r8, SPRN_DSCR | 1219 | mfspr r8, SPRN_DSCR |
| @@ -1134,9 +1286,13 @@ END_FTR_SECTION_IFSET(CPU_FTR_ARCH_206) | |||
| 1134 | std r3, VCPU_MMCR(r9) /* if not, set saved MMCR0 to FC */ | 1286 | std r3, VCPU_MMCR(r9) /* if not, set saved MMCR0 to FC */ |
| 1135 | b 22f | 1287 | b 22f |
| 1136 | 21: mfspr r5, SPRN_MMCR1 | 1288 | 21: mfspr r5, SPRN_MMCR1 |
| 1289 | mfspr r7, SPRN_SIAR | ||
| 1290 | mfspr r8, SPRN_SDAR | ||
| 1137 | std r4, VCPU_MMCR(r9) | 1291 | std r4, VCPU_MMCR(r9) |
| 1138 | std r5, VCPU_MMCR + 8(r9) | 1292 | std r5, VCPU_MMCR + 8(r9) |
| 1139 | std r6, VCPU_MMCR + 16(r9) | 1293 | std r6, VCPU_MMCR + 16(r9) |
| 1294 | std r7, VCPU_SIAR(r9) | ||
| 1295 | std r8, VCPU_SDAR(r9) | ||
| 1140 | mfspr r3, SPRN_PMC1 | 1296 | mfspr r3, SPRN_PMC1 |
| 1141 | mfspr r4, SPRN_PMC2 | 1297 | mfspr r4, SPRN_PMC2 |
| 1142 | mfspr r5, SPRN_PMC3 | 1298 | mfspr r5, SPRN_PMC3 |
| @@ -1158,103 +1314,30 @@ BEGIN_FTR_SECTION | |||
| 1158 | stw r11, VCPU_PMC + 28(r9) | 1314 | stw r11, VCPU_PMC + 28(r9) |
| 1159 | END_FTR_SECTION_IFSET(CPU_FTR_ARCH_201) | 1315 | END_FTR_SECTION_IFSET(CPU_FTR_ARCH_201) |
| 1160 | 22: | 1316 | 22: |
| 1317 | ld r0, 112+PPC_LR_STKOFF(r1) | ||
| 1318 | addi r1, r1, 112 | ||
| 1319 | mtlr r0 | ||
| 1320 | blr | ||
| 1321 | secondary_too_late: | ||
| 1322 | ld r5,HSTATE_KVM_VCORE(r13) | ||
| 1323 | HMT_LOW | ||
| 1324 | 13: lbz r3,VCORE_IN_GUEST(r5) | ||
| 1325 | cmpwi r3,0 | ||
| 1326 | bne 13b | ||
| 1327 | HMT_MEDIUM | ||
| 1328 | li r0, KVM_GUEST_MODE_NONE | ||
| 1329 | stb r0, HSTATE_IN_GUEST(r13) | ||
| 1330 | ld r11,PACA_SLBSHADOWPTR(r13) | ||
| 1161 | 1331 | ||
| 1162 | /* Secondary threads go off to take a nap on POWER7 */ | 1332 | .rept SLB_NUM_BOLTED |
| 1163 | BEGIN_FTR_SECTION | 1333 | ld r5,SLBSHADOW_SAVEAREA(r11) |
| 1164 | lwz r0,VCPU_PTID(r9) | 1334 | ld r6,SLBSHADOW_SAVEAREA+8(r11) |
| 1165 | cmpwi r0,0 | 1335 | andis. r7,r5,SLB_ESID_V@h |
| 1166 | bne secondary_nap | 1336 | beq 1f |
| 1167 | END_FTR_SECTION_IFSET(CPU_FTR_ARCH_206) | 1337 | slbmte r6,r5 |
| 1168 | 1338 | 1: addi r11,r11,16 | |
| 1169 | /* Restore host DABR and DABRX */ | 1339 | .endr |
| 1170 | ld r5,HSTATE_DABR(r13) | 1340 | b 22b |
| 1171 | li r6,7 | ||
| 1172 | mtspr SPRN_DABR,r5 | ||
| 1173 | mtspr SPRN_DABRX,r6 | ||
| 1174 | |||
| 1175 | /* Restore SPRG3 */ | ||
| 1176 | ld r3,PACA_SPRG3(r13) | ||
| 1177 | mtspr SPRN_SPRG3,r3 | ||
| 1178 | |||
| 1179 | /* | ||
| 1180 | * Reload DEC. HDEC interrupts were disabled when | ||
| 1181 | * we reloaded the host's LPCR value. | ||
| 1182 | */ | ||
| 1183 | ld r3, HSTATE_DECEXP(r13) | ||
| 1184 | mftb r4 | ||
| 1185 | subf r4, r4, r3 | ||
| 1186 | mtspr SPRN_DEC, r4 | ||
| 1187 | |||
| 1188 | /* Reload the host's PMU registers */ | ||
| 1189 | ld r3, PACALPPACAPTR(r13) /* is the host using the PMU? */ | ||
| 1190 | lbz r4, LPPACA_PMCINUSE(r3) | ||
| 1191 | cmpwi r4, 0 | ||
| 1192 | beq 23f /* skip if not */ | ||
| 1193 | lwz r3, HSTATE_PMC(r13) | ||
| 1194 | lwz r4, HSTATE_PMC + 4(r13) | ||
| 1195 | lwz r5, HSTATE_PMC + 8(r13) | ||
| 1196 | lwz r6, HSTATE_PMC + 12(r13) | ||
| 1197 | lwz r8, HSTATE_PMC + 16(r13) | ||
| 1198 | lwz r9, HSTATE_PMC + 20(r13) | ||
| 1199 | BEGIN_FTR_SECTION | ||
| 1200 | lwz r10, HSTATE_PMC + 24(r13) | ||
| 1201 | lwz r11, HSTATE_PMC + 28(r13) | ||
| 1202 | END_FTR_SECTION_IFSET(CPU_FTR_ARCH_201) | ||
| 1203 | mtspr SPRN_PMC1, r3 | ||
| 1204 | mtspr SPRN_PMC2, r4 | ||
| 1205 | mtspr SPRN_PMC3, r5 | ||
| 1206 | mtspr SPRN_PMC4, r6 | ||
| 1207 | mtspr SPRN_PMC5, r8 | ||
| 1208 | mtspr SPRN_PMC6, r9 | ||
| 1209 | BEGIN_FTR_SECTION | ||
| 1210 | mtspr SPRN_PMC7, r10 | ||
| 1211 | mtspr SPRN_PMC8, r11 | ||
| 1212 | END_FTR_SECTION_IFSET(CPU_FTR_ARCH_201) | ||
| 1213 | ld r3, HSTATE_MMCR(r13) | ||
| 1214 | ld r4, HSTATE_MMCR + 8(r13) | ||
| 1215 | ld r5, HSTATE_MMCR + 16(r13) | ||
| 1216 | mtspr SPRN_MMCR1, r4 | ||
| 1217 | mtspr SPRN_MMCRA, r5 | ||
| 1218 | mtspr SPRN_MMCR0, r3 | ||
| 1219 | isync | ||
| 1220 | 23: | ||
| 1221 | /* | ||
| 1222 | * For external and machine check interrupts, we need | ||
| 1223 | * to call the Linux handler to process the interrupt. | ||
| 1224 | * We do that by jumping to absolute address 0x500 for | ||
| 1225 | * external interrupts, or the machine_check_fwnmi label | ||
| 1226 | * for machine checks (since firmware might have patched | ||
| 1227 | * the vector area at 0x200). The [h]rfid at the end of the | ||
| 1228 | * handler will return to the book3s_hv_interrupts.S code. | ||
| 1229 | * For other interrupts we do the rfid to get back | ||
| 1230 | * to the book3s_hv_interrupts.S code here. | ||
| 1231 | */ | ||
| 1232 | ld r8, HSTATE_VMHANDLER(r13) | ||
| 1233 | ld r7, HSTATE_HOST_MSR(r13) | ||
| 1234 | |||
| 1235 | cmpwi cr1, r12, BOOK3S_INTERRUPT_MACHINE_CHECK | ||
| 1236 | cmpwi r12, BOOK3S_INTERRUPT_EXTERNAL | ||
| 1237 | BEGIN_FTR_SECTION | ||
| 1238 | beq 11f | ||
| 1239 | END_FTR_SECTION_IFSET(CPU_FTR_ARCH_206) | ||
| 1240 | |||
| 1241 | /* RFI into the highmem handler, or branch to interrupt handler */ | ||
| 1242 | mfmsr r6 | ||
| 1243 | li r0, MSR_RI | ||
| 1244 | andc r6, r6, r0 | ||
| 1245 | mtmsrd r6, 1 /* Clear RI in MSR */ | ||
| 1246 | mtsrr0 r8 | ||
| 1247 | mtsrr1 r7 | ||
| 1248 | beqa 0x500 /* external interrupt (PPC970) */ | ||
| 1249 | beq cr1, 13f /* machine check */ | ||
| 1250 | RFI | ||
| 1251 | |||
| 1252 | /* On POWER7, we have external interrupts set to use HSRR0/1 */ | ||
| 1253 | 11: mtspr SPRN_HSRR0, r8 | ||
| 1254 | mtspr SPRN_HSRR1, r7 | ||
| 1255 | ba 0x500 | ||
| 1256 | |||
| 1257 | 13: b machine_check_fwnmi | ||
| 1258 | 1341 | ||
| 1259 | /* | 1342 | /* |
| 1260 | * Check whether an HDSI is an HPTE not found fault or something else. | 1343 | * Check whether an HDSI is an HPTE not found fault or something else. |
| @@ -1333,7 +1416,7 @@ fast_interrupt_c_return: | |||
| 1333 | stw r8, VCPU_LAST_INST(r9) | 1416 | stw r8, VCPU_LAST_INST(r9) |
| 1334 | 1417 | ||
| 1335 | /* Unset guest mode. */ | 1418 | /* Unset guest mode. */ |
| 1336 | li r0, KVM_GUEST_MODE_NONE | 1419 | li r0, KVM_GUEST_MODE_HOST_HV |
| 1337 | stb r0, HSTATE_IN_GUEST(r13) | 1420 | stb r0, HSTATE_IN_GUEST(r13) |
| 1338 | b guest_exit_cont | 1421 | b guest_exit_cont |
| 1339 | 1422 | ||
| @@ -1701,67 +1784,70 @@ machine_check_realmode: | |||
| 1701 | rotldi r11, r11, 63 | 1784 | rotldi r11, r11, 63 |
| 1702 | b fast_interrupt_c_return | 1785 | b fast_interrupt_c_return |
| 1703 | 1786 | ||
| 1704 | secondary_too_late: | 1787 | /* |
| 1705 | ld r5,HSTATE_KVM_VCORE(r13) | 1788 | * Determine what sort of external interrupt is pending (if any). |
| 1706 | HMT_LOW | 1789 | * Returns: |
| 1707 | 13: lbz r3,VCORE_IN_GUEST(r5) | 1790 | * 0 if no interrupt is pending |
| 1708 | cmpwi r3,0 | 1791 | * 1 if an interrupt is pending that needs to be handled by the host |
| 1709 | bne 13b | 1792 | * -1 if there was a guest wakeup IPI (which has now been cleared) |
| 1710 | HMT_MEDIUM | 1793 | */ |
| 1711 | ld r11,PACA_SLBSHADOWPTR(r13) | 1794 | kvmppc_read_intr: |
| 1712 | 1795 | /* see if a host IPI is pending */ | |
| 1713 | .rept SLB_NUM_BOLTED | 1796 | li r3, 1 |
| 1714 | ld r5,SLBSHADOW_SAVEAREA(r11) | 1797 | lbz r0, HSTATE_HOST_IPI(r13) |
| 1715 | ld r6,SLBSHADOW_SAVEAREA+8(r11) | 1798 | cmpwi r0, 0 |
| 1716 | andis. r7,r5,SLB_ESID_V@h | 1799 | bne 1f |
| 1717 | beq 1f | ||
| 1718 | slbmte r6,r5 | ||
| 1719 | 1: addi r11,r11,16 | ||
| 1720 | .endr | ||
| 1721 | 1800 | ||
| 1722 | secondary_nap: | 1801 | /* Now read the interrupt from the ICP */ |
| 1723 | /* Clear our vcpu pointer so we don't come back in early */ | 1802 | ld r6, HSTATE_XICS_PHYS(r13) |
| 1724 | li r0, 0 | ||
| 1725 | std r0, HSTATE_KVM_VCPU(r13) | ||
| 1726 | lwsync | ||
| 1727 | /* Clear any pending IPI - assume we're a secondary thread */ | ||
| 1728 | ld r5, HSTATE_XICS_PHYS(r13) | ||
| 1729 | li r7, XICS_XIRR | 1803 | li r7, XICS_XIRR |
| 1730 | lwzcix r3, r5, r7 /* ack any pending interrupt */ | 1804 | cmpdi r6, 0 |
| 1731 | rlwinm. r0, r3, 0, 0xffffff /* any pending? */ | 1805 | beq- 1f |
| 1732 | beq 37f | 1806 | lwzcix r0, r6, r7 |
| 1807 | rlwinm. r3, r0, 0, 0xffffff | ||
| 1733 | sync | 1808 | sync |
| 1734 | li r0, 0xff | 1809 | beq 1f /* if nothing pending in the ICP */ |
| 1735 | li r6, XICS_MFRR | ||
| 1736 | stbcix r0, r5, r6 /* clear the IPI */ | ||
| 1737 | stwcix r3, r5, r7 /* EOI it */ | ||
| 1738 | 37: sync | ||
| 1739 | 1810 | ||
| 1740 | /* increment the nap count and then go to nap mode */ | 1811 | /* We found something in the ICP... |
| 1741 | ld r4, HSTATE_KVM_VCORE(r13) | 1812 | * |
| 1742 | addi r4, r4, VCORE_NAP_COUNT | 1813 | * If it's not an IPI, stash it in the PACA and return to |
| 1743 | lwsync /* make previous updates visible */ | 1814 | * the host, we don't (yet) handle directing real external |
| 1744 | 51: lwarx r3, 0, r4 | 1815 | * interrupts directly to the guest |
| 1745 | addi r3, r3, 1 | 1816 | */ |
| 1746 | stwcx. r3, 0, r4 | 1817 | cmpwi r3, XICS_IPI /* if there is, is it an IPI? */ |
| 1747 | bne 51b | 1818 | li r3, 1 |
| 1819 | bne 42f | ||
| 1748 | 1820 | ||
| 1749 | kvm_no_guest: | 1821 | /* It's an IPI, clear the MFRR and EOI it */ |
| 1750 | li r0, KVM_HWTHREAD_IN_NAP | 1822 | li r3, 0xff |
| 1751 | stb r0, HSTATE_HWTHREAD_STATE(r13) | 1823 | li r8, XICS_MFRR |
| 1824 | stbcix r3, r6, r8 /* clear the IPI */ | ||
| 1825 | stwcix r0, r6, r7 /* EOI it */ | ||
| 1826 | sync | ||
| 1752 | 1827 | ||
| 1753 | li r3, LPCR_PECE0 | 1828 | /* We need to re-check host IPI now in case it got set in the |
| 1754 | mfspr r4, SPRN_LPCR | 1829 | * meantime. If it's clear, we bounce the interrupt to the |
| 1755 | rlwimi r4, r3, 0, LPCR_PECE0 | LPCR_PECE1 | 1830 | * guest |
| 1756 | mtspr SPRN_LPCR, r4 | 1831 | */ |
| 1757 | isync | 1832 | lbz r0, HSTATE_HOST_IPI(r13) |
| 1758 | std r0, HSTATE_SCRATCH0(r13) | 1833 | cmpwi r0, 0 |
| 1759 | ptesync | 1834 | bne- 43f |
| 1760 | ld r0, HSTATE_SCRATCH0(r13) | 1835 | |
| 1761 | 1: cmpd r0, r0 | 1836 | /* OK, it's an IPI for us */ |
| 1762 | bne 1b | 1837 | li r3, -1 |
| 1763 | nap | 1838 | 1: blr |
| 1764 | b . | 1839 | |
| 1840 | 42: /* It's not an IPI and it's for the host, stash it in the PACA | ||
| 1841 | * before exit, it will be picked up by the host ICP driver | ||
| 1842 | */ | ||
| 1843 | stw r0, HSTATE_SAVED_XIRR(r13) | ||
| 1844 | b 1b | ||
| 1845 | |||
| 1846 | 43: /* We raced with the host, we need to resend that IPI, bummer */ | ||
| 1847 | li r0, IPI_PRIORITY | ||
| 1848 | stbcix r0, r6, r8 /* set the IPI */ | ||
| 1849 | sync | ||
| 1850 | b 1b | ||
| 1765 | 1851 | ||
| 1766 | /* | 1852 | /* |
| 1767 | * Save away FP, VMX and VSX registers. | 1853 | * Save away FP, VMX and VSX registers. |
| @@ -1879,3 +1965,11 @@ END_FTR_SECTION_IFSET(CPU_FTR_ALTIVEC) | |||
| 1879 | lwz r7,VCPU_VRSAVE(r4) | 1965 | lwz r7,VCPU_VRSAVE(r4) |
| 1880 | mtspr SPRN_VRSAVE,r7 | 1966 | mtspr SPRN_VRSAVE,r7 |
| 1881 | blr | 1967 | blr |
| 1968 | |||
| 1969 | /* | ||
| 1970 | * We come here if we get any exception or interrupt while we are | ||
| 1971 | * executing host real mode code while in guest MMU context. | ||
| 1972 | * For now just spin, but we should do something better. | ||
| 1973 | */ | ||
| 1974 | kvmppc_bad_host_intr: | ||
| 1975 | b . | ||
diff --git a/arch/powerpc/kvm/book3s_interrupts.S b/arch/powerpc/kvm/book3s_interrupts.S index 17cfae5497a3..f4dd041c14ea 100644 --- a/arch/powerpc/kvm/book3s_interrupts.S +++ b/arch/powerpc/kvm/book3s_interrupts.S | |||
| @@ -26,8 +26,12 @@ | |||
| 26 | 26 | ||
| 27 | #if defined(CONFIG_PPC_BOOK3S_64) | 27 | #if defined(CONFIG_PPC_BOOK3S_64) |
| 28 | #define FUNC(name) GLUE(.,name) | 28 | #define FUNC(name) GLUE(.,name) |
| 29 | #define GET_SHADOW_VCPU(reg) addi reg, r13, PACA_SVCPU | ||
| 30 | |||
| 29 | #elif defined(CONFIG_PPC_BOOK3S_32) | 31 | #elif defined(CONFIG_PPC_BOOK3S_32) |
| 30 | #define FUNC(name) name | 32 | #define FUNC(name) name |
| 33 | #define GET_SHADOW_VCPU(reg) lwz reg, (THREAD + THREAD_KVM_SVCPU)(r2) | ||
| 34 | |||
| 31 | #endif /* CONFIG_PPC_BOOK3S_XX */ | 35 | #endif /* CONFIG_PPC_BOOK3S_XX */ |
| 32 | 36 | ||
| 33 | #define VCPU_LOAD_NVGPRS(vcpu) \ | 37 | #define VCPU_LOAD_NVGPRS(vcpu) \ |
| @@ -87,8 +91,14 @@ kvm_start_entry: | |||
| 87 | VCPU_LOAD_NVGPRS(r4) | 91 | VCPU_LOAD_NVGPRS(r4) |
| 88 | 92 | ||
| 89 | kvm_start_lightweight: | 93 | kvm_start_lightweight: |
| 94 | /* Copy registers into shadow vcpu so we can access them in real mode */ | ||
| 95 | GET_SHADOW_VCPU(r3) | ||
| 96 | bl FUNC(kvmppc_copy_to_svcpu) | ||
| 97 | nop | ||
| 98 | REST_GPR(4, r1) | ||
| 90 | 99 | ||
| 91 | #ifdef CONFIG_PPC_BOOK3S_64 | 100 | #ifdef CONFIG_PPC_BOOK3S_64 |
| 101 | /* Get the dcbz32 flag */ | ||
| 92 | PPC_LL r3, VCPU_HFLAGS(r4) | 102 | PPC_LL r3, VCPU_HFLAGS(r4) |
| 93 | rldicl r3, r3, 0, 63 /* r3 &= 1 */ | 103 | rldicl r3, r3, 0, 63 /* r3 &= 1 */ |
| 94 | stb r3, HSTATE_RESTORE_HID5(r13) | 104 | stb r3, HSTATE_RESTORE_HID5(r13) |
| @@ -111,9 +121,6 @@ kvm_start_lightweight: | |||
| 111 | * | 121 | * |
| 112 | */ | 122 | */ |
| 113 | 123 | ||
| 114 | .global kvmppc_handler_highmem | ||
| 115 | kvmppc_handler_highmem: | ||
| 116 | |||
| 117 | /* | 124 | /* |
| 118 | * Register usage at this point: | 125 | * Register usage at this point: |
| 119 | * | 126 | * |
| @@ -125,18 +132,31 @@ kvmppc_handler_highmem: | |||
| 125 | * | 132 | * |
| 126 | */ | 133 | */ |
| 127 | 134 | ||
| 128 | /* R7 = vcpu */ | 135 | /* Transfer reg values from shadow vcpu back to vcpu struct */ |
| 129 | PPC_LL r7, GPR4(r1) | 136 | /* On 64-bit, interrupts are still off at this point */ |
| 137 | PPC_LL r3, GPR4(r1) /* vcpu pointer */ | ||
| 138 | GET_SHADOW_VCPU(r4) | ||
| 139 | bl FUNC(kvmppc_copy_from_svcpu) | ||
| 140 | nop | ||
| 130 | 141 | ||
| 131 | #ifdef CONFIG_PPC_BOOK3S_64 | 142 | #ifdef CONFIG_PPC_BOOK3S_64 |
| 143 | /* Re-enable interrupts */ | ||
| 144 | ld r3, HSTATE_HOST_MSR(r13) | ||
| 145 | ori r3, r3, MSR_EE | ||
| 146 | MTMSR_EERI(r3) | ||
| 147 | |||
| 132 | /* | 148 | /* |
| 133 | * Reload kernel SPRG3 value. | 149 | * Reload kernel SPRG3 value. |
| 134 | * No need to save guest value as usermode can't modify SPRG3. | 150 | * No need to save guest value as usermode can't modify SPRG3. |
| 135 | */ | 151 | */ |
| 136 | ld r3, PACA_SPRG3(r13) | 152 | ld r3, PACA_SPRG3(r13) |
| 137 | mtspr SPRN_SPRG3, r3 | 153 | mtspr SPRN_SPRG3, r3 |
| 154 | |||
| 138 | #endif /* CONFIG_PPC_BOOK3S_64 */ | 155 | #endif /* CONFIG_PPC_BOOK3S_64 */ |
| 139 | 156 | ||
| 157 | /* R7 = vcpu */ | ||
| 158 | PPC_LL r7, GPR4(r1) | ||
| 159 | |||
| 140 | PPC_STL r14, VCPU_GPR(R14)(r7) | 160 | PPC_STL r14, VCPU_GPR(R14)(r7) |
| 141 | PPC_STL r15, VCPU_GPR(R15)(r7) | 161 | PPC_STL r15, VCPU_GPR(R15)(r7) |
| 142 | PPC_STL r16, VCPU_GPR(R16)(r7) | 162 | PPC_STL r16, VCPU_GPR(R16)(r7) |
| @@ -161,7 +181,7 @@ kvmppc_handler_highmem: | |||
| 161 | 181 | ||
| 162 | /* Restore r3 (kvm_run) and r4 (vcpu) */ | 182 | /* Restore r3 (kvm_run) and r4 (vcpu) */ |
| 163 | REST_2GPRS(3, r1) | 183 | REST_2GPRS(3, r1) |
| 164 | bl FUNC(kvmppc_handle_exit) | 184 | bl FUNC(kvmppc_handle_exit_pr) |
| 165 | 185 | ||
| 166 | /* If RESUME_GUEST, get back in the loop */ | 186 | /* If RESUME_GUEST, get back in the loop */ |
| 167 | cmpwi r3, RESUME_GUEST | 187 | cmpwi r3, RESUME_GUEST |
diff --git a/arch/powerpc/kvm/book3s_mmu_hpte.c b/arch/powerpc/kvm/book3s_mmu_hpte.c index da8b13c4b776..5a1ab1250a05 100644 --- a/arch/powerpc/kvm/book3s_mmu_hpte.c +++ b/arch/powerpc/kvm/book3s_mmu_hpte.c | |||
| @@ -28,7 +28,7 @@ | |||
| 28 | #include <asm/mmu_context.h> | 28 | #include <asm/mmu_context.h> |
| 29 | #include <asm/hw_irq.h> | 29 | #include <asm/hw_irq.h> |
| 30 | 30 | ||
| 31 | #include "trace.h" | 31 | #include "trace_pr.h" |
| 32 | 32 | ||
| 33 | #define PTE_SIZE 12 | 33 | #define PTE_SIZE 12 |
| 34 | 34 | ||
| @@ -56,6 +56,14 @@ static inline u64 kvmppc_mmu_hash_vpte_long(u64 vpage) | |||
| 56 | HPTEG_HASH_BITS_VPTE_LONG); | 56 | HPTEG_HASH_BITS_VPTE_LONG); |
| 57 | } | 57 | } |
| 58 | 58 | ||
| 59 | #ifdef CONFIG_PPC_BOOK3S_64 | ||
| 60 | static inline u64 kvmppc_mmu_hash_vpte_64k(u64 vpage) | ||
| 61 | { | ||
| 62 | return hash_64((vpage & 0xffffffff0ULL) >> 4, | ||
| 63 | HPTEG_HASH_BITS_VPTE_64K); | ||
| 64 | } | ||
| 65 | #endif | ||
| 66 | |||
| 59 | void kvmppc_mmu_hpte_cache_map(struct kvm_vcpu *vcpu, struct hpte_cache *pte) | 67 | void kvmppc_mmu_hpte_cache_map(struct kvm_vcpu *vcpu, struct hpte_cache *pte) |
| 60 | { | 68 | { |
| 61 | u64 index; | 69 | u64 index; |
| @@ -83,6 +91,15 @@ void kvmppc_mmu_hpte_cache_map(struct kvm_vcpu *vcpu, struct hpte_cache *pte) | |||
| 83 | hlist_add_head_rcu(&pte->list_vpte_long, | 91 | hlist_add_head_rcu(&pte->list_vpte_long, |
| 84 | &vcpu3s->hpte_hash_vpte_long[index]); | 92 | &vcpu3s->hpte_hash_vpte_long[index]); |
| 85 | 93 | ||
| 94 | #ifdef CONFIG_PPC_BOOK3S_64 | ||
| 95 | /* Add to vPTE_64k list */ | ||
| 96 | index = kvmppc_mmu_hash_vpte_64k(pte->pte.vpage); | ||
| 97 | hlist_add_head_rcu(&pte->list_vpte_64k, | ||
| 98 | &vcpu3s->hpte_hash_vpte_64k[index]); | ||
| 99 | #endif | ||
| 100 | |||
| 101 | vcpu3s->hpte_cache_count++; | ||
| 102 | |||
| 86 | spin_unlock(&vcpu3s->mmu_lock); | 103 | spin_unlock(&vcpu3s->mmu_lock); |
| 87 | } | 104 | } |
| 88 | 105 | ||
| @@ -113,10 +130,13 @@ static void invalidate_pte(struct kvm_vcpu *vcpu, struct hpte_cache *pte) | |||
| 113 | hlist_del_init_rcu(&pte->list_pte_long); | 130 | hlist_del_init_rcu(&pte->list_pte_long); |
| 114 | hlist_del_init_rcu(&pte->list_vpte); | 131 | hlist_del_init_rcu(&pte->list_vpte); |
| 115 | hlist_del_init_rcu(&pte->list_vpte_long); | 132 | hlist_del_init_rcu(&pte->list_vpte_long); |
| 133 | #ifdef CONFIG_PPC_BOOK3S_64 | ||
| 134 | hlist_del_init_rcu(&pte->list_vpte_64k); | ||
| 135 | #endif | ||
| 136 | vcpu3s->hpte_cache_count--; | ||
| 116 | 137 | ||
| 117 | spin_unlock(&vcpu3s->mmu_lock); | 138 | spin_unlock(&vcpu3s->mmu_lock); |
| 118 | 139 | ||
| 119 | vcpu3s->hpte_cache_count--; | ||
| 120 | call_rcu(&pte->rcu_head, free_pte_rcu); | 140 | call_rcu(&pte->rcu_head, free_pte_rcu); |
| 121 | } | 141 | } |
| 122 | 142 | ||
| @@ -219,6 +239,29 @@ static void kvmppc_mmu_pte_vflush_short(struct kvm_vcpu *vcpu, u64 guest_vp) | |||
| 219 | rcu_read_unlock(); | 239 | rcu_read_unlock(); |
| 220 | } | 240 | } |
| 221 | 241 | ||
| 242 | #ifdef CONFIG_PPC_BOOK3S_64 | ||
| 243 | /* Flush with mask 0xffffffff0 */ | ||
| 244 | static void kvmppc_mmu_pte_vflush_64k(struct kvm_vcpu *vcpu, u64 guest_vp) | ||
| 245 | { | ||
| 246 | struct kvmppc_vcpu_book3s *vcpu3s = to_book3s(vcpu); | ||
| 247 | struct hlist_head *list; | ||
| 248 | struct hpte_cache *pte; | ||
| 249 | u64 vp_mask = 0xffffffff0ULL; | ||
| 250 | |||
| 251 | list = &vcpu3s->hpte_hash_vpte_64k[ | ||
| 252 | kvmppc_mmu_hash_vpte_64k(guest_vp)]; | ||
| 253 | |||
| 254 | rcu_read_lock(); | ||
| 255 | |||
| 256 | /* Check the list for matching entries and invalidate */ | ||
| 257 | hlist_for_each_entry_rcu(pte, list, list_vpte_64k) | ||
| 258 | if ((pte->pte.vpage & vp_mask) == guest_vp) | ||
| 259 | invalidate_pte(vcpu, pte); | ||
| 260 | |||
| 261 | rcu_read_unlock(); | ||
| 262 | } | ||
| 263 | #endif | ||
| 264 | |||
| 222 | /* Flush with mask 0xffffff000 */ | 265 | /* Flush with mask 0xffffff000 */ |
| 223 | static void kvmppc_mmu_pte_vflush_long(struct kvm_vcpu *vcpu, u64 guest_vp) | 266 | static void kvmppc_mmu_pte_vflush_long(struct kvm_vcpu *vcpu, u64 guest_vp) |
| 224 | { | 267 | { |
| @@ -249,6 +292,11 @@ void kvmppc_mmu_pte_vflush(struct kvm_vcpu *vcpu, u64 guest_vp, u64 vp_mask) | |||
| 249 | case 0xfffffffffULL: | 292 | case 0xfffffffffULL: |
| 250 | kvmppc_mmu_pte_vflush_short(vcpu, guest_vp); | 293 | kvmppc_mmu_pte_vflush_short(vcpu, guest_vp); |
| 251 | break; | 294 | break; |
| 295 | #ifdef CONFIG_PPC_BOOK3S_64 | ||
| 296 | case 0xffffffff0ULL: | ||
| 297 | kvmppc_mmu_pte_vflush_64k(vcpu, guest_vp); | ||
| 298 | break; | ||
| 299 | #endif | ||
| 252 | case 0xffffff000ULL: | 300 | case 0xffffff000ULL: |
| 253 | kvmppc_mmu_pte_vflush_long(vcpu, guest_vp); | 301 | kvmppc_mmu_pte_vflush_long(vcpu, guest_vp); |
| 254 | break; | 302 | break; |
| @@ -285,15 +333,19 @@ struct hpte_cache *kvmppc_mmu_hpte_cache_next(struct kvm_vcpu *vcpu) | |||
| 285 | struct kvmppc_vcpu_book3s *vcpu3s = to_book3s(vcpu); | 333 | struct kvmppc_vcpu_book3s *vcpu3s = to_book3s(vcpu); |
| 286 | struct hpte_cache *pte; | 334 | struct hpte_cache *pte; |
| 287 | 335 | ||
| 288 | pte = kmem_cache_zalloc(hpte_cache, GFP_KERNEL); | ||
| 289 | vcpu3s->hpte_cache_count++; | ||
| 290 | |||
| 291 | if (vcpu3s->hpte_cache_count == HPTEG_CACHE_NUM) | 336 | if (vcpu3s->hpte_cache_count == HPTEG_CACHE_NUM) |
| 292 | kvmppc_mmu_pte_flush_all(vcpu); | 337 | kvmppc_mmu_pte_flush_all(vcpu); |
| 293 | 338 | ||
| 339 | pte = kmem_cache_zalloc(hpte_cache, GFP_KERNEL); | ||
| 340 | |||
| 294 | return pte; | 341 | return pte; |
| 295 | } | 342 | } |
| 296 | 343 | ||
| 344 | void kvmppc_mmu_hpte_cache_free(struct hpte_cache *pte) | ||
| 345 | { | ||
| 346 | kmem_cache_free(hpte_cache, pte); | ||
| 347 | } | ||
| 348 | |||
| 297 | void kvmppc_mmu_hpte_destroy(struct kvm_vcpu *vcpu) | 349 | void kvmppc_mmu_hpte_destroy(struct kvm_vcpu *vcpu) |
| 298 | { | 350 | { |
| 299 | kvmppc_mmu_pte_flush(vcpu, 0, 0); | 351 | kvmppc_mmu_pte_flush(vcpu, 0, 0); |
| @@ -320,6 +372,10 @@ int kvmppc_mmu_hpte_init(struct kvm_vcpu *vcpu) | |||
| 320 | ARRAY_SIZE(vcpu3s->hpte_hash_vpte)); | 372 | ARRAY_SIZE(vcpu3s->hpte_hash_vpte)); |
| 321 | kvmppc_mmu_hpte_init_hash(vcpu3s->hpte_hash_vpte_long, | 373 | kvmppc_mmu_hpte_init_hash(vcpu3s->hpte_hash_vpte_long, |
| 322 | ARRAY_SIZE(vcpu3s->hpte_hash_vpte_long)); | 374 | ARRAY_SIZE(vcpu3s->hpte_hash_vpte_long)); |
| 375 | #ifdef CONFIG_PPC_BOOK3S_64 | ||
| 376 | kvmppc_mmu_hpte_init_hash(vcpu3s->hpte_hash_vpte_64k, | ||
| 377 | ARRAY_SIZE(vcpu3s->hpte_hash_vpte_64k)); | ||
| 378 | #endif | ||
| 323 | 379 | ||
| 324 | spin_lock_init(&vcpu3s->mmu_lock); | 380 | spin_lock_init(&vcpu3s->mmu_lock); |
| 325 | 381 | ||
diff --git a/arch/powerpc/kvm/book3s_pr.c b/arch/powerpc/kvm/book3s_pr.c index c0b48f96a91c..fe14ca3dd171 100644 --- a/arch/powerpc/kvm/book3s_pr.c +++ b/arch/powerpc/kvm/book3s_pr.c | |||
| @@ -40,8 +40,12 @@ | |||
| 40 | #include <linux/sched.h> | 40 | #include <linux/sched.h> |
| 41 | #include <linux/vmalloc.h> | 41 | #include <linux/vmalloc.h> |
| 42 | #include <linux/highmem.h> | 42 | #include <linux/highmem.h> |
| 43 | #include <linux/module.h> | ||
| 43 | 44 | ||
| 44 | #include "trace.h" | 45 | #include "book3s.h" |
| 46 | |||
| 47 | #define CREATE_TRACE_POINTS | ||
| 48 | #include "trace_pr.h" | ||
| 45 | 49 | ||
| 46 | /* #define EXIT_DEBUG */ | 50 | /* #define EXIT_DEBUG */ |
| 47 | /* #define DEBUG_EXT */ | 51 | /* #define DEBUG_EXT */ |
| @@ -56,29 +60,25 @@ static int kvmppc_handle_ext(struct kvm_vcpu *vcpu, unsigned int exit_nr, | |||
| 56 | #define HW_PAGE_SIZE PAGE_SIZE | 60 | #define HW_PAGE_SIZE PAGE_SIZE |
| 57 | #endif | 61 | #endif |
| 58 | 62 | ||
| 59 | void kvmppc_core_vcpu_load(struct kvm_vcpu *vcpu, int cpu) | 63 | static void kvmppc_core_vcpu_load_pr(struct kvm_vcpu *vcpu, int cpu) |
| 60 | { | 64 | { |
| 61 | #ifdef CONFIG_PPC_BOOK3S_64 | 65 | #ifdef CONFIG_PPC_BOOK3S_64 |
| 62 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | 66 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); |
| 63 | memcpy(svcpu->slb, to_book3s(vcpu)->slb_shadow, sizeof(svcpu->slb)); | 67 | memcpy(svcpu->slb, to_book3s(vcpu)->slb_shadow, sizeof(svcpu->slb)); |
| 64 | memcpy(&get_paca()->shadow_vcpu, to_book3s(vcpu)->shadow_vcpu, | ||
| 65 | sizeof(get_paca()->shadow_vcpu)); | ||
| 66 | svcpu->slb_max = to_book3s(vcpu)->slb_shadow_max; | 68 | svcpu->slb_max = to_book3s(vcpu)->slb_shadow_max; |
| 67 | svcpu_put(svcpu); | 69 | svcpu_put(svcpu); |
| 68 | #endif | 70 | #endif |
| 69 | vcpu->cpu = smp_processor_id(); | 71 | vcpu->cpu = smp_processor_id(); |
| 70 | #ifdef CONFIG_PPC_BOOK3S_32 | 72 | #ifdef CONFIG_PPC_BOOK3S_32 |
| 71 | current->thread.kvm_shadow_vcpu = to_book3s(vcpu)->shadow_vcpu; | 73 | current->thread.kvm_shadow_vcpu = vcpu->arch.shadow_vcpu; |
| 72 | #endif | 74 | #endif |
| 73 | } | 75 | } |
| 74 | 76 | ||
| 75 | void kvmppc_core_vcpu_put(struct kvm_vcpu *vcpu) | 77 | static void kvmppc_core_vcpu_put_pr(struct kvm_vcpu *vcpu) |
| 76 | { | 78 | { |
| 77 | #ifdef CONFIG_PPC_BOOK3S_64 | 79 | #ifdef CONFIG_PPC_BOOK3S_64 |
| 78 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | 80 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); |
| 79 | memcpy(to_book3s(vcpu)->slb_shadow, svcpu->slb, sizeof(svcpu->slb)); | 81 | memcpy(to_book3s(vcpu)->slb_shadow, svcpu->slb, sizeof(svcpu->slb)); |
| 80 | memcpy(to_book3s(vcpu)->shadow_vcpu, &get_paca()->shadow_vcpu, | ||
| 81 | sizeof(get_paca()->shadow_vcpu)); | ||
| 82 | to_book3s(vcpu)->slb_shadow_max = svcpu->slb_max; | 82 | to_book3s(vcpu)->slb_shadow_max = svcpu->slb_max; |
| 83 | svcpu_put(svcpu); | 83 | svcpu_put(svcpu); |
| 84 | #endif | 84 | #endif |
| @@ -87,7 +87,61 @@ void kvmppc_core_vcpu_put(struct kvm_vcpu *vcpu) | |||
| 87 | vcpu->cpu = -1; | 87 | vcpu->cpu = -1; |
| 88 | } | 88 | } |
| 89 | 89 | ||
| 90 | int kvmppc_core_check_requests(struct kvm_vcpu *vcpu) | 90 | /* Copy data needed by real-mode code from vcpu to shadow vcpu */ |
| 91 | void kvmppc_copy_to_svcpu(struct kvmppc_book3s_shadow_vcpu *svcpu, | ||
| 92 | struct kvm_vcpu *vcpu) | ||
| 93 | { | ||
| 94 | svcpu->gpr[0] = vcpu->arch.gpr[0]; | ||
| 95 | svcpu->gpr[1] = vcpu->arch.gpr[1]; | ||
| 96 | svcpu->gpr[2] = vcpu->arch.gpr[2]; | ||
| 97 | svcpu->gpr[3] = vcpu->arch.gpr[3]; | ||
| 98 | svcpu->gpr[4] = vcpu->arch.gpr[4]; | ||
| 99 | svcpu->gpr[5] = vcpu->arch.gpr[5]; | ||
| 100 | svcpu->gpr[6] = vcpu->arch.gpr[6]; | ||
| 101 | svcpu->gpr[7] = vcpu->arch.gpr[7]; | ||
| 102 | svcpu->gpr[8] = vcpu->arch.gpr[8]; | ||
| 103 | svcpu->gpr[9] = vcpu->arch.gpr[9]; | ||
| 104 | svcpu->gpr[10] = vcpu->arch.gpr[10]; | ||
| 105 | svcpu->gpr[11] = vcpu->arch.gpr[11]; | ||
| 106 | svcpu->gpr[12] = vcpu->arch.gpr[12]; | ||
| 107 | svcpu->gpr[13] = vcpu->arch.gpr[13]; | ||
| 108 | svcpu->cr = vcpu->arch.cr; | ||
| 109 | svcpu->xer = vcpu->arch.xer; | ||
| 110 | svcpu->ctr = vcpu->arch.ctr; | ||
| 111 | svcpu->lr = vcpu->arch.lr; | ||
| 112 | svcpu->pc = vcpu->arch.pc; | ||
| 113 | } | ||
| 114 | |||
| 115 | /* Copy data touched by real-mode code from shadow vcpu back to vcpu */ | ||
| 116 | void kvmppc_copy_from_svcpu(struct kvm_vcpu *vcpu, | ||
| 117 | struct kvmppc_book3s_shadow_vcpu *svcpu) | ||
| 118 | { | ||
| 119 | vcpu->arch.gpr[0] = svcpu->gpr[0]; | ||
| 120 | vcpu->arch.gpr[1] = svcpu->gpr[1]; | ||
| 121 | vcpu->arch.gpr[2] = svcpu->gpr[2]; | ||
| 122 | vcpu->arch.gpr[3] = svcpu->gpr[3]; | ||
| 123 | vcpu->arch.gpr[4] = svcpu->gpr[4]; | ||
| 124 | vcpu->arch.gpr[5] = svcpu->gpr[5]; | ||
| 125 | vcpu->arch.gpr[6] = svcpu->gpr[6]; | ||
| 126 | vcpu->arch.gpr[7] = svcpu->gpr[7]; | ||
| 127 | vcpu->arch.gpr[8] = svcpu->gpr[8]; | ||
| 128 | vcpu->arch.gpr[9] = svcpu->gpr[9]; | ||
| 129 | vcpu->arch.gpr[10] = svcpu->gpr[10]; | ||
| 130 | vcpu->arch.gpr[11] = svcpu->gpr[11]; | ||
| 131 | vcpu->arch.gpr[12] = svcpu->gpr[12]; | ||
| 132 | vcpu->arch.gpr[13] = svcpu->gpr[13]; | ||
| 133 | vcpu->arch.cr = svcpu->cr; | ||
| 134 | vcpu->arch.xer = svcpu->xer; | ||
| 135 | vcpu->arch.ctr = svcpu->ctr; | ||
| 136 | vcpu->arch.lr = svcpu->lr; | ||
| 137 | vcpu->arch.pc = svcpu->pc; | ||
| 138 | vcpu->arch.shadow_srr1 = svcpu->shadow_srr1; | ||
| 139 | vcpu->arch.fault_dar = svcpu->fault_dar; | ||
| 140 | vcpu->arch.fault_dsisr = svcpu->fault_dsisr; | ||
| 141 | vcpu->arch.last_inst = svcpu->last_inst; | ||
| 142 | } | ||
| 143 | |||
| 144 | static int kvmppc_core_check_requests_pr(struct kvm_vcpu *vcpu) | ||
| 91 | { | 145 | { |
| 92 | int r = 1; /* Indicate we want to get back into the guest */ | 146 | int r = 1; /* Indicate we want to get back into the guest */ |
| 93 | 147 | ||
| @@ -100,44 +154,69 @@ int kvmppc_core_check_requests(struct kvm_vcpu *vcpu) | |||
| 100 | } | 154 | } |
| 101 | 155 | ||
| 102 | /************* MMU Notifiers *************/ | 156 | /************* MMU Notifiers *************/ |
| 157 | static void do_kvm_unmap_hva(struct kvm *kvm, unsigned long start, | ||
| 158 | unsigned long end) | ||
| 159 | { | ||
| 160 | long i; | ||
| 161 | struct kvm_vcpu *vcpu; | ||
| 162 | struct kvm_memslots *slots; | ||
| 163 | struct kvm_memory_slot *memslot; | ||
| 164 | |||
| 165 | slots = kvm_memslots(kvm); | ||
| 166 | kvm_for_each_memslot(memslot, slots) { | ||
| 167 | unsigned long hva_start, hva_end; | ||
| 168 | gfn_t gfn, gfn_end; | ||
| 169 | |||
| 170 | hva_start = max(start, memslot->userspace_addr); | ||
| 171 | hva_end = min(end, memslot->userspace_addr + | ||
| 172 | (memslot->npages << PAGE_SHIFT)); | ||
| 173 | if (hva_start >= hva_end) | ||
| 174 | continue; | ||
| 175 | /* | ||
| 176 | * {gfn(page) | page intersects with [hva_start, hva_end)} = | ||
| 177 | * {gfn, gfn+1, ..., gfn_end-1}. | ||
| 178 | */ | ||
| 179 | gfn = hva_to_gfn_memslot(hva_start, memslot); | ||
| 180 | gfn_end = hva_to_gfn_memslot(hva_end + PAGE_SIZE - 1, memslot); | ||
| 181 | kvm_for_each_vcpu(i, vcpu, kvm) | ||
| 182 | kvmppc_mmu_pte_pflush(vcpu, gfn << PAGE_SHIFT, | ||
| 183 | gfn_end << PAGE_SHIFT); | ||
| 184 | } | ||
| 185 | } | ||
| 103 | 186 | ||
| 104 | int kvm_unmap_hva(struct kvm *kvm, unsigned long hva) | 187 | static int kvm_unmap_hva_pr(struct kvm *kvm, unsigned long hva) |
| 105 | { | 188 | { |
| 106 | trace_kvm_unmap_hva(hva); | 189 | trace_kvm_unmap_hva(hva); |
| 107 | 190 | ||
| 108 | /* | 191 | do_kvm_unmap_hva(kvm, hva, hva + PAGE_SIZE); |
| 109 | * Flush all shadow tlb entries everywhere. This is slow, but | ||
| 110 | * we are 100% sure that we catch the to be unmapped page | ||
| 111 | */ | ||
| 112 | kvm_flush_remote_tlbs(kvm); | ||
| 113 | 192 | ||
| 114 | return 0; | 193 | return 0; |
| 115 | } | 194 | } |
| 116 | 195 | ||
| 117 | int kvm_unmap_hva_range(struct kvm *kvm, unsigned long start, unsigned long end) | 196 | static int kvm_unmap_hva_range_pr(struct kvm *kvm, unsigned long start, |
| 197 | unsigned long end) | ||
| 118 | { | 198 | { |
| 119 | /* kvm_unmap_hva flushes everything anyways */ | 199 | do_kvm_unmap_hva(kvm, start, end); |
| 120 | kvm_unmap_hva(kvm, start); | ||
| 121 | 200 | ||
| 122 | return 0; | 201 | return 0; |
| 123 | } | 202 | } |
| 124 | 203 | ||
| 125 | int kvm_age_hva(struct kvm *kvm, unsigned long hva) | 204 | static int kvm_age_hva_pr(struct kvm *kvm, unsigned long hva) |
| 126 | { | 205 | { |
| 127 | /* XXX could be more clever ;) */ | 206 | /* XXX could be more clever ;) */ |
| 128 | return 0; | 207 | return 0; |
| 129 | } | 208 | } |
| 130 | 209 | ||
| 131 | int kvm_test_age_hva(struct kvm *kvm, unsigned long hva) | 210 | static int kvm_test_age_hva_pr(struct kvm *kvm, unsigned long hva) |
| 132 | { | 211 | { |
| 133 | /* XXX could be more clever ;) */ | 212 | /* XXX could be more clever ;) */ |
| 134 | return 0; | 213 | return 0; |
| 135 | } | 214 | } |
| 136 | 215 | ||
| 137 | void kvm_set_spte_hva(struct kvm *kvm, unsigned long hva, pte_t pte) | 216 | static void kvm_set_spte_hva_pr(struct kvm *kvm, unsigned long hva, pte_t pte) |
| 138 | { | 217 | { |
| 139 | /* The page will get remapped properly on its next fault */ | 218 | /* The page will get remapped properly on its next fault */ |
| 140 | kvm_unmap_hva(kvm, hva); | 219 | do_kvm_unmap_hva(kvm, hva, hva + PAGE_SIZE); |
| 141 | } | 220 | } |
| 142 | 221 | ||
| 143 | /*****************************************/ | 222 | /*****************************************/ |
| @@ -159,7 +238,7 @@ static void kvmppc_recalc_shadow_msr(struct kvm_vcpu *vcpu) | |||
| 159 | vcpu->arch.shadow_msr = smsr; | 238 | vcpu->arch.shadow_msr = smsr; |
| 160 | } | 239 | } |
| 161 | 240 | ||
| 162 | void kvmppc_set_msr(struct kvm_vcpu *vcpu, u64 msr) | 241 | static void kvmppc_set_msr_pr(struct kvm_vcpu *vcpu, u64 msr) |
| 163 | { | 242 | { |
| 164 | ulong old_msr = vcpu->arch.shared->msr; | 243 | ulong old_msr = vcpu->arch.shared->msr; |
| 165 | 244 | ||
| @@ -219,7 +298,7 @@ void kvmppc_set_msr(struct kvm_vcpu *vcpu, u64 msr) | |||
| 219 | kvmppc_handle_ext(vcpu, BOOK3S_INTERRUPT_FP_UNAVAIL, MSR_FP); | 298 | kvmppc_handle_ext(vcpu, BOOK3S_INTERRUPT_FP_UNAVAIL, MSR_FP); |
| 220 | } | 299 | } |
| 221 | 300 | ||
| 222 | void kvmppc_set_pvr(struct kvm_vcpu *vcpu, u32 pvr) | 301 | void kvmppc_set_pvr_pr(struct kvm_vcpu *vcpu, u32 pvr) |
| 223 | { | 302 | { |
| 224 | u32 host_pvr; | 303 | u32 host_pvr; |
| 225 | 304 | ||
| @@ -256,6 +335,23 @@ void kvmppc_set_pvr(struct kvm_vcpu *vcpu, u32 pvr) | |||
| 256 | if (!strcmp(cur_cpu_spec->platform, "ppc-cell-be")) | 335 | if (!strcmp(cur_cpu_spec->platform, "ppc-cell-be")) |
| 257 | to_book3s(vcpu)->msr_mask &= ~(MSR_FE0 | MSR_FE1); | 336 | to_book3s(vcpu)->msr_mask &= ~(MSR_FE0 | MSR_FE1); |
| 258 | 337 | ||
| 338 | /* | ||
| 339 | * If they're asking for POWER6 or later, set the flag | ||
| 340 | * indicating that we can do multiple large page sizes | ||
| 341 | * and 1TB segments. | ||
| 342 | * Also set the flag that indicates that tlbie has the large | ||
| 343 | * page bit in the RB operand instead of the instruction. | ||
| 344 | */ | ||
| 345 | switch (PVR_VER(pvr)) { | ||
| 346 | case PVR_POWER6: | ||
| 347 | case PVR_POWER7: | ||
| 348 | case PVR_POWER7p: | ||
| 349 | case PVR_POWER8: | ||
| 350 | vcpu->arch.hflags |= BOOK3S_HFLAG_MULTI_PGSIZE | | ||
| 351 | BOOK3S_HFLAG_NEW_TLBIE; | ||
| 352 | break; | ||
| 353 | } | ||
| 354 | |||
| 259 | #ifdef CONFIG_PPC_BOOK3S_32 | 355 | #ifdef CONFIG_PPC_BOOK3S_32 |
| 260 | /* 32 bit Book3S always has 32 byte dcbz */ | 356 | /* 32 bit Book3S always has 32 byte dcbz */ |
| 261 | vcpu->arch.hflags |= BOOK3S_HFLAG_DCBZ32; | 357 | vcpu->arch.hflags |= BOOK3S_HFLAG_DCBZ32; |
| @@ -334,6 +430,7 @@ int kvmppc_handle_pagefault(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 334 | ulong eaddr, int vec) | 430 | ulong eaddr, int vec) |
| 335 | { | 431 | { |
| 336 | bool data = (vec == BOOK3S_INTERRUPT_DATA_STORAGE); | 432 | bool data = (vec == BOOK3S_INTERRUPT_DATA_STORAGE); |
| 433 | bool iswrite = false; | ||
| 337 | int r = RESUME_GUEST; | 434 | int r = RESUME_GUEST; |
| 338 | int relocated; | 435 | int relocated; |
| 339 | int page_found = 0; | 436 | int page_found = 0; |
| @@ -344,10 +441,12 @@ int kvmppc_handle_pagefault(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 344 | u64 vsid; | 441 | u64 vsid; |
| 345 | 442 | ||
| 346 | relocated = data ? dr : ir; | 443 | relocated = data ? dr : ir; |
| 444 | if (data && (vcpu->arch.fault_dsisr & DSISR_ISSTORE)) | ||
| 445 | iswrite = true; | ||
| 347 | 446 | ||
| 348 | /* Resolve real address if translation turned on */ | 447 | /* Resolve real address if translation turned on */ |
| 349 | if (relocated) { | 448 | if (relocated) { |
| 350 | page_found = vcpu->arch.mmu.xlate(vcpu, eaddr, &pte, data); | 449 | page_found = vcpu->arch.mmu.xlate(vcpu, eaddr, &pte, data, iswrite); |
| 351 | } else { | 450 | } else { |
| 352 | pte.may_execute = true; | 451 | pte.may_execute = true; |
| 353 | pte.may_read = true; | 452 | pte.may_read = true; |
| @@ -355,6 +454,7 @@ int kvmppc_handle_pagefault(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 355 | pte.raddr = eaddr & KVM_PAM; | 454 | pte.raddr = eaddr & KVM_PAM; |
| 356 | pte.eaddr = eaddr; | 455 | pte.eaddr = eaddr; |
| 357 | pte.vpage = eaddr >> 12; | 456 | pte.vpage = eaddr >> 12; |
| 457 | pte.page_size = MMU_PAGE_64K; | ||
| 358 | } | 458 | } |
| 359 | 459 | ||
| 360 | switch (vcpu->arch.shared->msr & (MSR_DR|MSR_IR)) { | 460 | switch (vcpu->arch.shared->msr & (MSR_DR|MSR_IR)) { |
| @@ -388,22 +488,18 @@ int kvmppc_handle_pagefault(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 388 | 488 | ||
| 389 | if (page_found == -ENOENT) { | 489 | if (page_found == -ENOENT) { |
| 390 | /* Page not found in guest PTE entries */ | 490 | /* Page not found in guest PTE entries */ |
| 391 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 392 | vcpu->arch.shared->dar = kvmppc_get_fault_dar(vcpu); | 491 | vcpu->arch.shared->dar = kvmppc_get_fault_dar(vcpu); |
| 393 | vcpu->arch.shared->dsisr = svcpu->fault_dsisr; | 492 | vcpu->arch.shared->dsisr = vcpu->arch.fault_dsisr; |
| 394 | vcpu->arch.shared->msr |= | 493 | vcpu->arch.shared->msr |= |
| 395 | (svcpu->shadow_srr1 & 0x00000000f8000000ULL); | 494 | vcpu->arch.shadow_srr1 & 0x00000000f8000000ULL; |
| 396 | svcpu_put(svcpu); | ||
| 397 | kvmppc_book3s_queue_irqprio(vcpu, vec); | 495 | kvmppc_book3s_queue_irqprio(vcpu, vec); |
| 398 | } else if (page_found == -EPERM) { | 496 | } else if (page_found == -EPERM) { |
| 399 | /* Storage protection */ | 497 | /* Storage protection */ |
| 400 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | ||
| 401 | vcpu->arch.shared->dar = kvmppc_get_fault_dar(vcpu); | 498 | vcpu->arch.shared->dar = kvmppc_get_fault_dar(vcpu); |
| 402 | vcpu->arch.shared->dsisr = svcpu->fault_dsisr & ~DSISR_NOHPTE; | 499 | vcpu->arch.shared->dsisr = vcpu->arch.fault_dsisr & ~DSISR_NOHPTE; |
| 403 | vcpu->arch.shared->dsisr |= DSISR_PROTFAULT; | 500 | vcpu->arch.shared->dsisr |= DSISR_PROTFAULT; |
| 404 | vcpu->arch.shared->msr |= | 501 | vcpu->arch.shared->msr |= |
| 405 | svcpu->shadow_srr1 & 0x00000000f8000000ULL; | 502 | vcpu->arch.shadow_srr1 & 0x00000000f8000000ULL; |
| 406 | svcpu_put(svcpu); | ||
| 407 | kvmppc_book3s_queue_irqprio(vcpu, vec); | 503 | kvmppc_book3s_queue_irqprio(vcpu, vec); |
| 408 | } else if (page_found == -EINVAL) { | 504 | } else if (page_found == -EINVAL) { |
| 409 | /* Page not found in guest SLB */ | 505 | /* Page not found in guest SLB */ |
| @@ -411,12 +507,20 @@ int kvmppc_handle_pagefault(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 411 | kvmppc_book3s_queue_irqprio(vcpu, vec + 0x80); | 507 | kvmppc_book3s_queue_irqprio(vcpu, vec + 0x80); |
| 412 | } else if (!is_mmio && | 508 | } else if (!is_mmio && |
| 413 | kvmppc_visible_gfn(vcpu, pte.raddr >> PAGE_SHIFT)) { | 509 | kvmppc_visible_gfn(vcpu, pte.raddr >> PAGE_SHIFT)) { |
| 510 | if (data && !(vcpu->arch.fault_dsisr & DSISR_NOHPTE)) { | ||
| 511 | /* | ||
| 512 | * There is already a host HPTE there, presumably | ||
| 513 | * a read-only one for a page the guest thinks | ||
| 514 | * is writable, so get rid of it first. | ||
| 515 | */ | ||
| 516 | kvmppc_mmu_unmap_page(vcpu, &pte); | ||
| 517 | } | ||
| 414 | /* The guest's PTE is not mapped yet. Map on the host */ | 518 | /* The guest's PTE is not mapped yet. Map on the host */ |
| 415 | kvmppc_mmu_map_page(vcpu, &pte); | 519 | kvmppc_mmu_map_page(vcpu, &pte, iswrite); |
| 416 | if (data) | 520 | if (data) |
| 417 | vcpu->stat.sp_storage++; | 521 | vcpu->stat.sp_storage++; |
| 418 | else if (vcpu->arch.mmu.is_dcbz32(vcpu) && | 522 | else if (vcpu->arch.mmu.is_dcbz32(vcpu) && |
| 419 | (!(vcpu->arch.hflags & BOOK3S_HFLAG_DCBZ32))) | 523 | (!(vcpu->arch.hflags & BOOK3S_HFLAG_DCBZ32))) |
| 420 | kvmppc_patch_dcbz(vcpu, &pte); | 524 | kvmppc_patch_dcbz(vcpu, &pte); |
| 421 | } else { | 525 | } else { |
| 422 | /* MMIO */ | 526 | /* MMIO */ |
| @@ -619,13 +723,15 @@ static void kvmppc_handle_lost_ext(struct kvm_vcpu *vcpu) | |||
| 619 | 723 | ||
| 620 | if (lost_ext & MSR_FP) | 724 | if (lost_ext & MSR_FP) |
| 621 | kvmppc_load_up_fpu(); | 725 | kvmppc_load_up_fpu(); |
| 726 | #ifdef CONFIG_ALTIVEC | ||
| 622 | if (lost_ext & MSR_VEC) | 727 | if (lost_ext & MSR_VEC) |
| 623 | kvmppc_load_up_altivec(); | 728 | kvmppc_load_up_altivec(); |
| 729 | #endif | ||
| 624 | current->thread.regs->msr |= lost_ext; | 730 | current->thread.regs->msr |= lost_ext; |
| 625 | } | 731 | } |
| 626 | 732 | ||
| 627 | int kvmppc_handle_exit(struct kvm_run *run, struct kvm_vcpu *vcpu, | 733 | int kvmppc_handle_exit_pr(struct kvm_run *run, struct kvm_vcpu *vcpu, |
| 628 | unsigned int exit_nr) | 734 | unsigned int exit_nr) |
| 629 | { | 735 | { |
| 630 | int r = RESUME_HOST; | 736 | int r = RESUME_HOST; |
| 631 | int s; | 737 | int s; |
| @@ -643,25 +749,32 @@ int kvmppc_handle_exit(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 643 | switch (exit_nr) { | 749 | switch (exit_nr) { |
| 644 | case BOOK3S_INTERRUPT_INST_STORAGE: | 750 | case BOOK3S_INTERRUPT_INST_STORAGE: |
| 645 | { | 751 | { |
| 646 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | 752 | ulong shadow_srr1 = vcpu->arch.shadow_srr1; |
| 647 | ulong shadow_srr1 = svcpu->shadow_srr1; | ||
| 648 | vcpu->stat.pf_instruc++; | 753 | vcpu->stat.pf_instruc++; |
| 649 | 754 | ||
| 650 | #ifdef CONFIG_PPC_BOOK3S_32 | 755 | #ifdef CONFIG_PPC_BOOK3S_32 |
| 651 | /* We set segments as unused segments when invalidating them. So | 756 | /* We set segments as unused segments when invalidating them. So |
| 652 | * treat the respective fault as segment fault. */ | 757 | * treat the respective fault as segment fault. */ |
| 653 | if (svcpu->sr[kvmppc_get_pc(vcpu) >> SID_SHIFT] == SR_INVALID) { | 758 | { |
| 654 | kvmppc_mmu_map_segment(vcpu, kvmppc_get_pc(vcpu)); | 759 | struct kvmppc_book3s_shadow_vcpu *svcpu; |
| 655 | r = RESUME_GUEST; | 760 | u32 sr; |
| 761 | |||
| 762 | svcpu = svcpu_get(vcpu); | ||
| 763 | sr = svcpu->sr[kvmppc_get_pc(vcpu) >> SID_SHIFT]; | ||
| 656 | svcpu_put(svcpu); | 764 | svcpu_put(svcpu); |
| 657 | break; | 765 | if (sr == SR_INVALID) { |
| 766 | kvmppc_mmu_map_segment(vcpu, kvmppc_get_pc(vcpu)); | ||
| 767 | r = RESUME_GUEST; | ||
| 768 | break; | ||
| 769 | } | ||
| 658 | } | 770 | } |
| 659 | #endif | 771 | #endif |
| 660 | svcpu_put(svcpu); | ||
| 661 | 772 | ||
| 662 | /* only care about PTEG not found errors, but leave NX alone */ | 773 | /* only care about PTEG not found errors, but leave NX alone */ |
| 663 | if (shadow_srr1 & 0x40000000) { | 774 | if (shadow_srr1 & 0x40000000) { |
| 775 | int idx = srcu_read_lock(&vcpu->kvm->srcu); | ||
| 664 | r = kvmppc_handle_pagefault(run, vcpu, kvmppc_get_pc(vcpu), exit_nr); | 776 | r = kvmppc_handle_pagefault(run, vcpu, kvmppc_get_pc(vcpu), exit_nr); |
| 777 | srcu_read_unlock(&vcpu->kvm->srcu, idx); | ||
| 665 | vcpu->stat.sp_instruc++; | 778 | vcpu->stat.sp_instruc++; |
| 666 | } else if (vcpu->arch.mmu.is_dcbz32(vcpu) && | 779 | } else if (vcpu->arch.mmu.is_dcbz32(vcpu) && |
| 667 | (!(vcpu->arch.hflags & BOOK3S_HFLAG_DCBZ32))) { | 780 | (!(vcpu->arch.hflags & BOOK3S_HFLAG_DCBZ32))) { |
| @@ -682,25 +795,36 @@ int kvmppc_handle_exit(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 682 | case BOOK3S_INTERRUPT_DATA_STORAGE: | 795 | case BOOK3S_INTERRUPT_DATA_STORAGE: |
| 683 | { | 796 | { |
| 684 | ulong dar = kvmppc_get_fault_dar(vcpu); | 797 | ulong dar = kvmppc_get_fault_dar(vcpu); |
| 685 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | 798 | u32 fault_dsisr = vcpu->arch.fault_dsisr; |
| 686 | u32 fault_dsisr = svcpu->fault_dsisr; | ||
| 687 | vcpu->stat.pf_storage++; | 799 | vcpu->stat.pf_storage++; |
| 688 | 800 | ||
| 689 | #ifdef CONFIG_PPC_BOOK3S_32 | 801 | #ifdef CONFIG_PPC_BOOK3S_32 |
| 690 | /* We set segments as unused segments when invalidating them. So | 802 | /* We set segments as unused segments when invalidating them. So |
| 691 | * treat the respective fault as segment fault. */ | 803 | * treat the respective fault as segment fault. */ |
| 692 | if ((svcpu->sr[dar >> SID_SHIFT]) == SR_INVALID) { | 804 | { |
| 693 | kvmppc_mmu_map_segment(vcpu, dar); | 805 | struct kvmppc_book3s_shadow_vcpu *svcpu; |
| 694 | r = RESUME_GUEST; | 806 | u32 sr; |
| 807 | |||
| 808 | svcpu = svcpu_get(vcpu); | ||
| 809 | sr = svcpu->sr[dar >> SID_SHIFT]; | ||
| 695 | svcpu_put(svcpu); | 810 | svcpu_put(svcpu); |
| 696 | break; | 811 | if (sr == SR_INVALID) { |
| 812 | kvmppc_mmu_map_segment(vcpu, dar); | ||
| 813 | r = RESUME_GUEST; | ||
| 814 | break; | ||
| 815 | } | ||
| 697 | } | 816 | } |
| 698 | #endif | 817 | #endif |
| 699 | svcpu_put(svcpu); | ||
| 700 | 818 | ||
| 701 | /* The only case we need to handle is missing shadow PTEs */ | 819 | /* |
| 702 | if (fault_dsisr & DSISR_NOHPTE) { | 820 | * We need to handle missing shadow PTEs, and |
| 821 | * protection faults due to us mapping a page read-only | ||
| 822 | * when the guest thinks it is writable. | ||
| 823 | */ | ||
| 824 | if (fault_dsisr & (DSISR_NOHPTE | DSISR_PROTFAULT)) { | ||
| 825 | int idx = srcu_read_lock(&vcpu->kvm->srcu); | ||
| 703 | r = kvmppc_handle_pagefault(run, vcpu, dar, exit_nr); | 826 | r = kvmppc_handle_pagefault(run, vcpu, dar, exit_nr); |
| 827 | srcu_read_unlock(&vcpu->kvm->srcu, idx); | ||
| 704 | } else { | 828 | } else { |
| 705 | vcpu->arch.shared->dar = dar; | 829 | vcpu->arch.shared->dar = dar; |
| 706 | vcpu->arch.shared->dsisr = fault_dsisr; | 830 | vcpu->arch.shared->dsisr = fault_dsisr; |
| @@ -743,13 +867,10 @@ int kvmppc_handle_exit(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 743 | case BOOK3S_INTERRUPT_H_EMUL_ASSIST: | 867 | case BOOK3S_INTERRUPT_H_EMUL_ASSIST: |
| 744 | { | 868 | { |
| 745 | enum emulation_result er; | 869 | enum emulation_result er; |
| 746 | struct kvmppc_book3s_shadow_vcpu *svcpu; | ||
| 747 | ulong flags; | 870 | ulong flags; |
| 748 | 871 | ||
| 749 | program_interrupt: | 872 | program_interrupt: |
| 750 | svcpu = svcpu_get(vcpu); | 873 | flags = vcpu->arch.shadow_srr1 & 0x1f0000ull; |
| 751 | flags = svcpu->shadow_srr1 & 0x1f0000ull; | ||
| 752 | svcpu_put(svcpu); | ||
| 753 | 874 | ||
| 754 | if (vcpu->arch.shared->msr & MSR_PR) { | 875 | if (vcpu->arch.shared->msr & MSR_PR) { |
| 755 | #ifdef EXIT_DEBUG | 876 | #ifdef EXIT_DEBUG |
| @@ -798,7 +919,7 @@ program_interrupt: | |||
| 798 | ulong cmd = kvmppc_get_gpr(vcpu, 3); | 919 | ulong cmd = kvmppc_get_gpr(vcpu, 3); |
| 799 | int i; | 920 | int i; |
| 800 | 921 | ||
| 801 | #ifdef CONFIG_KVM_BOOK3S_64_PR | 922 | #ifdef CONFIG_PPC_BOOK3S_64 |
| 802 | if (kvmppc_h_pr(vcpu, cmd) == EMULATE_DONE) { | 923 | if (kvmppc_h_pr(vcpu, cmd) == EMULATE_DONE) { |
| 803 | r = RESUME_GUEST; | 924 | r = RESUME_GUEST; |
| 804 | break; | 925 | break; |
| @@ -881,9 +1002,7 @@ program_interrupt: | |||
| 881 | break; | 1002 | break; |
| 882 | default: | 1003 | default: |
| 883 | { | 1004 | { |
| 884 | struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu); | 1005 | ulong shadow_srr1 = vcpu->arch.shadow_srr1; |
| 885 | ulong shadow_srr1 = svcpu->shadow_srr1; | ||
| 886 | svcpu_put(svcpu); | ||
| 887 | /* Ugh - bork here! What did we get? */ | 1006 | /* Ugh - bork here! What did we get? */ |
| 888 | printk(KERN_EMERG "exit_nr=0x%x | pc=0x%lx | msr=0x%lx\n", | 1007 | printk(KERN_EMERG "exit_nr=0x%x | pc=0x%lx | msr=0x%lx\n", |
| 889 | exit_nr, kvmppc_get_pc(vcpu), shadow_srr1); | 1008 | exit_nr, kvmppc_get_pc(vcpu), shadow_srr1); |
| @@ -920,8 +1039,8 @@ program_interrupt: | |||
| 920 | return r; | 1039 | return r; |
| 921 | } | 1040 | } |
| 922 | 1041 | ||
| 923 | int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, | 1042 | static int kvm_arch_vcpu_ioctl_get_sregs_pr(struct kvm_vcpu *vcpu, |
| 924 | struct kvm_sregs *sregs) | 1043 | struct kvm_sregs *sregs) |
| 925 | { | 1044 | { |
| 926 | struct kvmppc_vcpu_book3s *vcpu3s = to_book3s(vcpu); | 1045 | struct kvmppc_vcpu_book3s *vcpu3s = to_book3s(vcpu); |
| 927 | int i; | 1046 | int i; |
| @@ -947,13 +1066,13 @@ int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, | |||
| 947 | return 0; | 1066 | return 0; |
| 948 | } | 1067 | } |
| 949 | 1068 | ||
| 950 | int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, | 1069 | static int kvm_arch_vcpu_ioctl_set_sregs_pr(struct kvm_vcpu *vcpu, |
| 951 | struct kvm_sregs *sregs) | 1070 | struct kvm_sregs *sregs) |
| 952 | { | 1071 | { |
| 953 | struct kvmppc_vcpu_book3s *vcpu3s = to_book3s(vcpu); | 1072 | struct kvmppc_vcpu_book3s *vcpu3s = to_book3s(vcpu); |
| 954 | int i; | 1073 | int i; |
| 955 | 1074 | ||
| 956 | kvmppc_set_pvr(vcpu, sregs->pvr); | 1075 | kvmppc_set_pvr_pr(vcpu, sregs->pvr); |
| 957 | 1076 | ||
| 958 | vcpu3s->sdr1 = sregs->u.s.sdr1; | 1077 | vcpu3s->sdr1 = sregs->u.s.sdr1; |
| 959 | if (vcpu->arch.hflags & BOOK3S_HFLAG_SLB) { | 1078 | if (vcpu->arch.hflags & BOOK3S_HFLAG_SLB) { |
| @@ -983,7 +1102,8 @@ int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, | |||
| 983 | return 0; | 1102 | return 0; |
| 984 | } | 1103 | } |
| 985 | 1104 | ||
| 986 | int kvmppc_get_one_reg(struct kvm_vcpu *vcpu, u64 id, union kvmppc_one_reg *val) | 1105 | static int kvmppc_get_one_reg_pr(struct kvm_vcpu *vcpu, u64 id, |
| 1106 | union kvmppc_one_reg *val) | ||
| 987 | { | 1107 | { |
| 988 | int r = 0; | 1108 | int r = 0; |
| 989 | 1109 | ||
| @@ -1012,7 +1132,8 @@ int kvmppc_get_one_reg(struct kvm_vcpu *vcpu, u64 id, union kvmppc_one_reg *val) | |||
| 1012 | return r; | 1132 | return r; |
| 1013 | } | 1133 | } |
| 1014 | 1134 | ||
| 1015 | int kvmppc_set_one_reg(struct kvm_vcpu *vcpu, u64 id, union kvmppc_one_reg *val) | 1135 | static int kvmppc_set_one_reg_pr(struct kvm_vcpu *vcpu, u64 id, |
| 1136 | union kvmppc_one_reg *val) | ||
| 1016 | { | 1137 | { |
| 1017 | int r = 0; | 1138 | int r = 0; |
| 1018 | 1139 | ||
| @@ -1042,28 +1163,30 @@ int kvmppc_set_one_reg(struct kvm_vcpu *vcpu, u64 id, union kvmppc_one_reg *val) | |||
| 1042 | return r; | 1163 | return r; |
| 1043 | } | 1164 | } |
| 1044 | 1165 | ||
| 1045 | int kvmppc_core_check_processor_compat(void) | 1166 | static struct kvm_vcpu *kvmppc_core_vcpu_create_pr(struct kvm *kvm, |
| 1046 | { | 1167 | unsigned int id) |
| 1047 | return 0; | ||
| 1048 | } | ||
| 1049 | |||
| 1050 | struct kvm_vcpu *kvmppc_core_vcpu_create(struct kvm *kvm, unsigned int id) | ||
| 1051 | { | 1168 | { |
| 1052 | struct kvmppc_vcpu_book3s *vcpu_book3s; | 1169 | struct kvmppc_vcpu_book3s *vcpu_book3s; |
| 1053 | struct kvm_vcpu *vcpu; | 1170 | struct kvm_vcpu *vcpu; |
| 1054 | int err = -ENOMEM; | 1171 | int err = -ENOMEM; |
| 1055 | unsigned long p; | 1172 | unsigned long p; |
| 1056 | 1173 | ||
| 1057 | vcpu_book3s = vzalloc(sizeof(struct kvmppc_vcpu_book3s)); | 1174 | vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL); |
| 1058 | if (!vcpu_book3s) | 1175 | if (!vcpu) |
| 1059 | goto out; | 1176 | goto out; |
| 1060 | 1177 | ||
| 1061 | vcpu_book3s->shadow_vcpu = | 1178 | vcpu_book3s = vzalloc(sizeof(struct kvmppc_vcpu_book3s)); |
| 1062 | kzalloc(sizeof(*vcpu_book3s->shadow_vcpu), GFP_KERNEL); | 1179 | if (!vcpu_book3s) |
| 1063 | if (!vcpu_book3s->shadow_vcpu) | ||
| 1064 | goto free_vcpu; | 1180 | goto free_vcpu; |
| 1181 | vcpu->arch.book3s = vcpu_book3s; | ||
| 1182 | |||
| 1183 | #ifdef CONFIG_KVM_BOOK3S_32 | ||
| 1184 | vcpu->arch.shadow_vcpu = | ||
| 1185 | kzalloc(sizeof(*vcpu->arch.shadow_vcpu), GFP_KERNEL); | ||
| 1186 | if (!vcpu->arch.shadow_vcpu) | ||
| 1187 | goto free_vcpu3s; | ||
| 1188 | #endif | ||
| 1065 | 1189 | ||
| 1066 | vcpu = &vcpu_book3s->vcpu; | ||
| 1067 | err = kvm_vcpu_init(vcpu, kvm, id); | 1190 | err = kvm_vcpu_init(vcpu, kvm, id); |
| 1068 | if (err) | 1191 | if (err) |
| 1069 | goto free_shadow_vcpu; | 1192 | goto free_shadow_vcpu; |
| @@ -1076,13 +1199,19 @@ struct kvm_vcpu *kvmppc_core_vcpu_create(struct kvm *kvm, unsigned int id) | |||
| 1076 | vcpu->arch.shared = (void *)(p + PAGE_SIZE - 4096); | 1199 | vcpu->arch.shared = (void *)(p + PAGE_SIZE - 4096); |
| 1077 | 1200 | ||
| 1078 | #ifdef CONFIG_PPC_BOOK3S_64 | 1201 | #ifdef CONFIG_PPC_BOOK3S_64 |
| 1079 | /* default to book3s_64 (970fx) */ | 1202 | /* |
| 1203 | * Default to the same as the host if we're on sufficiently | ||
| 1204 | * recent machine that we have 1TB segments; | ||
| 1205 | * otherwise default to PPC970FX. | ||
| 1206 | */ | ||
| 1080 | vcpu->arch.pvr = 0x3C0301; | 1207 | vcpu->arch.pvr = 0x3C0301; |
| 1208 | if (mmu_has_feature(MMU_FTR_1T_SEGMENT)) | ||
| 1209 | vcpu->arch.pvr = mfspr(SPRN_PVR); | ||
| 1081 | #else | 1210 | #else |
| 1082 | /* default to book3s_32 (750) */ | 1211 | /* default to book3s_32 (750) */ |
| 1083 | vcpu->arch.pvr = 0x84202; | 1212 | vcpu->arch.pvr = 0x84202; |
| 1084 | #endif | 1213 | #endif |
| 1085 | kvmppc_set_pvr(vcpu, vcpu->arch.pvr); | 1214 | kvmppc_set_pvr_pr(vcpu, vcpu->arch.pvr); |
| 1086 | vcpu->arch.slb_nr = 64; | 1215 | vcpu->arch.slb_nr = 64; |
| 1087 | 1216 | ||
| 1088 | vcpu->arch.shadow_msr = MSR_USER64; | 1217 | vcpu->arch.shadow_msr = MSR_USER64; |
| @@ -1096,24 +1225,31 @@ struct kvm_vcpu *kvmppc_core_vcpu_create(struct kvm *kvm, unsigned int id) | |||
| 1096 | uninit_vcpu: | 1225 | uninit_vcpu: |
| 1097 | kvm_vcpu_uninit(vcpu); | 1226 | kvm_vcpu_uninit(vcpu); |
| 1098 | free_shadow_vcpu: | 1227 | free_shadow_vcpu: |
| 1099 | kfree(vcpu_book3s->shadow_vcpu); | 1228 | #ifdef CONFIG_KVM_BOOK3S_32 |
| 1100 | free_vcpu: | 1229 | kfree(vcpu->arch.shadow_vcpu); |
| 1230 | free_vcpu3s: | ||
| 1231 | #endif | ||
| 1101 | vfree(vcpu_book3s); | 1232 | vfree(vcpu_book3s); |
| 1233 | free_vcpu: | ||
| 1234 | kmem_cache_free(kvm_vcpu_cache, vcpu); | ||
| 1102 | out: | 1235 | out: |
| 1103 | return ERR_PTR(err); | 1236 | return ERR_PTR(err); |
| 1104 | } | 1237 | } |
| 1105 | 1238 | ||
| 1106 | void kvmppc_core_vcpu_free(struct kvm_vcpu *vcpu) | 1239 | static void kvmppc_core_vcpu_free_pr(struct kvm_vcpu *vcpu) |
| 1107 | { | 1240 | { |
| 1108 | struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu); | 1241 | struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu); |
| 1109 | 1242 | ||
| 1110 | free_page((unsigned long)vcpu->arch.shared & PAGE_MASK); | 1243 | free_page((unsigned long)vcpu->arch.shared & PAGE_MASK); |
| 1111 | kvm_vcpu_uninit(vcpu); | 1244 | kvm_vcpu_uninit(vcpu); |
| 1112 | kfree(vcpu_book3s->shadow_vcpu); | 1245 | #ifdef CONFIG_KVM_BOOK3S_32 |
| 1246 | kfree(vcpu->arch.shadow_vcpu); | ||
| 1247 | #endif | ||
| 1113 | vfree(vcpu_book3s); | 1248 | vfree(vcpu_book3s); |
| 1249 | kmem_cache_free(kvm_vcpu_cache, vcpu); | ||
| 1114 | } | 1250 | } |
| 1115 | 1251 | ||
| 1116 | int kvmppc_vcpu_run(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu) | 1252 | static int kvmppc_vcpu_run_pr(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu) |
| 1117 | { | 1253 | { |
| 1118 | int ret; | 1254 | int ret; |
| 1119 | struct thread_fp_state fp; | 1255 | struct thread_fp_state fp; |
| @@ -1216,8 +1352,8 @@ out: | |||
| 1216 | /* | 1352 | /* |
| 1217 | * Get (and clear) the dirty memory log for a memory slot. | 1353 | * Get (and clear) the dirty memory log for a memory slot. |
| 1218 | */ | 1354 | */ |
| 1219 | int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, | 1355 | static int kvm_vm_ioctl_get_dirty_log_pr(struct kvm *kvm, |
| 1220 | struct kvm_dirty_log *log) | 1356 | struct kvm_dirty_log *log) |
| 1221 | { | 1357 | { |
| 1222 | struct kvm_memory_slot *memslot; | 1358 | struct kvm_memory_slot *memslot; |
| 1223 | struct kvm_vcpu *vcpu; | 1359 | struct kvm_vcpu *vcpu; |
| @@ -1252,67 +1388,100 @@ out: | |||
| 1252 | return r; | 1388 | return r; |
| 1253 | } | 1389 | } |
| 1254 | 1390 | ||
| 1255 | #ifdef CONFIG_PPC64 | 1391 | static void kvmppc_core_flush_memslot_pr(struct kvm *kvm, |
| 1256 | int kvm_vm_ioctl_get_smmu_info(struct kvm *kvm, struct kvm_ppc_smmu_info *info) | 1392 | struct kvm_memory_slot *memslot) |
| 1257 | { | 1393 | { |
| 1258 | info->flags = KVM_PPC_1T_SEGMENTS; | 1394 | return; |
| 1259 | 1395 | } | |
| 1260 | /* SLB is always 64 entries */ | ||
| 1261 | info->slb_size = 64; | ||
| 1262 | |||
| 1263 | /* Standard 4k base page size segment */ | ||
| 1264 | info->sps[0].page_shift = 12; | ||
| 1265 | info->sps[0].slb_enc = 0; | ||
| 1266 | info->sps[0].enc[0].page_shift = 12; | ||
| 1267 | info->sps[0].enc[0].pte_enc = 0; | ||
| 1268 | |||
| 1269 | /* Standard 16M large page size segment */ | ||
| 1270 | info->sps[1].page_shift = 24; | ||
| 1271 | info->sps[1].slb_enc = SLB_VSID_L; | ||
| 1272 | info->sps[1].enc[0].page_shift = 24; | ||
| 1273 | info->sps[1].enc[0].pte_enc = 0; | ||
| 1274 | 1396 | ||
| 1397 | static int kvmppc_core_prepare_memory_region_pr(struct kvm *kvm, | ||
| 1398 | struct kvm_memory_slot *memslot, | ||
| 1399 | struct kvm_userspace_memory_region *mem) | ||
| 1400 | { | ||
| 1275 | return 0; | 1401 | return 0; |
| 1276 | } | 1402 | } |
| 1277 | #endif /* CONFIG_PPC64 */ | ||
| 1278 | 1403 | ||
| 1279 | void kvmppc_core_free_memslot(struct kvm_memory_slot *free, | 1404 | static void kvmppc_core_commit_memory_region_pr(struct kvm *kvm, |
| 1280 | struct kvm_memory_slot *dont) | 1405 | struct kvm_userspace_memory_region *mem, |
| 1406 | const struct kvm_memory_slot *old) | ||
| 1281 | { | 1407 | { |
| 1408 | return; | ||
| 1282 | } | 1409 | } |
| 1283 | 1410 | ||
| 1284 | int kvmppc_core_create_memslot(struct kvm_memory_slot *slot, | 1411 | static void kvmppc_core_free_memslot_pr(struct kvm_memory_slot *free, |
| 1285 | unsigned long npages) | 1412 | struct kvm_memory_slot *dont) |
| 1286 | { | 1413 | { |
| 1287 | return 0; | 1414 | return; |
| 1288 | } | 1415 | } |
| 1289 | 1416 | ||
| 1290 | int kvmppc_core_prepare_memory_region(struct kvm *kvm, | 1417 | static int kvmppc_core_create_memslot_pr(struct kvm_memory_slot *slot, |
| 1291 | struct kvm_memory_slot *memslot, | 1418 | unsigned long npages) |
| 1292 | struct kvm_userspace_memory_region *mem) | ||
| 1293 | { | 1419 | { |
| 1294 | return 0; | 1420 | return 0; |
| 1295 | } | 1421 | } |
| 1296 | 1422 | ||
| 1297 | void kvmppc_core_commit_memory_region(struct kvm *kvm, | 1423 | |
| 1298 | struct kvm_userspace_memory_region *mem, | 1424 | #ifdef CONFIG_PPC64 |
| 1299 | const struct kvm_memory_slot *old) | 1425 | static int kvm_vm_ioctl_get_smmu_info_pr(struct kvm *kvm, |
| 1426 | struct kvm_ppc_smmu_info *info) | ||
| 1300 | { | 1427 | { |
| 1301 | } | 1428 | long int i; |
| 1429 | struct kvm_vcpu *vcpu; | ||
| 1430 | |||
| 1431 | info->flags = 0; | ||
| 1432 | |||
| 1433 | /* SLB is always 64 entries */ | ||
| 1434 | info->slb_size = 64; | ||
| 1435 | |||
| 1436 | /* Standard 4k base page size segment */ | ||
| 1437 | info->sps[0].page_shift = 12; | ||
| 1438 | info->sps[0].slb_enc = 0; | ||
| 1439 | info->sps[0].enc[0].page_shift = 12; | ||
| 1440 | info->sps[0].enc[0].pte_enc = 0; | ||
| 1441 | |||
| 1442 | /* | ||
| 1443 | * 64k large page size. | ||
| 1444 | * We only want to put this in if the CPUs we're emulating | ||
| 1445 | * support it, but unfortunately we don't have a vcpu easily | ||
| 1446 | * to hand here to test. Just pick the first vcpu, and if | ||
| 1447 | * that doesn't exist yet, report the minimum capability, | ||
| 1448 | * i.e., no 64k pages. | ||
| 1449 | * 1T segment support goes along with 64k pages. | ||
| 1450 | */ | ||
| 1451 | i = 1; | ||
| 1452 | vcpu = kvm_get_vcpu(kvm, 0); | ||
| 1453 | if (vcpu && (vcpu->arch.hflags & BOOK3S_HFLAG_MULTI_PGSIZE)) { | ||
| 1454 | info->flags = KVM_PPC_1T_SEGMENTS; | ||
| 1455 | info->sps[i].page_shift = 16; | ||
| 1456 | info->sps[i].slb_enc = SLB_VSID_L | SLB_VSID_LP_01; | ||
| 1457 | info->sps[i].enc[0].page_shift = 16; | ||
| 1458 | info->sps[i].enc[0].pte_enc = 1; | ||
| 1459 | ++i; | ||
| 1460 | } | ||
| 1461 | |||
| 1462 | /* Standard 16M large page size segment */ | ||
| 1463 | info->sps[i].page_shift = 24; | ||
| 1464 | info->sps[i].slb_enc = SLB_VSID_L; | ||
| 1465 | info->sps[i].enc[0].page_shift = 24; | ||
| 1466 | info->sps[i].enc[0].pte_enc = 0; | ||
| 1302 | 1467 | ||
| 1303 | void kvmppc_core_flush_memslot(struct kvm *kvm, struct kvm_memory_slot *memslot) | 1468 | return 0; |
| 1469 | } | ||
| 1470 | #else | ||
| 1471 | static int kvm_vm_ioctl_get_smmu_info_pr(struct kvm *kvm, | ||
| 1472 | struct kvm_ppc_smmu_info *info) | ||
| 1304 | { | 1473 | { |
| 1474 | /* We should not get called */ | ||
| 1475 | BUG(); | ||
| 1305 | } | 1476 | } |
| 1477 | #endif /* CONFIG_PPC64 */ | ||
| 1306 | 1478 | ||
| 1307 | static unsigned int kvm_global_user_count = 0; | 1479 | static unsigned int kvm_global_user_count = 0; |
| 1308 | static DEFINE_SPINLOCK(kvm_global_user_count_lock); | 1480 | static DEFINE_SPINLOCK(kvm_global_user_count_lock); |
| 1309 | 1481 | ||
| 1310 | int kvmppc_core_init_vm(struct kvm *kvm) | 1482 | static int kvmppc_core_init_vm_pr(struct kvm *kvm) |
| 1311 | { | 1483 | { |
| 1312 | #ifdef CONFIG_PPC64 | 1484 | mutex_init(&kvm->arch.hpt_mutex); |
| 1313 | INIT_LIST_HEAD(&kvm->arch.spapr_tce_tables); | ||
| 1314 | INIT_LIST_HEAD(&kvm->arch.rtas_tokens); | ||
| 1315 | #endif | ||
| 1316 | 1485 | ||
| 1317 | if (firmware_has_feature(FW_FEATURE_SET_MODE)) { | 1486 | if (firmware_has_feature(FW_FEATURE_SET_MODE)) { |
| 1318 | spin_lock(&kvm_global_user_count_lock); | 1487 | spin_lock(&kvm_global_user_count_lock); |
| @@ -1323,7 +1492,7 @@ int kvmppc_core_init_vm(struct kvm *kvm) | |||
| 1323 | return 0; | 1492 | return 0; |
| 1324 | } | 1493 | } |
| 1325 | 1494 | ||
| 1326 | void kvmppc_core_destroy_vm(struct kvm *kvm) | 1495 | static void kvmppc_core_destroy_vm_pr(struct kvm *kvm) |
| 1327 | { | 1496 | { |
| 1328 | #ifdef CONFIG_PPC64 | 1497 | #ifdef CONFIG_PPC64 |
| 1329 | WARN_ON(!list_empty(&kvm->arch.spapr_tce_tables)); | 1498 | WARN_ON(!list_empty(&kvm->arch.spapr_tce_tables)); |
| @@ -1338,26 +1507,81 @@ void kvmppc_core_destroy_vm(struct kvm *kvm) | |||
| 1338 | } | 1507 | } |
| 1339 | } | 1508 | } |
| 1340 | 1509 | ||
| 1341 | static int kvmppc_book3s_init(void) | 1510 | static int kvmppc_core_check_processor_compat_pr(void) |
| 1342 | { | 1511 | { |
| 1343 | int r; | 1512 | /* we are always compatible */ |
| 1513 | return 0; | ||
| 1514 | } | ||
| 1344 | 1515 | ||
| 1345 | r = kvm_init(NULL, sizeof(struct kvmppc_vcpu_book3s), 0, | 1516 | static long kvm_arch_vm_ioctl_pr(struct file *filp, |
| 1346 | THIS_MODULE); | 1517 | unsigned int ioctl, unsigned long arg) |
| 1518 | { | ||
| 1519 | return -ENOTTY; | ||
| 1520 | } | ||
| 1347 | 1521 | ||
| 1348 | if (r) | 1522 | static struct kvmppc_ops kvm_ops_pr = { |
| 1523 | .get_sregs = kvm_arch_vcpu_ioctl_get_sregs_pr, | ||
| 1524 | .set_sregs = kvm_arch_vcpu_ioctl_set_sregs_pr, | ||
| 1525 | .get_one_reg = kvmppc_get_one_reg_pr, | ||
| 1526 | .set_one_reg = kvmppc_set_one_reg_pr, | ||
| 1527 | .vcpu_load = kvmppc_core_vcpu_load_pr, | ||
| 1528 | .vcpu_put = kvmppc_core_vcpu_put_pr, | ||
| 1529 | .set_msr = kvmppc_set_msr_pr, | ||
| 1530 | .vcpu_run = kvmppc_vcpu_run_pr, | ||
| 1531 | .vcpu_create = kvmppc_core_vcpu_create_pr, | ||
| 1532 | .vcpu_free = kvmppc_core_vcpu_free_pr, | ||
| 1533 | .check_requests = kvmppc_core_check_requests_pr, | ||
| 1534 | .get_dirty_log = kvm_vm_ioctl_get_dirty_log_pr, | ||
| 1535 | .flush_memslot = kvmppc_core_flush_memslot_pr, | ||
| 1536 | .prepare_memory_region = kvmppc_core_prepare_memory_region_pr, | ||
| 1537 | .commit_memory_region = kvmppc_core_commit_memory_region_pr, | ||
| 1538 | .unmap_hva = kvm_unmap_hva_pr, | ||
| 1539 | .unmap_hva_range = kvm_unmap_hva_range_pr, | ||
| 1540 | .age_hva = kvm_age_hva_pr, | ||
| 1541 | .test_age_hva = kvm_test_age_hva_pr, | ||
| 1542 | .set_spte_hva = kvm_set_spte_hva_pr, | ||
| 1543 | .mmu_destroy = kvmppc_mmu_destroy_pr, | ||
| 1544 | .free_memslot = kvmppc_core_free_memslot_pr, | ||
| 1545 | .create_memslot = kvmppc_core_create_memslot_pr, | ||
| 1546 | .init_vm = kvmppc_core_init_vm_pr, | ||
| 1547 | .destroy_vm = kvmppc_core_destroy_vm_pr, | ||
| 1548 | .get_smmu_info = kvm_vm_ioctl_get_smmu_info_pr, | ||
| 1549 | .emulate_op = kvmppc_core_emulate_op_pr, | ||
| 1550 | .emulate_mtspr = kvmppc_core_emulate_mtspr_pr, | ||
| 1551 | .emulate_mfspr = kvmppc_core_emulate_mfspr_pr, | ||
| 1552 | .fast_vcpu_kick = kvm_vcpu_kick, | ||
| 1553 | .arch_vm_ioctl = kvm_arch_vm_ioctl_pr, | ||
| 1554 | }; | ||
| 1555 | |||
| 1556 | |||
| 1557 | int kvmppc_book3s_init_pr(void) | ||
| 1558 | { | ||
| 1559 | int r; | ||
| 1560 | |||
| 1561 | r = kvmppc_core_check_processor_compat_pr(); | ||
| 1562 | if (r < 0) | ||
| 1349 | return r; | 1563 | return r; |
| 1350 | 1564 | ||
| 1351 | r = kvmppc_mmu_hpte_sysinit(); | 1565 | kvm_ops_pr.owner = THIS_MODULE; |
| 1566 | kvmppc_pr_ops = &kvm_ops_pr; | ||
| 1352 | 1567 | ||
| 1568 | r = kvmppc_mmu_hpte_sysinit(); | ||
| 1353 | return r; | 1569 | return r; |
| 1354 | } | 1570 | } |
| 1355 | 1571 | ||
| 1356 | static void kvmppc_book3s_exit(void) | 1572 | void kvmppc_book3s_exit_pr(void) |
| 1357 | { | 1573 | { |
| 1574 | kvmppc_pr_ops = NULL; | ||
| 1358 | kvmppc_mmu_hpte_sysexit(); | 1575 | kvmppc_mmu_hpte_sysexit(); |
| 1359 | kvm_exit(); | ||
| 1360 | } | 1576 | } |
| 1361 | 1577 | ||
| 1362 | module_init(kvmppc_book3s_init); | 1578 | /* |
| 1363 | module_exit(kvmppc_book3s_exit); | 1579 | * We only support separate modules for book3s 64 |
| 1580 | */ | ||
| 1581 | #ifdef CONFIG_PPC_BOOK3S_64 | ||
| 1582 | |||
| 1583 | module_init(kvmppc_book3s_init_pr); | ||
| 1584 | module_exit(kvmppc_book3s_exit_pr); | ||
| 1585 | |||
| 1586 | MODULE_LICENSE("GPL"); | ||
| 1587 | #endif | ||
diff --git a/arch/powerpc/kvm/book3s_pr_papr.c b/arch/powerpc/kvm/book3s_pr_papr.c index da0e0bc268bd..5efa97b993d8 100644 --- a/arch/powerpc/kvm/book3s_pr_papr.c +++ b/arch/powerpc/kvm/book3s_pr_papr.c | |||
| @@ -21,6 +21,8 @@ | |||
| 21 | #include <asm/kvm_ppc.h> | 21 | #include <asm/kvm_ppc.h> |
| 22 | #include <asm/kvm_book3s.h> | 22 | #include <asm/kvm_book3s.h> |
| 23 | 23 | ||
| 24 | #define HPTE_SIZE 16 /* bytes per HPT entry */ | ||
| 25 | |||
| 24 | static unsigned long get_pteg_addr(struct kvm_vcpu *vcpu, long pte_index) | 26 | static unsigned long get_pteg_addr(struct kvm_vcpu *vcpu, long pte_index) |
| 25 | { | 27 | { |
| 26 | struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu); | 28 | struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu); |
| @@ -40,32 +42,41 @@ static int kvmppc_h_pr_enter(struct kvm_vcpu *vcpu) | |||
| 40 | long pte_index = kvmppc_get_gpr(vcpu, 5); | 42 | long pte_index = kvmppc_get_gpr(vcpu, 5); |
| 41 | unsigned long pteg[2 * 8]; | 43 | unsigned long pteg[2 * 8]; |
| 42 | unsigned long pteg_addr, i, *hpte; | 44 | unsigned long pteg_addr, i, *hpte; |
| 45 | long int ret; | ||
| 43 | 46 | ||
| 47 | i = pte_index & 7; | ||
| 44 | pte_index &= ~7UL; | 48 | pte_index &= ~7UL; |
| 45 | pteg_addr = get_pteg_addr(vcpu, pte_index); | 49 | pteg_addr = get_pteg_addr(vcpu, pte_index); |
| 46 | 50 | ||
| 51 | mutex_lock(&vcpu->kvm->arch.hpt_mutex); | ||
| 47 | copy_from_user(pteg, (void __user *)pteg_addr, sizeof(pteg)); | 52 | copy_from_user(pteg, (void __user *)pteg_addr, sizeof(pteg)); |
| 48 | hpte = pteg; | 53 | hpte = pteg; |
| 49 | 54 | ||
| 55 | ret = H_PTEG_FULL; | ||
| 50 | if (likely((flags & H_EXACT) == 0)) { | 56 | if (likely((flags & H_EXACT) == 0)) { |
| 51 | pte_index &= ~7UL; | ||
| 52 | for (i = 0; ; ++i) { | 57 | for (i = 0; ; ++i) { |
| 53 | if (i == 8) | 58 | if (i == 8) |
| 54 | return H_PTEG_FULL; | 59 | goto done; |
| 55 | if ((*hpte & HPTE_V_VALID) == 0) | 60 | if ((*hpte & HPTE_V_VALID) == 0) |
| 56 | break; | 61 | break; |
| 57 | hpte += 2; | 62 | hpte += 2; |
| 58 | } | 63 | } |
| 59 | } else { | 64 | } else { |
| 60 | i = kvmppc_get_gpr(vcpu, 5) & 7UL; | ||
| 61 | hpte += i * 2; | 65 | hpte += i * 2; |
| 66 | if (*hpte & HPTE_V_VALID) | ||
| 67 | goto done; | ||
| 62 | } | 68 | } |
| 63 | 69 | ||
| 64 | hpte[0] = kvmppc_get_gpr(vcpu, 6); | 70 | hpte[0] = kvmppc_get_gpr(vcpu, 6); |
| 65 | hpte[1] = kvmppc_get_gpr(vcpu, 7); | 71 | hpte[1] = kvmppc_get_gpr(vcpu, 7); |
| 66 | copy_to_user((void __user *)pteg_addr, pteg, sizeof(pteg)); | 72 | pteg_addr += i * HPTE_SIZE; |
| 67 | kvmppc_set_gpr(vcpu, 3, H_SUCCESS); | 73 | copy_to_user((void __user *)pteg_addr, hpte, HPTE_SIZE); |
| 68 | kvmppc_set_gpr(vcpu, 4, pte_index | i); | 74 | kvmppc_set_gpr(vcpu, 4, pte_index | i); |
| 75 | ret = H_SUCCESS; | ||
| 76 | |||
| 77 | done: | ||
| 78 | mutex_unlock(&vcpu->kvm->arch.hpt_mutex); | ||
| 79 | kvmppc_set_gpr(vcpu, 3, ret); | ||
| 69 | 80 | ||
| 70 | return EMULATE_DONE; | 81 | return EMULATE_DONE; |
| 71 | } | 82 | } |
| @@ -77,26 +88,31 @@ static int kvmppc_h_pr_remove(struct kvm_vcpu *vcpu) | |||
| 77 | unsigned long avpn = kvmppc_get_gpr(vcpu, 6); | 88 | unsigned long avpn = kvmppc_get_gpr(vcpu, 6); |
| 78 | unsigned long v = 0, pteg, rb; | 89 | unsigned long v = 0, pteg, rb; |
| 79 | unsigned long pte[2]; | 90 | unsigned long pte[2]; |
| 91 | long int ret; | ||
| 80 | 92 | ||
| 81 | pteg = get_pteg_addr(vcpu, pte_index); | 93 | pteg = get_pteg_addr(vcpu, pte_index); |
| 94 | mutex_lock(&vcpu->kvm->arch.hpt_mutex); | ||
| 82 | copy_from_user(pte, (void __user *)pteg, sizeof(pte)); | 95 | copy_from_user(pte, (void __user *)pteg, sizeof(pte)); |
| 83 | 96 | ||
| 97 | ret = H_NOT_FOUND; | ||
| 84 | if ((pte[0] & HPTE_V_VALID) == 0 || | 98 | if ((pte[0] & HPTE_V_VALID) == 0 || |
| 85 | ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn) || | 99 | ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn) || |
| 86 | ((flags & H_ANDCOND) && (pte[0] & avpn) != 0)) { | 100 | ((flags & H_ANDCOND) && (pte[0] & avpn) != 0)) |
| 87 | kvmppc_set_gpr(vcpu, 3, H_NOT_FOUND); | 101 | goto done; |
| 88 | return EMULATE_DONE; | ||
| 89 | } | ||
| 90 | 102 | ||
| 91 | copy_to_user((void __user *)pteg, &v, sizeof(v)); | 103 | copy_to_user((void __user *)pteg, &v, sizeof(v)); |
| 92 | 104 | ||
| 93 | rb = compute_tlbie_rb(pte[0], pte[1], pte_index); | 105 | rb = compute_tlbie_rb(pte[0], pte[1], pte_index); |
| 94 | vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false); | 106 | vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false); |
| 95 | 107 | ||
| 96 | kvmppc_set_gpr(vcpu, 3, H_SUCCESS); | 108 | ret = H_SUCCESS; |
| 97 | kvmppc_set_gpr(vcpu, 4, pte[0]); | 109 | kvmppc_set_gpr(vcpu, 4, pte[0]); |
| 98 | kvmppc_set_gpr(vcpu, 5, pte[1]); | 110 | kvmppc_set_gpr(vcpu, 5, pte[1]); |
| 99 | 111 | ||
| 112 | done: | ||
| 113 | mutex_unlock(&vcpu->kvm->arch.hpt_mutex); | ||
| 114 | kvmppc_set_gpr(vcpu, 3, ret); | ||
| 115 | |||
| 100 | return EMULATE_DONE; | 116 | return EMULATE_DONE; |
| 101 | } | 117 | } |
| 102 | 118 | ||
| @@ -124,6 +140,7 @@ static int kvmppc_h_pr_bulk_remove(struct kvm_vcpu *vcpu) | |||
| 124 | int paramnr = 4; | 140 | int paramnr = 4; |
| 125 | int ret = H_SUCCESS; | 141 | int ret = H_SUCCESS; |
| 126 | 142 | ||
| 143 | mutex_lock(&vcpu->kvm->arch.hpt_mutex); | ||
| 127 | for (i = 0; i < H_BULK_REMOVE_MAX_BATCH; i++) { | 144 | for (i = 0; i < H_BULK_REMOVE_MAX_BATCH; i++) { |
| 128 | unsigned long tsh = kvmppc_get_gpr(vcpu, paramnr+(2*i)); | 145 | unsigned long tsh = kvmppc_get_gpr(vcpu, paramnr+(2*i)); |
| 129 | unsigned long tsl = kvmppc_get_gpr(vcpu, paramnr+(2*i)+1); | 146 | unsigned long tsl = kvmppc_get_gpr(vcpu, paramnr+(2*i)+1); |
| @@ -172,6 +189,7 @@ static int kvmppc_h_pr_bulk_remove(struct kvm_vcpu *vcpu) | |||
| 172 | } | 189 | } |
| 173 | kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh); | 190 | kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh); |
| 174 | } | 191 | } |
| 192 | mutex_unlock(&vcpu->kvm->arch.hpt_mutex); | ||
| 175 | kvmppc_set_gpr(vcpu, 3, ret); | 193 | kvmppc_set_gpr(vcpu, 3, ret); |
| 176 | 194 | ||
| 177 | return EMULATE_DONE; | 195 | return EMULATE_DONE; |
| @@ -184,15 +202,16 @@ static int kvmppc_h_pr_protect(struct kvm_vcpu *vcpu) | |||
| 184 | unsigned long avpn = kvmppc_get_gpr(vcpu, 6); | 202 | unsigned long avpn = kvmppc_get_gpr(vcpu, 6); |
| 185 | unsigned long rb, pteg, r, v; | 203 | unsigned long rb, pteg, r, v; |
| 186 | unsigned long pte[2]; | 204 | unsigned long pte[2]; |
| 205 | long int ret; | ||
| 187 | 206 | ||
| 188 | pteg = get_pteg_addr(vcpu, pte_index); | 207 | pteg = get_pteg_addr(vcpu, pte_index); |
| 208 | mutex_lock(&vcpu->kvm->arch.hpt_mutex); | ||
| 189 | copy_from_user(pte, (void __user *)pteg, sizeof(pte)); | 209 | copy_from_user(pte, (void __user *)pteg, sizeof(pte)); |
| 190 | 210 | ||
| 211 | ret = H_NOT_FOUND; | ||
| 191 | if ((pte[0] & HPTE_V_VALID) == 0 || | 212 | if ((pte[0] & HPTE_V_VALID) == 0 || |
| 192 | ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn)) { | 213 | ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn)) |
| 193 | kvmppc_set_gpr(vcpu, 3, H_NOT_FOUND); | 214 | goto done; |
| 194 | return EMULATE_DONE; | ||
| 195 | } | ||
| 196 | 215 | ||
| 197 | v = pte[0]; | 216 | v = pte[0]; |
| 198 | r = pte[1]; | 217 | r = pte[1]; |
| @@ -207,8 +226,11 @@ static int kvmppc_h_pr_protect(struct kvm_vcpu *vcpu) | |||
| 207 | rb = compute_tlbie_rb(v, r, pte_index); | 226 | rb = compute_tlbie_rb(v, r, pte_index); |
| 208 | vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false); | 227 | vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false); |
| 209 | copy_to_user((void __user *)pteg, pte, sizeof(pte)); | 228 | copy_to_user((void __user *)pteg, pte, sizeof(pte)); |
| 229 | ret = H_SUCCESS; | ||
| 210 | 230 | ||
| 211 | kvmppc_set_gpr(vcpu, 3, H_SUCCESS); | 231 | done: |
| 232 | mutex_unlock(&vcpu->kvm->arch.hpt_mutex); | ||
| 233 | kvmppc_set_gpr(vcpu, 3, ret); | ||
| 212 | 234 | ||
| 213 | return EMULATE_DONE; | 235 | return EMULATE_DONE; |
| 214 | } | 236 | } |
diff --git a/arch/powerpc/kvm/book3s_rmhandlers.S b/arch/powerpc/kvm/book3s_rmhandlers.S index 8f7633e3afb8..a38c4c9edab8 100644 --- a/arch/powerpc/kvm/book3s_rmhandlers.S +++ b/arch/powerpc/kvm/book3s_rmhandlers.S | |||
| @@ -38,32 +38,6 @@ | |||
| 38 | 38 | ||
| 39 | #define FUNC(name) GLUE(.,name) | 39 | #define FUNC(name) GLUE(.,name) |
| 40 | 40 | ||
| 41 | .globl kvmppc_skip_interrupt | ||
| 42 | kvmppc_skip_interrupt: | ||
| 43 | /* | ||
| 44 | * Here all GPRs are unchanged from when the interrupt happened | ||
| 45 | * except for r13, which is saved in SPRG_SCRATCH0. | ||
| 46 | */ | ||
| 47 | mfspr r13, SPRN_SRR0 | ||
| 48 | addi r13, r13, 4 | ||
| 49 | mtspr SPRN_SRR0, r13 | ||
| 50 | GET_SCRATCH0(r13) | ||
| 51 | rfid | ||
| 52 | b . | ||
| 53 | |||
| 54 | .globl kvmppc_skip_Hinterrupt | ||
| 55 | kvmppc_skip_Hinterrupt: | ||
| 56 | /* | ||
| 57 | * Here all GPRs are unchanged from when the interrupt happened | ||
| 58 | * except for r13, which is saved in SPRG_SCRATCH0. | ||
| 59 | */ | ||
| 60 | mfspr r13, SPRN_HSRR0 | ||
| 61 | addi r13, r13, 4 | ||
| 62 | mtspr SPRN_HSRR0, r13 | ||
| 63 | GET_SCRATCH0(r13) | ||
| 64 | hrfid | ||
| 65 | b . | ||
| 66 | |||
| 67 | #elif defined(CONFIG_PPC_BOOK3S_32) | 41 | #elif defined(CONFIG_PPC_BOOK3S_32) |
| 68 | 42 | ||
| 69 | #define FUNC(name) name | 43 | #define FUNC(name) name |
| @@ -179,11 +153,15 @@ _GLOBAL(kvmppc_entry_trampoline) | |||
| 179 | 153 | ||
| 180 | li r6, MSR_IR | MSR_DR | 154 | li r6, MSR_IR | MSR_DR |
| 181 | andc r6, r5, r6 /* Clear DR and IR in MSR value */ | 155 | andc r6, r5, r6 /* Clear DR and IR in MSR value */ |
| 156 | #ifdef CONFIG_PPC_BOOK3S_32 | ||
| 182 | /* | 157 | /* |
| 183 | * Set EE in HOST_MSR so that it's enabled when we get into our | 158 | * Set EE in HOST_MSR so that it's enabled when we get into our |
| 184 | * C exit handler function | 159 | * C exit handler function. On 64-bit we delay enabling |
| 160 | * interrupts until we have finished transferring stuff | ||
| 161 | * to or from the PACA. | ||
| 185 | */ | 162 | */ |
| 186 | ori r5, r5, MSR_EE | 163 | ori r5, r5, MSR_EE |
| 164 | #endif | ||
| 187 | mtsrr0 r7 | 165 | mtsrr0 r7 |
| 188 | mtsrr1 r6 | 166 | mtsrr1 r6 |
| 189 | RFI | 167 | RFI |
diff --git a/arch/powerpc/kvm/book3s_rtas.c b/arch/powerpc/kvm/book3s_rtas.c index 3219ba895246..cf95cdef73c9 100644 --- a/arch/powerpc/kvm/book3s_rtas.c +++ b/arch/powerpc/kvm/book3s_rtas.c | |||
| @@ -260,6 +260,7 @@ fail: | |||
| 260 | */ | 260 | */ |
| 261 | return rc; | 261 | return rc; |
| 262 | } | 262 | } |
| 263 | EXPORT_SYMBOL_GPL(kvmppc_rtas_hcall); | ||
| 263 | 264 | ||
| 264 | void kvmppc_rtas_tokens_free(struct kvm *kvm) | 265 | void kvmppc_rtas_tokens_free(struct kvm *kvm) |
| 265 | { | 266 | { |
diff --git a/arch/powerpc/kvm/book3s_segment.S b/arch/powerpc/kvm/book3s_segment.S index 1abe4788191a..bc50c97751d3 100644 --- a/arch/powerpc/kvm/book3s_segment.S +++ b/arch/powerpc/kvm/book3s_segment.S | |||
| @@ -161,8 +161,8 @@ kvmppc_handler_trampoline_enter_end: | |||
| 161 | .global kvmppc_handler_trampoline_exit | 161 | .global kvmppc_handler_trampoline_exit |
| 162 | kvmppc_handler_trampoline_exit: | 162 | kvmppc_handler_trampoline_exit: |
| 163 | 163 | ||
| 164 | .global kvmppc_interrupt | 164 | .global kvmppc_interrupt_pr |
| 165 | kvmppc_interrupt: | 165 | kvmppc_interrupt_pr: |
| 166 | 166 | ||
| 167 | /* Register usage at this point: | 167 | /* Register usage at this point: |
| 168 | * | 168 | * |
diff --git a/arch/powerpc/kvm/book3s_xics.c b/arch/powerpc/kvm/book3s_xics.c index a3a5cb8ee7ea..02a17dcf1610 100644 --- a/arch/powerpc/kvm/book3s_xics.c +++ b/arch/powerpc/kvm/book3s_xics.c | |||
| @@ -818,7 +818,7 @@ int kvmppc_xics_hcall(struct kvm_vcpu *vcpu, u32 req) | |||
| 818 | } | 818 | } |
| 819 | 819 | ||
| 820 | /* Check for real mode returning too hard */ | 820 | /* Check for real mode returning too hard */ |
| 821 | if (xics->real_mode) | 821 | if (xics->real_mode && is_kvmppc_hv_enabled(vcpu->kvm)) |
| 822 | return kvmppc_xics_rm_complete(vcpu, req); | 822 | return kvmppc_xics_rm_complete(vcpu, req); |
| 823 | 823 | ||
| 824 | switch (req) { | 824 | switch (req) { |
| @@ -840,6 +840,7 @@ int kvmppc_xics_hcall(struct kvm_vcpu *vcpu, u32 req) | |||
| 840 | 840 | ||
| 841 | return rc; | 841 | return rc; |
| 842 | } | 842 | } |
| 843 | EXPORT_SYMBOL_GPL(kvmppc_xics_hcall); | ||
| 843 | 844 | ||
| 844 | 845 | ||
| 845 | /* -- Initialisation code etc. -- */ | 846 | /* -- Initialisation code etc. -- */ |
| @@ -1250,13 +1251,13 @@ static int kvmppc_xics_create(struct kvm_device *dev, u32 type) | |||
| 1250 | 1251 | ||
| 1251 | xics_debugfs_init(xics); | 1252 | xics_debugfs_init(xics); |
| 1252 | 1253 | ||
| 1253 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 1254 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE |
| 1254 | if (cpu_has_feature(CPU_FTR_ARCH_206)) { | 1255 | if (cpu_has_feature(CPU_FTR_ARCH_206)) { |
| 1255 | /* Enable real mode support */ | 1256 | /* Enable real mode support */ |
| 1256 | xics->real_mode = ENABLE_REALMODE; | 1257 | xics->real_mode = ENABLE_REALMODE; |
| 1257 | xics->real_mode_dbg = DEBUG_REALMODE; | 1258 | xics->real_mode_dbg = DEBUG_REALMODE; |
| 1258 | } | 1259 | } |
| 1259 | #endif /* CONFIG_KVM_BOOK3S_64_HV */ | 1260 | #endif /* CONFIG_KVM_BOOK3S_HV_POSSIBLE */ |
| 1260 | 1261 | ||
| 1261 | return 0; | 1262 | return 0; |
| 1262 | } | 1263 | } |
diff --git a/arch/powerpc/kvm/booke.c b/arch/powerpc/kvm/booke.c index 5133199f6cb7..53e65a210b9a 100644 --- a/arch/powerpc/kvm/booke.c +++ b/arch/powerpc/kvm/booke.c | |||
| @@ -40,7 +40,9 @@ | |||
| 40 | 40 | ||
| 41 | #include "timing.h" | 41 | #include "timing.h" |
| 42 | #include "booke.h" | 42 | #include "booke.h" |
| 43 | #include "trace.h" | 43 | |
| 44 | #define CREATE_TRACE_POINTS | ||
| 45 | #include "trace_booke.h" | ||
| 44 | 46 | ||
| 45 | unsigned long kvmppc_booke_handlers; | 47 | unsigned long kvmppc_booke_handlers; |
| 46 | 48 | ||
| @@ -133,6 +135,29 @@ static void kvmppc_vcpu_sync_fpu(struct kvm_vcpu *vcpu) | |||
| 133 | #endif | 135 | #endif |
| 134 | } | 136 | } |
| 135 | 137 | ||
| 138 | static void kvmppc_vcpu_sync_debug(struct kvm_vcpu *vcpu) | ||
| 139 | { | ||
| 140 | /* Synchronize guest's desire to get debug interrupts into shadow MSR */ | ||
| 141 | #ifndef CONFIG_KVM_BOOKE_HV | ||
| 142 | vcpu->arch.shadow_msr &= ~MSR_DE; | ||
| 143 | vcpu->arch.shadow_msr |= vcpu->arch.shared->msr & MSR_DE; | ||
| 144 | #endif | ||
| 145 | |||
| 146 | /* Force enable debug interrupts when user space wants to debug */ | ||
| 147 | if (vcpu->guest_debug) { | ||
| 148 | #ifdef CONFIG_KVM_BOOKE_HV | ||
| 149 | /* | ||
| 150 | * Since there is no shadow MSR, sync MSR_DE into the guest | ||
| 151 | * visible MSR. | ||
| 152 | */ | ||
| 153 | vcpu->arch.shared->msr |= MSR_DE; | ||
| 154 | #else | ||
| 155 | vcpu->arch.shadow_msr |= MSR_DE; | ||
| 156 | vcpu->arch.shared->msr &= ~MSR_DE; | ||
| 157 | #endif | ||
| 158 | } | ||
| 159 | } | ||
| 160 | |||
| 136 | /* | 161 | /* |
| 137 | * Helper function for "full" MSR writes. No need to call this if only | 162 | * Helper function for "full" MSR writes. No need to call this if only |
| 138 | * EE/CE/ME/DE/RI are changing. | 163 | * EE/CE/ME/DE/RI are changing. |
| @@ -150,6 +175,7 @@ void kvmppc_set_msr(struct kvm_vcpu *vcpu, u32 new_msr) | |||
| 150 | kvmppc_mmu_msr_notify(vcpu, old_msr); | 175 | kvmppc_mmu_msr_notify(vcpu, old_msr); |
| 151 | kvmppc_vcpu_sync_spe(vcpu); | 176 | kvmppc_vcpu_sync_spe(vcpu); |
| 152 | kvmppc_vcpu_sync_fpu(vcpu); | 177 | kvmppc_vcpu_sync_fpu(vcpu); |
| 178 | kvmppc_vcpu_sync_debug(vcpu); | ||
| 153 | } | 179 | } |
| 154 | 180 | ||
| 155 | static void kvmppc_booke_queue_irqprio(struct kvm_vcpu *vcpu, | 181 | static void kvmppc_booke_queue_irqprio(struct kvm_vcpu *vcpu, |
| @@ -655,6 +681,7 @@ int kvmppc_core_check_requests(struct kvm_vcpu *vcpu) | |||
| 655 | int kvmppc_vcpu_run(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu) | 681 | int kvmppc_vcpu_run(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu) |
| 656 | { | 682 | { |
| 657 | int ret, s; | 683 | int ret, s; |
| 684 | struct thread_struct thread; | ||
| 658 | #ifdef CONFIG_PPC_FPU | 685 | #ifdef CONFIG_PPC_FPU |
| 659 | struct thread_fp_state fp; | 686 | struct thread_fp_state fp; |
| 660 | int fpexc_mode; | 687 | int fpexc_mode; |
| @@ -695,6 +722,12 @@ int kvmppc_vcpu_run(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu) | |||
| 695 | kvmppc_load_guest_fp(vcpu); | 722 | kvmppc_load_guest_fp(vcpu); |
| 696 | #endif | 723 | #endif |
| 697 | 724 | ||
| 725 | /* Switch to guest debug context */ | ||
| 726 | thread.debug = vcpu->arch.shadow_dbg_reg; | ||
| 727 | switch_booke_debug_regs(&thread); | ||
| 728 | thread.debug = current->thread.debug; | ||
| 729 | current->thread.debug = vcpu->arch.shadow_dbg_reg; | ||
| 730 | |||
| 698 | kvmppc_fix_ee_before_entry(); | 731 | kvmppc_fix_ee_before_entry(); |
| 699 | 732 | ||
| 700 | ret = __kvmppc_vcpu_run(kvm_run, vcpu); | 733 | ret = __kvmppc_vcpu_run(kvm_run, vcpu); |
| @@ -702,6 +735,10 @@ int kvmppc_vcpu_run(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu) | |||
| 702 | /* No need for kvm_guest_exit. It's done in handle_exit. | 735 | /* No need for kvm_guest_exit. It's done in handle_exit. |
| 703 | We also get here with interrupts enabled. */ | 736 | We also get here with interrupts enabled. */ |
| 704 | 737 | ||
| 738 | /* Switch back to user space debug context */ | ||
| 739 | switch_booke_debug_regs(&thread); | ||
| 740 | current->thread.debug = thread.debug; | ||
| 741 | |||
| 705 | #ifdef CONFIG_PPC_FPU | 742 | #ifdef CONFIG_PPC_FPU |
| 706 | kvmppc_save_guest_fp(vcpu); | 743 | kvmppc_save_guest_fp(vcpu); |
| 707 | 744 | ||
| @@ -757,6 +794,30 @@ static int emulation_exit(struct kvm_run *run, struct kvm_vcpu *vcpu) | |||
| 757 | } | 794 | } |
| 758 | } | 795 | } |
| 759 | 796 | ||
| 797 | static int kvmppc_handle_debug(struct kvm_run *run, struct kvm_vcpu *vcpu) | ||
| 798 | { | ||
| 799 | struct debug_reg *dbg_reg = &(vcpu->arch.shadow_dbg_reg); | ||
| 800 | u32 dbsr = vcpu->arch.dbsr; | ||
| 801 | |||
| 802 | run->debug.arch.status = 0; | ||
| 803 | run->debug.arch.address = vcpu->arch.pc; | ||
| 804 | |||
| 805 | if (dbsr & (DBSR_IAC1 | DBSR_IAC2 | DBSR_IAC3 | DBSR_IAC4)) { | ||
| 806 | run->debug.arch.status |= KVMPPC_DEBUG_BREAKPOINT; | ||
| 807 | } else { | ||
| 808 | if (dbsr & (DBSR_DAC1W | DBSR_DAC2W)) | ||
| 809 | run->debug.arch.status |= KVMPPC_DEBUG_WATCH_WRITE; | ||
| 810 | else if (dbsr & (DBSR_DAC1R | DBSR_DAC2R)) | ||
| 811 | run->debug.arch.status |= KVMPPC_DEBUG_WATCH_READ; | ||
| 812 | if (dbsr & (DBSR_DAC1R | DBSR_DAC1W)) | ||
| 813 | run->debug.arch.address = dbg_reg->dac1; | ||
| 814 | else if (dbsr & (DBSR_DAC2R | DBSR_DAC2W)) | ||
| 815 | run->debug.arch.address = dbg_reg->dac2; | ||
| 816 | } | ||
| 817 | |||
| 818 | return RESUME_HOST; | ||
| 819 | } | ||
| 820 | |||
| 760 | static void kvmppc_fill_pt_regs(struct pt_regs *regs) | 821 | static void kvmppc_fill_pt_regs(struct pt_regs *regs) |
| 761 | { | 822 | { |
| 762 | ulong r1, ip, msr, lr; | 823 | ulong r1, ip, msr, lr; |
| @@ -817,6 +878,11 @@ static void kvmppc_restart_interrupt(struct kvm_vcpu *vcpu, | |||
| 817 | case BOOKE_INTERRUPT_CRITICAL: | 878 | case BOOKE_INTERRUPT_CRITICAL: |
| 818 | unknown_exception(®s); | 879 | unknown_exception(®s); |
| 819 | break; | 880 | break; |
| 881 | case BOOKE_INTERRUPT_DEBUG: | ||
| 882 | /* Save DBSR before preemption is enabled */ | ||
| 883 | vcpu->arch.dbsr = mfspr(SPRN_DBSR); | ||
| 884 | kvmppc_clear_dbsr(); | ||
| 885 | break; | ||
| 820 | } | 886 | } |
| 821 | } | 887 | } |
| 822 | 888 | ||
| @@ -1134,18 +1200,10 @@ int kvmppc_handle_exit(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 1134 | } | 1200 | } |
| 1135 | 1201 | ||
| 1136 | case BOOKE_INTERRUPT_DEBUG: { | 1202 | case BOOKE_INTERRUPT_DEBUG: { |
| 1137 | u32 dbsr; | 1203 | r = kvmppc_handle_debug(run, vcpu); |
| 1138 | 1204 | if (r == RESUME_HOST) | |
| 1139 | vcpu->arch.pc = mfspr(SPRN_CSRR0); | 1205 | run->exit_reason = KVM_EXIT_DEBUG; |
| 1140 | |||
| 1141 | /* clear IAC events in DBSR register */ | ||
| 1142 | dbsr = mfspr(SPRN_DBSR); | ||
| 1143 | dbsr &= DBSR_IAC1 | DBSR_IAC2 | DBSR_IAC3 | DBSR_IAC4; | ||
| 1144 | mtspr(SPRN_DBSR, dbsr); | ||
| 1145 | |||
| 1146 | run->exit_reason = KVM_EXIT_DEBUG; | ||
| 1147 | kvmppc_account_exit(vcpu, DEBUG_EXITS); | 1206 | kvmppc_account_exit(vcpu, DEBUG_EXITS); |
| 1148 | r = RESUME_HOST; | ||
| 1149 | break; | 1207 | break; |
| 1150 | } | 1208 | } |
| 1151 | 1209 | ||
| @@ -1196,7 +1254,7 @@ int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) | |||
| 1196 | kvmppc_set_msr(vcpu, 0); | 1254 | kvmppc_set_msr(vcpu, 0); |
| 1197 | 1255 | ||
| 1198 | #ifndef CONFIG_KVM_BOOKE_HV | 1256 | #ifndef CONFIG_KVM_BOOKE_HV |
| 1199 | vcpu->arch.shadow_msr = MSR_USER | MSR_DE | MSR_IS | MSR_DS; | 1257 | vcpu->arch.shadow_msr = MSR_USER | MSR_IS | MSR_DS; |
| 1200 | vcpu->arch.shadow_pid = 1; | 1258 | vcpu->arch.shadow_pid = 1; |
| 1201 | vcpu->arch.shared->msr = 0; | 1259 | vcpu->arch.shared->msr = 0; |
| 1202 | #endif | 1260 | #endif |
| @@ -1358,7 +1416,7 @@ static int set_sregs_arch206(struct kvm_vcpu *vcpu, | |||
| 1358 | return 0; | 1416 | return 0; |
| 1359 | } | 1417 | } |
| 1360 | 1418 | ||
| 1361 | void kvmppc_get_sregs_ivor(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) | 1419 | int kvmppc_get_sregs_ivor(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) |
| 1362 | { | 1420 | { |
| 1363 | sregs->u.e.features |= KVM_SREGS_E_IVOR; | 1421 | sregs->u.e.features |= KVM_SREGS_E_IVOR; |
| 1364 | 1422 | ||
| @@ -1378,6 +1436,7 @@ void kvmppc_get_sregs_ivor(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) | |||
| 1378 | sregs->u.e.ivor_low[13] = vcpu->arch.ivor[BOOKE_IRQPRIO_DTLB_MISS]; | 1436 | sregs->u.e.ivor_low[13] = vcpu->arch.ivor[BOOKE_IRQPRIO_DTLB_MISS]; |
| 1379 | sregs->u.e.ivor_low[14] = vcpu->arch.ivor[BOOKE_IRQPRIO_ITLB_MISS]; | 1437 | sregs->u.e.ivor_low[14] = vcpu->arch.ivor[BOOKE_IRQPRIO_ITLB_MISS]; |
| 1380 | sregs->u.e.ivor_low[15] = vcpu->arch.ivor[BOOKE_IRQPRIO_DEBUG]; | 1438 | sregs->u.e.ivor_low[15] = vcpu->arch.ivor[BOOKE_IRQPRIO_DEBUG]; |
| 1439 | return 0; | ||
| 1381 | } | 1440 | } |
| 1382 | 1441 | ||
| 1383 | int kvmppc_set_sregs_ivor(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) | 1442 | int kvmppc_set_sregs_ivor(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) |
| @@ -1412,8 +1471,7 @@ int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, | |||
| 1412 | 1471 | ||
| 1413 | get_sregs_base(vcpu, sregs); | 1472 | get_sregs_base(vcpu, sregs); |
| 1414 | get_sregs_arch206(vcpu, sregs); | 1473 | get_sregs_arch206(vcpu, sregs); |
| 1415 | kvmppc_core_get_sregs(vcpu, sregs); | 1474 | return vcpu->kvm->arch.kvm_ops->get_sregs(vcpu, sregs); |
| 1416 | return 0; | ||
| 1417 | } | 1475 | } |
| 1418 | 1476 | ||
| 1419 | int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, | 1477 | int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, |
| @@ -1432,7 +1490,7 @@ int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, | |||
| 1432 | if (ret < 0) | 1490 | if (ret < 0) |
| 1433 | return ret; | 1491 | return ret; |
| 1434 | 1492 | ||
| 1435 | return kvmppc_core_set_sregs(vcpu, sregs); | 1493 | return vcpu->kvm->arch.kvm_ops->set_sregs(vcpu, sregs); |
| 1436 | } | 1494 | } |
| 1437 | 1495 | ||
| 1438 | int kvm_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg) | 1496 | int kvm_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg) |
| @@ -1440,7 +1498,6 @@ int kvm_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg) | |||
| 1440 | int r = 0; | 1498 | int r = 0; |
| 1441 | union kvmppc_one_reg val; | 1499 | union kvmppc_one_reg val; |
| 1442 | int size; | 1500 | int size; |
| 1443 | long int i; | ||
| 1444 | 1501 | ||
| 1445 | size = one_reg_size(reg->id); | 1502 | size = one_reg_size(reg->id); |
| 1446 | if (size > sizeof(val)) | 1503 | if (size > sizeof(val)) |
| @@ -1448,16 +1505,24 @@ int kvm_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg) | |||
| 1448 | 1505 | ||
| 1449 | switch (reg->id) { | 1506 | switch (reg->id) { |
| 1450 | case KVM_REG_PPC_IAC1: | 1507 | case KVM_REG_PPC_IAC1: |
| 1508 | val = get_reg_val(reg->id, vcpu->arch.dbg_reg.iac1); | ||
| 1509 | break; | ||
| 1451 | case KVM_REG_PPC_IAC2: | 1510 | case KVM_REG_PPC_IAC2: |
| 1511 | val = get_reg_val(reg->id, vcpu->arch.dbg_reg.iac2); | ||
| 1512 | break; | ||
| 1513 | #if CONFIG_PPC_ADV_DEBUG_IACS > 2 | ||
| 1452 | case KVM_REG_PPC_IAC3: | 1514 | case KVM_REG_PPC_IAC3: |
| 1515 | val = get_reg_val(reg->id, vcpu->arch.dbg_reg.iac3); | ||
| 1516 | break; | ||
| 1453 | case KVM_REG_PPC_IAC4: | 1517 | case KVM_REG_PPC_IAC4: |
| 1454 | i = reg->id - KVM_REG_PPC_IAC1; | 1518 | val = get_reg_val(reg->id, vcpu->arch.dbg_reg.iac4); |
| 1455 | val = get_reg_val(reg->id, vcpu->arch.dbg_reg.iac[i]); | ||
| 1456 | break; | 1519 | break; |
| 1520 | #endif | ||
| 1457 | case KVM_REG_PPC_DAC1: | 1521 | case KVM_REG_PPC_DAC1: |
| 1522 | val = get_reg_val(reg->id, vcpu->arch.dbg_reg.dac1); | ||
| 1523 | break; | ||
| 1458 | case KVM_REG_PPC_DAC2: | 1524 | case KVM_REG_PPC_DAC2: |
| 1459 | i = reg->id - KVM_REG_PPC_DAC1; | 1525 | val = get_reg_val(reg->id, vcpu->arch.dbg_reg.dac2); |
| 1460 | val = get_reg_val(reg->id, vcpu->arch.dbg_reg.dac[i]); | ||
| 1461 | break; | 1526 | break; |
| 1462 | case KVM_REG_PPC_EPR: { | 1527 | case KVM_REG_PPC_EPR: { |
| 1463 | u32 epr = get_guest_epr(vcpu); | 1528 | u32 epr = get_guest_epr(vcpu); |
| @@ -1476,10 +1541,13 @@ int kvm_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg) | |||
| 1476 | val = get_reg_val(reg->id, vcpu->arch.tsr); | 1541 | val = get_reg_val(reg->id, vcpu->arch.tsr); |
| 1477 | break; | 1542 | break; |
| 1478 | case KVM_REG_PPC_DEBUG_INST: | 1543 | case KVM_REG_PPC_DEBUG_INST: |
| 1479 | val = get_reg_val(reg->id, KVMPPC_INST_EHPRIV); | 1544 | val = get_reg_val(reg->id, KVMPPC_INST_EHPRIV_DEBUG); |
| 1545 | break; | ||
| 1546 | case KVM_REG_PPC_VRSAVE: | ||
| 1547 | val = get_reg_val(reg->id, vcpu->arch.vrsave); | ||
| 1480 | break; | 1548 | break; |
| 1481 | default: | 1549 | default: |
| 1482 | r = kvmppc_get_one_reg(vcpu, reg->id, &val); | 1550 | r = vcpu->kvm->arch.kvm_ops->get_one_reg(vcpu, reg->id, &val); |
| 1483 | break; | 1551 | break; |
| 1484 | } | 1552 | } |
| 1485 | 1553 | ||
| @@ -1497,7 +1565,6 @@ int kvm_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg) | |||
| 1497 | int r = 0; | 1565 | int r = 0; |
| 1498 | union kvmppc_one_reg val; | 1566 | union kvmppc_one_reg val; |
| 1499 | int size; | 1567 | int size; |
| 1500 | long int i; | ||
| 1501 | 1568 | ||
| 1502 | size = one_reg_size(reg->id); | 1569 | size = one_reg_size(reg->id); |
| 1503 | if (size > sizeof(val)) | 1570 | if (size > sizeof(val)) |
| @@ -1508,16 +1575,24 @@ int kvm_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg) | |||
| 1508 | 1575 | ||
| 1509 | switch (reg->id) { | 1576 | switch (reg->id) { |
| 1510 | case KVM_REG_PPC_IAC1: | 1577 | case KVM_REG_PPC_IAC1: |
| 1578 | vcpu->arch.dbg_reg.iac1 = set_reg_val(reg->id, val); | ||
| 1579 | break; | ||
| 1511 | case KVM_REG_PPC_IAC2: | 1580 | case KVM_REG_PPC_IAC2: |
| 1581 | vcpu->arch.dbg_reg.iac2 = set_reg_val(reg->id, val); | ||
| 1582 | break; | ||
| 1583 | #if CONFIG_PPC_ADV_DEBUG_IACS > 2 | ||
| 1512 | case KVM_REG_PPC_IAC3: | 1584 | case KVM_REG_PPC_IAC3: |
| 1585 | vcpu->arch.dbg_reg.iac3 = set_reg_val(reg->id, val); | ||
| 1586 | break; | ||
| 1513 | case KVM_REG_PPC_IAC4: | 1587 | case KVM_REG_PPC_IAC4: |
| 1514 | i = reg->id - KVM_REG_PPC_IAC1; | 1588 | vcpu->arch.dbg_reg.iac4 = set_reg_val(reg->id, val); |
| 1515 | vcpu->arch.dbg_reg.iac[i] = set_reg_val(reg->id, val); | ||
| 1516 | break; | 1589 | break; |
| 1590 | #endif | ||
| 1517 | case KVM_REG_PPC_DAC1: | 1591 | case KVM_REG_PPC_DAC1: |
| 1592 | vcpu->arch.dbg_reg.dac1 = set_reg_val(reg->id, val); | ||
| 1593 | break; | ||
| 1518 | case KVM_REG_PPC_DAC2: | 1594 | case KVM_REG_PPC_DAC2: |
| 1519 | i = reg->id - KVM_REG_PPC_DAC1; | 1595 | vcpu->arch.dbg_reg.dac2 = set_reg_val(reg->id, val); |
| 1520 | vcpu->arch.dbg_reg.dac[i] = set_reg_val(reg->id, val); | ||
| 1521 | break; | 1596 | break; |
| 1522 | case KVM_REG_PPC_EPR: { | 1597 | case KVM_REG_PPC_EPR: { |
| 1523 | u32 new_epr = set_reg_val(reg->id, val); | 1598 | u32 new_epr = set_reg_val(reg->id, val); |
| @@ -1551,20 +1626,17 @@ int kvm_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg) | |||
| 1551 | kvmppc_set_tcr(vcpu, tcr); | 1626 | kvmppc_set_tcr(vcpu, tcr); |
| 1552 | break; | 1627 | break; |
| 1553 | } | 1628 | } |
| 1629 | case KVM_REG_PPC_VRSAVE: | ||
| 1630 | vcpu->arch.vrsave = set_reg_val(reg->id, val); | ||
| 1631 | break; | ||
| 1554 | default: | 1632 | default: |
| 1555 | r = kvmppc_set_one_reg(vcpu, reg->id, &val); | 1633 | r = vcpu->kvm->arch.kvm_ops->set_one_reg(vcpu, reg->id, &val); |
| 1556 | break; | 1634 | break; |
| 1557 | } | 1635 | } |
| 1558 | 1636 | ||
| 1559 | return r; | 1637 | return r; |
| 1560 | } | 1638 | } |
| 1561 | 1639 | ||
| 1562 | int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, | ||
| 1563 | struct kvm_guest_debug *dbg) | ||
| 1564 | { | ||
| 1565 | return -EINVAL; | ||
| 1566 | } | ||
| 1567 | |||
| 1568 | int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) | 1640 | int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) |
| 1569 | { | 1641 | { |
| 1570 | return -ENOTSUPP; | 1642 | return -ENOTSUPP; |
| @@ -1589,12 +1661,12 @@ int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, struct kvm_dirty_log *log) | |||
| 1589 | return -ENOTSUPP; | 1661 | return -ENOTSUPP; |
| 1590 | } | 1662 | } |
| 1591 | 1663 | ||
| 1592 | void kvmppc_core_free_memslot(struct kvm_memory_slot *free, | 1664 | void kvmppc_core_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free, |
| 1593 | struct kvm_memory_slot *dont) | 1665 | struct kvm_memory_slot *dont) |
| 1594 | { | 1666 | { |
| 1595 | } | 1667 | } |
| 1596 | 1668 | ||
| 1597 | int kvmppc_core_create_memslot(struct kvm_memory_slot *slot, | 1669 | int kvmppc_core_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, |
| 1598 | unsigned long npages) | 1670 | unsigned long npages) |
| 1599 | { | 1671 | { |
| 1600 | return 0; | 1672 | return 0; |
| @@ -1670,6 +1742,157 @@ void kvmppc_decrementer_func(unsigned long data) | |||
| 1670 | kvmppc_set_tsr_bits(vcpu, TSR_DIS); | 1742 | kvmppc_set_tsr_bits(vcpu, TSR_DIS); |
| 1671 | } | 1743 | } |
| 1672 | 1744 | ||
| 1745 | static int kvmppc_booke_add_breakpoint(struct debug_reg *dbg_reg, | ||
| 1746 | uint64_t addr, int index) | ||
| 1747 | { | ||
| 1748 | switch (index) { | ||
| 1749 | case 0: | ||
| 1750 | dbg_reg->dbcr0 |= DBCR0_IAC1; | ||
| 1751 | dbg_reg->iac1 = addr; | ||
| 1752 | break; | ||
| 1753 | case 1: | ||
| 1754 | dbg_reg->dbcr0 |= DBCR0_IAC2; | ||
| 1755 | dbg_reg->iac2 = addr; | ||
| 1756 | break; | ||
| 1757 | #if CONFIG_PPC_ADV_DEBUG_IACS > 2 | ||
| 1758 | case 2: | ||
| 1759 | dbg_reg->dbcr0 |= DBCR0_IAC3; | ||
| 1760 | dbg_reg->iac3 = addr; | ||
| 1761 | break; | ||
| 1762 | case 3: | ||
| 1763 | dbg_reg->dbcr0 |= DBCR0_IAC4; | ||
| 1764 | dbg_reg->iac4 = addr; | ||
| 1765 | break; | ||
| 1766 | #endif | ||
| 1767 | default: | ||
| 1768 | return -EINVAL; | ||
| 1769 | } | ||
| 1770 | |||
| 1771 | dbg_reg->dbcr0 |= DBCR0_IDM; | ||
| 1772 | return 0; | ||
| 1773 | } | ||
| 1774 | |||
| 1775 | static int kvmppc_booke_add_watchpoint(struct debug_reg *dbg_reg, uint64_t addr, | ||
| 1776 | int type, int index) | ||
| 1777 | { | ||
| 1778 | switch (index) { | ||
| 1779 | case 0: | ||
| 1780 | if (type & KVMPPC_DEBUG_WATCH_READ) | ||
| 1781 | dbg_reg->dbcr0 |= DBCR0_DAC1R; | ||
| 1782 | if (type & KVMPPC_DEBUG_WATCH_WRITE) | ||
| 1783 | dbg_reg->dbcr0 |= DBCR0_DAC1W; | ||
| 1784 | dbg_reg->dac1 = addr; | ||
| 1785 | break; | ||
| 1786 | case 1: | ||
| 1787 | if (type & KVMPPC_DEBUG_WATCH_READ) | ||
| 1788 | dbg_reg->dbcr0 |= DBCR0_DAC2R; | ||
| 1789 | if (type & KVMPPC_DEBUG_WATCH_WRITE) | ||
| 1790 | dbg_reg->dbcr0 |= DBCR0_DAC2W; | ||
| 1791 | dbg_reg->dac2 = addr; | ||
| 1792 | break; | ||
| 1793 | default: | ||
| 1794 | return -EINVAL; | ||
| 1795 | } | ||
| 1796 | |||
| 1797 | dbg_reg->dbcr0 |= DBCR0_IDM; | ||
| 1798 | return 0; | ||
| 1799 | } | ||
| 1800 | void kvm_guest_protect_msr(struct kvm_vcpu *vcpu, ulong prot_bitmap, bool set) | ||
| 1801 | { | ||
| 1802 | /* XXX: Add similar MSR protection for BookE-PR */ | ||
| 1803 | #ifdef CONFIG_KVM_BOOKE_HV | ||
| 1804 | BUG_ON(prot_bitmap & ~(MSRP_UCLEP | MSRP_DEP | MSRP_PMMP)); | ||
| 1805 | if (set) { | ||
| 1806 | if (prot_bitmap & MSR_UCLE) | ||
| 1807 | vcpu->arch.shadow_msrp |= MSRP_UCLEP; | ||
| 1808 | if (prot_bitmap & MSR_DE) | ||
| 1809 | vcpu->arch.shadow_msrp |= MSRP_DEP; | ||
| 1810 | if (prot_bitmap & MSR_PMM) | ||
| 1811 | vcpu->arch.shadow_msrp |= MSRP_PMMP; | ||
| 1812 | } else { | ||
| 1813 | if (prot_bitmap & MSR_UCLE) | ||
| 1814 | vcpu->arch.shadow_msrp &= ~MSRP_UCLEP; | ||
| 1815 | if (prot_bitmap & MSR_DE) | ||
| 1816 | vcpu->arch.shadow_msrp &= ~MSRP_DEP; | ||
| 1817 | if (prot_bitmap & MSR_PMM) | ||
| 1818 | vcpu->arch.shadow_msrp &= ~MSRP_PMMP; | ||
| 1819 | } | ||
| 1820 | #endif | ||
| 1821 | } | ||
| 1822 | |||
| 1823 | int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, | ||
| 1824 | struct kvm_guest_debug *dbg) | ||
| 1825 | { | ||
| 1826 | struct debug_reg *dbg_reg; | ||
| 1827 | int n, b = 0, w = 0; | ||
| 1828 | |||
| 1829 | if (!(dbg->control & KVM_GUESTDBG_ENABLE)) { | ||
| 1830 | vcpu->arch.shadow_dbg_reg.dbcr0 = 0; | ||
| 1831 | vcpu->guest_debug = 0; | ||
| 1832 | kvm_guest_protect_msr(vcpu, MSR_DE, false); | ||
| 1833 | return 0; | ||
| 1834 | } | ||
| 1835 | |||
| 1836 | kvm_guest_protect_msr(vcpu, MSR_DE, true); | ||
| 1837 | vcpu->guest_debug = dbg->control; | ||
| 1838 | vcpu->arch.shadow_dbg_reg.dbcr0 = 0; | ||
| 1839 | /* Set DBCR0_EDM in guest visible DBCR0 register. */ | ||
| 1840 | vcpu->arch.dbg_reg.dbcr0 = DBCR0_EDM; | ||
| 1841 | |||
| 1842 | if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP) | ||
| 1843 | vcpu->arch.shadow_dbg_reg.dbcr0 |= DBCR0_IDM | DBCR0_IC; | ||
| 1844 | |||
| 1845 | /* Code below handles only HW breakpoints */ | ||
| 1846 | dbg_reg = &(vcpu->arch.shadow_dbg_reg); | ||
| 1847 | |||
| 1848 | #ifdef CONFIG_KVM_BOOKE_HV | ||
| 1849 | /* | ||
| 1850 | * On BookE-HV (e500mc) the guest is always executed with MSR.GS=1 | ||
| 1851 | * DBCR1 and DBCR2 are set to trigger debug events when MSR.PR is 0 | ||
| 1852 | */ | ||
| 1853 | dbg_reg->dbcr1 = 0; | ||
| 1854 | dbg_reg->dbcr2 = 0; | ||
| 1855 | #else | ||
| 1856 | /* | ||
| 1857 | * On BookE-PR (e500v2) the guest is always executed with MSR.PR=1 | ||
| 1858 | * We set DBCR1 and DBCR2 to only trigger debug events when MSR.PR | ||
| 1859 | * is set. | ||
| 1860 | */ | ||
| 1861 | dbg_reg->dbcr1 = DBCR1_IAC1US | DBCR1_IAC2US | DBCR1_IAC3US | | ||
| 1862 | DBCR1_IAC4US; | ||
| 1863 | dbg_reg->dbcr2 = DBCR2_DAC1US | DBCR2_DAC2US; | ||
| 1864 | #endif | ||
| 1865 | |||
| 1866 | if (!(vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP)) | ||
| 1867 | return 0; | ||
| 1868 | |||
| 1869 | for (n = 0; n < (KVMPPC_BOOKE_IAC_NUM + KVMPPC_BOOKE_DAC_NUM); n++) { | ||
| 1870 | uint64_t addr = dbg->arch.bp[n].addr; | ||
| 1871 | uint32_t type = dbg->arch.bp[n].type; | ||
| 1872 | |||
| 1873 | if (type == KVMPPC_DEBUG_NONE) | ||
| 1874 | continue; | ||
| 1875 | |||
| 1876 | if (type & !(KVMPPC_DEBUG_WATCH_READ | | ||
| 1877 | KVMPPC_DEBUG_WATCH_WRITE | | ||
| 1878 | KVMPPC_DEBUG_BREAKPOINT)) | ||
| 1879 | return -EINVAL; | ||
| 1880 | |||
| 1881 | if (type & KVMPPC_DEBUG_BREAKPOINT) { | ||
| 1882 | /* Setting H/W breakpoint */ | ||
| 1883 | if (kvmppc_booke_add_breakpoint(dbg_reg, addr, b++)) | ||
| 1884 | return -EINVAL; | ||
| 1885 | } else { | ||
| 1886 | /* Setting H/W watchpoint */ | ||
| 1887 | if (kvmppc_booke_add_watchpoint(dbg_reg, addr, | ||
| 1888 | type, w++)) | ||
| 1889 | return -EINVAL; | ||
| 1890 | } | ||
| 1891 | } | ||
| 1892 | |||
| 1893 | return 0; | ||
| 1894 | } | ||
| 1895 | |||
| 1673 | void kvmppc_booke_vcpu_load(struct kvm_vcpu *vcpu, int cpu) | 1896 | void kvmppc_booke_vcpu_load(struct kvm_vcpu *vcpu, int cpu) |
| 1674 | { | 1897 | { |
| 1675 | vcpu->cpu = smp_processor_id(); | 1898 | vcpu->cpu = smp_processor_id(); |
| @@ -1680,6 +1903,44 @@ void kvmppc_booke_vcpu_put(struct kvm_vcpu *vcpu) | |||
| 1680 | { | 1903 | { |
| 1681 | current->thread.kvm_vcpu = NULL; | 1904 | current->thread.kvm_vcpu = NULL; |
| 1682 | vcpu->cpu = -1; | 1905 | vcpu->cpu = -1; |
| 1906 | |||
| 1907 | /* Clear pending debug event in DBSR */ | ||
| 1908 | kvmppc_clear_dbsr(); | ||
| 1909 | } | ||
| 1910 | |||
| 1911 | void kvmppc_mmu_destroy(struct kvm_vcpu *vcpu) | ||
| 1912 | { | ||
| 1913 | vcpu->kvm->arch.kvm_ops->mmu_destroy(vcpu); | ||
| 1914 | } | ||
| 1915 | |||
| 1916 | int kvmppc_core_init_vm(struct kvm *kvm) | ||
| 1917 | { | ||
| 1918 | return kvm->arch.kvm_ops->init_vm(kvm); | ||
| 1919 | } | ||
| 1920 | |||
| 1921 | struct kvm_vcpu *kvmppc_core_vcpu_create(struct kvm *kvm, unsigned int id) | ||
| 1922 | { | ||
| 1923 | return kvm->arch.kvm_ops->vcpu_create(kvm, id); | ||
| 1924 | } | ||
| 1925 | |||
| 1926 | void kvmppc_core_vcpu_free(struct kvm_vcpu *vcpu) | ||
| 1927 | { | ||
| 1928 | vcpu->kvm->arch.kvm_ops->vcpu_free(vcpu); | ||
| 1929 | } | ||
| 1930 | |||
| 1931 | void kvmppc_core_destroy_vm(struct kvm *kvm) | ||
| 1932 | { | ||
| 1933 | kvm->arch.kvm_ops->destroy_vm(kvm); | ||
| 1934 | } | ||
| 1935 | |||
| 1936 | void kvmppc_core_vcpu_load(struct kvm_vcpu *vcpu, int cpu) | ||
| 1937 | { | ||
| 1938 | vcpu->kvm->arch.kvm_ops->vcpu_load(vcpu, cpu); | ||
| 1939 | } | ||
| 1940 | |||
| 1941 | void kvmppc_core_vcpu_put(struct kvm_vcpu *vcpu) | ||
| 1942 | { | ||
| 1943 | vcpu->kvm->arch.kvm_ops->vcpu_put(vcpu); | ||
| 1683 | } | 1944 | } |
| 1684 | 1945 | ||
| 1685 | int __init kvmppc_booke_init(void) | 1946 | int __init kvmppc_booke_init(void) |
diff --git a/arch/powerpc/kvm/booke.h b/arch/powerpc/kvm/booke.h index 5fd1ba693579..09bfd9bc7cf8 100644 --- a/arch/powerpc/kvm/booke.h +++ b/arch/powerpc/kvm/booke.h | |||
| @@ -99,6 +99,30 @@ enum int_class { | |||
| 99 | 99 | ||
| 100 | void kvmppc_set_pending_interrupt(struct kvm_vcpu *vcpu, enum int_class type); | 100 | void kvmppc_set_pending_interrupt(struct kvm_vcpu *vcpu, enum int_class type); |
| 101 | 101 | ||
| 102 | extern void kvmppc_mmu_destroy_44x(struct kvm_vcpu *vcpu); | ||
| 103 | extern int kvmppc_core_emulate_op_44x(struct kvm_run *run, struct kvm_vcpu *vcpu, | ||
| 104 | unsigned int inst, int *advance); | ||
| 105 | extern int kvmppc_core_emulate_mtspr_44x(struct kvm_vcpu *vcpu, int sprn, | ||
| 106 | ulong spr_val); | ||
| 107 | extern int kvmppc_core_emulate_mfspr_44x(struct kvm_vcpu *vcpu, int sprn, | ||
| 108 | ulong *spr_val); | ||
| 109 | extern void kvmppc_mmu_destroy_e500(struct kvm_vcpu *vcpu); | ||
| 110 | extern int kvmppc_core_emulate_op_e500(struct kvm_run *run, | ||
| 111 | struct kvm_vcpu *vcpu, | ||
| 112 | unsigned int inst, int *advance); | ||
| 113 | extern int kvmppc_core_emulate_mtspr_e500(struct kvm_vcpu *vcpu, int sprn, | ||
| 114 | ulong spr_val); | ||
| 115 | extern int kvmppc_core_emulate_mfspr_e500(struct kvm_vcpu *vcpu, int sprn, | ||
| 116 | ulong *spr_val); | ||
| 117 | extern void kvmppc_mmu_destroy_e500(struct kvm_vcpu *vcpu); | ||
| 118 | extern int kvmppc_core_emulate_op_e500(struct kvm_run *run, | ||
| 119 | struct kvm_vcpu *vcpu, | ||
| 120 | unsigned int inst, int *advance); | ||
| 121 | extern int kvmppc_core_emulate_mtspr_e500(struct kvm_vcpu *vcpu, int sprn, | ||
| 122 | ulong spr_val); | ||
| 123 | extern int kvmppc_core_emulate_mfspr_e500(struct kvm_vcpu *vcpu, int sprn, | ||
| 124 | ulong *spr_val); | ||
| 125 | |||
| 102 | /* | 126 | /* |
| 103 | * Load up guest vcpu FP state if it's needed. | 127 | * Load up guest vcpu FP state if it's needed. |
| 104 | * It also set the MSR_FP in thread so that host know | 128 | * It also set the MSR_FP in thread so that host know |
| @@ -129,4 +153,9 @@ static inline void kvmppc_save_guest_fp(struct kvm_vcpu *vcpu) | |||
| 129 | giveup_fpu(current); | 153 | giveup_fpu(current); |
| 130 | #endif | 154 | #endif |
| 131 | } | 155 | } |
| 156 | |||
| 157 | static inline void kvmppc_clear_dbsr(void) | ||
| 158 | { | ||
| 159 | mtspr(SPRN_DBSR, mfspr(SPRN_DBSR)); | ||
| 160 | } | ||
| 132 | #endif /* __KVM_BOOKE_H__ */ | 161 | #endif /* __KVM_BOOKE_H__ */ |
diff --git a/arch/powerpc/kvm/e500.c b/arch/powerpc/kvm/e500.c index ce6b73c29612..497b142f651c 100644 --- a/arch/powerpc/kvm/e500.c +++ b/arch/powerpc/kvm/e500.c | |||
| @@ -305,7 +305,7 @@ void kvmppc_core_load_guest_debugstate(struct kvm_vcpu *vcpu) | |||
| 305 | { | 305 | { |
| 306 | } | 306 | } |
| 307 | 307 | ||
| 308 | void kvmppc_core_vcpu_load(struct kvm_vcpu *vcpu, int cpu) | 308 | static void kvmppc_core_vcpu_load_e500(struct kvm_vcpu *vcpu, int cpu) |
| 309 | { | 309 | { |
| 310 | kvmppc_booke_vcpu_load(vcpu, cpu); | 310 | kvmppc_booke_vcpu_load(vcpu, cpu); |
| 311 | 311 | ||
| @@ -313,7 +313,7 @@ void kvmppc_core_vcpu_load(struct kvm_vcpu *vcpu, int cpu) | |||
| 313 | kvmppc_e500_recalc_shadow_pid(to_e500(vcpu)); | 313 | kvmppc_e500_recalc_shadow_pid(to_e500(vcpu)); |
| 314 | } | 314 | } |
| 315 | 315 | ||
| 316 | void kvmppc_core_vcpu_put(struct kvm_vcpu *vcpu) | 316 | static void kvmppc_core_vcpu_put_e500(struct kvm_vcpu *vcpu) |
| 317 | { | 317 | { |
| 318 | #ifdef CONFIG_SPE | 318 | #ifdef CONFIG_SPE |
| 319 | if (vcpu->arch.shadow_msr & MSR_SPE) | 319 | if (vcpu->arch.shadow_msr & MSR_SPE) |
| @@ -367,7 +367,8 @@ int kvmppc_core_vcpu_setup(struct kvm_vcpu *vcpu) | |||
| 367 | return 0; | 367 | return 0; |
| 368 | } | 368 | } |
| 369 | 369 | ||
| 370 | void kvmppc_core_get_sregs(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) | 370 | static int kvmppc_core_get_sregs_e500(struct kvm_vcpu *vcpu, |
| 371 | struct kvm_sregs *sregs) | ||
| 371 | { | 372 | { |
| 372 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); | 373 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); |
| 373 | 374 | ||
| @@ -388,9 +389,11 @@ void kvmppc_core_get_sregs(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) | |||
| 388 | 389 | ||
| 389 | kvmppc_get_sregs_ivor(vcpu, sregs); | 390 | kvmppc_get_sregs_ivor(vcpu, sregs); |
| 390 | kvmppc_get_sregs_e500_tlb(vcpu, sregs); | 391 | kvmppc_get_sregs_e500_tlb(vcpu, sregs); |
| 392 | return 0; | ||
| 391 | } | 393 | } |
| 392 | 394 | ||
| 393 | int kvmppc_core_set_sregs(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) | 395 | static int kvmppc_core_set_sregs_e500(struct kvm_vcpu *vcpu, |
| 396 | struct kvm_sregs *sregs) | ||
| 394 | { | 397 | { |
| 395 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); | 398 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); |
| 396 | int ret; | 399 | int ret; |
| @@ -425,21 +428,22 @@ int kvmppc_core_set_sregs(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) | |||
| 425 | return kvmppc_set_sregs_ivor(vcpu, sregs); | 428 | return kvmppc_set_sregs_ivor(vcpu, sregs); |
| 426 | } | 429 | } |
| 427 | 430 | ||
| 428 | int kvmppc_get_one_reg(struct kvm_vcpu *vcpu, u64 id, | 431 | static int kvmppc_get_one_reg_e500(struct kvm_vcpu *vcpu, u64 id, |
| 429 | union kvmppc_one_reg *val) | 432 | union kvmppc_one_reg *val) |
| 430 | { | 433 | { |
| 431 | int r = kvmppc_get_one_reg_e500_tlb(vcpu, id, val); | 434 | int r = kvmppc_get_one_reg_e500_tlb(vcpu, id, val); |
| 432 | return r; | 435 | return r; |
| 433 | } | 436 | } |
| 434 | 437 | ||
| 435 | int kvmppc_set_one_reg(struct kvm_vcpu *vcpu, u64 id, | 438 | static int kvmppc_set_one_reg_e500(struct kvm_vcpu *vcpu, u64 id, |
| 436 | union kvmppc_one_reg *val) | 439 | union kvmppc_one_reg *val) |
| 437 | { | 440 | { |
| 438 | int r = kvmppc_get_one_reg_e500_tlb(vcpu, id, val); | 441 | int r = kvmppc_get_one_reg_e500_tlb(vcpu, id, val); |
| 439 | return r; | 442 | return r; |
| 440 | } | 443 | } |
| 441 | 444 | ||
| 442 | struct kvm_vcpu *kvmppc_core_vcpu_create(struct kvm *kvm, unsigned int id) | 445 | static struct kvm_vcpu *kvmppc_core_vcpu_create_e500(struct kvm *kvm, |
| 446 | unsigned int id) | ||
| 443 | { | 447 | { |
| 444 | struct kvmppc_vcpu_e500 *vcpu_e500; | 448 | struct kvmppc_vcpu_e500 *vcpu_e500; |
| 445 | struct kvm_vcpu *vcpu; | 449 | struct kvm_vcpu *vcpu; |
| @@ -481,7 +485,7 @@ out: | |||
| 481 | return ERR_PTR(err); | 485 | return ERR_PTR(err); |
| 482 | } | 486 | } |
| 483 | 487 | ||
| 484 | void kvmppc_core_vcpu_free(struct kvm_vcpu *vcpu) | 488 | static void kvmppc_core_vcpu_free_e500(struct kvm_vcpu *vcpu) |
| 485 | { | 489 | { |
| 486 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); | 490 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); |
| 487 | 491 | ||
| @@ -492,15 +496,32 @@ void kvmppc_core_vcpu_free(struct kvm_vcpu *vcpu) | |||
| 492 | kmem_cache_free(kvm_vcpu_cache, vcpu_e500); | 496 | kmem_cache_free(kvm_vcpu_cache, vcpu_e500); |
| 493 | } | 497 | } |
| 494 | 498 | ||
| 495 | int kvmppc_core_init_vm(struct kvm *kvm) | 499 | static int kvmppc_core_init_vm_e500(struct kvm *kvm) |
| 496 | { | 500 | { |
| 497 | return 0; | 501 | return 0; |
| 498 | } | 502 | } |
| 499 | 503 | ||
| 500 | void kvmppc_core_destroy_vm(struct kvm *kvm) | 504 | static void kvmppc_core_destroy_vm_e500(struct kvm *kvm) |
| 501 | { | 505 | { |
| 502 | } | 506 | } |
| 503 | 507 | ||
| 508 | static struct kvmppc_ops kvm_ops_e500 = { | ||
| 509 | .get_sregs = kvmppc_core_get_sregs_e500, | ||
| 510 | .set_sregs = kvmppc_core_set_sregs_e500, | ||
| 511 | .get_one_reg = kvmppc_get_one_reg_e500, | ||
| 512 | .set_one_reg = kvmppc_set_one_reg_e500, | ||
| 513 | .vcpu_load = kvmppc_core_vcpu_load_e500, | ||
| 514 | .vcpu_put = kvmppc_core_vcpu_put_e500, | ||
| 515 | .vcpu_create = kvmppc_core_vcpu_create_e500, | ||
| 516 | .vcpu_free = kvmppc_core_vcpu_free_e500, | ||
| 517 | .mmu_destroy = kvmppc_mmu_destroy_e500, | ||
| 518 | .init_vm = kvmppc_core_init_vm_e500, | ||
| 519 | .destroy_vm = kvmppc_core_destroy_vm_e500, | ||
| 520 | .emulate_op = kvmppc_core_emulate_op_e500, | ||
| 521 | .emulate_mtspr = kvmppc_core_emulate_mtspr_e500, | ||
| 522 | .emulate_mfspr = kvmppc_core_emulate_mfspr_e500, | ||
| 523 | }; | ||
| 524 | |||
| 504 | static int __init kvmppc_e500_init(void) | 525 | static int __init kvmppc_e500_init(void) |
| 505 | { | 526 | { |
| 506 | int r, i; | 527 | int r, i; |
| @@ -512,11 +533,11 @@ static int __init kvmppc_e500_init(void) | |||
| 512 | 533 | ||
| 513 | r = kvmppc_core_check_processor_compat(); | 534 | r = kvmppc_core_check_processor_compat(); |
| 514 | if (r) | 535 | if (r) |
| 515 | return r; | 536 | goto err_out; |
| 516 | 537 | ||
| 517 | r = kvmppc_booke_init(); | 538 | r = kvmppc_booke_init(); |
| 518 | if (r) | 539 | if (r) |
| 519 | return r; | 540 | goto err_out; |
| 520 | 541 | ||
| 521 | /* copy extra E500 exception handlers */ | 542 | /* copy extra E500 exception handlers */ |
| 522 | ivor[0] = mfspr(SPRN_IVOR32); | 543 | ivor[0] = mfspr(SPRN_IVOR32); |
| @@ -534,11 +555,19 @@ static int __init kvmppc_e500_init(void) | |||
| 534 | flush_icache_range(kvmppc_booke_handlers, kvmppc_booke_handlers + | 555 | flush_icache_range(kvmppc_booke_handlers, kvmppc_booke_handlers + |
| 535 | ivor[max_ivor] + handler_len); | 556 | ivor[max_ivor] + handler_len); |
| 536 | 557 | ||
| 537 | return kvm_init(NULL, sizeof(struct kvmppc_vcpu_e500), 0, THIS_MODULE); | 558 | r = kvm_init(NULL, sizeof(struct kvmppc_vcpu_e500), 0, THIS_MODULE); |
| 559 | if (r) | ||
| 560 | goto err_out; | ||
| 561 | kvm_ops_e500.owner = THIS_MODULE; | ||
| 562 | kvmppc_pr_ops = &kvm_ops_e500; | ||
| 563 | |||
| 564 | err_out: | ||
| 565 | return r; | ||
| 538 | } | 566 | } |
| 539 | 567 | ||
| 540 | static void __exit kvmppc_e500_exit(void) | 568 | static void __exit kvmppc_e500_exit(void) |
| 541 | { | 569 | { |
| 570 | kvmppc_pr_ops = NULL; | ||
| 542 | kvmppc_booke_exit(); | 571 | kvmppc_booke_exit(); |
| 543 | } | 572 | } |
| 544 | 573 | ||
diff --git a/arch/powerpc/kvm/e500.h b/arch/powerpc/kvm/e500.h index c2e5e98453a6..4fd9650eb018 100644 --- a/arch/powerpc/kvm/e500.h +++ b/arch/powerpc/kvm/e500.h | |||
| @@ -117,7 +117,7 @@ static inline struct kvmppc_vcpu_e500 *to_e500(struct kvm_vcpu *vcpu) | |||
| 117 | #define E500_TLB_USER_PERM_MASK (MAS3_UX|MAS3_UR|MAS3_UW) | 117 | #define E500_TLB_USER_PERM_MASK (MAS3_UX|MAS3_UR|MAS3_UW) |
| 118 | #define E500_TLB_SUPER_PERM_MASK (MAS3_SX|MAS3_SR|MAS3_SW) | 118 | #define E500_TLB_SUPER_PERM_MASK (MAS3_SX|MAS3_SR|MAS3_SW) |
| 119 | #define MAS2_ATTRIB_MASK \ | 119 | #define MAS2_ATTRIB_MASK \ |
| 120 | (MAS2_X0 | MAS2_X1) | 120 | (MAS2_X0 | MAS2_X1 | MAS2_E | MAS2_G) |
| 121 | #define MAS3_ATTRIB_MASK \ | 121 | #define MAS3_ATTRIB_MASK \ |
| 122 | (MAS3_U0 | MAS3_U1 | MAS3_U2 | MAS3_U3 \ | 122 | (MAS3_U0 | MAS3_U1 | MAS3_U2 | MAS3_U3 \ |
| 123 | | E500_TLB_USER_PERM_MASK | E500_TLB_SUPER_PERM_MASK) | 123 | | E500_TLB_USER_PERM_MASK | E500_TLB_SUPER_PERM_MASK) |
diff --git a/arch/powerpc/kvm/e500_emulate.c b/arch/powerpc/kvm/e500_emulate.c index b10a01243abd..89b7f821f6c4 100644 --- a/arch/powerpc/kvm/e500_emulate.c +++ b/arch/powerpc/kvm/e500_emulate.c | |||
| @@ -26,6 +26,7 @@ | |||
| 26 | #define XOP_TLBRE 946 | 26 | #define XOP_TLBRE 946 |
| 27 | #define XOP_TLBWE 978 | 27 | #define XOP_TLBWE 978 |
| 28 | #define XOP_TLBILX 18 | 28 | #define XOP_TLBILX 18 |
| 29 | #define XOP_EHPRIV 270 | ||
| 29 | 30 | ||
| 30 | #ifdef CONFIG_KVM_E500MC | 31 | #ifdef CONFIG_KVM_E500MC |
| 31 | static int dbell2prio(ulong param) | 32 | static int dbell2prio(ulong param) |
| @@ -82,8 +83,28 @@ static int kvmppc_e500_emul_msgsnd(struct kvm_vcpu *vcpu, int rb) | |||
| 82 | } | 83 | } |
| 83 | #endif | 84 | #endif |
| 84 | 85 | ||
| 85 | int kvmppc_core_emulate_op(struct kvm_run *run, struct kvm_vcpu *vcpu, | 86 | static int kvmppc_e500_emul_ehpriv(struct kvm_run *run, struct kvm_vcpu *vcpu, |
| 86 | unsigned int inst, int *advance) | 87 | unsigned int inst, int *advance) |
| 88 | { | ||
| 89 | int emulated = EMULATE_DONE; | ||
| 90 | |||
| 91 | switch (get_oc(inst)) { | ||
| 92 | case EHPRIV_OC_DEBUG: | ||
| 93 | run->exit_reason = KVM_EXIT_DEBUG; | ||
| 94 | run->debug.arch.address = vcpu->arch.pc; | ||
| 95 | run->debug.arch.status = 0; | ||
| 96 | kvmppc_account_exit(vcpu, DEBUG_EXITS); | ||
| 97 | emulated = EMULATE_EXIT_USER; | ||
| 98 | *advance = 0; | ||
| 99 | break; | ||
| 100 | default: | ||
| 101 | emulated = EMULATE_FAIL; | ||
| 102 | } | ||
| 103 | return emulated; | ||
| 104 | } | ||
| 105 | |||
| 106 | int kvmppc_core_emulate_op_e500(struct kvm_run *run, struct kvm_vcpu *vcpu, | ||
| 107 | unsigned int inst, int *advance) | ||
| 87 | { | 108 | { |
| 88 | int emulated = EMULATE_DONE; | 109 | int emulated = EMULATE_DONE; |
| 89 | int ra = get_ra(inst); | 110 | int ra = get_ra(inst); |
| @@ -130,6 +151,11 @@ int kvmppc_core_emulate_op(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 130 | emulated = kvmppc_e500_emul_tlbivax(vcpu, ea); | 151 | emulated = kvmppc_e500_emul_tlbivax(vcpu, ea); |
| 131 | break; | 152 | break; |
| 132 | 153 | ||
| 154 | case XOP_EHPRIV: | ||
| 155 | emulated = kvmppc_e500_emul_ehpriv(run, vcpu, inst, | ||
| 156 | advance); | ||
| 157 | break; | ||
| 158 | |||
| 133 | default: | 159 | default: |
| 134 | emulated = EMULATE_FAIL; | 160 | emulated = EMULATE_FAIL; |
| 135 | } | 161 | } |
| @@ -146,7 +172,7 @@ int kvmppc_core_emulate_op(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 146 | return emulated; | 172 | return emulated; |
| 147 | } | 173 | } |
| 148 | 174 | ||
| 149 | int kvmppc_core_emulate_mtspr(struct kvm_vcpu *vcpu, int sprn, ulong spr_val) | 175 | int kvmppc_core_emulate_mtspr_e500(struct kvm_vcpu *vcpu, int sprn, ulong spr_val) |
| 150 | { | 176 | { |
| 151 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); | 177 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); |
| 152 | int emulated = EMULATE_DONE; | 178 | int emulated = EMULATE_DONE; |
| @@ -237,7 +263,7 @@ int kvmppc_core_emulate_mtspr(struct kvm_vcpu *vcpu, int sprn, ulong spr_val) | |||
| 237 | return emulated; | 263 | return emulated; |
| 238 | } | 264 | } |
| 239 | 265 | ||
| 240 | int kvmppc_core_emulate_mfspr(struct kvm_vcpu *vcpu, int sprn, ulong *spr_val) | 266 | int kvmppc_core_emulate_mfspr_e500(struct kvm_vcpu *vcpu, int sprn, ulong *spr_val) |
| 241 | { | 267 | { |
| 242 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); | 268 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); |
| 243 | int emulated = EMULATE_DONE; | 269 | int emulated = EMULATE_DONE; |
diff --git a/arch/powerpc/kvm/e500_mmu.c b/arch/powerpc/kvm/e500_mmu.c index 6d6f153b6c1d..ebca6b88ea5e 100644 --- a/arch/powerpc/kvm/e500_mmu.c +++ b/arch/powerpc/kvm/e500_mmu.c | |||
| @@ -32,7 +32,7 @@ | |||
| 32 | #include <asm/kvm_ppc.h> | 32 | #include <asm/kvm_ppc.h> |
| 33 | 33 | ||
| 34 | #include "e500.h" | 34 | #include "e500.h" |
| 35 | #include "trace.h" | 35 | #include "trace_booke.h" |
| 36 | #include "timing.h" | 36 | #include "timing.h" |
| 37 | #include "e500_mmu_host.h" | 37 | #include "e500_mmu_host.h" |
| 38 | 38 | ||
| @@ -536,7 +536,7 @@ gpa_t kvmppc_mmu_xlate(struct kvm_vcpu *vcpu, unsigned int index, | |||
| 536 | return get_tlb_raddr(gtlbe) | (eaddr & pgmask); | 536 | return get_tlb_raddr(gtlbe) | (eaddr & pgmask); |
| 537 | } | 537 | } |
| 538 | 538 | ||
| 539 | void kvmppc_mmu_destroy(struct kvm_vcpu *vcpu) | 539 | void kvmppc_mmu_destroy_e500(struct kvm_vcpu *vcpu) |
| 540 | { | 540 | { |
| 541 | } | 541 | } |
| 542 | 542 | ||
diff --git a/arch/powerpc/kvm/e500_mmu_host.c b/arch/powerpc/kvm/e500_mmu_host.c index c65593abae8e..ecf2247b13be 100644 --- a/arch/powerpc/kvm/e500_mmu_host.c +++ b/arch/powerpc/kvm/e500_mmu_host.c | |||
| @@ -32,10 +32,11 @@ | |||
| 32 | #include <asm/kvm_ppc.h> | 32 | #include <asm/kvm_ppc.h> |
| 33 | 33 | ||
| 34 | #include "e500.h" | 34 | #include "e500.h" |
| 35 | #include "trace.h" | ||
| 36 | #include "timing.h" | 35 | #include "timing.h" |
| 37 | #include "e500_mmu_host.h" | 36 | #include "e500_mmu_host.h" |
| 38 | 37 | ||
| 38 | #include "trace_booke.h" | ||
| 39 | |||
| 39 | #define to_htlb1_esel(esel) (host_tlb_params[1].entries - (esel) - 1) | 40 | #define to_htlb1_esel(esel) (host_tlb_params[1].entries - (esel) - 1) |
| 40 | 41 | ||
| 41 | static struct kvmppc_e500_tlb_params host_tlb_params[E500_TLB_NUM]; | 42 | static struct kvmppc_e500_tlb_params host_tlb_params[E500_TLB_NUM]; |
| @@ -253,6 +254,9 @@ static inline void kvmppc_e500_ref_setup(struct tlbe_ref *ref, | |||
| 253 | ref->pfn = pfn; | 254 | ref->pfn = pfn; |
| 254 | ref->flags |= E500_TLB_VALID; | 255 | ref->flags |= E500_TLB_VALID; |
| 255 | 256 | ||
| 257 | /* Mark the page accessed */ | ||
| 258 | kvm_set_pfn_accessed(pfn); | ||
| 259 | |||
| 256 | if (tlbe_is_writable(gtlbe)) | 260 | if (tlbe_is_writable(gtlbe)) |
| 257 | kvm_set_pfn_dirty(pfn); | 261 | kvm_set_pfn_dirty(pfn); |
| 258 | } | 262 | } |
diff --git a/arch/powerpc/kvm/e500mc.c b/arch/powerpc/kvm/e500mc.c index 19c8379575f7..4132cd2fc171 100644 --- a/arch/powerpc/kvm/e500mc.c +++ b/arch/powerpc/kvm/e500mc.c | |||
| @@ -110,7 +110,7 @@ void kvmppc_mmu_msr_notify(struct kvm_vcpu *vcpu, u32 old_msr) | |||
| 110 | 110 | ||
| 111 | static DEFINE_PER_CPU(struct kvm_vcpu *, last_vcpu_on_cpu); | 111 | static DEFINE_PER_CPU(struct kvm_vcpu *, last_vcpu_on_cpu); |
| 112 | 112 | ||
| 113 | void kvmppc_core_vcpu_load(struct kvm_vcpu *vcpu, int cpu) | 113 | static void kvmppc_core_vcpu_load_e500mc(struct kvm_vcpu *vcpu, int cpu) |
| 114 | { | 114 | { |
| 115 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); | 115 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); |
| 116 | 116 | ||
| @@ -147,7 +147,7 @@ void kvmppc_core_vcpu_load(struct kvm_vcpu *vcpu, int cpu) | |||
| 147 | kvmppc_load_guest_fp(vcpu); | 147 | kvmppc_load_guest_fp(vcpu); |
| 148 | } | 148 | } |
| 149 | 149 | ||
| 150 | void kvmppc_core_vcpu_put(struct kvm_vcpu *vcpu) | 150 | static void kvmppc_core_vcpu_put_e500mc(struct kvm_vcpu *vcpu) |
| 151 | { | 151 | { |
| 152 | vcpu->arch.eplc = mfspr(SPRN_EPLC); | 152 | vcpu->arch.eplc = mfspr(SPRN_EPLC); |
| 153 | vcpu->arch.epsc = mfspr(SPRN_EPSC); | 153 | vcpu->arch.epsc = mfspr(SPRN_EPSC); |
| @@ -204,7 +204,8 @@ int kvmppc_core_vcpu_setup(struct kvm_vcpu *vcpu) | |||
| 204 | return 0; | 204 | return 0; |
| 205 | } | 205 | } |
| 206 | 206 | ||
| 207 | void kvmppc_core_get_sregs(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) | 207 | static int kvmppc_core_get_sregs_e500mc(struct kvm_vcpu *vcpu, |
| 208 | struct kvm_sregs *sregs) | ||
| 208 | { | 209 | { |
| 209 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); | 210 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); |
| 210 | 211 | ||
| @@ -224,10 +225,11 @@ void kvmppc_core_get_sregs(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) | |||
| 224 | sregs->u.e.ivor_high[4] = vcpu->arch.ivor[BOOKE_IRQPRIO_DBELL]; | 225 | sregs->u.e.ivor_high[4] = vcpu->arch.ivor[BOOKE_IRQPRIO_DBELL]; |
| 225 | sregs->u.e.ivor_high[5] = vcpu->arch.ivor[BOOKE_IRQPRIO_DBELL_CRIT]; | 226 | sregs->u.e.ivor_high[5] = vcpu->arch.ivor[BOOKE_IRQPRIO_DBELL_CRIT]; |
| 226 | 227 | ||
| 227 | kvmppc_get_sregs_ivor(vcpu, sregs); | 228 | return kvmppc_get_sregs_ivor(vcpu, sregs); |
| 228 | } | 229 | } |
| 229 | 230 | ||
| 230 | int kvmppc_core_set_sregs(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) | 231 | static int kvmppc_core_set_sregs_e500mc(struct kvm_vcpu *vcpu, |
| 232 | struct kvm_sregs *sregs) | ||
| 231 | { | 233 | { |
| 232 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); | 234 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); |
| 233 | int ret; | 235 | int ret; |
| @@ -260,21 +262,22 @@ int kvmppc_core_set_sregs(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) | |||
| 260 | return kvmppc_set_sregs_ivor(vcpu, sregs); | 262 | return kvmppc_set_sregs_ivor(vcpu, sregs); |
| 261 | } | 263 | } |
| 262 | 264 | ||
| 263 | int kvmppc_get_one_reg(struct kvm_vcpu *vcpu, u64 id, | 265 | static int kvmppc_get_one_reg_e500mc(struct kvm_vcpu *vcpu, u64 id, |
| 264 | union kvmppc_one_reg *val) | 266 | union kvmppc_one_reg *val) |
| 265 | { | 267 | { |
| 266 | int r = kvmppc_get_one_reg_e500_tlb(vcpu, id, val); | 268 | int r = kvmppc_get_one_reg_e500_tlb(vcpu, id, val); |
| 267 | return r; | 269 | return r; |
| 268 | } | 270 | } |
| 269 | 271 | ||
| 270 | int kvmppc_set_one_reg(struct kvm_vcpu *vcpu, u64 id, | 272 | static int kvmppc_set_one_reg_e500mc(struct kvm_vcpu *vcpu, u64 id, |
| 271 | union kvmppc_one_reg *val) | 273 | union kvmppc_one_reg *val) |
| 272 | { | 274 | { |
| 273 | int r = kvmppc_set_one_reg_e500_tlb(vcpu, id, val); | 275 | int r = kvmppc_set_one_reg_e500_tlb(vcpu, id, val); |
| 274 | return r; | 276 | return r; |
| 275 | } | 277 | } |
| 276 | 278 | ||
| 277 | struct kvm_vcpu *kvmppc_core_vcpu_create(struct kvm *kvm, unsigned int id) | 279 | static struct kvm_vcpu *kvmppc_core_vcpu_create_e500mc(struct kvm *kvm, |
| 280 | unsigned int id) | ||
| 278 | { | 281 | { |
| 279 | struct kvmppc_vcpu_e500 *vcpu_e500; | 282 | struct kvmppc_vcpu_e500 *vcpu_e500; |
| 280 | struct kvm_vcpu *vcpu; | 283 | struct kvm_vcpu *vcpu; |
| @@ -315,7 +318,7 @@ out: | |||
| 315 | return ERR_PTR(err); | 318 | return ERR_PTR(err); |
| 316 | } | 319 | } |
| 317 | 320 | ||
| 318 | void kvmppc_core_vcpu_free(struct kvm_vcpu *vcpu) | 321 | static void kvmppc_core_vcpu_free_e500mc(struct kvm_vcpu *vcpu) |
| 319 | { | 322 | { |
| 320 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); | 323 | struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu); |
| 321 | 324 | ||
| @@ -325,7 +328,7 @@ void kvmppc_core_vcpu_free(struct kvm_vcpu *vcpu) | |||
| 325 | kmem_cache_free(kvm_vcpu_cache, vcpu_e500); | 328 | kmem_cache_free(kvm_vcpu_cache, vcpu_e500); |
| 326 | } | 329 | } |
| 327 | 330 | ||
| 328 | int kvmppc_core_init_vm(struct kvm *kvm) | 331 | static int kvmppc_core_init_vm_e500mc(struct kvm *kvm) |
| 329 | { | 332 | { |
| 330 | int lpid; | 333 | int lpid; |
| 331 | 334 | ||
| @@ -337,27 +340,52 @@ int kvmppc_core_init_vm(struct kvm *kvm) | |||
| 337 | return 0; | 340 | return 0; |
| 338 | } | 341 | } |
| 339 | 342 | ||
| 340 | void kvmppc_core_destroy_vm(struct kvm *kvm) | 343 | static void kvmppc_core_destroy_vm_e500mc(struct kvm *kvm) |
| 341 | { | 344 | { |
| 342 | kvmppc_free_lpid(kvm->arch.lpid); | 345 | kvmppc_free_lpid(kvm->arch.lpid); |
| 343 | } | 346 | } |
| 344 | 347 | ||
| 348 | static struct kvmppc_ops kvm_ops_e500mc = { | ||
| 349 | .get_sregs = kvmppc_core_get_sregs_e500mc, | ||
| 350 | .set_sregs = kvmppc_core_set_sregs_e500mc, | ||
| 351 | .get_one_reg = kvmppc_get_one_reg_e500mc, | ||
| 352 | .set_one_reg = kvmppc_set_one_reg_e500mc, | ||
| 353 | .vcpu_load = kvmppc_core_vcpu_load_e500mc, | ||
| 354 | .vcpu_put = kvmppc_core_vcpu_put_e500mc, | ||
| 355 | .vcpu_create = kvmppc_core_vcpu_create_e500mc, | ||
| 356 | .vcpu_free = kvmppc_core_vcpu_free_e500mc, | ||
| 357 | .mmu_destroy = kvmppc_mmu_destroy_e500, | ||
| 358 | .init_vm = kvmppc_core_init_vm_e500mc, | ||
| 359 | .destroy_vm = kvmppc_core_destroy_vm_e500mc, | ||
| 360 | .emulate_op = kvmppc_core_emulate_op_e500, | ||
| 361 | .emulate_mtspr = kvmppc_core_emulate_mtspr_e500, | ||
| 362 | .emulate_mfspr = kvmppc_core_emulate_mfspr_e500, | ||
| 363 | }; | ||
| 364 | |||
| 345 | static int __init kvmppc_e500mc_init(void) | 365 | static int __init kvmppc_e500mc_init(void) |
| 346 | { | 366 | { |
| 347 | int r; | 367 | int r; |
| 348 | 368 | ||
| 349 | r = kvmppc_booke_init(); | 369 | r = kvmppc_booke_init(); |
| 350 | if (r) | 370 | if (r) |
| 351 | return r; | 371 | goto err_out; |
| 352 | 372 | ||
| 353 | kvmppc_init_lpid(64); | 373 | kvmppc_init_lpid(64); |
| 354 | kvmppc_claim_lpid(0); /* host */ | 374 | kvmppc_claim_lpid(0); /* host */ |
| 355 | 375 | ||
| 356 | return kvm_init(NULL, sizeof(struct kvmppc_vcpu_e500), 0, THIS_MODULE); | 376 | r = kvm_init(NULL, sizeof(struct kvmppc_vcpu_e500), 0, THIS_MODULE); |
| 377 | if (r) | ||
| 378 | goto err_out; | ||
| 379 | kvm_ops_e500mc.owner = THIS_MODULE; | ||
| 380 | kvmppc_pr_ops = &kvm_ops_e500mc; | ||
| 381 | |||
| 382 | err_out: | ||
| 383 | return r; | ||
| 357 | } | 384 | } |
| 358 | 385 | ||
| 359 | static void __exit kvmppc_e500mc_exit(void) | 386 | static void __exit kvmppc_e500mc_exit(void) |
| 360 | { | 387 | { |
| 388 | kvmppc_pr_ops = NULL; | ||
| 361 | kvmppc_booke_exit(); | 389 | kvmppc_booke_exit(); |
| 362 | } | 390 | } |
| 363 | 391 | ||
diff --git a/arch/powerpc/kvm/emulate.c b/arch/powerpc/kvm/emulate.c index 751cd45f65a0..2f9a0873b44f 100644 --- a/arch/powerpc/kvm/emulate.c +++ b/arch/powerpc/kvm/emulate.c | |||
| @@ -130,8 +130,8 @@ static int kvmppc_emulate_mtspr(struct kvm_vcpu *vcpu, int sprn, int rs) | |||
| 130 | case SPRN_PIR: break; | 130 | case SPRN_PIR: break; |
| 131 | 131 | ||
| 132 | default: | 132 | default: |
| 133 | emulated = kvmppc_core_emulate_mtspr(vcpu, sprn, | 133 | emulated = vcpu->kvm->arch.kvm_ops->emulate_mtspr(vcpu, sprn, |
| 134 | spr_val); | 134 | spr_val); |
| 135 | if (emulated == EMULATE_FAIL) | 135 | if (emulated == EMULATE_FAIL) |
| 136 | printk(KERN_INFO "mtspr: unknown spr " | 136 | printk(KERN_INFO "mtspr: unknown spr " |
| 137 | "0x%x\n", sprn); | 137 | "0x%x\n", sprn); |
| @@ -191,8 +191,8 @@ static int kvmppc_emulate_mfspr(struct kvm_vcpu *vcpu, int sprn, int rt) | |||
| 191 | spr_val = kvmppc_get_dec(vcpu, get_tb()); | 191 | spr_val = kvmppc_get_dec(vcpu, get_tb()); |
| 192 | break; | 192 | break; |
| 193 | default: | 193 | default: |
| 194 | emulated = kvmppc_core_emulate_mfspr(vcpu, sprn, | 194 | emulated = vcpu->kvm->arch.kvm_ops->emulate_mfspr(vcpu, sprn, |
| 195 | &spr_val); | 195 | &spr_val); |
| 196 | if (unlikely(emulated == EMULATE_FAIL)) { | 196 | if (unlikely(emulated == EMULATE_FAIL)) { |
| 197 | printk(KERN_INFO "mfspr: unknown spr " | 197 | printk(KERN_INFO "mfspr: unknown spr " |
| 198 | "0x%x\n", sprn); | 198 | "0x%x\n", sprn); |
| @@ -464,7 +464,8 @@ int kvmppc_emulate_instruction(struct kvm_run *run, struct kvm_vcpu *vcpu) | |||
| 464 | } | 464 | } |
| 465 | 465 | ||
| 466 | if (emulated == EMULATE_FAIL) { | 466 | if (emulated == EMULATE_FAIL) { |
| 467 | emulated = kvmppc_core_emulate_op(run, vcpu, inst, &advance); | 467 | emulated = vcpu->kvm->arch.kvm_ops->emulate_op(run, vcpu, inst, |
| 468 | &advance); | ||
| 468 | if (emulated == EMULATE_AGAIN) { | 469 | if (emulated == EMULATE_AGAIN) { |
| 469 | advance = 0; | 470 | advance = 0; |
| 470 | } else if (emulated == EMULATE_FAIL) { | 471 | } else if (emulated == EMULATE_FAIL) { |
| @@ -483,3 +484,4 @@ int kvmppc_emulate_instruction(struct kvm_run *run, struct kvm_vcpu *vcpu) | |||
| 483 | 484 | ||
| 484 | return emulated; | 485 | return emulated; |
| 485 | } | 486 | } |
| 487 | EXPORT_SYMBOL_GPL(kvmppc_emulate_instruction); | ||
diff --git a/arch/powerpc/kvm/powerpc.c b/arch/powerpc/kvm/powerpc.c index 07c0106fab76..9ae97686e9f4 100644 --- a/arch/powerpc/kvm/powerpc.c +++ b/arch/powerpc/kvm/powerpc.c | |||
| @@ -26,6 +26,7 @@ | |||
| 26 | #include <linux/fs.h> | 26 | #include <linux/fs.h> |
| 27 | #include <linux/slab.h> | 27 | #include <linux/slab.h> |
| 28 | #include <linux/file.h> | 28 | #include <linux/file.h> |
| 29 | #include <linux/module.h> | ||
| 29 | #include <asm/cputable.h> | 30 | #include <asm/cputable.h> |
| 30 | #include <asm/uaccess.h> | 31 | #include <asm/uaccess.h> |
| 31 | #include <asm/kvm_ppc.h> | 32 | #include <asm/kvm_ppc.h> |
| @@ -39,6 +40,12 @@ | |||
| 39 | #define CREATE_TRACE_POINTS | 40 | #define CREATE_TRACE_POINTS |
| 40 | #include "trace.h" | 41 | #include "trace.h" |
| 41 | 42 | ||
| 43 | struct kvmppc_ops *kvmppc_hv_ops; | ||
| 44 | EXPORT_SYMBOL_GPL(kvmppc_hv_ops); | ||
| 45 | struct kvmppc_ops *kvmppc_pr_ops; | ||
| 46 | EXPORT_SYMBOL_GPL(kvmppc_pr_ops); | ||
| 47 | |||
| 48 | |||
| 42 | int kvm_arch_vcpu_runnable(struct kvm_vcpu *v) | 49 | int kvm_arch_vcpu_runnable(struct kvm_vcpu *v) |
| 43 | { | 50 | { |
| 44 | return !!(v->arch.pending_exceptions) || | 51 | return !!(v->arch.pending_exceptions) || |
| @@ -50,7 +57,6 @@ int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu) | |||
| 50 | return 1; | 57 | return 1; |
| 51 | } | 58 | } |
| 52 | 59 | ||
| 53 | #ifndef CONFIG_KVM_BOOK3S_64_HV | ||
| 54 | /* | 60 | /* |
| 55 | * Common checks before entering the guest world. Call with interrupts | 61 | * Common checks before entering the guest world. Call with interrupts |
| 56 | * disabled. | 62 | * disabled. |
| @@ -125,7 +131,7 @@ int kvmppc_prepare_to_enter(struct kvm_vcpu *vcpu) | |||
| 125 | 131 | ||
| 126 | return r; | 132 | return r; |
| 127 | } | 133 | } |
| 128 | #endif /* CONFIG_KVM_BOOK3S_64_HV */ | 134 | EXPORT_SYMBOL_GPL(kvmppc_prepare_to_enter); |
| 129 | 135 | ||
| 130 | int kvmppc_kvm_pv(struct kvm_vcpu *vcpu) | 136 | int kvmppc_kvm_pv(struct kvm_vcpu *vcpu) |
| 131 | { | 137 | { |
| @@ -179,6 +185,7 @@ int kvmppc_kvm_pv(struct kvm_vcpu *vcpu) | |||
| 179 | 185 | ||
| 180 | return r; | 186 | return r; |
| 181 | } | 187 | } |
| 188 | EXPORT_SYMBOL_GPL(kvmppc_kvm_pv); | ||
| 182 | 189 | ||
| 183 | int kvmppc_sanity_check(struct kvm_vcpu *vcpu) | 190 | int kvmppc_sanity_check(struct kvm_vcpu *vcpu) |
| 184 | { | 191 | { |
| @@ -192,11 +199,9 @@ int kvmppc_sanity_check(struct kvm_vcpu *vcpu) | |||
| 192 | if ((vcpu->arch.cpu_type != KVM_CPU_3S_64) && vcpu->arch.papr_enabled) | 199 | if ((vcpu->arch.cpu_type != KVM_CPU_3S_64) && vcpu->arch.papr_enabled) |
| 193 | goto out; | 200 | goto out; |
| 194 | 201 | ||
| 195 | #ifdef CONFIG_KVM_BOOK3S_64_HV | ||
| 196 | /* HV KVM can only do PAPR mode for now */ | 202 | /* HV KVM can only do PAPR mode for now */ |
| 197 | if (!vcpu->arch.papr_enabled) | 203 | if (!vcpu->arch.papr_enabled && is_kvmppc_hv_enabled(vcpu->kvm)) |
| 198 | goto out; | 204 | goto out; |
| 199 | #endif | ||
| 200 | 205 | ||
| 201 | #ifdef CONFIG_KVM_BOOKE_HV | 206 | #ifdef CONFIG_KVM_BOOKE_HV |
| 202 | if (!cpu_has_feature(CPU_FTR_EMB_HV)) | 207 | if (!cpu_has_feature(CPU_FTR_EMB_HV)) |
| @@ -209,6 +214,7 @@ out: | |||
| 209 | vcpu->arch.sane = r; | 214 | vcpu->arch.sane = r; |
| 210 | return r ? 0 : -EINVAL; | 215 | return r ? 0 : -EINVAL; |
| 211 | } | 216 | } |
| 217 | EXPORT_SYMBOL_GPL(kvmppc_sanity_check); | ||
| 212 | 218 | ||
| 213 | int kvmppc_emulate_mmio(struct kvm_run *run, struct kvm_vcpu *vcpu) | 219 | int kvmppc_emulate_mmio(struct kvm_run *run, struct kvm_vcpu *vcpu) |
| 214 | { | 220 | { |
| @@ -243,6 +249,7 @@ int kvmppc_emulate_mmio(struct kvm_run *run, struct kvm_vcpu *vcpu) | |||
| 243 | 249 | ||
| 244 | return r; | 250 | return r; |
| 245 | } | 251 | } |
| 252 | EXPORT_SYMBOL_GPL(kvmppc_emulate_mmio); | ||
| 246 | 253 | ||
| 247 | int kvm_arch_hardware_enable(void *garbage) | 254 | int kvm_arch_hardware_enable(void *garbage) |
| 248 | { | 255 | { |
| @@ -269,10 +276,35 @@ void kvm_arch_check_processor_compat(void *rtn) | |||
| 269 | 276 | ||
| 270 | int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) | 277 | int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) |
| 271 | { | 278 | { |
| 272 | if (type) | 279 | struct kvmppc_ops *kvm_ops = NULL; |
| 273 | return -EINVAL; | 280 | /* |
| 274 | 281 | * if we have both HV and PR enabled, default is HV | |
| 282 | */ | ||
| 283 | if (type == 0) { | ||
| 284 | if (kvmppc_hv_ops) | ||
| 285 | kvm_ops = kvmppc_hv_ops; | ||
| 286 | else | ||
| 287 | kvm_ops = kvmppc_pr_ops; | ||
| 288 | if (!kvm_ops) | ||
| 289 | goto err_out; | ||
| 290 | } else if (type == KVM_VM_PPC_HV) { | ||
| 291 | if (!kvmppc_hv_ops) | ||
| 292 | goto err_out; | ||
| 293 | kvm_ops = kvmppc_hv_ops; | ||
| 294 | } else if (type == KVM_VM_PPC_PR) { | ||
| 295 | if (!kvmppc_pr_ops) | ||
| 296 | goto err_out; | ||
| 297 | kvm_ops = kvmppc_pr_ops; | ||
| 298 | } else | ||
| 299 | goto err_out; | ||
| 300 | |||
| 301 | if (kvm_ops->owner && !try_module_get(kvm_ops->owner)) | ||
| 302 | return -ENOENT; | ||
| 303 | |||
| 304 | kvm->arch.kvm_ops = kvm_ops; | ||
| 275 | return kvmppc_core_init_vm(kvm); | 305 | return kvmppc_core_init_vm(kvm); |
| 306 | err_out: | ||
| 307 | return -EINVAL; | ||
| 276 | } | 308 | } |
| 277 | 309 | ||
| 278 | void kvm_arch_destroy_vm(struct kvm *kvm) | 310 | void kvm_arch_destroy_vm(struct kvm *kvm) |
| @@ -292,6 +324,9 @@ void kvm_arch_destroy_vm(struct kvm *kvm) | |||
| 292 | kvmppc_core_destroy_vm(kvm); | 324 | kvmppc_core_destroy_vm(kvm); |
| 293 | 325 | ||
| 294 | mutex_unlock(&kvm->lock); | 326 | mutex_unlock(&kvm->lock); |
| 327 | |||
| 328 | /* drop the module reference */ | ||
| 329 | module_put(kvm->arch.kvm_ops->owner); | ||
| 295 | } | 330 | } |
| 296 | 331 | ||
| 297 | void kvm_arch_sync_events(struct kvm *kvm) | 332 | void kvm_arch_sync_events(struct kvm *kvm) |
| @@ -301,6 +336,10 @@ void kvm_arch_sync_events(struct kvm *kvm) | |||
| 301 | int kvm_dev_ioctl_check_extension(long ext) | 336 | int kvm_dev_ioctl_check_extension(long ext) |
| 302 | { | 337 | { |
| 303 | int r; | 338 | int r; |
| 339 | /* FIXME!! | ||
| 340 | * Should some of this be vm ioctl ? is it possible now ? | ||
| 341 | */ | ||
| 342 | int hv_enabled = kvmppc_hv_ops ? 1 : 0; | ||
| 304 | 343 | ||
| 305 | switch (ext) { | 344 | switch (ext) { |
| 306 | #ifdef CONFIG_BOOKE | 345 | #ifdef CONFIG_BOOKE |
| @@ -320,22 +359,26 @@ int kvm_dev_ioctl_check_extension(long ext) | |||
| 320 | case KVM_CAP_DEVICE_CTRL: | 359 | case KVM_CAP_DEVICE_CTRL: |
| 321 | r = 1; | 360 | r = 1; |
| 322 | break; | 361 | break; |
| 323 | #ifndef CONFIG_KVM_BOOK3S_64_HV | ||
| 324 | case KVM_CAP_PPC_PAIRED_SINGLES: | 362 | case KVM_CAP_PPC_PAIRED_SINGLES: |
| 325 | case KVM_CAP_PPC_OSI: | 363 | case KVM_CAP_PPC_OSI: |
| 326 | case KVM_CAP_PPC_GET_PVINFO: | 364 | case KVM_CAP_PPC_GET_PVINFO: |
| 327 | #if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC) | 365 | #if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC) |
| 328 | case KVM_CAP_SW_TLB: | 366 | case KVM_CAP_SW_TLB: |
| 329 | #endif | 367 | #endif |
| 330 | #ifdef CONFIG_KVM_MPIC | 368 | /* We support this only for PR */ |
| 331 | case KVM_CAP_IRQ_MPIC: | 369 | r = !hv_enabled; |
| 332 | #endif | ||
| 333 | r = 1; | ||
| 334 | break; | 370 | break; |
| 371 | #ifdef CONFIG_KVM_MMIO | ||
| 335 | case KVM_CAP_COALESCED_MMIO: | 372 | case KVM_CAP_COALESCED_MMIO: |
| 336 | r = KVM_COALESCED_MMIO_PAGE_OFFSET; | 373 | r = KVM_COALESCED_MMIO_PAGE_OFFSET; |
| 337 | break; | 374 | break; |
| 338 | #endif | 375 | #endif |
| 376 | #ifdef CONFIG_KVM_MPIC | ||
| 377 | case KVM_CAP_IRQ_MPIC: | ||
| 378 | r = 1; | ||
| 379 | break; | ||
| 380 | #endif | ||
| 381 | |||
| 339 | #ifdef CONFIG_PPC_BOOK3S_64 | 382 | #ifdef CONFIG_PPC_BOOK3S_64 |
| 340 | case KVM_CAP_SPAPR_TCE: | 383 | case KVM_CAP_SPAPR_TCE: |
| 341 | case KVM_CAP_PPC_ALLOC_HTAB: | 384 | case KVM_CAP_PPC_ALLOC_HTAB: |
| @@ -346,32 +389,37 @@ int kvm_dev_ioctl_check_extension(long ext) | |||
| 346 | r = 1; | 389 | r = 1; |
| 347 | break; | 390 | break; |
| 348 | #endif /* CONFIG_PPC_BOOK3S_64 */ | 391 | #endif /* CONFIG_PPC_BOOK3S_64 */ |
| 349 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 392 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE |
| 350 | case KVM_CAP_PPC_SMT: | 393 | case KVM_CAP_PPC_SMT: |
| 351 | r = threads_per_core; | 394 | if (hv_enabled) |
| 395 | r = threads_per_core; | ||
| 396 | else | ||
| 397 | r = 0; | ||
| 352 | break; | 398 | break; |
| 353 | case KVM_CAP_PPC_RMA: | 399 | case KVM_CAP_PPC_RMA: |
| 354 | r = 1; | 400 | r = hv_enabled; |
| 355 | /* PPC970 requires an RMA */ | 401 | /* PPC970 requires an RMA */ |
| 356 | if (cpu_has_feature(CPU_FTR_ARCH_201)) | 402 | if (r && cpu_has_feature(CPU_FTR_ARCH_201)) |
| 357 | r = 2; | 403 | r = 2; |
| 358 | break; | 404 | break; |
| 359 | #endif | 405 | #endif |
| 360 | case KVM_CAP_SYNC_MMU: | 406 | case KVM_CAP_SYNC_MMU: |
| 361 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 407 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE |
| 362 | r = cpu_has_feature(CPU_FTR_ARCH_206) ? 1 : 0; | 408 | if (hv_enabled) |
| 409 | r = cpu_has_feature(CPU_FTR_ARCH_206) ? 1 : 0; | ||
| 410 | else | ||
| 411 | r = 0; | ||
| 363 | #elif defined(KVM_ARCH_WANT_MMU_NOTIFIER) | 412 | #elif defined(KVM_ARCH_WANT_MMU_NOTIFIER) |
| 364 | r = 1; | 413 | r = 1; |
| 365 | #else | 414 | #else |
| 366 | r = 0; | 415 | r = 0; |
| 367 | break; | ||
| 368 | #endif | 416 | #endif |
| 369 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 417 | break; |
| 418 | #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE | ||
| 370 | case KVM_CAP_PPC_HTAB_FD: | 419 | case KVM_CAP_PPC_HTAB_FD: |
| 371 | r = 1; | 420 | r = hv_enabled; |
| 372 | break; | 421 | break; |
| 373 | #endif | 422 | #endif |
| 374 | break; | ||
| 375 | case KVM_CAP_NR_VCPUS: | 423 | case KVM_CAP_NR_VCPUS: |
| 376 | /* | 424 | /* |
| 377 | * Recommending a number of CPUs is somewhat arbitrary; we | 425 | * Recommending a number of CPUs is somewhat arbitrary; we |
| @@ -379,11 +427,10 @@ int kvm_dev_ioctl_check_extension(long ext) | |||
| 379 | * will have secondary threads "offline"), and for other KVM | 427 | * will have secondary threads "offline"), and for other KVM |
| 380 | * implementations just count online CPUs. | 428 | * implementations just count online CPUs. |
| 381 | */ | 429 | */ |
| 382 | #ifdef CONFIG_KVM_BOOK3S_64_HV | 430 | if (hv_enabled) |
| 383 | r = num_present_cpus(); | 431 | r = num_present_cpus(); |
| 384 | #else | 432 | else |
| 385 | r = num_online_cpus(); | 433 | r = num_online_cpus(); |
| 386 | #endif | ||
| 387 | break; | 434 | break; |
| 388 | case KVM_CAP_MAX_VCPUS: | 435 | case KVM_CAP_MAX_VCPUS: |
| 389 | r = KVM_MAX_VCPUS; | 436 | r = KVM_MAX_VCPUS; |
| @@ -407,15 +454,16 @@ long kvm_arch_dev_ioctl(struct file *filp, | |||
| 407 | return -EINVAL; | 454 | return -EINVAL; |
| 408 | } | 455 | } |
| 409 | 456 | ||
| 410 | void kvm_arch_free_memslot(struct kvm_memory_slot *free, | 457 | void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free, |
| 411 | struct kvm_memory_slot *dont) | 458 | struct kvm_memory_slot *dont) |
| 412 | { | 459 | { |
| 413 | kvmppc_core_free_memslot(free, dont); | 460 | kvmppc_core_free_memslot(kvm, free, dont); |
| 414 | } | 461 | } |
| 415 | 462 | ||
| 416 | int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages) | 463 | int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, |
| 464 | unsigned long npages) | ||
| 417 | { | 465 | { |
| 418 | return kvmppc_core_create_memslot(slot, npages); | 466 | return kvmppc_core_create_memslot(kvm, slot, npages); |
| 419 | } | 467 | } |
| 420 | 468 | ||
| 421 | void kvm_arch_memslots_updated(struct kvm *kvm) | 469 | void kvm_arch_memslots_updated(struct kvm *kvm) |
| @@ -659,6 +707,7 @@ int kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 659 | 707 | ||
| 660 | return EMULATE_DO_MMIO; | 708 | return EMULATE_DO_MMIO; |
| 661 | } | 709 | } |
| 710 | EXPORT_SYMBOL_GPL(kvmppc_handle_load); | ||
| 662 | 711 | ||
| 663 | /* Same as above, but sign extends */ | 712 | /* Same as above, but sign extends */ |
| 664 | int kvmppc_handle_loads(struct kvm_run *run, struct kvm_vcpu *vcpu, | 713 | int kvmppc_handle_loads(struct kvm_run *run, struct kvm_vcpu *vcpu, |
| @@ -720,6 +769,7 @@ int kvmppc_handle_store(struct kvm_run *run, struct kvm_vcpu *vcpu, | |||
| 720 | 769 | ||
| 721 | return EMULATE_DO_MMIO; | 770 | return EMULATE_DO_MMIO; |
| 722 | } | 771 | } |
| 772 | EXPORT_SYMBOL_GPL(kvmppc_handle_store); | ||
| 723 | 773 | ||
| 724 | int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run) | 774 | int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run) |
| 725 | { | 775 | { |
| @@ -1024,52 +1074,12 @@ long kvm_arch_vm_ioctl(struct file *filp, | |||
| 1024 | r = kvm_vm_ioctl_create_spapr_tce(kvm, &create_tce); | 1074 | r = kvm_vm_ioctl_create_spapr_tce(kvm, &create_tce); |
| 1025 | goto out; | 1075 | goto out; |
| 1026 | } | 1076 | } |
| 1027 | #endif /* CONFIG_PPC_BOOK3S_64 */ | ||
| 1028 | |||
| 1029 | #ifdef CONFIG_KVM_BOOK3S_64_HV | ||
| 1030 | case KVM_ALLOCATE_RMA: { | ||
| 1031 | struct kvm_allocate_rma rma; | ||
| 1032 | struct kvm *kvm = filp->private_data; | ||
| 1033 | |||
| 1034 | r = kvm_vm_ioctl_allocate_rma(kvm, &rma); | ||
| 1035 | if (r >= 0 && copy_to_user(argp, &rma, sizeof(rma))) | ||
| 1036 | r = -EFAULT; | ||
| 1037 | break; | ||
| 1038 | } | ||
| 1039 | |||
| 1040 | case KVM_PPC_ALLOCATE_HTAB: { | ||
| 1041 | u32 htab_order; | ||
| 1042 | |||
| 1043 | r = -EFAULT; | ||
| 1044 | if (get_user(htab_order, (u32 __user *)argp)) | ||
| 1045 | break; | ||
| 1046 | r = kvmppc_alloc_reset_hpt(kvm, &htab_order); | ||
| 1047 | if (r) | ||
| 1048 | break; | ||
| 1049 | r = -EFAULT; | ||
| 1050 | if (put_user(htab_order, (u32 __user *)argp)) | ||
| 1051 | break; | ||
| 1052 | r = 0; | ||
| 1053 | break; | ||
| 1054 | } | ||
| 1055 | |||
| 1056 | case KVM_PPC_GET_HTAB_FD: { | ||
| 1057 | struct kvm_get_htab_fd ghf; | ||
| 1058 | |||
| 1059 | r = -EFAULT; | ||
| 1060 | if (copy_from_user(&ghf, argp, sizeof(ghf))) | ||
| 1061 | break; | ||
| 1062 | r = kvm_vm_ioctl_get_htab_fd(kvm, &ghf); | ||
| 1063 | break; | ||
| 1064 | } | ||
| 1065 | #endif /* CONFIG_KVM_BOOK3S_64_HV */ | ||
| 1066 | |||
| 1067 | #ifdef CONFIG_PPC_BOOK3S_64 | ||
| 1068 | case KVM_PPC_GET_SMMU_INFO: { | 1077 | case KVM_PPC_GET_SMMU_INFO: { |
| 1069 | struct kvm_ppc_smmu_info info; | 1078 | struct kvm_ppc_smmu_info info; |
| 1079 | struct kvm *kvm = filp->private_data; | ||
| 1070 | 1080 | ||
| 1071 | memset(&info, 0, sizeof(info)); | 1081 | memset(&info, 0, sizeof(info)); |
| 1072 | r = kvm_vm_ioctl_get_smmu_info(kvm, &info); | 1082 | r = kvm->arch.kvm_ops->get_smmu_info(kvm, &info); |
| 1073 | if (r >= 0 && copy_to_user(argp, &info, sizeof(info))) | 1083 | if (r >= 0 && copy_to_user(argp, &info, sizeof(info))) |
| 1074 | r = -EFAULT; | 1084 | r = -EFAULT; |
| 1075 | break; | 1085 | break; |
| @@ -1080,11 +1090,15 @@ long kvm_arch_vm_ioctl(struct file *filp, | |||
| 1080 | r = kvm_vm_ioctl_rtas_define_token(kvm, argp); | 1090 | r = kvm_vm_ioctl_rtas_define_token(kvm, argp); |
| 1081 | break; | 1091 | break; |
| 1082 | } | 1092 | } |
| 1083 | #endif /* CONFIG_PPC_BOOK3S_64 */ | 1093 | default: { |
| 1094 | struct kvm *kvm = filp->private_data; | ||
| 1095 | r = kvm->arch.kvm_ops->arch_vm_ioctl(filp, ioctl, arg); | ||
| 1096 | } | ||
| 1097 | #else /* CONFIG_PPC_BOOK3S_64 */ | ||
| 1084 | default: | 1098 | default: |
| 1085 | r = -ENOTTY; | 1099 | r = -ENOTTY; |
| 1100 | #endif | ||
| 1086 | } | 1101 | } |
| 1087 | |||
| 1088 | out: | 1102 | out: |
| 1089 | return r; | 1103 | return r; |
| 1090 | } | 1104 | } |
| @@ -1106,22 +1120,26 @@ long kvmppc_alloc_lpid(void) | |||
| 1106 | 1120 | ||
| 1107 | return lpid; | 1121 | return lpid; |
| 1108 | } | 1122 | } |
| 1123 | EXPORT_SYMBOL_GPL(kvmppc_alloc_lpid); | ||
| 1109 | 1124 | ||
| 1110 | void kvmppc_claim_lpid(long lpid) | 1125 | void kvmppc_claim_lpid(long lpid) |
| 1111 | { | 1126 | { |
| 1112 | set_bit(lpid, lpid_inuse); | 1127 | set_bit(lpid, lpid_inuse); |
| 1113 | } | 1128 | } |
| 1129 | EXPORT_SYMBOL_GPL(kvmppc_claim_lpid); | ||
| 1114 | 1130 | ||
| 1115 | void kvmppc_free_lpid(long lpid) | 1131 | void kvmppc_free_lpid(long lpid) |
| 1116 | { | 1132 | { |
| 1117 | clear_bit(lpid, lpid_inuse); | 1133 | clear_bit(lpid, lpid_inuse); |
| 1118 | } | 1134 | } |
| 1135 | EXPORT_SYMBOL_GPL(kvmppc_free_lpid); | ||
| 1119 | 1136 | ||
| 1120 | void kvmppc_init_lpid(unsigned long nr_lpids_param) | 1137 | void kvmppc_init_lpid(unsigned long nr_lpids_param) |
| 1121 | { | 1138 | { |
| 1122 | nr_lpids = min_t(unsigned long, KVMPPC_NR_LPIDS, nr_lpids_param); | 1139 | nr_lpids = min_t(unsigned long, KVMPPC_NR_LPIDS, nr_lpids_param); |
| 1123 | memset(lpid_inuse, 0, sizeof(lpid_inuse)); | 1140 | memset(lpid_inuse, 0, sizeof(lpid_inuse)); |
| 1124 | } | 1141 | } |
| 1142 | EXPORT_SYMBOL_GPL(kvmppc_init_lpid); | ||
| 1125 | 1143 | ||
| 1126 | int kvm_arch_init(void *opaque) | 1144 | int kvm_arch_init(void *opaque) |
| 1127 | { | 1145 | { |
| @@ -1130,4 +1148,5 @@ int kvm_arch_init(void *opaque) | |||
| 1130 | 1148 | ||
| 1131 | void kvm_arch_exit(void) | 1149 | void kvm_arch_exit(void) |
| 1132 | { | 1150 | { |
| 1151 | |||
| 1133 | } | 1152 | } |
diff --git a/arch/powerpc/kvm/trace.h b/arch/powerpc/kvm/trace.h index e326489a5420..2e0e67ef3544 100644 --- a/arch/powerpc/kvm/trace.h +++ b/arch/powerpc/kvm/trace.h | |||
| @@ -31,126 +31,6 @@ TRACE_EVENT(kvm_ppc_instr, | |||
| 31 | __entry->inst, __entry->pc, __entry->emulate) | 31 | __entry->inst, __entry->pc, __entry->emulate) |
| 32 | ); | 32 | ); |
| 33 | 33 | ||
| 34 | #ifdef CONFIG_PPC_BOOK3S | ||
| 35 | #define kvm_trace_symbol_exit \ | ||
| 36 | {0x100, "SYSTEM_RESET"}, \ | ||
| 37 | {0x200, "MACHINE_CHECK"}, \ | ||
| 38 | {0x300, "DATA_STORAGE"}, \ | ||
| 39 | {0x380, "DATA_SEGMENT"}, \ | ||
| 40 | {0x400, "INST_STORAGE"}, \ | ||
| 41 | {0x480, "INST_SEGMENT"}, \ | ||
| 42 | {0x500, "EXTERNAL"}, \ | ||
| 43 | {0x501, "EXTERNAL_LEVEL"}, \ | ||
| 44 | {0x502, "EXTERNAL_HV"}, \ | ||
| 45 | {0x600, "ALIGNMENT"}, \ | ||
| 46 | {0x700, "PROGRAM"}, \ | ||
| 47 | {0x800, "FP_UNAVAIL"}, \ | ||
| 48 | {0x900, "DECREMENTER"}, \ | ||
| 49 | {0x980, "HV_DECREMENTER"}, \ | ||
| 50 | {0xc00, "SYSCALL"}, \ | ||
| 51 | {0xd00, "TRACE"}, \ | ||
| 52 | {0xe00, "H_DATA_STORAGE"}, \ | ||
| 53 | {0xe20, "H_INST_STORAGE"}, \ | ||
| 54 | {0xe40, "H_EMUL_ASSIST"}, \ | ||
| 55 | {0xf00, "PERFMON"}, \ | ||
| 56 | {0xf20, "ALTIVEC"}, \ | ||
| 57 | {0xf40, "VSX"} | ||
| 58 | #else | ||
| 59 | #define kvm_trace_symbol_exit \ | ||
| 60 | {0, "CRITICAL"}, \ | ||
| 61 | {1, "MACHINE_CHECK"}, \ | ||
| 62 | {2, "DATA_STORAGE"}, \ | ||
| 63 | {3, "INST_STORAGE"}, \ | ||
| 64 | {4, "EXTERNAL"}, \ | ||
| 65 | {5, "ALIGNMENT"}, \ | ||
| 66 | {6, "PROGRAM"}, \ | ||
| 67 | {7, "FP_UNAVAIL"}, \ | ||
| 68 | {8, "SYSCALL"}, \ | ||
| 69 | {9, "AP_UNAVAIL"}, \ | ||
| 70 | {10, "DECREMENTER"}, \ | ||
| 71 | {11, "FIT"}, \ | ||
| 72 | {12, "WATCHDOG"}, \ | ||
| 73 | {13, "DTLB_MISS"}, \ | ||
| 74 | {14, "ITLB_MISS"}, \ | ||
| 75 | {15, "DEBUG"}, \ | ||
| 76 | {32, "SPE_UNAVAIL"}, \ | ||
| 77 | {33, "SPE_FP_DATA"}, \ | ||
| 78 | {34, "SPE_FP_ROUND"}, \ | ||
| 79 | {35, "PERFORMANCE_MONITOR"}, \ | ||
| 80 | {36, "DOORBELL"}, \ | ||
| 81 | {37, "DOORBELL_CRITICAL"}, \ | ||
| 82 | {38, "GUEST_DBELL"}, \ | ||
| 83 | {39, "GUEST_DBELL_CRIT"}, \ | ||
| 84 | {40, "HV_SYSCALL"}, \ | ||
| 85 | {41, "HV_PRIV"} | ||
| 86 | #endif | ||
| 87 | |||
| 88 | TRACE_EVENT(kvm_exit, | ||
| 89 | TP_PROTO(unsigned int exit_nr, struct kvm_vcpu *vcpu), | ||
| 90 | TP_ARGS(exit_nr, vcpu), | ||
| 91 | |||
| 92 | TP_STRUCT__entry( | ||
| 93 | __field( unsigned int, exit_nr ) | ||
| 94 | __field( unsigned long, pc ) | ||
| 95 | __field( unsigned long, msr ) | ||
| 96 | __field( unsigned long, dar ) | ||
| 97 | #ifdef CONFIG_KVM_BOOK3S_PR | ||
| 98 | __field( unsigned long, srr1 ) | ||
| 99 | #endif | ||
| 100 | __field( unsigned long, last_inst ) | ||
| 101 | ), | ||
| 102 | |||
| 103 | TP_fast_assign( | ||
| 104 | #ifdef CONFIG_KVM_BOOK3S_PR | ||
| 105 | struct kvmppc_book3s_shadow_vcpu *svcpu; | ||
| 106 | #endif | ||
| 107 | __entry->exit_nr = exit_nr; | ||
| 108 | __entry->pc = kvmppc_get_pc(vcpu); | ||
| 109 | __entry->dar = kvmppc_get_fault_dar(vcpu); | ||
| 110 | __entry->msr = vcpu->arch.shared->msr; | ||
| 111 | #ifdef CONFIG_KVM_BOOK3S_PR | ||
| 112 | svcpu = svcpu_get(vcpu); | ||
| 113 | __entry->srr1 = svcpu->shadow_srr1; | ||
| 114 | svcpu_put(svcpu); | ||
| 115 | #endif | ||
| 116 | __entry->last_inst = vcpu->arch.last_inst; | ||
| 117 | ), | ||
| 118 | |||
| 119 | TP_printk("exit=%s" | ||
| 120 | " | pc=0x%lx" | ||
| 121 | " | msr=0x%lx" | ||
| 122 | " | dar=0x%lx" | ||
| 123 | #ifdef CONFIG_KVM_BOOK3S_PR | ||
| 124 | " | srr1=0x%lx" | ||
| 125 | #endif | ||
| 126 | " | last_inst=0x%lx" | ||
| 127 | , | ||
| 128 | __print_symbolic(__entry->exit_nr, kvm_trace_symbol_exit), | ||
| 129 | __entry->pc, | ||
| 130 | __entry->msr, | ||
| 131 | __entry->dar, | ||
| 132 | #ifdef CONFIG_KVM_BOOK3S_PR | ||
| 133 | __entry->srr1, | ||
| 134 | #endif | ||
| 135 | __entry->last_inst | ||
| 136 | ) | ||
| 137 | ); | ||
| 138 | |||
| 139 | TRACE_EVENT(kvm_unmap_hva, | ||
| 140 | TP_PROTO(unsigned long hva), | ||
| 141 | TP_ARGS(hva), | ||
| 142 | |||
| 143 | TP_STRUCT__entry( | ||
| 144 | __field( unsigned long, hva ) | ||
| 145 | ), | ||
| 146 | |||
| 147 | TP_fast_assign( | ||
| 148 | __entry->hva = hva; | ||
| 149 | ), | ||
| 150 | |||
| 151 | TP_printk("unmap hva 0x%lx\n", __entry->hva) | ||
| 152 | ); | ||
| 153 | |||
| 154 | TRACE_EVENT(kvm_stlb_inval, | 34 | TRACE_EVENT(kvm_stlb_inval, |
| 155 | TP_PROTO(unsigned int stlb_index), | 35 | TP_PROTO(unsigned int stlb_index), |
| 156 | TP_ARGS(stlb_index), | 36 | TP_ARGS(stlb_index), |
| @@ -236,315 +116,6 @@ TRACE_EVENT(kvm_check_requests, | |||
| 236 | __entry->cpu_nr, __entry->requests) | 116 | __entry->cpu_nr, __entry->requests) |
| 237 | ); | 117 | ); |
| 238 | 118 | ||
| 239 | |||
| 240 | /************************************************************************* | ||
| 241 | * Book3S trace points * | ||
| 242 | *************************************************************************/ | ||
| 243 | |||
| 244 | #ifdef CONFIG_KVM_BOOK3S_PR | ||
| 245 | |||
| 246 | TRACE_EVENT(kvm_book3s_reenter, | ||
| 247 | TP_PROTO(int r, struct kvm_vcpu *vcpu), | ||
| 248 | TP_ARGS(r, vcpu), | ||
| 249 | |||
| 250 | TP_STRUCT__entry( | ||
| 251 | __field( unsigned int, r ) | ||
| 252 | __field( unsigned long, pc ) | ||
| 253 | ), | ||
| 254 | |||
| 255 | TP_fast_assign( | ||
| 256 | __entry->r = r; | ||
| 257 | __entry->pc = kvmppc_get_pc(vcpu); | ||
| 258 | ), | ||
| 259 | |||
| 260 | TP_printk("reentry r=%d | pc=0x%lx", __entry->r, __entry->pc) | ||
| 261 | ); | ||
| 262 | |||
| 263 | #ifdef CONFIG_PPC_BOOK3S_64 | ||
| 264 | |||
| 265 | TRACE_EVENT(kvm_book3s_64_mmu_map, | ||
| 266 | TP_PROTO(int rflags, ulong hpteg, ulong va, pfn_t hpaddr, | ||
| 267 | struct kvmppc_pte *orig_pte), | ||
| 268 | TP_ARGS(rflags, hpteg, va, hpaddr, orig_pte), | ||
| 269 | |||
| 270 | TP_STRUCT__entry( | ||
| 271 | __field( unsigned char, flag_w ) | ||
| 272 | __field( unsigned char, flag_x ) | ||
| 273 | __field( unsigned long, eaddr ) | ||
| 274 | __field( unsigned long, hpteg ) | ||
| 275 | __field( unsigned long, va ) | ||
| 276 | __field( unsigned long long, vpage ) | ||
| 277 | __field( unsigned long, hpaddr ) | ||
| 278 | ), | ||
| 279 | |||
| 280 | TP_fast_assign( | ||
| 281 | __entry->flag_w = ((rflags & HPTE_R_PP) == 3) ? '-' : 'w'; | ||
| 282 | __entry->flag_x = (rflags & HPTE_R_N) ? '-' : 'x'; | ||
| 283 | __entry->eaddr = orig_pte->eaddr; | ||
| 284 | __entry->hpteg = hpteg; | ||
| 285 | __entry->va = va; | ||
| 286 | __entry->vpage = orig_pte->vpage; | ||
| 287 | __entry->hpaddr = hpaddr; | ||
| 288 | ), | ||
| 289 | |||
| 290 | TP_printk("KVM: %c%c Map 0x%lx: [%lx] 0x%lx (0x%llx) -> %lx", | ||
| 291 | __entry->flag_w, __entry->flag_x, __entry->eaddr, | ||
| 292 | __entry->hpteg, __entry->va, __entry->vpage, __entry->hpaddr) | ||
| 293 | ); | ||
| 294 | |||
| 295 | #endif /* CONFIG_PPC_BOOK3S_64 */ | ||
| 296 | |||
| 297 | TRACE_EVENT(kvm_book3s_mmu_map, | ||
| 298 | TP_PROTO(struct hpte_cache *pte), | ||
| 299 | TP_ARGS(pte), | ||
| 300 | |||
| 301 | TP_STRUCT__entry( | ||
| 302 | __field( u64, host_vpn ) | ||
| 303 | __field( u64, pfn ) | ||
| 304 | __field( ulong, eaddr ) | ||
| 305 | __field( u64, vpage ) | ||
| 306 | __field( ulong, raddr ) | ||
| 307 | __field( int, flags ) | ||
| 308 | ), | ||
| 309 | |||
| 310 | TP_fast_assign( | ||
| 311 | __entry->host_vpn = pte->host_vpn; | ||
| 312 | __entry->pfn = pte->pfn; | ||
| 313 | __entry->eaddr = pte->pte.eaddr; | ||
| 314 | __entry->vpage = pte->pte.vpage; | ||
| 315 | __entry->raddr = pte->pte.raddr; | ||
| 316 | __entry->flags = (pte->pte.may_read ? 0x4 : 0) | | ||
| 317 | (pte->pte.may_write ? 0x2 : 0) | | ||
| 318 | (pte->pte.may_execute ? 0x1 : 0); | ||
| 319 | ), | ||
| 320 | |||
| 321 | TP_printk("Map: hvpn=%llx pfn=%llx ea=%lx vp=%llx ra=%lx [%x]", | ||
| 322 | __entry->host_vpn, __entry->pfn, __entry->eaddr, | ||
| 323 | __entry->vpage, __entry->raddr, __entry->flags) | ||
| 324 | ); | ||
| 325 | |||
| 326 | TRACE_EVENT(kvm_book3s_mmu_invalidate, | ||
| 327 | TP_PROTO(struct hpte_cache *pte), | ||
| 328 | TP_ARGS(pte), | ||
| 329 | |||
| 330 | TP_STRUCT__entry( | ||
| 331 | __field( u64, host_vpn ) | ||
| 332 | __field( u64, pfn ) | ||
| 333 | __field( ulong, eaddr ) | ||
| 334 | __field( u64, vpage ) | ||
| 335 | __field( ulong, raddr ) | ||
| 336 | __field( int, flags ) | ||
| 337 | ), | ||
| 338 | |||
| 339 | TP_fast_assign( | ||
| 340 | __entry->host_vpn = pte->host_vpn; | ||
| 341 | __entry->pfn = pte->pfn; | ||
| 342 | __entry->eaddr = pte->pte.eaddr; | ||
| 343 | __entry->vpage = pte->pte.vpage; | ||
| 344 | __entry->raddr = pte->pte.raddr; | ||
| 345 | __entry->flags = (pte->pte.may_read ? 0x4 : 0) | | ||
| 346 | (pte->pte.may_write ? 0x2 : 0) | | ||
| 347 | (pte->pte.may_execute ? 0x1 : 0); | ||
| 348 | ), | ||
| 349 | |||
| 350 | TP_printk("Flush: hva=%llx pfn=%llx ea=%lx vp=%llx ra=%lx [%x]", | ||
| 351 | __entry->host_vpn, __entry->pfn, __entry->eaddr, | ||
| 352 | __entry->vpage, __entry->raddr, __entry->flags) | ||
| 353 | ); | ||
| 354 | |||
| 355 | TRACE_EVENT(kvm_book3s_mmu_flush, | ||
| 356 | TP_PROTO(const char *type, struct kvm_vcpu *vcpu, unsigned long long p1, | ||
| 357 | unsigned long long p2), | ||
| 358 | TP_ARGS(type, vcpu, p1, p2), | ||
| 359 | |||
| 360 | TP_STRUCT__entry( | ||
| 361 | __field( int, count ) | ||
| 362 | __field( unsigned long long, p1 ) | ||
| 363 | __field( unsigned long long, p2 ) | ||
| 364 | __field( const char *, type ) | ||
| 365 | ), | ||
| 366 | |||
| 367 | TP_fast_assign( | ||
| 368 | __entry->count = to_book3s(vcpu)->hpte_cache_count; | ||
| 369 | __entry->p1 = p1; | ||
| 370 | __entry->p2 = p2; | ||
| 371 | __entry->type = type; | ||
| 372 | ), | ||
| 373 | |||
| 374 | TP_printk("Flush %d %sPTEs: %llx - %llx", | ||
| 375 | __entry->count, __entry->type, __entry->p1, __entry->p2) | ||
| 376 | ); | ||
| 377 | |||
| 378 | TRACE_EVENT(kvm_book3s_slb_found, | ||
| 379 | TP_PROTO(unsigned long long gvsid, unsigned long long hvsid), | ||
| 380 | TP_ARGS(gvsid, hvsid), | ||
| 381 | |||
| 382 | TP_STRUCT__entry( | ||
| 383 | __field( unsigned long long, gvsid ) | ||
| 384 | __field( unsigned long long, hvsid ) | ||
| 385 | ), | ||
| 386 | |||
| 387 | TP_fast_assign( | ||
| 388 | __entry->gvsid = gvsid; | ||
| 389 | __entry->hvsid = hvsid; | ||
| 390 | ), | ||
| 391 | |||
| 392 | TP_printk("%llx -> %llx", __entry->gvsid, __entry->hvsid) | ||
| 393 | ); | ||
| 394 | |||
| 395 | TRACE_EVENT(kvm_book3s_slb_fail, | ||
| 396 | TP_PROTO(u16 sid_map_mask, unsigned long long gvsid), | ||
| 397 | TP_ARGS(sid_map_mask, gvsid), | ||
| 398 | |||
| 399 | TP_STRUCT__entry( | ||
| 400 | __field( unsigned short, sid_map_mask ) | ||
| 401 | __field( unsigned long long, gvsid ) | ||
| 402 | ), | ||
| 403 | |||
| 404 | TP_fast_assign( | ||
| 405 | __entry->sid_map_mask = sid_map_mask; | ||
| 406 | __entry->gvsid = gvsid; | ||
| 407 | ), | ||
| 408 | |||
| 409 | TP_printk("%x/%x: %llx", __entry->sid_map_mask, | ||
| 410 | SID_MAP_MASK - __entry->sid_map_mask, __entry->gvsid) | ||
| 411 | ); | ||
| 412 | |||
| 413 | TRACE_EVENT(kvm_book3s_slb_map, | ||
| 414 | TP_PROTO(u16 sid_map_mask, unsigned long long gvsid, | ||
| 415 | unsigned long long hvsid), | ||
| 416 | TP_ARGS(sid_map_mask, gvsid, hvsid), | ||
| 417 | |||
| 418 | TP_STRUCT__entry( | ||
| 419 | __field( unsigned short, sid_map_mask ) | ||
| 420 | __field( unsigned long long, guest_vsid ) | ||
| 421 | __field( unsigned long long, host_vsid ) | ||
| 422 | ), | ||
| 423 | |||
| 424 | TP_fast_assign( | ||
| 425 | __entry->sid_map_mask = sid_map_mask; | ||
| 426 | __entry->guest_vsid = gvsid; | ||
| 427 | __entry->host_vsid = hvsid; | ||
| 428 | ), | ||
| 429 | |||
| 430 | TP_printk("%x: %llx -> %llx", __entry->sid_map_mask, | ||
| 431 | __entry->guest_vsid, __entry->host_vsid) | ||
| 432 | ); | ||
| 433 | |||
| 434 | TRACE_EVENT(kvm_book3s_slbmte, | ||
| 435 | TP_PROTO(u64 slb_vsid, u64 slb_esid), | ||
| 436 | TP_ARGS(slb_vsid, slb_esid), | ||
| 437 | |||
| 438 | TP_STRUCT__entry( | ||
| 439 | __field( u64, slb_vsid ) | ||
| 440 | __field( u64, slb_esid ) | ||
| 441 | ), | ||
| 442 | |||
| 443 | TP_fast_assign( | ||
| 444 | __entry->slb_vsid = slb_vsid; | ||
| 445 | __entry->slb_esid = slb_esid; | ||
| 446 | ), | ||
| 447 | |||
| 448 | TP_printk("%llx, %llx", __entry->slb_vsid, __entry->slb_esid) | ||
| 449 | ); | ||
| 450 | |||
| 451 | #endif /* CONFIG_PPC_BOOK3S */ | ||
| 452 | |||
| 453 | |||
| 454 | /************************************************************************* | ||
| 455 | * Book3E trace points * | ||
| 456 | *************************************************************************/ | ||
| 457 | |||
| 458 | #ifdef CONFIG_BOOKE | ||
| 459 | |||
| 460 | TRACE_EVENT(kvm_booke206_stlb_write, | ||
| 461 | TP_PROTO(__u32 mas0, __u32 mas8, __u32 mas1, __u64 mas2, __u64 mas7_3), | ||
| 462 | TP_ARGS(mas0, mas8, mas1, mas2, mas7_3), | ||
| 463 | |||
| 464 | TP_STRUCT__entry( | ||
| 465 | __field( __u32, mas0 ) | ||
| 466 | __field( __u32, mas8 ) | ||
| 467 | __field( __u32, mas1 ) | ||
| 468 | __field( __u64, mas2 ) | ||
| 469 | __field( __u64, mas7_3 ) | ||
| 470 | ), | ||
| 471 | |||
| 472 | TP_fast_assign( | ||
| 473 | __entry->mas0 = mas0; | ||
| 474 | __entry->mas8 = mas8; | ||
| 475 | __entry->mas1 = mas1; | ||
| 476 | __entry->mas2 = mas2; | ||
| 477 | __entry->mas7_3 = mas7_3; | ||
| 478 | ), | ||
| 479 | |||
| 480 | TP_printk("mas0=%x mas8=%x mas1=%x mas2=%llx mas7_3=%llx", | ||
| 481 | __entry->mas0, __entry->mas8, __entry->mas1, | ||
| 482 | __entry->mas2, __entry->mas7_3) | ||
| 483 | ); | ||
| 484 | |||
| 485 | TRACE_EVENT(kvm_booke206_gtlb_write, | ||
| 486 | TP_PROTO(__u32 mas0, __u32 mas1, __u64 mas2, __u64 mas7_3), | ||
| 487 | TP_ARGS(mas0, mas1, mas2, mas7_3), | ||
| 488 | |||
| 489 | TP_STRUCT__entry( | ||
| 490 | __field( __u32, mas0 ) | ||
| 491 | __field( __u32, mas1 ) | ||
| 492 | __field( __u64, mas2 ) | ||
| 493 | __field( __u64, mas7_3 ) | ||
| 494 | ), | ||
| 495 | |||
| 496 | TP_fast_assign( | ||
| 497 | __entry->mas0 = mas0; | ||
| 498 | __entry->mas1 = mas1; | ||
| 499 | __entry->mas2 = mas2; | ||
| 500 | __entry->mas7_3 = mas7_3; | ||
| 501 | ), | ||
| 502 | |||
| 503 | TP_printk("mas0=%x mas1=%x mas2=%llx mas7_3=%llx", | ||
| 504 | __entry->mas0, __entry->mas1, | ||
| 505 | __entry->mas2, __entry->mas7_3) | ||
| 506 | ); | ||
| 507 | |||
| 508 | TRACE_EVENT(kvm_booke206_ref_release, | ||
| 509 | TP_PROTO(__u64 pfn, __u32 flags), | ||
| 510 | TP_ARGS(pfn, flags), | ||
| 511 | |||
| 512 | TP_STRUCT__entry( | ||
| 513 | __field( __u64, pfn ) | ||
| 514 | __field( __u32, flags ) | ||
| 515 | ), | ||
| 516 | |||
| 517 | TP_fast_assign( | ||
| 518 | __entry->pfn = pfn; | ||
| 519 | __entry->flags = flags; | ||
| 520 | ), | ||
| 521 | |||
| 522 | TP_printk("pfn=%llx flags=%x", | ||
| 523 | __entry->pfn, __entry->flags) | ||
| 524 | ); | ||
| 525 | |||
| 526 | TRACE_EVENT(kvm_booke_queue_irqprio, | ||
| 527 | TP_PROTO(struct kvm_vcpu *vcpu, unsigned int priority), | ||
| 528 | TP_ARGS(vcpu, priority), | ||
| 529 | |||
| 530 | TP_STRUCT__entry( | ||
| 531 | __field( __u32, cpu_nr ) | ||
| 532 | __field( __u32, priority ) | ||
| 533 | __field( unsigned long, pending ) | ||
| 534 | ), | ||
| 535 | |||
| 536 | TP_fast_assign( | ||
| 537 | __entry->cpu_nr = vcpu->vcpu_id; | ||
| 538 | __entry->priority = priority; | ||
| 539 | __entry->pending = vcpu->arch.pending_exceptions; | ||
| 540 | ), | ||
| 541 | |||
| 542 | TP_printk("vcpu=%x prio=%x pending=%lx", | ||
| 543 | __entry->cpu_nr, __entry->priority, __entry->pending) | ||
| 544 | ); | ||
| 545 | |||
| 546 | #endif | ||
| 547 | |||
| 548 | #endif /* _TRACE_KVM_H */ | 119 | #endif /* _TRACE_KVM_H */ |
| 549 | 120 | ||
| 550 | /* This part must be outside protection */ | 121 | /* This part must be outside protection */ |
diff --git a/arch/powerpc/kvm/trace_booke.h b/arch/powerpc/kvm/trace_booke.h new file mode 100644 index 000000000000..f7537cf26ce7 --- /dev/null +++ b/arch/powerpc/kvm/trace_booke.h | |||
| @@ -0,0 +1,177 @@ | |||
| 1 | #if !defined(_TRACE_KVM_BOOKE_H) || defined(TRACE_HEADER_MULTI_READ) | ||
| 2 | #define _TRACE_KVM_BOOKE_H | ||
| 3 | |||
| 4 | #include <linux/tracepoint.h> | ||
| 5 | |||
| 6 | #undef TRACE_SYSTEM | ||
| 7 | #define TRACE_SYSTEM kvm_booke | ||
| 8 | #define TRACE_INCLUDE_PATH . | ||
| 9 | #define TRACE_INCLUDE_FILE trace_booke | ||
| 10 | |||
| 11 | #define kvm_trace_symbol_exit \ | ||
| 12 | {0, "CRITICAL"}, \ | ||
| 13 | {1, "MACHINE_CHECK"}, \ | ||
| 14 | {2, "DATA_STORAGE"}, \ | ||
| 15 | {3, "INST_STORAGE"}, \ | ||
| 16 | {4, "EXTERNAL"}, \ | ||
| 17 | {5, "ALIGNMENT"}, \ | ||
| 18 | {6, "PROGRAM"}, \ | ||
| 19 | {7, "FP_UNAVAIL"}, \ | ||
| 20 | {8, "SYSCALL"}, \ | ||
| 21 | {9, "AP_UNAVAIL"}, \ | ||
| 22 | {10, "DECREMENTER"}, \ | ||
| 23 | {11, "FIT"}, \ | ||
| 24 | {12, "WATCHDOG"}, \ | ||
| 25 | {13, "DTLB_MISS"}, \ | ||
| 26 | {14, "ITLB_MISS"}, \ | ||
| 27 | {15, "DEBUG"}, \ | ||
| 28 | {32, "SPE_UNAVAIL"}, \ | ||
| 29 | {33, "SPE_FP_DATA"}, \ | ||
| 30 | {34, "SPE_FP_ROUND"}, \ | ||
| 31 | {35, "PERFORMANCE_MONITOR"}, \ | ||
| 32 | {36, "DOORBELL"}, \ | ||
| 33 | {37, "DOORBELL_CRITICAL"}, \ | ||
| 34 | {38, "GUEST_DBELL"}, \ | ||
| 35 | {39, "GUEST_DBELL_CRIT"}, \ | ||
| 36 | {40, "HV_SYSCALL"}, \ | ||
| 37 | {41, "HV_PRIV"} | ||
| 38 | |||
| 39 | TRACE_EVENT(kvm_exit, | ||
| 40 | TP_PROTO(unsigned int exit_nr, struct kvm_vcpu *vcpu), | ||
| 41 | TP_ARGS(exit_nr, vcpu), | ||
| 42 | |||
| 43 | TP_STRUCT__entry( | ||
| 44 | __field( unsigned int, exit_nr ) | ||
| 45 | __field( unsigned long, pc ) | ||
| 46 | __field( unsigned long, msr ) | ||
| 47 | __field( unsigned long, dar ) | ||
| 48 | __field( unsigned long, last_inst ) | ||
| 49 | ), | ||
| 50 | |||
| 51 | TP_fast_assign( | ||
| 52 | __entry->exit_nr = exit_nr; | ||
| 53 | __entry->pc = kvmppc_get_pc(vcpu); | ||
| 54 | __entry->dar = kvmppc_get_fault_dar(vcpu); | ||
| 55 | __entry->msr = vcpu->arch.shared->msr; | ||
| 56 | __entry->last_inst = vcpu->arch.last_inst; | ||
| 57 | ), | ||
| 58 | |||
| 59 | TP_printk("exit=%s" | ||
| 60 | " | pc=0x%lx" | ||
| 61 | " | msr=0x%lx" | ||
| 62 | " | dar=0x%lx" | ||
| 63 | " | last_inst=0x%lx" | ||
| 64 | , | ||
| 65 | __print_symbolic(__entry->exit_nr, kvm_trace_symbol_exit), | ||
| 66 | __entry->pc, | ||
| 67 | __entry->msr, | ||
| 68 | __entry->dar, | ||
| 69 | __entry->last_inst | ||
| 70 | ) | ||
| 71 | ); | ||
| 72 | |||
| 73 | TRACE_EVENT(kvm_unmap_hva, | ||
| 74 | TP_PROTO(unsigned long hva), | ||
| 75 | TP_ARGS(hva), | ||
| 76 | |||
| 77 | TP_STRUCT__entry( | ||
| 78 | __field( unsigned long, hva ) | ||
| 79 | ), | ||
| 80 | |||
| 81 | TP_fast_assign( | ||
| 82 | __entry->hva = hva; | ||
| 83 | ), | ||
| 84 | |||
| 85 | TP_printk("unmap hva 0x%lx\n", __entry->hva) | ||
| 86 | ); | ||
| 87 | |||
| 88 | TRACE_EVENT(kvm_booke206_stlb_write, | ||
| 89 | TP_PROTO(__u32 mas0, __u32 mas8, __u32 mas1, __u64 mas2, __u64 mas7_3), | ||
| 90 | TP_ARGS(mas0, mas8, mas1, mas2, mas7_3), | ||
| 91 | |||
| 92 | TP_STRUCT__entry( | ||
| 93 | __field( __u32, mas0 ) | ||
| 94 | __field( __u32, mas8 ) | ||
| 95 | __field( __u32, mas1 ) | ||
| 96 | __field( __u64, mas2 ) | ||
| 97 | __field( __u64, mas7_3 ) | ||
| 98 | ), | ||
| 99 | |||
| 100 | TP_fast_assign( | ||
| 101 | __entry->mas0 = mas0; | ||
| 102 | __entry->mas8 = mas8; | ||
| 103 | __entry->mas1 = mas1; | ||
| 104 | __entry->mas2 = mas2; | ||
| 105 | __entry->mas7_3 = mas7_3; | ||
| 106 | ), | ||
| 107 | |||
| 108 | TP_printk("mas0=%x mas8=%x mas1=%x mas2=%llx mas7_3=%llx", | ||
| 109 | __entry->mas0, __entry->mas8, __entry->mas1, | ||
| 110 | __entry->mas2, __entry->mas7_3) | ||
| 111 | ); | ||
| 112 | |||
| 113 | TRACE_EVENT(kvm_booke206_gtlb_write, | ||
| 114 | TP_PROTO(__u32 mas0, __u32 mas1, __u64 mas2, __u64 mas7_3), | ||
| 115 | TP_ARGS(mas0, mas1, mas2, mas7_3), | ||
| 116 | |||
| 117 | TP_STRUCT__entry( | ||
| 118 | __field( __u32, mas0 ) | ||
| 119 | __field( __u32, mas1 ) | ||
| 120 | __field( __u64, mas2 ) | ||
| 121 | __field( __u64, mas7_3 ) | ||
| 122 | ), | ||
| 123 | |||
| 124 | TP_fast_assign( | ||
| 125 | __entry->mas0 = mas0; | ||
| 126 | __entry->mas1 = mas1; | ||
| 127 | __entry->mas2 = mas2; | ||
| 128 | __entry->mas7_3 = mas7_3; | ||
| 129 | ), | ||
| 130 | |||
| 131 | TP_printk("mas0=%x mas1=%x mas2=%llx mas7_3=%llx", | ||
| 132 | __entry->mas0, __entry->mas1, | ||
| 133 | __entry->mas2, __entry->mas7_3) | ||
| 134 | ); | ||
| 135 | |||
| 136 | TRACE_EVENT(kvm_booke206_ref_release, | ||
| 137 | TP_PROTO(__u64 pfn, __u32 flags), | ||
| 138 | TP_ARGS(pfn, flags), | ||
| 139 | |||
| 140 | TP_STRUCT__entry( | ||
| 141 | __field( __u64, pfn ) | ||
| 142 | __field( __u32, flags ) | ||
| 143 | ), | ||
| 144 | |||
| 145 | TP_fast_assign( | ||
| 146 | __entry->pfn = pfn; | ||
| 147 | __entry->flags = flags; | ||
| 148 | ), | ||
| 149 | |||
| 150 | TP_printk("pfn=%llx flags=%x", | ||
| 151 | __entry->pfn, __entry->flags) | ||
| 152 | ); | ||
| 153 | |||
| 154 | TRACE_EVENT(kvm_booke_queue_irqprio, | ||
| 155 | TP_PROTO(struct kvm_vcpu *vcpu, unsigned int priority), | ||
| 156 | TP_ARGS(vcpu, priority), | ||
| 157 | |||
| 158 | TP_STRUCT__entry( | ||
| 159 | __field( __u32, cpu_nr ) | ||
| 160 | __field( __u32, priority ) | ||
| 161 | __field( unsigned long, pending ) | ||
| 162 | ), | ||
| 163 | |||
| 164 | TP_fast_assign( | ||
| 165 | __entry->cpu_nr = vcpu->vcpu_id; | ||
| 166 | __entry->priority = priority; | ||
| 167 | __entry->pending = vcpu->arch.pending_exceptions; | ||
| 168 | ), | ||
| 169 | |||
| 170 | TP_printk("vcpu=%x prio=%x pending=%lx", | ||
| 171 | __entry->cpu_nr, __entry->priority, __entry->pending) | ||
| 172 | ); | ||
| 173 | |||
| 174 | #endif | ||
| 175 | |||
| 176 | /* This part must be outside protection */ | ||
| 177 | #include <trace/define_trace.h> | ||
diff --git a/arch/powerpc/kvm/trace_pr.h b/arch/powerpc/kvm/trace_pr.h new file mode 100644 index 000000000000..8b22e4748344 --- /dev/null +++ b/arch/powerpc/kvm/trace_pr.h | |||
| @@ -0,0 +1,297 @@ | |||
| 1 | |||
| 2 | #if !defined(_TRACE_KVM_PR_H) || defined(TRACE_HEADER_MULTI_READ) | ||
| 3 | #define _TRACE_KVM_PR_H | ||
| 4 | |||
| 5 | #include <linux/tracepoint.h> | ||
| 6 | |||
| 7 | #undef TRACE_SYSTEM | ||
| 8 | #define TRACE_SYSTEM kvm_pr | ||
| 9 | #define TRACE_INCLUDE_PATH . | ||
| 10 | #define TRACE_INCLUDE_FILE trace_pr | ||
| 11 | |||
| 12 | #define kvm_trace_symbol_exit \ | ||
| 13 | {0x100, "SYSTEM_RESET"}, \ | ||
| 14 | {0x200, "MACHINE_CHECK"}, \ | ||
| 15 | {0x300, "DATA_STORAGE"}, \ | ||
| 16 | {0x380, "DATA_SEGMENT"}, \ | ||
| 17 | {0x400, "INST_STORAGE"}, \ | ||
| 18 | {0x480, "INST_SEGMENT"}, \ | ||
| 19 | {0x500, "EXTERNAL"}, \ | ||
| 20 | {0x501, "EXTERNAL_LEVEL"}, \ | ||
| 21 | {0x502, "EXTERNAL_HV"}, \ | ||
| 22 | {0x600, "ALIGNMENT"}, \ | ||
| 23 | {0x700, "PROGRAM"}, \ | ||
| 24 | {0x800, "FP_UNAVAIL"}, \ | ||
| 25 | {0x900, "DECREMENTER"}, \ | ||
| 26 | {0x980, "HV_DECREMENTER"}, \ | ||
| 27 | {0xc00, "SYSCALL"}, \ | ||
| 28 | {0xd00, "TRACE"}, \ | ||
| 29 | {0xe00, "H_DATA_STORAGE"}, \ | ||
| 30 | {0xe20, "H_INST_STORAGE"}, \ | ||
| 31 | {0xe40, "H_EMUL_ASSIST"}, \ | ||
| 32 | {0xf00, "PERFMON"}, \ | ||
| 33 | {0xf20, "ALTIVEC"}, \ | ||
| 34 | {0xf40, "VSX"} | ||
| 35 | |||
| 36 | TRACE_EVENT(kvm_book3s_reenter, | ||
| 37 | TP_PROTO(int r, struct kvm_vcpu *vcpu), | ||
| 38 | TP_ARGS(r, vcpu), | ||
| 39 | |||
| 40 | TP_STRUCT__entry( | ||
| 41 | __field( unsigned int, r ) | ||
| 42 | __field( unsigned long, pc ) | ||
| 43 | ), | ||
| 44 | |||
| 45 | TP_fast_assign( | ||
| 46 | __entry->r = r; | ||
| 47 | __entry->pc = kvmppc_get_pc(vcpu); | ||
| 48 | ), | ||
| 49 | |||
| 50 | TP_printk("reentry r=%d | pc=0x%lx", __entry->r, __entry->pc) | ||
| 51 | ); | ||
| 52 | |||
| 53 | #ifdef CONFIG_PPC_BOOK3S_64 | ||
| 54 | |||
| 55 | TRACE_EVENT(kvm_book3s_64_mmu_map, | ||
| 56 | TP_PROTO(int rflags, ulong hpteg, ulong va, pfn_t hpaddr, | ||
| 57 | struct kvmppc_pte *orig_pte), | ||
| 58 | TP_ARGS(rflags, hpteg, va, hpaddr, orig_pte), | ||
| 59 | |||
| 60 | TP_STRUCT__entry( | ||
| 61 | __field( unsigned char, flag_w ) | ||
| 62 | __field( unsigned char, flag_x ) | ||
| 63 | __field( unsigned long, eaddr ) | ||
| 64 | __field( unsigned long, hpteg ) | ||
| 65 | __field( unsigned long, va ) | ||
| 66 | __field( unsigned long long, vpage ) | ||
| 67 | __field( unsigned long, hpaddr ) | ||
| 68 | ), | ||
| 69 | |||
| 70 | TP_fast_assign( | ||
| 71 | __entry->flag_w = ((rflags & HPTE_R_PP) == 3) ? '-' : 'w'; | ||
| 72 | __entry->flag_x = (rflags & HPTE_R_N) ? '-' : 'x'; | ||
| 73 | __entry->eaddr = orig_pte->eaddr; | ||
| 74 | __entry->hpteg = hpteg; | ||
| 75 | __entry->va = va; | ||
| 76 | __entry->vpage = orig_pte->vpage; | ||
| 77 | __entry->hpaddr = hpaddr; | ||
| 78 | ), | ||
| 79 | |||
| 80 | TP_printk("KVM: %c%c Map 0x%lx: [%lx] 0x%lx (0x%llx) -> %lx", | ||
| 81 | __entry->flag_w, __entry->flag_x, __entry->eaddr, | ||
| 82 | __entry->hpteg, __entry->va, __entry->vpage, __entry->hpaddr) | ||
| 83 | ); | ||
| 84 | |||
| 85 | #endif /* CONFIG_PPC_BOOK3S_64 */ | ||
| 86 | |||
| 87 | TRACE_EVENT(kvm_book3s_mmu_map, | ||
| 88 | TP_PROTO(struct hpte_cache *pte), | ||
| 89 | TP_ARGS(pte), | ||
| 90 | |||
| 91 | TP_STRUCT__entry( | ||
| 92 | __field( u64, host_vpn ) | ||
| 93 | __field( u64, pfn ) | ||
| 94 | __field( ulong, eaddr ) | ||
| 95 | __field( u64, vpage ) | ||
| 96 | __field( ulong, raddr ) | ||
| 97 | __field( int, flags ) | ||
| 98 | ), | ||
| 99 | |||
| 100 | TP_fast_assign( | ||
| 101 | __entry->host_vpn = pte->host_vpn; | ||
| 102 | __entry->pfn = pte->pfn; | ||
| 103 | __entry->eaddr = pte->pte.eaddr; | ||
| 104 | __entry->vpage = pte->pte.vpage; | ||
| 105 | __entry->raddr = pte->pte.raddr; | ||
| 106 | __entry->flags = (pte->pte.may_read ? 0x4 : 0) | | ||
| 107 | (pte->pte.may_write ? 0x2 : 0) | | ||
| 108 | (pte->pte.may_execute ? 0x1 : 0); | ||
| 109 | ), | ||
| 110 | |||
| 111 | TP_printk("Map: hvpn=%llx pfn=%llx ea=%lx vp=%llx ra=%lx [%x]", | ||
| 112 | __entry->host_vpn, __entry->pfn, __entry->eaddr, | ||
| 113 | __entry->vpage, __entry->raddr, __entry->flags) | ||
| 114 | ); | ||
| 115 | |||
| 116 | TRACE_EVENT(kvm_book3s_mmu_invalidate, | ||
| 117 | TP_PROTO(struct hpte_cache *pte), | ||
| 118 | TP_ARGS(pte), | ||
| 119 | |||
| 120 | TP_STRUCT__entry( | ||
| 121 | __field( u64, host_vpn ) | ||
| 122 | __field( u64, pfn ) | ||
| 123 | __field( ulong, eaddr ) | ||
| 124 | __field( u64, vpage ) | ||
| 125 | __field( ulong, raddr ) | ||
| 126 | __field( int, flags ) | ||
| 127 | ), | ||
| 128 | |||
| 129 | TP_fast_assign( | ||
| 130 | __entry->host_vpn = pte->host_vpn; | ||
| 131 | __entry->pfn = pte->pfn; | ||
| 132 | __entry->eaddr = pte->pte.eaddr; | ||
| 133 | __entry->vpage = pte->pte.vpage; | ||
| 134 | __entry->raddr = pte->pte.raddr; | ||
| 135 | __entry->flags = (pte->pte.may_read ? 0x4 : 0) | | ||
| 136 | (pte->pte.may_write ? 0x2 : 0) | | ||
| 137 | (pte->pte.may_execute ? 0x1 : 0); | ||
| 138 | ), | ||
| 139 | |||
| 140 | TP_printk("Flush: hva=%llx pfn=%llx ea=%lx vp=%llx ra=%lx [%x]", | ||
| 141 | __entry->host_vpn, __entry->pfn, __entry->eaddr, | ||
| 142 | __entry->vpage, __entry->raddr, __entry->flags) | ||
| 143 | ); | ||
| 144 | |||
| 145 | TRACE_EVENT(kvm_book3s_mmu_flush, | ||
| 146 | TP_PROTO(const char *type, struct kvm_vcpu *vcpu, unsigned long long p1, | ||
| 147 | unsigned long long p2), | ||
| 148 | TP_ARGS(type, vcpu, p1, p2), | ||
| 149 | |||
| 150 | TP_STRUCT__entry( | ||
| 151 | __field( int, count ) | ||
| 152 | __field( unsigned long long, p1 ) | ||
| 153 | __field( unsigned long long, p2 ) | ||
| 154 | __field( const char *, type ) | ||
| 155 | ), | ||
| 156 | |||
| 157 | TP_fast_assign( | ||
| 158 | __entry->count = to_book3s(vcpu)->hpte_cache_count; | ||
| 159 | __entry->p1 = p1; | ||
| 160 | __entry->p2 = p2; | ||
| 161 | __entry->type = type; | ||
| 162 | ), | ||
| 163 | |||
| 164 | TP_printk("Flush %d %sPTEs: %llx - %llx", | ||
| 165 | __entry->count, __entry->type, __entry->p1, __entry->p2) | ||
| 166 | ); | ||
| 167 | |||
| 168 | TRACE_EVENT(kvm_book3s_slb_found, | ||
| 169 | TP_PROTO(unsigned long long gvsid, unsigned long long hvsid), | ||
| 170 | TP_ARGS(gvsid, hvsid), | ||
| 171 | |||
| 172 | TP_STRUCT__entry( | ||
| 173 | __field( unsigned long long, gvsid ) | ||
| 174 | __field( unsigned long long, hvsid ) | ||
| 175 | ), | ||
| 176 | |||
| 177 | TP_fast_assign( | ||
| 178 | __entry->gvsid = gvsid; | ||
| 179 | __entry->hvsid = hvsid; | ||
| 180 | ), | ||
| 181 | |||
| 182 | TP_printk("%llx -> %llx", __entry->gvsid, __entry->hvsid) | ||
| 183 | ); | ||
| 184 | |||
| 185 | TRACE_EVENT(kvm_book3s_slb_fail, | ||
| 186 | TP_PROTO(u16 sid_map_mask, unsigned long long gvsid), | ||
| 187 | TP_ARGS(sid_map_mask, gvsid), | ||
| 188 | |||
| 189 | TP_STRUCT__entry( | ||
| 190 | __field( unsigned short, sid_map_mask ) | ||
| 191 | __field( unsigned long long, gvsid ) | ||
| 192 | ), | ||
| 193 | |||
| 194 | TP_fast_assign( | ||
| 195 | __entry->sid_map_mask = sid_map_mask; | ||
| 196 | __entry->gvsid = gvsid; | ||
| 197 | ), | ||
| 198 | |||
| 199 | TP_printk("%x/%x: %llx", __entry->sid_map_mask, | ||
| 200 | SID_MAP_MASK - __entry->sid_map_mask, __entry->gvsid) | ||
| 201 | ); | ||
| 202 | |||
| 203 | TRACE_EVENT(kvm_book3s_slb_map, | ||
| 204 | TP_PROTO(u16 sid_map_mask, unsigned long long gvsid, | ||
| 205 | unsigned long long hvsid), | ||
| 206 | TP_ARGS(sid_map_mask, gvsid, hvsid), | ||
| 207 | |||
| 208 | TP_STRUCT__entry( | ||
| 209 | __field( unsigned short, sid_map_mask ) | ||
| 210 | __field( unsigned long long, guest_vsid ) | ||
| 211 | __field( unsigned long long, host_vsid ) | ||
| 212 | ), | ||
| 213 | |||
| 214 | TP_fast_assign( | ||
| 215 | __entry->sid_map_mask = sid_map_mask; | ||
| 216 | __entry->guest_vsid = gvsid; | ||
| 217 | __entry->host_vsid = hvsid; | ||
| 218 | ), | ||
| 219 | |||
| 220 | TP_printk("%x: %llx -> %llx", __entry->sid_map_mask, | ||
| 221 | __entry->guest_vsid, __entry->host_vsid) | ||
| 222 | ); | ||
| 223 | |||
| 224 | TRACE_EVENT(kvm_book3s_slbmte, | ||
| 225 | TP_PROTO(u64 slb_vsid, u64 slb_esid), | ||
| 226 | TP_ARGS(slb_vsid, slb_esid), | ||
| 227 | |||
| 228 | TP_STRUCT__entry( | ||
| 229 | __field( u64, slb_vsid ) | ||
| 230 | __field( u64, slb_esid ) | ||
| 231 | ), | ||
| 232 | |||
| 233 | TP_fast_assign( | ||
| 234 | __entry->slb_vsid = slb_vsid; | ||
| 235 | __entry->slb_esid = slb_esid; | ||
| 236 | ), | ||
| 237 | |||
| 238 | TP_printk("%llx, %llx", __entry->slb_vsid, __entry->slb_esid) | ||
| 239 | ); | ||
| 240 | |||
| 241 | TRACE_EVENT(kvm_exit, | ||
| 242 | TP_PROTO(unsigned int exit_nr, struct kvm_vcpu *vcpu), | ||
| 243 | TP_ARGS(exit_nr, vcpu), | ||
| 244 | |||
| 245 | TP_STRUCT__entry( | ||
| 246 | __field( unsigned int, exit_nr ) | ||
| 247 | __field( unsigned long, pc ) | ||
| 248 | __field( unsigned long, msr ) | ||
| 249 | __field( unsigned long, dar ) | ||
| 250 | __field( unsigned long, srr1 ) | ||
| 251 | __field( unsigned long, last_inst ) | ||
| 252 | ), | ||
| 253 | |||
| 254 | TP_fast_assign( | ||
| 255 | __entry->exit_nr = exit_nr; | ||
| 256 | __entry->pc = kvmppc_get_pc(vcpu); | ||
| 257 | __entry->dar = kvmppc_get_fault_dar(vcpu); | ||
| 258 | __entry->msr = vcpu->arch.shared->msr; | ||
| 259 | __entry->srr1 = vcpu->arch.shadow_srr1; | ||
| 260 | __entry->last_inst = vcpu->arch.last_inst; | ||
| 261 | ), | ||
| 262 | |||
| 263 | TP_printk("exit=%s" | ||
| 264 | " | pc=0x%lx" | ||
| 265 | " | msr=0x%lx" | ||
| 266 | " | dar=0x%lx" | ||
| 267 | " | srr1=0x%lx" | ||
| 268 | " | last_inst=0x%lx" | ||
| 269 | , | ||
| 270 | __print_symbolic(__entry->exit_nr, kvm_trace_symbol_exit), | ||
| 271 | __entry->pc, | ||
| 272 | __entry->msr, | ||
| 273 | __entry->dar, | ||
| 274 | __entry->srr1, | ||
| 275 | __entry->last_inst | ||
| 276 | ) | ||
| 277 | ); | ||
| 278 | |||
| 279 | TRACE_EVENT(kvm_unmap_hva, | ||
| 280 | TP_PROTO(unsigned long hva), | ||
| 281 | TP_ARGS(hva), | ||
| 282 | |||
| 283 | TP_STRUCT__entry( | ||
| 284 | __field( unsigned long, hva ) | ||
| 285 | ), | ||
| 286 | |||
| 287 | TP_fast_assign( | ||
| 288 | __entry->hva = hva; | ||
| 289 | ), | ||
| 290 | |||
| 291 | TP_printk("unmap hva 0x%lx\n", __entry->hva) | ||
| 292 | ); | ||
| 293 | |||
| 294 | #endif /* _TRACE_KVM_H */ | ||
| 295 | |||
| 296 | /* This part must be outside protection */ | ||
| 297 | #include <trace/define_trace.h> | ||
diff --git a/arch/s390/include/asm/kvm_host.h b/arch/s390/include/asm/kvm_host.h index e87ecaa2c569..d5bc3750616e 100644 --- a/arch/s390/include/asm/kvm_host.h +++ b/arch/s390/include/asm/kvm_host.h | |||
| @@ -38,13 +38,6 @@ struct sca_block { | |||
| 38 | struct sca_entry cpu[64]; | 38 | struct sca_entry cpu[64]; |
| 39 | } __attribute__((packed)); | 39 | } __attribute__((packed)); |
| 40 | 40 | ||
| 41 | #define KVM_NR_PAGE_SIZES 2 | ||
| 42 | #define KVM_HPAGE_GFN_SHIFT(x) (((x) - 1) * 8) | ||
| 43 | #define KVM_HPAGE_SHIFT(x) (PAGE_SHIFT + KVM_HPAGE_GFN_SHIFT(x)) | ||
| 44 | #define KVM_HPAGE_SIZE(x) (1UL << KVM_HPAGE_SHIFT(x)) | ||
| 45 | #define KVM_HPAGE_MASK(x) (~(KVM_HPAGE_SIZE(x) - 1)) | ||
| 46 | #define KVM_PAGES_PER_HPAGE(x) (KVM_HPAGE_SIZE(x) / PAGE_SIZE) | ||
| 47 | |||
| 48 | #define CPUSTAT_STOPPED 0x80000000 | 41 | #define CPUSTAT_STOPPED 0x80000000 |
| 49 | #define CPUSTAT_WAIT 0x10000000 | 42 | #define CPUSTAT_WAIT 0x10000000 |
| 50 | #define CPUSTAT_ECALL_PEND 0x08000000 | 43 | #define CPUSTAT_ECALL_PEND 0x08000000 |
| @@ -220,7 +213,6 @@ struct kvm_s390_interrupt_info { | |||
| 220 | /* for local_interrupt.action_flags */ | 213 | /* for local_interrupt.action_flags */ |
| 221 | #define ACTION_STORE_ON_STOP (1<<0) | 214 | #define ACTION_STORE_ON_STOP (1<<0) |
| 222 | #define ACTION_STOP_ON_STOP (1<<1) | 215 | #define ACTION_STOP_ON_STOP (1<<1) |
| 223 | #define ACTION_RELOADVCPU_ON_STOP (1<<2) | ||
| 224 | 216 | ||
| 225 | struct kvm_s390_local_interrupt { | 217 | struct kvm_s390_local_interrupt { |
| 226 | spinlock_t lock; | 218 | spinlock_t lock; |
diff --git a/arch/s390/kvm/diag.c b/arch/s390/kvm/diag.c index 3a74d8af0d69..78d967f180f4 100644 --- a/arch/s390/kvm/diag.c +++ b/arch/s390/kvm/diag.c | |||
| @@ -107,14 +107,13 @@ static int __diag_ipl_functions(struct kvm_vcpu *vcpu) | |||
| 107 | 107 | ||
| 108 | static int __diag_virtio_hypercall(struct kvm_vcpu *vcpu) | 108 | static int __diag_virtio_hypercall(struct kvm_vcpu *vcpu) |
| 109 | { | 109 | { |
| 110 | int ret, idx; | 110 | int ret; |
| 111 | 111 | ||
| 112 | /* No virtio-ccw notification? Get out quickly. */ | 112 | /* No virtio-ccw notification? Get out quickly. */ |
| 113 | if (!vcpu->kvm->arch.css_support || | 113 | if (!vcpu->kvm->arch.css_support || |
| 114 | (vcpu->run->s.regs.gprs[1] != KVM_S390_VIRTIO_CCW_NOTIFY)) | 114 | (vcpu->run->s.regs.gprs[1] != KVM_S390_VIRTIO_CCW_NOTIFY)) |
| 115 | return -EOPNOTSUPP; | 115 | return -EOPNOTSUPP; |
| 116 | 116 | ||
| 117 | idx = srcu_read_lock(&vcpu->kvm->srcu); | ||
| 118 | /* | 117 | /* |
| 119 | * The layout is as follows: | 118 | * The layout is as follows: |
| 120 | * - gpr 2 contains the subchannel id (passed as addr) | 119 | * - gpr 2 contains the subchannel id (passed as addr) |
| @@ -125,7 +124,6 @@ static int __diag_virtio_hypercall(struct kvm_vcpu *vcpu) | |||
| 125 | vcpu->run->s.regs.gprs[2], | 124 | vcpu->run->s.regs.gprs[2], |
| 126 | 8, &vcpu->run->s.regs.gprs[3], | 125 | 8, &vcpu->run->s.regs.gprs[3], |
| 127 | vcpu->run->s.regs.gprs[4]); | 126 | vcpu->run->s.regs.gprs[4]); |
| 128 | srcu_read_unlock(&vcpu->kvm->srcu, idx); | ||
| 129 | 127 | ||
| 130 | /* | 128 | /* |
| 131 | * Return cookie in gpr 2, but don't overwrite the register if the | 129 | * Return cookie in gpr 2, but don't overwrite the register if the |
diff --git a/arch/s390/kvm/gaccess.h b/arch/s390/kvm/gaccess.h index 99d789e8a018..374a439ccc60 100644 --- a/arch/s390/kvm/gaccess.h +++ b/arch/s390/kvm/gaccess.h | |||
| @@ -18,20 +18,27 @@ | |||
| 18 | #include <asm/uaccess.h> | 18 | #include <asm/uaccess.h> |
| 19 | #include "kvm-s390.h" | 19 | #include "kvm-s390.h" |
| 20 | 20 | ||
| 21 | /* Convert real to absolute address by applying the prefix of the CPU */ | ||
| 22 | static inline unsigned long kvm_s390_real_to_abs(struct kvm_vcpu *vcpu, | ||
| 23 | unsigned long gaddr) | ||
| 24 | { | ||
| 25 | unsigned long prefix = vcpu->arch.sie_block->prefix; | ||
| 26 | if (gaddr < 2 * PAGE_SIZE) | ||
| 27 | gaddr += prefix; | ||
| 28 | else if (gaddr >= prefix && gaddr < prefix + 2 * PAGE_SIZE) | ||
| 29 | gaddr -= prefix; | ||
| 30 | return gaddr; | ||
| 31 | } | ||
| 32 | |||
| 21 | static inline void __user *__gptr_to_uptr(struct kvm_vcpu *vcpu, | 33 | static inline void __user *__gptr_to_uptr(struct kvm_vcpu *vcpu, |
| 22 | void __user *gptr, | 34 | void __user *gptr, |
| 23 | int prefixing) | 35 | int prefixing) |
| 24 | { | 36 | { |
| 25 | unsigned long prefix = vcpu->arch.sie_block->prefix; | ||
| 26 | unsigned long gaddr = (unsigned long) gptr; | 37 | unsigned long gaddr = (unsigned long) gptr; |
| 27 | unsigned long uaddr; | 38 | unsigned long uaddr; |
| 28 | 39 | ||
| 29 | if (prefixing) { | 40 | if (prefixing) |
| 30 | if (gaddr < 2 * PAGE_SIZE) | 41 | gaddr = kvm_s390_real_to_abs(vcpu, gaddr); |
| 31 | gaddr += prefix; | ||
| 32 | else if ((gaddr >= prefix) && (gaddr < prefix + 2 * PAGE_SIZE)) | ||
| 33 | gaddr -= prefix; | ||
| 34 | } | ||
| 35 | uaddr = gmap_fault(gaddr, vcpu->arch.gmap); | 42 | uaddr = gmap_fault(gaddr, vcpu->arch.gmap); |
| 36 | if (IS_ERR_VALUE(uaddr)) | 43 | if (IS_ERR_VALUE(uaddr)) |
| 37 | uaddr = -EFAULT; | 44 | uaddr = -EFAULT; |
diff --git a/arch/s390/kvm/intercept.c b/arch/s390/kvm/intercept.c index 5ee56e5acc23..5ddbbde6f65c 100644 --- a/arch/s390/kvm/intercept.c +++ b/arch/s390/kvm/intercept.c | |||
| @@ -62,12 +62,6 @@ static int handle_stop(struct kvm_vcpu *vcpu) | |||
| 62 | 62 | ||
| 63 | trace_kvm_s390_stop_request(vcpu->arch.local_int.action_bits); | 63 | trace_kvm_s390_stop_request(vcpu->arch.local_int.action_bits); |
| 64 | 64 | ||
| 65 | if (vcpu->arch.local_int.action_bits & ACTION_RELOADVCPU_ON_STOP) { | ||
| 66 | vcpu->arch.local_int.action_bits &= ~ACTION_RELOADVCPU_ON_STOP; | ||
| 67 | rc = SIE_INTERCEPT_RERUNVCPU; | ||
| 68 | vcpu->run->exit_reason = KVM_EXIT_INTR; | ||
| 69 | } | ||
| 70 | |||
| 71 | if (vcpu->arch.local_int.action_bits & ACTION_STOP_ON_STOP) { | 65 | if (vcpu->arch.local_int.action_bits & ACTION_STOP_ON_STOP) { |
| 72 | atomic_set_mask(CPUSTAT_STOPPED, | 66 | atomic_set_mask(CPUSTAT_STOPPED, |
| 73 | &vcpu->arch.sie_block->cpuflags); | 67 | &vcpu->arch.sie_block->cpuflags); |
diff --git a/arch/s390/kvm/interrupt.c b/arch/s390/kvm/interrupt.c index 7f1f7ac5cf7f..5f79d2d79ca7 100644 --- a/arch/s390/kvm/interrupt.c +++ b/arch/s390/kvm/interrupt.c | |||
| @@ -436,6 +436,7 @@ int kvm_s390_handle_wait(struct kvm_vcpu *vcpu) | |||
| 436 | hrtimer_start(&vcpu->arch.ckc_timer, ktime_set (0, sltime) , HRTIMER_MODE_REL); | 436 | hrtimer_start(&vcpu->arch.ckc_timer, ktime_set (0, sltime) , HRTIMER_MODE_REL); |
| 437 | VCPU_EVENT(vcpu, 5, "enabled wait via clock comparator: %llx ns", sltime); | 437 | VCPU_EVENT(vcpu, 5, "enabled wait via clock comparator: %llx ns", sltime); |
| 438 | no_timer: | 438 | no_timer: |
| 439 | srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); | ||
| 439 | spin_lock(&vcpu->arch.local_int.float_int->lock); | 440 | spin_lock(&vcpu->arch.local_int.float_int->lock); |
| 440 | spin_lock_bh(&vcpu->arch.local_int.lock); | 441 | spin_lock_bh(&vcpu->arch.local_int.lock); |
| 441 | add_wait_queue(&vcpu->wq, &wait); | 442 | add_wait_queue(&vcpu->wq, &wait); |
| @@ -455,6 +456,8 @@ no_timer: | |||
| 455 | remove_wait_queue(&vcpu->wq, &wait); | 456 | remove_wait_queue(&vcpu->wq, &wait); |
| 456 | spin_unlock_bh(&vcpu->arch.local_int.lock); | 457 | spin_unlock_bh(&vcpu->arch.local_int.lock); |
| 457 | spin_unlock(&vcpu->arch.local_int.float_int->lock); | 458 | spin_unlock(&vcpu->arch.local_int.float_int->lock); |
| 459 | vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); | ||
| 460 | |||
| 458 | hrtimer_try_to_cancel(&vcpu->arch.ckc_timer); | 461 | hrtimer_try_to_cancel(&vcpu->arch.ckc_timer); |
| 459 | return 0; | 462 | return 0; |
| 460 | } | 463 | } |
diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c index ed8064cb5c49..569494e01ec6 100644 --- a/arch/s390/kvm/kvm-s390.c +++ b/arch/s390/kvm/kvm-s390.c | |||
| @@ -695,9 +695,9 @@ static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu) | |||
| 695 | return 0; | 695 | return 0; |
| 696 | } | 696 | } |
| 697 | 697 | ||
| 698 | static int __vcpu_run(struct kvm_vcpu *vcpu) | 698 | static int vcpu_pre_run(struct kvm_vcpu *vcpu) |
| 699 | { | 699 | { |
| 700 | int rc; | 700 | int rc, cpuflags; |
| 701 | 701 | ||
| 702 | memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16); | 702 | memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16); |
| 703 | 703 | ||
| @@ -715,28 +715,24 @@ static int __vcpu_run(struct kvm_vcpu *vcpu) | |||
| 715 | return rc; | 715 | return rc; |
| 716 | 716 | ||
| 717 | vcpu->arch.sie_block->icptcode = 0; | 717 | vcpu->arch.sie_block->icptcode = 0; |
| 718 | VCPU_EVENT(vcpu, 6, "entering sie flags %x", | 718 | cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags); |
| 719 | atomic_read(&vcpu->arch.sie_block->cpuflags)); | 719 | VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags); |
| 720 | trace_kvm_s390_sie_enter(vcpu, | 720 | trace_kvm_s390_sie_enter(vcpu, cpuflags); |
| 721 | atomic_read(&vcpu->arch.sie_block->cpuflags)); | ||
| 722 | 721 | ||
| 723 | /* | 722 | return 0; |
| 724 | * As PF_VCPU will be used in fault handler, between guest_enter | 723 | } |
| 725 | * and guest_exit should be no uaccess. | 724 | |
| 726 | */ | 725 | static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason) |
| 727 | preempt_disable(); | 726 | { |
| 728 | kvm_guest_enter(); | 727 | int rc; |
| 729 | preempt_enable(); | ||
| 730 | rc = sie64a(vcpu->arch.sie_block, vcpu->run->s.regs.gprs); | ||
| 731 | kvm_guest_exit(); | ||
| 732 | 728 | ||
| 733 | VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", | 729 | VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", |
| 734 | vcpu->arch.sie_block->icptcode); | 730 | vcpu->arch.sie_block->icptcode); |
| 735 | trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode); | 731 | trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode); |
| 736 | 732 | ||
| 737 | if (rc > 0) | 733 | if (exit_reason >= 0) { |
| 738 | rc = 0; | 734 | rc = 0; |
| 739 | if (rc < 0) { | 735 | } else { |
| 740 | if (kvm_is_ucontrol(vcpu->kvm)) { | 736 | if (kvm_is_ucontrol(vcpu->kvm)) { |
| 741 | rc = SIE_INTERCEPT_UCONTROL; | 737 | rc = SIE_INTERCEPT_UCONTROL; |
| 742 | } else { | 738 | } else { |
| @@ -747,6 +743,49 @@ static int __vcpu_run(struct kvm_vcpu *vcpu) | |||
| 747 | } | 743 | } |
| 748 | 744 | ||
| 749 | memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16); | 745 | memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16); |
| 746 | |||
| 747 | if (rc == 0) { | ||
| 748 | if (kvm_is_ucontrol(vcpu->kvm)) | ||
| 749 | rc = -EOPNOTSUPP; | ||
| 750 | else | ||
| 751 | rc = kvm_handle_sie_intercept(vcpu); | ||
| 752 | } | ||
| 753 | |||
| 754 | return rc; | ||
| 755 | } | ||
| 756 | |||
| 757 | static int __vcpu_run(struct kvm_vcpu *vcpu) | ||
| 758 | { | ||
| 759 | int rc, exit_reason; | ||
| 760 | |||
| 761 | /* | ||
| 762 | * We try to hold kvm->srcu during most of vcpu_run (except when run- | ||
| 763 | * ning the guest), so that memslots (and other stuff) are protected | ||
| 764 | */ | ||
| 765 | vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); | ||
| 766 | |||
| 767 | do { | ||
| 768 | rc = vcpu_pre_run(vcpu); | ||
| 769 | if (rc) | ||
| 770 | break; | ||
| 771 | |||
| 772 | srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); | ||
| 773 | /* | ||
| 774 | * As PF_VCPU will be used in fault handler, between | ||
| 775 | * guest_enter and guest_exit should be no uaccess. | ||
| 776 | */ | ||
| 777 | preempt_disable(); | ||
| 778 | kvm_guest_enter(); | ||
| 779 | preempt_enable(); | ||
| 780 | exit_reason = sie64a(vcpu->arch.sie_block, | ||
| 781 | vcpu->run->s.regs.gprs); | ||
| 782 | kvm_guest_exit(); | ||
| 783 | vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); | ||
| 784 | |||
| 785 | rc = vcpu_post_run(vcpu, exit_reason); | ||
| 786 | } while (!signal_pending(current) && !rc); | ||
| 787 | |||
| 788 | srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); | ||
| 750 | return rc; | 789 | return rc; |
| 751 | } | 790 | } |
| 752 | 791 | ||
| @@ -755,7 +794,6 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) | |||
| 755 | int rc; | 794 | int rc; |
| 756 | sigset_t sigsaved; | 795 | sigset_t sigsaved; |
| 757 | 796 | ||
| 758 | rerun_vcpu: | ||
| 759 | if (vcpu->sigset_active) | 797 | if (vcpu->sigset_active) |
| 760 | sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); | 798 | sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); |
| 761 | 799 | ||
| @@ -788,19 +826,7 @@ rerun_vcpu: | |||
| 788 | } | 826 | } |
| 789 | 827 | ||
| 790 | might_fault(); | 828 | might_fault(); |
| 791 | 829 | rc = __vcpu_run(vcpu); | |
| 792 | do { | ||
| 793 | rc = __vcpu_run(vcpu); | ||
| 794 | if (rc) | ||
| 795 | break; | ||
| 796 | if (kvm_is_ucontrol(vcpu->kvm)) | ||
| 797 | rc = -EOPNOTSUPP; | ||
| 798 | else | ||
| 799 | rc = kvm_handle_sie_intercept(vcpu); | ||
| 800 | } while (!signal_pending(current) && !rc); | ||
| 801 | |||
| 802 | if (rc == SIE_INTERCEPT_RERUNVCPU) | ||
| 803 | goto rerun_vcpu; | ||
| 804 | 830 | ||
| 805 | if (signal_pending(current) && !rc) { | 831 | if (signal_pending(current) && !rc) { |
| 806 | kvm_run->exit_reason = KVM_EXIT_INTR; | 832 | kvm_run->exit_reason = KVM_EXIT_INTR; |
| @@ -958,6 +984,7 @@ long kvm_arch_vcpu_ioctl(struct file *filp, | |||
| 958 | { | 984 | { |
| 959 | struct kvm_vcpu *vcpu = filp->private_data; | 985 | struct kvm_vcpu *vcpu = filp->private_data; |
| 960 | void __user *argp = (void __user *)arg; | 986 | void __user *argp = (void __user *)arg; |
| 987 | int idx; | ||
| 961 | long r; | 988 | long r; |
| 962 | 989 | ||
| 963 | switch (ioctl) { | 990 | switch (ioctl) { |
| @@ -971,7 +998,9 @@ long kvm_arch_vcpu_ioctl(struct file *filp, | |||
| 971 | break; | 998 | break; |
| 972 | } | 999 | } |
| 973 | case KVM_S390_STORE_STATUS: | 1000 | case KVM_S390_STORE_STATUS: |
| 1001 | idx = srcu_read_lock(&vcpu->kvm->srcu); | ||
| 974 | r = kvm_s390_vcpu_store_status(vcpu, arg); | 1002 | r = kvm_s390_vcpu_store_status(vcpu, arg); |
| 1003 | srcu_read_unlock(&vcpu->kvm->srcu, idx); | ||
| 975 | break; | 1004 | break; |
| 976 | case KVM_S390_SET_INITIAL_PSW: { | 1005 | case KVM_S390_SET_INITIAL_PSW: { |
| 977 | psw_t psw; | 1006 | psw_t psw; |
| @@ -1067,12 +1096,13 @@ int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf) | |||
| 1067 | return VM_FAULT_SIGBUS; | 1096 | return VM_FAULT_SIGBUS; |
| 1068 | } | 1097 | } |
| 1069 | 1098 | ||
| 1070 | void kvm_arch_free_memslot(struct kvm_memory_slot *free, | 1099 | void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free, |
| 1071 | struct kvm_memory_slot *dont) | 1100 | struct kvm_memory_slot *dont) |
| 1072 | { | 1101 | { |
| 1073 | } | 1102 | } |
| 1074 | 1103 | ||
| 1075 | int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages) | 1104 | int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, |
| 1105 | unsigned long npages) | ||
| 1076 | { | 1106 | { |
| 1077 | return 0; | 1107 | return 0; |
| 1078 | } | 1108 | } |
diff --git a/arch/s390/kvm/kvm-s390.h b/arch/s390/kvm/kvm-s390.h index dc99f1ca4267..b44912a32949 100644 --- a/arch/s390/kvm/kvm-s390.h +++ b/arch/s390/kvm/kvm-s390.h | |||
| @@ -28,8 +28,7 @@ typedef int (*intercept_handler_t)(struct kvm_vcpu *vcpu); | |||
| 28 | extern unsigned long *vfacilities; | 28 | extern unsigned long *vfacilities; |
| 29 | 29 | ||
| 30 | /* negativ values are error codes, positive values for internal conditions */ | 30 | /* negativ values are error codes, positive values for internal conditions */ |
| 31 | #define SIE_INTERCEPT_RERUNVCPU (1<<0) | 31 | #define SIE_INTERCEPT_UCONTROL (1<<0) |
| 32 | #define SIE_INTERCEPT_UCONTROL (1<<1) | ||
| 33 | int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu); | 32 | int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu); |
| 34 | 33 | ||
| 35 | #define VM_EVENT(d_kvm, d_loglevel, d_string, d_args...)\ | 34 | #define VM_EVENT(d_kvm, d_loglevel, d_string, d_args...)\ |
| @@ -91,8 +90,10 @@ static inline void kvm_s390_get_base_disp_sse(struct kvm_vcpu *vcpu, | |||
| 91 | 90 | ||
| 92 | static inline void kvm_s390_get_regs_rre(struct kvm_vcpu *vcpu, int *r1, int *r2) | 91 | static inline void kvm_s390_get_regs_rre(struct kvm_vcpu *vcpu, int *r1, int *r2) |
| 93 | { | 92 | { |
| 94 | *r1 = (vcpu->arch.sie_block->ipb & 0x00f00000) >> 20; | 93 | if (r1) |
| 95 | *r2 = (vcpu->arch.sie_block->ipb & 0x000f0000) >> 16; | 94 | *r1 = (vcpu->arch.sie_block->ipb & 0x00f00000) >> 20; |
| 95 | if (r2) | ||
| 96 | *r2 = (vcpu->arch.sie_block->ipb & 0x000f0000) >> 16; | ||
| 96 | } | 97 | } |
| 97 | 98 | ||
| 98 | static inline u64 kvm_s390_get_base_disp_rsy(struct kvm_vcpu *vcpu) | 99 | static inline u64 kvm_s390_get_base_disp_rsy(struct kvm_vcpu *vcpu) |
diff --git a/arch/s390/kvm/priv.c b/arch/s390/kvm/priv.c index 59200ee275e5..2440602e6df1 100644 --- a/arch/s390/kvm/priv.c +++ b/arch/s390/kvm/priv.c | |||
| @@ -30,6 +30,38 @@ | |||
| 30 | #include "kvm-s390.h" | 30 | #include "kvm-s390.h" |
| 31 | #include "trace.h" | 31 | #include "trace.h" |
| 32 | 32 | ||
| 33 | /* Handle SCK (SET CLOCK) interception */ | ||
| 34 | static int handle_set_clock(struct kvm_vcpu *vcpu) | ||
| 35 | { | ||
| 36 | struct kvm_vcpu *cpup; | ||
| 37 | s64 hostclk, val; | ||
| 38 | u64 op2; | ||
| 39 | int i; | ||
| 40 | |||
| 41 | if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE) | ||
| 42 | return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP); | ||
| 43 | |||
| 44 | op2 = kvm_s390_get_base_disp_s(vcpu); | ||
| 45 | if (op2 & 7) /* Operand must be on a doubleword boundary */ | ||
| 46 | return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION); | ||
| 47 | if (get_guest(vcpu, val, (u64 __user *) op2)) | ||
| 48 | return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING); | ||
| 49 | |||
| 50 | if (store_tod_clock(&hostclk)) { | ||
| 51 | kvm_s390_set_psw_cc(vcpu, 3); | ||
| 52 | return 0; | ||
| 53 | } | ||
| 54 | val = (val - hostclk) & ~0x3fUL; | ||
| 55 | |||
| 56 | mutex_lock(&vcpu->kvm->lock); | ||
| 57 | kvm_for_each_vcpu(i, cpup, vcpu->kvm) | ||
| 58 | cpup->arch.sie_block->epoch = val; | ||
| 59 | mutex_unlock(&vcpu->kvm->lock); | ||
| 60 | |||
| 61 | kvm_s390_set_psw_cc(vcpu, 0); | ||
| 62 | return 0; | ||
| 63 | } | ||
| 64 | |||
| 33 | static int handle_set_prefix(struct kvm_vcpu *vcpu) | 65 | static int handle_set_prefix(struct kvm_vcpu *vcpu) |
| 34 | { | 66 | { |
| 35 | u64 operand2; | 67 | u64 operand2; |
| @@ -128,6 +160,33 @@ static int handle_skey(struct kvm_vcpu *vcpu) | |||
| 128 | return 0; | 160 | return 0; |
| 129 | } | 161 | } |
| 130 | 162 | ||
| 163 | static int handle_test_block(struct kvm_vcpu *vcpu) | ||
| 164 | { | ||
| 165 | unsigned long hva; | ||
| 166 | gpa_t addr; | ||
| 167 | int reg2; | ||
| 168 | |||
| 169 | if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE) | ||
| 170 | return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP); | ||
| 171 | |||
| 172 | kvm_s390_get_regs_rre(vcpu, NULL, ®2); | ||
| 173 | addr = vcpu->run->s.regs.gprs[reg2] & PAGE_MASK; | ||
| 174 | addr = kvm_s390_real_to_abs(vcpu, addr); | ||
| 175 | |||
| 176 | hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(addr)); | ||
| 177 | if (kvm_is_error_hva(hva)) | ||
| 178 | return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING); | ||
| 179 | /* | ||
| 180 | * We don't expect errors on modern systems, and do not care | ||
| 181 | * about storage keys (yet), so let's just clear the page. | ||
| 182 | */ | ||
| 183 | if (clear_user((void __user *)hva, PAGE_SIZE) != 0) | ||
| 184 | return -EFAULT; | ||
| 185 | kvm_s390_set_psw_cc(vcpu, 0); | ||
| 186 | vcpu->run->s.regs.gprs[0] = 0; | ||
| 187 | return 0; | ||
| 188 | } | ||
| 189 | |||
| 131 | static int handle_tpi(struct kvm_vcpu *vcpu) | 190 | static int handle_tpi(struct kvm_vcpu *vcpu) |
| 132 | { | 191 | { |
| 133 | struct kvm_s390_interrupt_info *inti; | 192 | struct kvm_s390_interrupt_info *inti; |
| @@ -438,12 +497,14 @@ out_exception: | |||
| 438 | 497 | ||
| 439 | static const intercept_handler_t b2_handlers[256] = { | 498 | static const intercept_handler_t b2_handlers[256] = { |
| 440 | [0x02] = handle_stidp, | 499 | [0x02] = handle_stidp, |
| 500 | [0x04] = handle_set_clock, | ||
| 441 | [0x10] = handle_set_prefix, | 501 | [0x10] = handle_set_prefix, |
| 442 | [0x11] = handle_store_prefix, | 502 | [0x11] = handle_store_prefix, |
| 443 | [0x12] = handle_store_cpu_address, | 503 | [0x12] = handle_store_cpu_address, |
| 444 | [0x29] = handle_skey, | 504 | [0x29] = handle_skey, |
| 445 | [0x2a] = handle_skey, | 505 | [0x2a] = handle_skey, |
| 446 | [0x2b] = handle_skey, | 506 | [0x2b] = handle_skey, |
| 507 | [0x2c] = handle_test_block, | ||
| 447 | [0x30] = handle_io_inst, | 508 | [0x30] = handle_io_inst, |
| 448 | [0x31] = handle_io_inst, | 509 | [0x31] = handle_io_inst, |
| 449 | [0x32] = handle_io_inst, | 510 | [0x32] = handle_io_inst, |
diff --git a/arch/x86/include/asm/kvm_emulate.h b/arch/x86/include/asm/kvm_emulate.h index 15f960c06ff7..24ec1216596e 100644 --- a/arch/x86/include/asm/kvm_emulate.h +++ b/arch/x86/include/asm/kvm_emulate.h | |||
| @@ -274,13 +274,17 @@ struct x86_emulate_ctxt { | |||
| 274 | 274 | ||
| 275 | bool guest_mode; /* guest running a nested guest */ | 275 | bool guest_mode; /* guest running a nested guest */ |
| 276 | bool perm_ok; /* do not check permissions if true */ | 276 | bool perm_ok; /* do not check permissions if true */ |
| 277 | bool only_vendor_specific_insn; | 277 | bool ud; /* inject an #UD if host doesn't support insn */ |
| 278 | 278 | ||
| 279 | bool have_exception; | 279 | bool have_exception; |
| 280 | struct x86_exception exception; | 280 | struct x86_exception exception; |
| 281 | 281 | ||
| 282 | /* decode cache */ | 282 | /* |
| 283 | u8 twobyte; | 283 | * decode cache |
| 284 | */ | ||
| 285 | |||
| 286 | /* current opcode length in bytes */ | ||
| 287 | u8 opcode_len; | ||
| 284 | u8 b; | 288 | u8 b; |
| 285 | u8 intercept; | 289 | u8 intercept; |
| 286 | u8 lock_prefix; | 290 | u8 lock_prefix; |
diff --git a/arch/x86/include/asm/kvm_host.h b/arch/x86/include/asm/kvm_host.h index c76ff74a98f2..ae5d7830855c 100644 --- a/arch/x86/include/asm/kvm_host.h +++ b/arch/x86/include/asm/kvm_host.h | |||
| @@ -79,6 +79,13 @@ | |||
| 79 | #define KVM_HPAGE_MASK(x) (~(KVM_HPAGE_SIZE(x) - 1)) | 79 | #define KVM_HPAGE_MASK(x) (~(KVM_HPAGE_SIZE(x) - 1)) |
| 80 | #define KVM_PAGES_PER_HPAGE(x) (KVM_HPAGE_SIZE(x) / PAGE_SIZE) | 80 | #define KVM_PAGES_PER_HPAGE(x) (KVM_HPAGE_SIZE(x) / PAGE_SIZE) |
| 81 | 81 | ||
| 82 | static inline gfn_t gfn_to_index(gfn_t gfn, gfn_t base_gfn, int level) | ||
| 83 | { | ||
| 84 | /* KVM_HPAGE_GFN_SHIFT(PT_PAGE_TABLE_LEVEL) must be 0. */ | ||
| 85 | return (gfn >> KVM_HPAGE_GFN_SHIFT(level)) - | ||
| 86 | (base_gfn >> KVM_HPAGE_GFN_SHIFT(level)); | ||
| 87 | } | ||
| 88 | |||
| 82 | #define SELECTOR_TI_MASK (1 << 2) | 89 | #define SELECTOR_TI_MASK (1 << 2) |
| 83 | #define SELECTOR_RPL_MASK 0x03 | 90 | #define SELECTOR_RPL_MASK 0x03 |
| 84 | 91 | ||
| @@ -253,7 +260,6 @@ struct kvm_pio_request { | |||
| 253 | * mode. | 260 | * mode. |
| 254 | */ | 261 | */ |
| 255 | struct kvm_mmu { | 262 | struct kvm_mmu { |
| 256 | void (*new_cr3)(struct kvm_vcpu *vcpu); | ||
| 257 | void (*set_cr3)(struct kvm_vcpu *vcpu, unsigned long root); | 263 | void (*set_cr3)(struct kvm_vcpu *vcpu, unsigned long root); |
| 258 | unsigned long (*get_cr3)(struct kvm_vcpu *vcpu); | 264 | unsigned long (*get_cr3)(struct kvm_vcpu *vcpu); |
| 259 | u64 (*get_pdptr)(struct kvm_vcpu *vcpu, int index); | 265 | u64 (*get_pdptr)(struct kvm_vcpu *vcpu, int index); |
| @@ -261,7 +267,6 @@ struct kvm_mmu { | |||
| 261 | bool prefault); | 267 | bool prefault); |
| 262 | void (*inject_page_fault)(struct kvm_vcpu *vcpu, | 268 | void (*inject_page_fault)(struct kvm_vcpu *vcpu, |
| 263 | struct x86_exception *fault); | 269 | struct x86_exception *fault); |
| 264 | void (*free)(struct kvm_vcpu *vcpu); | ||
| 265 | gpa_t (*gva_to_gpa)(struct kvm_vcpu *vcpu, gva_t gva, u32 access, | 270 | gpa_t (*gva_to_gpa)(struct kvm_vcpu *vcpu, gva_t gva, u32 access, |
| 266 | struct x86_exception *exception); | 271 | struct x86_exception *exception); |
| 267 | gpa_t (*translate_gpa)(struct kvm_vcpu *vcpu, gpa_t gpa, u32 access); | 272 | gpa_t (*translate_gpa)(struct kvm_vcpu *vcpu, gpa_t gpa, u32 access); |
| @@ -389,6 +394,8 @@ struct kvm_vcpu_arch { | |||
| 389 | 394 | ||
| 390 | struct fpu guest_fpu; | 395 | struct fpu guest_fpu; |
| 391 | u64 xcr0; | 396 | u64 xcr0; |
| 397 | u64 guest_supported_xcr0; | ||
| 398 | u32 guest_xstate_size; | ||
| 392 | 399 | ||
| 393 | struct kvm_pio_request pio; | 400 | struct kvm_pio_request pio; |
| 394 | void *pio_data; | 401 | void *pio_data; |
| @@ -557,7 +564,9 @@ struct kvm_arch { | |||
| 557 | 564 | ||
| 558 | struct list_head assigned_dev_head; | 565 | struct list_head assigned_dev_head; |
| 559 | struct iommu_domain *iommu_domain; | 566 | struct iommu_domain *iommu_domain; |
| 560 | int iommu_flags; | 567 | bool iommu_noncoherent; |
| 568 | #define __KVM_HAVE_ARCH_NONCOHERENT_DMA | ||
| 569 | atomic_t noncoherent_dma_count; | ||
| 561 | struct kvm_pic *vpic; | 570 | struct kvm_pic *vpic; |
| 562 | struct kvm_ioapic *vioapic; | 571 | struct kvm_ioapic *vioapic; |
| 563 | struct kvm_pit *vpit; | 572 | struct kvm_pit *vpit; |
| @@ -780,11 +789,11 @@ void kvm_mmu_module_exit(void); | |||
| 780 | 789 | ||
| 781 | void kvm_mmu_destroy(struct kvm_vcpu *vcpu); | 790 | void kvm_mmu_destroy(struct kvm_vcpu *vcpu); |
| 782 | int kvm_mmu_create(struct kvm_vcpu *vcpu); | 791 | int kvm_mmu_create(struct kvm_vcpu *vcpu); |
| 783 | int kvm_mmu_setup(struct kvm_vcpu *vcpu); | 792 | void kvm_mmu_setup(struct kvm_vcpu *vcpu); |
| 784 | void kvm_mmu_set_mask_ptes(u64 user_mask, u64 accessed_mask, | 793 | void kvm_mmu_set_mask_ptes(u64 user_mask, u64 accessed_mask, |
| 785 | u64 dirty_mask, u64 nx_mask, u64 x_mask); | 794 | u64 dirty_mask, u64 nx_mask, u64 x_mask); |
| 786 | 795 | ||
| 787 | int kvm_mmu_reset_context(struct kvm_vcpu *vcpu); | 796 | void kvm_mmu_reset_context(struct kvm_vcpu *vcpu); |
| 788 | void kvm_mmu_slot_remove_write_access(struct kvm *kvm, int slot); | 797 | void kvm_mmu_slot_remove_write_access(struct kvm *kvm, int slot); |
| 789 | void kvm_mmu_write_protect_pt_masked(struct kvm *kvm, | 798 | void kvm_mmu_write_protect_pt_masked(struct kvm *kvm, |
| 790 | struct kvm_memory_slot *slot, | 799 | struct kvm_memory_slot *slot, |
| @@ -922,13 +931,11 @@ int kvm_emulate_hypercall(struct kvm_vcpu *vcpu); | |||
| 922 | int kvm_mmu_page_fault(struct kvm_vcpu *vcpu, gva_t gva, u32 error_code, | 931 | int kvm_mmu_page_fault(struct kvm_vcpu *vcpu, gva_t gva, u32 error_code, |
| 923 | void *insn, int insn_len); | 932 | void *insn, int insn_len); |
| 924 | void kvm_mmu_invlpg(struct kvm_vcpu *vcpu, gva_t gva); | 933 | void kvm_mmu_invlpg(struct kvm_vcpu *vcpu, gva_t gva); |
| 934 | void kvm_mmu_new_cr3(struct kvm_vcpu *vcpu); | ||
| 925 | 935 | ||
| 926 | void kvm_enable_tdp(void); | 936 | void kvm_enable_tdp(void); |
| 927 | void kvm_disable_tdp(void); | 937 | void kvm_disable_tdp(void); |
| 928 | 938 | ||
| 929 | int complete_pio(struct kvm_vcpu *vcpu); | ||
| 930 | bool kvm_check_iopl(struct kvm_vcpu *vcpu); | ||
| 931 | |||
| 932 | static inline gpa_t translate_gpa(struct kvm_vcpu *vcpu, gpa_t gpa, u32 access) | 939 | static inline gpa_t translate_gpa(struct kvm_vcpu *vcpu, gpa_t gpa, u32 access) |
| 933 | { | 940 | { |
| 934 | return gpa; | 941 | return gpa; |
diff --git a/arch/x86/include/asm/pvclock.h b/arch/x86/include/asm/pvclock.h index be8269b00e2a..d6b078e9fa28 100644 --- a/arch/x86/include/asm/pvclock.h +++ b/arch/x86/include/asm/pvclock.h | |||
| @@ -14,6 +14,8 @@ void pvclock_read_wallclock(struct pvclock_wall_clock *wall, | |||
| 14 | struct timespec *ts); | 14 | struct timespec *ts); |
| 15 | void pvclock_resume(void); | 15 | void pvclock_resume(void); |
| 16 | 16 | ||
| 17 | void pvclock_touch_watchdogs(void); | ||
| 18 | |||
| 17 | /* | 19 | /* |
| 18 | * Scale a 64-bit delta by scaling and multiplying by a 32-bit fraction, | 20 | * Scale a 64-bit delta by scaling and multiplying by a 32-bit fraction, |
| 19 | * yielding a 64-bit result. | 21 | * yielding a 64-bit result. |
diff --git a/arch/x86/include/uapi/asm/kvm.h b/arch/x86/include/uapi/asm/kvm.h index 5d9a3033b3d7..d3a87780c70b 100644 --- a/arch/x86/include/uapi/asm/kvm.h +++ b/arch/x86/include/uapi/asm/kvm.h | |||
| @@ -211,9 +211,9 @@ struct kvm_cpuid_entry2 { | |||
| 211 | __u32 padding[3]; | 211 | __u32 padding[3]; |
| 212 | }; | 212 | }; |
| 213 | 213 | ||
| 214 | #define KVM_CPUID_FLAG_SIGNIFCANT_INDEX 1 | 214 | #define KVM_CPUID_FLAG_SIGNIFCANT_INDEX BIT(0) |
| 215 | #define KVM_CPUID_FLAG_STATEFUL_FUNC 2 | 215 | #define KVM_CPUID_FLAG_STATEFUL_FUNC BIT(1) |
| 216 | #define KVM_CPUID_FLAG_STATE_READ_NEXT 4 | 216 | #define KVM_CPUID_FLAG_STATE_READ_NEXT BIT(2) |
| 217 | 217 | ||
| 218 | /* for KVM_SET_CPUID2 */ | 218 | /* for KVM_SET_CPUID2 */ |
| 219 | struct kvm_cpuid2 { | 219 | struct kvm_cpuid2 { |
diff --git a/arch/x86/include/uapi/asm/msr-index.h b/arch/x86/include/uapi/asm/msr-index.h index bb0465090ae5..b93e09a0fa21 100644 --- a/arch/x86/include/uapi/asm/msr-index.h +++ b/arch/x86/include/uapi/asm/msr-index.h | |||
| @@ -536,6 +536,7 @@ | |||
| 536 | 536 | ||
| 537 | /* MSR_IA32_VMX_MISC bits */ | 537 | /* MSR_IA32_VMX_MISC bits */ |
| 538 | #define MSR_IA32_VMX_MISC_VMWRITE_SHADOW_RO_FIELDS (1ULL << 29) | 538 | #define MSR_IA32_VMX_MISC_VMWRITE_SHADOW_RO_FIELDS (1ULL << 29) |
| 539 | #define MSR_IA32_VMX_MISC_PREEMPTION_TIMER_SCALE 0x1F | ||
| 539 | /* AMD-V MSRs */ | 540 | /* AMD-V MSRs */ |
| 540 | 541 | ||
| 541 | #define MSR_VM_CR 0xc0010114 | 542 | #define MSR_VM_CR 0xc0010114 |
diff --git a/arch/x86/kernel/kvmclock.c b/arch/x86/kernel/kvmclock.c index 1570e0741344..e6041094ff26 100644 --- a/arch/x86/kernel/kvmclock.c +++ b/arch/x86/kernel/kvmclock.c | |||
| @@ -139,6 +139,7 @@ bool kvm_check_and_clear_guest_paused(void) | |||
| 139 | src = &hv_clock[cpu].pvti; | 139 | src = &hv_clock[cpu].pvti; |
| 140 | if ((src->flags & PVCLOCK_GUEST_STOPPED) != 0) { | 140 | if ((src->flags & PVCLOCK_GUEST_STOPPED) != 0) { |
| 141 | src->flags &= ~PVCLOCK_GUEST_STOPPED; | 141 | src->flags &= ~PVCLOCK_GUEST_STOPPED; |
| 142 | pvclock_touch_watchdogs(); | ||
| 142 | ret = true; | 143 | ret = true; |
| 143 | } | 144 | } |
| 144 | 145 | ||
diff --git a/arch/x86/kernel/pvclock.c b/arch/x86/kernel/pvclock.c index a16bae3f83b3..2f355d229a58 100644 --- a/arch/x86/kernel/pvclock.c +++ b/arch/x86/kernel/pvclock.c | |||
| @@ -43,6 +43,14 @@ unsigned long pvclock_tsc_khz(struct pvclock_vcpu_time_info *src) | |||
| 43 | return pv_tsc_khz; | 43 | return pv_tsc_khz; |
| 44 | } | 44 | } |
| 45 | 45 | ||
| 46 | void pvclock_touch_watchdogs(void) | ||
| 47 | { | ||
| 48 | touch_softlockup_watchdog_sync(); | ||
| 49 | clocksource_touch_watchdog(); | ||
| 50 | rcu_cpu_stall_reset(); | ||
| 51 | reset_hung_task_detector(); | ||
| 52 | } | ||
| 53 | |||
| 46 | static atomic64_t last_value = ATOMIC64_INIT(0); | 54 | static atomic64_t last_value = ATOMIC64_INIT(0); |
| 47 | 55 | ||
| 48 | void pvclock_resume(void) | 56 | void pvclock_resume(void) |
| @@ -74,6 +82,11 @@ cycle_t pvclock_clocksource_read(struct pvclock_vcpu_time_info *src) | |||
| 74 | version = __pvclock_read_cycles(src, &ret, &flags); | 82 | version = __pvclock_read_cycles(src, &ret, &flags); |
| 75 | } while ((src->version & 1) || version != src->version); | 83 | } while ((src->version & 1) || version != src->version); |
| 76 | 84 | ||
| 85 | if (unlikely((flags & PVCLOCK_GUEST_STOPPED) != 0)) { | ||
| 86 | src->flags &= ~PVCLOCK_GUEST_STOPPED; | ||
| 87 | pvclock_touch_watchdogs(); | ||
| 88 | } | ||
| 89 | |||
| 77 | if ((valid_flags & PVCLOCK_TSC_STABLE_BIT) && | 90 | if ((valid_flags & PVCLOCK_TSC_STABLE_BIT) && |
| 78 | (flags & PVCLOCK_TSC_STABLE_BIT)) | 91 | (flags & PVCLOCK_TSC_STABLE_BIT)) |
| 79 | return ret; | 92 | return ret; |
diff --git a/arch/x86/kvm/Kconfig b/arch/x86/kvm/Kconfig index a47a3e54b964..b89c5db2b832 100644 --- a/arch/x86/kvm/Kconfig +++ b/arch/x86/kvm/Kconfig | |||
| @@ -38,6 +38,7 @@ config KVM | |||
| 38 | select PERF_EVENTS | 38 | select PERF_EVENTS |
| 39 | select HAVE_KVM_MSI | 39 | select HAVE_KVM_MSI |
| 40 | select HAVE_KVM_CPU_RELAX_INTERCEPT | 40 | select HAVE_KVM_CPU_RELAX_INTERCEPT |
| 41 | select KVM_VFIO | ||
| 41 | ---help--- | 42 | ---help--- |
| 42 | Support hosting fully virtualized guest machines using hardware | 43 | Support hosting fully virtualized guest machines using hardware |
| 43 | virtualization extensions. You will need a fairly recent | 44 | virtualization extensions. You will need a fairly recent |
diff --git a/arch/x86/kvm/Makefile b/arch/x86/kvm/Makefile index bf4fb04d0112..25d22b2d6509 100644 --- a/arch/x86/kvm/Makefile +++ b/arch/x86/kvm/Makefile | |||
| @@ -9,7 +9,7 @@ KVM := ../../../virt/kvm | |||
| 9 | 9 | ||
| 10 | kvm-y += $(KVM)/kvm_main.o $(KVM)/ioapic.o \ | 10 | kvm-y += $(KVM)/kvm_main.o $(KVM)/ioapic.o \ |
| 11 | $(KVM)/coalesced_mmio.o $(KVM)/irq_comm.o \ | 11 | $(KVM)/coalesced_mmio.o $(KVM)/irq_comm.o \ |
| 12 | $(KVM)/eventfd.o $(KVM)/irqchip.o | 12 | $(KVM)/eventfd.o $(KVM)/irqchip.o $(KVM)/vfio.o |
| 13 | kvm-$(CONFIG_KVM_DEVICE_ASSIGNMENT) += $(KVM)/assigned-dev.o $(KVM)/iommu.o | 13 | kvm-$(CONFIG_KVM_DEVICE_ASSIGNMENT) += $(KVM)/assigned-dev.o $(KVM)/iommu.o |
| 14 | kvm-$(CONFIG_KVM_ASYNC_PF) += $(KVM)/async_pf.o | 14 | kvm-$(CONFIG_KVM_ASYNC_PF) += $(KVM)/async_pf.o |
| 15 | 15 | ||
diff --git a/arch/x86/kvm/cpuid.c b/arch/x86/kvm/cpuid.c index b110fe6c03d4..c6976257eff5 100644 --- a/arch/x86/kvm/cpuid.c +++ b/arch/x86/kvm/cpuid.c | |||
| @@ -23,6 +23,26 @@ | |||
| 23 | #include "mmu.h" | 23 | #include "mmu.h" |
| 24 | #include "trace.h" | 24 | #include "trace.h" |
| 25 | 25 | ||
| 26 | static u32 xstate_required_size(u64 xstate_bv) | ||
| 27 | { | ||
| 28 | int feature_bit = 0; | ||
| 29 | u32 ret = XSAVE_HDR_SIZE + XSAVE_HDR_OFFSET; | ||
| 30 | |||
| 31 | xstate_bv &= ~XSTATE_FPSSE; | ||
| 32 | while (xstate_bv) { | ||
| 33 | if (xstate_bv & 0x1) { | ||
| 34 | u32 eax, ebx, ecx, edx; | ||
| 35 | cpuid_count(0xD, feature_bit, &eax, &ebx, &ecx, &edx); | ||
| 36 | ret = max(ret, eax + ebx); | ||
| 37 | } | ||
| 38 | |||
| 39 | xstate_bv >>= 1; | ||
| 40 | feature_bit++; | ||
| 41 | } | ||
| 42 | |||
| 43 | return ret; | ||
| 44 | } | ||
| 45 | |||
| 26 | void kvm_update_cpuid(struct kvm_vcpu *vcpu) | 46 | void kvm_update_cpuid(struct kvm_vcpu *vcpu) |
| 27 | { | 47 | { |
| 28 | struct kvm_cpuid_entry2 *best; | 48 | struct kvm_cpuid_entry2 *best; |
| @@ -46,6 +66,18 @@ void kvm_update_cpuid(struct kvm_vcpu *vcpu) | |||
| 46 | apic->lapic_timer.timer_mode_mask = 1 << 17; | 66 | apic->lapic_timer.timer_mode_mask = 1 << 17; |
| 47 | } | 67 | } |
| 48 | 68 | ||
| 69 | best = kvm_find_cpuid_entry(vcpu, 0xD, 0); | ||
| 70 | if (!best) { | ||
| 71 | vcpu->arch.guest_supported_xcr0 = 0; | ||
| 72 | vcpu->arch.guest_xstate_size = XSAVE_HDR_SIZE + XSAVE_HDR_OFFSET; | ||
| 73 | } else { | ||
| 74 | vcpu->arch.guest_supported_xcr0 = | ||
| 75 | (best->eax | ((u64)best->edx << 32)) & | ||
| 76 | host_xcr0 & KVM_SUPPORTED_XCR0; | ||
| 77 | vcpu->arch.guest_xstate_size = | ||
| 78 | xstate_required_size(vcpu->arch.guest_supported_xcr0); | ||
| 79 | } | ||
| 80 | |||
| 49 | kvm_pmu_cpuid_update(vcpu); | 81 | kvm_pmu_cpuid_update(vcpu); |
| 50 | } | 82 | } |
| 51 | 83 | ||
| @@ -182,13 +214,35 @@ static bool supported_xcr0_bit(unsigned bit) | |||
| 182 | { | 214 | { |
| 183 | u64 mask = ((u64)1 << bit); | 215 | u64 mask = ((u64)1 << bit); |
| 184 | 216 | ||
| 185 | return mask & (XSTATE_FP | XSTATE_SSE | XSTATE_YMM) & host_xcr0; | 217 | return mask & KVM_SUPPORTED_XCR0 & host_xcr0; |
| 186 | } | 218 | } |
| 187 | 219 | ||
| 188 | #define F(x) bit(X86_FEATURE_##x) | 220 | #define F(x) bit(X86_FEATURE_##x) |
| 189 | 221 | ||
| 190 | static int do_cpuid_ent(struct kvm_cpuid_entry2 *entry, u32 function, | 222 | static int __do_cpuid_ent_emulated(struct kvm_cpuid_entry2 *entry, |
| 191 | u32 index, int *nent, int maxnent) | 223 | u32 func, u32 index, int *nent, int maxnent) |
| 224 | { | ||
| 225 | switch (func) { | ||
| 226 | case 0: | ||
| 227 | entry->eax = 1; /* only one leaf currently */ | ||
| 228 | ++*nent; | ||
| 229 | break; | ||
| 230 | case 1: | ||
| 231 | entry->ecx = F(MOVBE); | ||
| 232 | ++*nent; | ||
| 233 | break; | ||
| 234 | default: | ||
| 235 | break; | ||
| 236 | } | ||
| 237 | |||
| 238 | entry->function = func; | ||
| 239 | entry->index = index; | ||
| 240 | |||
| 241 | return 0; | ||
| 242 | } | ||
| 243 | |||
| 244 | static inline int __do_cpuid_ent(struct kvm_cpuid_entry2 *entry, u32 function, | ||
| 245 | u32 index, int *nent, int maxnent) | ||
| 192 | { | 246 | { |
| 193 | int r; | 247 | int r; |
| 194 | unsigned f_nx = is_efer_nx() ? F(NX) : 0; | 248 | unsigned f_nx = is_efer_nx() ? F(NX) : 0; |
| @@ -383,6 +437,8 @@ static int do_cpuid_ent(struct kvm_cpuid_entry2 *entry, u32 function, | |||
| 383 | case 0xd: { | 437 | case 0xd: { |
| 384 | int idx, i; | 438 | int idx, i; |
| 385 | 439 | ||
| 440 | entry->eax &= host_xcr0 & KVM_SUPPORTED_XCR0; | ||
| 441 | entry->edx &= (host_xcr0 & KVM_SUPPORTED_XCR0) >> 32; | ||
| 386 | entry->flags |= KVM_CPUID_FLAG_SIGNIFCANT_INDEX; | 442 | entry->flags |= KVM_CPUID_FLAG_SIGNIFCANT_INDEX; |
| 387 | for (idx = 1, i = 1; idx < 64; ++idx) { | 443 | for (idx = 1, i = 1; idx < 64; ++idx) { |
| 388 | if (*nent >= maxnent) | 444 | if (*nent >= maxnent) |
| @@ -481,6 +537,15 @@ out: | |||
| 481 | return r; | 537 | return r; |
| 482 | } | 538 | } |
| 483 | 539 | ||
| 540 | static int do_cpuid_ent(struct kvm_cpuid_entry2 *entry, u32 func, | ||
| 541 | u32 idx, int *nent, int maxnent, unsigned int type) | ||
| 542 | { | ||
| 543 | if (type == KVM_GET_EMULATED_CPUID) | ||
| 544 | return __do_cpuid_ent_emulated(entry, func, idx, nent, maxnent); | ||
| 545 | |||
| 546 | return __do_cpuid_ent(entry, func, idx, nent, maxnent); | ||
| 547 | } | ||
| 548 | |||
| 484 | #undef F | 549 | #undef F |
| 485 | 550 | ||
| 486 | struct kvm_cpuid_param { | 551 | struct kvm_cpuid_param { |
| @@ -495,8 +560,36 @@ static bool is_centaur_cpu(const struct kvm_cpuid_param *param) | |||
| 495 | return boot_cpu_data.x86_vendor == X86_VENDOR_CENTAUR; | 560 | return boot_cpu_data.x86_vendor == X86_VENDOR_CENTAUR; |
| 496 | } | 561 | } |
| 497 | 562 | ||
| 498 | int kvm_dev_ioctl_get_supported_cpuid(struct kvm_cpuid2 *cpuid, | 563 | static bool sanity_check_entries(struct kvm_cpuid_entry2 __user *entries, |
| 499 | struct kvm_cpuid_entry2 __user *entries) | 564 | __u32 num_entries, unsigned int ioctl_type) |
| 565 | { | ||
| 566 | int i; | ||
| 567 | __u32 pad[3]; | ||
| 568 | |||
| 569 | if (ioctl_type != KVM_GET_EMULATED_CPUID) | ||
| 570 | return false; | ||
| 571 | |||
| 572 | /* | ||
| 573 | * We want to make sure that ->padding is being passed clean from | ||
| 574 | * userspace in case we want to use it for something in the future. | ||
| 575 | * | ||
| 576 | * Sadly, this wasn't enforced for KVM_GET_SUPPORTED_CPUID and so we | ||
| 577 | * have to give ourselves satisfied only with the emulated side. /me | ||
| 578 | * sheds a tear. | ||
| 579 | */ | ||
| 580 | for (i = 0; i < num_entries; i++) { | ||
| 581 | if (copy_from_user(pad, entries[i].padding, sizeof(pad))) | ||
| 582 | return true; | ||
| 583 | |||
| 584 | if (pad[0] || pad[1] || pad[2]) | ||
| 585 | return true; | ||
| 586 | } | ||
| 587 | return false; | ||
| 588 | } | ||
| 589 | |||
| 590 | int kvm_dev_ioctl_get_cpuid(struct kvm_cpuid2 *cpuid, | ||
| 591 | struct kvm_cpuid_entry2 __user *entries, | ||
| 592 | unsigned int type) | ||
| 500 | { | 593 | { |
| 501 | struct kvm_cpuid_entry2 *cpuid_entries; | 594 | struct kvm_cpuid_entry2 *cpuid_entries; |
| 502 | int limit, nent = 0, r = -E2BIG, i; | 595 | int limit, nent = 0, r = -E2BIG, i; |
| @@ -513,8 +606,12 @@ int kvm_dev_ioctl_get_supported_cpuid(struct kvm_cpuid2 *cpuid, | |||
| 513 | goto out; | 606 | goto out; |
| 514 | if (cpuid->nent > KVM_MAX_CPUID_ENTRIES) | 607 | if (cpuid->nent > KVM_MAX_CPUID_ENTRIES) |
| 515 | cpuid->nent = KVM_MAX_CPUID_ENTRIES; | 608 | cpuid->nent = KVM_MAX_CPUID_ENTRIES; |
| 609 | |||
| 610 | if (sanity_check_entries(entries, cpuid->nent, type)) | ||
| 611 | return -EINVAL; | ||
| 612 | |||
| 516 | r = -ENOMEM; | 613 | r = -ENOMEM; |
| 517 | cpuid_entries = vmalloc(sizeof(struct kvm_cpuid_entry2) * cpuid->nent); | 614 | cpuid_entries = vzalloc(sizeof(struct kvm_cpuid_entry2) * cpuid->nent); |
| 518 | if (!cpuid_entries) | 615 | if (!cpuid_entries) |
| 519 | goto out; | 616 | goto out; |
| 520 | 617 | ||
| @@ -526,7 +623,7 @@ int kvm_dev_ioctl_get_supported_cpuid(struct kvm_cpuid2 *cpuid, | |||
| 526 | continue; | 623 | continue; |
| 527 | 624 | ||
| 528 | r = do_cpuid_ent(&cpuid_entries[nent], ent->func, ent->idx, | 625 | r = do_cpuid_ent(&cpuid_entries[nent], ent->func, ent->idx, |
| 529 | &nent, cpuid->nent); | 626 | &nent, cpuid->nent, type); |
| 530 | 627 | ||
| 531 | if (r) | 628 | if (r) |
| 532 | goto out_free; | 629 | goto out_free; |
| @@ -537,7 +634,7 @@ int kvm_dev_ioctl_get_supported_cpuid(struct kvm_cpuid2 *cpuid, | |||
| 537 | limit = cpuid_entries[nent - 1].eax; | 634 | limit = cpuid_entries[nent - 1].eax; |
| 538 | for (func = ent->func + 1; func <= limit && nent < cpuid->nent && r == 0; ++func) | 635 | for (func = ent->func + 1; func <= limit && nent < cpuid->nent && r == 0; ++func) |
| 539 | r = do_cpuid_ent(&cpuid_entries[nent], func, ent->idx, | 636 | r = do_cpuid_ent(&cpuid_entries[nent], func, ent->idx, |
| 540 | &nent, cpuid->nent); | 637 | &nent, cpuid->nent, type); |
| 541 | 638 | ||
| 542 | if (r) | 639 | if (r) |
| 543 | goto out_free; | 640 | goto out_free; |
| @@ -661,6 +758,7 @@ void kvm_cpuid(struct kvm_vcpu *vcpu, u32 *eax, u32 *ebx, u32 *ecx, u32 *edx) | |||
| 661 | *edx = best->edx; | 758 | *edx = best->edx; |
| 662 | } else | 759 | } else |
| 663 | *eax = *ebx = *ecx = *edx = 0; | 760 | *eax = *ebx = *ecx = *edx = 0; |
| 761 | trace_kvm_cpuid(function, *eax, *ebx, *ecx, *edx); | ||
| 664 | } | 762 | } |
| 665 | EXPORT_SYMBOL_GPL(kvm_cpuid); | 763 | EXPORT_SYMBOL_GPL(kvm_cpuid); |
| 666 | 764 | ||
| @@ -676,6 +774,5 @@ void kvm_emulate_cpuid(struct kvm_vcpu *vcpu) | |||
| 676 | kvm_register_write(vcpu, VCPU_REGS_RCX, ecx); | 774 | kvm_register_write(vcpu, VCPU_REGS_RCX, ecx); |
| 677 | kvm_register_write(vcpu, VCPU_REGS_RDX, edx); | 775 | kvm_register_write(vcpu, VCPU_REGS_RDX, edx); |
| 678 | kvm_x86_ops->skip_emulated_instruction(vcpu); | 776 | kvm_x86_ops->skip_emulated_instruction(vcpu); |
| 679 | trace_kvm_cpuid(function, eax, ebx, ecx, edx); | ||
| 680 | } | 777 | } |
| 681 | EXPORT_SYMBOL_GPL(kvm_emulate_cpuid); | 778 | EXPORT_SYMBOL_GPL(kvm_emulate_cpuid); |
diff --git a/arch/x86/kvm/cpuid.h b/arch/x86/kvm/cpuid.h index b7fd07984888..f1e4895174b2 100644 --- a/arch/x86/kvm/cpuid.h +++ b/arch/x86/kvm/cpuid.h | |||
| @@ -6,8 +6,9 @@ | |||
| 6 | void kvm_update_cpuid(struct kvm_vcpu *vcpu); | 6 | void kvm_update_cpuid(struct kvm_vcpu *vcpu); |
| 7 | struct kvm_cpuid_entry2 *kvm_find_cpuid_entry(struct kvm_vcpu *vcpu, | 7 | struct kvm_cpuid_entry2 *kvm_find_cpuid_entry(struct kvm_vcpu *vcpu, |
| 8 | u32 function, u32 index); | 8 | u32 function, u32 index); |
| 9 | int kvm_dev_ioctl_get_supported_cpuid(struct kvm_cpuid2 *cpuid, | 9 | int kvm_dev_ioctl_get_cpuid(struct kvm_cpuid2 *cpuid, |
| 10 | struct kvm_cpuid_entry2 __user *entries); | 10 | struct kvm_cpuid_entry2 __user *entries, |
| 11 | unsigned int type); | ||
| 11 | int kvm_vcpu_ioctl_set_cpuid(struct kvm_vcpu *vcpu, | 12 | int kvm_vcpu_ioctl_set_cpuid(struct kvm_vcpu *vcpu, |
| 12 | struct kvm_cpuid *cpuid, | 13 | struct kvm_cpuid *cpuid, |
| 13 | struct kvm_cpuid_entry __user *entries); | 14 | struct kvm_cpuid_entry __user *entries); |
diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c index ddc3f3d2afdb..07ffca0a89e9 100644 --- a/arch/x86/kvm/emulate.c +++ b/arch/x86/kvm/emulate.c | |||
| @@ -130,7 +130,7 @@ | |||
| 130 | #define Mov (1<<20) | 130 | #define Mov (1<<20) |
| 131 | /* Misc flags */ | 131 | /* Misc flags */ |
| 132 | #define Prot (1<<21) /* instruction generates #UD if not in prot-mode */ | 132 | #define Prot (1<<21) /* instruction generates #UD if not in prot-mode */ |
| 133 | #define VendorSpecific (1<<22) /* Vendor specific instruction */ | 133 | #define EmulateOnUD (1<<22) /* Emulate if unsupported by the host */ |
| 134 | #define NoAccess (1<<23) /* Don't access memory (lea/invlpg/verr etc) */ | 134 | #define NoAccess (1<<23) /* Don't access memory (lea/invlpg/verr etc) */ |
| 135 | #define Op3264 (1<<24) /* Operand is 64b in long mode, 32b otherwise */ | 135 | #define Op3264 (1<<24) /* Operand is 64b in long mode, 32b otherwise */ |
| 136 | #define Undefined (1<<25) /* No Such Instruction */ | 136 | #define Undefined (1<<25) /* No Such Instruction */ |
| @@ -785,9 +785,10 @@ static int do_insn_fetch(struct x86_emulate_ctxt *ctxt, | |||
| 785 | * @highbyte_regs specifies whether to decode AH,CH,DH,BH. | 785 | * @highbyte_regs specifies whether to decode AH,CH,DH,BH. |
| 786 | */ | 786 | */ |
| 787 | static void *decode_register(struct x86_emulate_ctxt *ctxt, u8 modrm_reg, | 787 | static void *decode_register(struct x86_emulate_ctxt *ctxt, u8 modrm_reg, |
| 788 | int highbyte_regs) | 788 | int byteop) |
| 789 | { | 789 | { |
| 790 | void *p; | 790 | void *p; |
| 791 | int highbyte_regs = (ctxt->rex_prefix == 0) && byteop; | ||
| 791 | 792 | ||
| 792 | if (highbyte_regs && modrm_reg >= 4 && modrm_reg < 8) | 793 | if (highbyte_regs && modrm_reg >= 4 && modrm_reg < 8) |
| 793 | p = (unsigned char *)reg_rmw(ctxt, modrm_reg & 3) + 1; | 794 | p = (unsigned char *)reg_rmw(ctxt, modrm_reg & 3) + 1; |
| @@ -1024,7 +1025,6 @@ static void decode_register_operand(struct x86_emulate_ctxt *ctxt, | |||
| 1024 | struct operand *op) | 1025 | struct operand *op) |
| 1025 | { | 1026 | { |
| 1026 | unsigned reg = ctxt->modrm_reg; | 1027 | unsigned reg = ctxt->modrm_reg; |
| 1027 | int highbyte_regs = ctxt->rex_prefix == 0; | ||
| 1028 | 1028 | ||
| 1029 | if (!(ctxt->d & ModRM)) | 1029 | if (!(ctxt->d & ModRM)) |
| 1030 | reg = (ctxt->b & 7) | ((ctxt->rex_prefix & 1) << 3); | 1030 | reg = (ctxt->b & 7) | ((ctxt->rex_prefix & 1) << 3); |
| @@ -1045,13 +1045,9 @@ static void decode_register_operand(struct x86_emulate_ctxt *ctxt, | |||
| 1045 | } | 1045 | } |
| 1046 | 1046 | ||
| 1047 | op->type = OP_REG; | 1047 | op->type = OP_REG; |
| 1048 | if (ctxt->d & ByteOp) { | 1048 | op->bytes = (ctxt->d & ByteOp) ? 1 : ctxt->op_bytes; |
| 1049 | op->addr.reg = decode_register(ctxt, reg, highbyte_regs); | 1049 | op->addr.reg = decode_register(ctxt, reg, ctxt->d & ByteOp); |
| 1050 | op->bytes = 1; | 1050 | |
| 1051 | } else { | ||
| 1052 | op->addr.reg = decode_register(ctxt, reg, 0); | ||
| 1053 | op->bytes = ctxt->op_bytes; | ||
| 1054 | } | ||
| 1055 | fetch_register_operand(op); | 1051 | fetch_register_operand(op); |
| 1056 | op->orig_val = op->val; | 1052 | op->orig_val = op->val; |
| 1057 | } | 1053 | } |
| @@ -1082,12 +1078,10 @@ static int decode_modrm(struct x86_emulate_ctxt *ctxt, | |||
| 1082 | ctxt->modrm_seg = VCPU_SREG_DS; | 1078 | ctxt->modrm_seg = VCPU_SREG_DS; |
| 1083 | 1079 | ||
| 1084 | if (ctxt->modrm_mod == 3) { | 1080 | if (ctxt->modrm_mod == 3) { |
| 1085 | int highbyte_regs = ctxt->rex_prefix == 0; | ||
| 1086 | |||
| 1087 | op->type = OP_REG; | 1081 | op->type = OP_REG; |
| 1088 | op->bytes = (ctxt->d & ByteOp) ? 1 : ctxt->op_bytes; | 1082 | op->bytes = (ctxt->d & ByteOp) ? 1 : ctxt->op_bytes; |
| 1089 | op->addr.reg = decode_register(ctxt, ctxt->modrm_rm, | 1083 | op->addr.reg = decode_register(ctxt, ctxt->modrm_rm, |
| 1090 | highbyte_regs && (ctxt->d & ByteOp)); | 1084 | ctxt->d & ByteOp); |
| 1091 | if (ctxt->d & Sse) { | 1085 | if (ctxt->d & Sse) { |
| 1092 | op->type = OP_XMM; | 1086 | op->type = OP_XMM; |
| 1093 | op->bytes = 16; | 1087 | op->bytes = 16; |
| @@ -2961,6 +2955,46 @@ static int em_mov(struct x86_emulate_ctxt *ctxt) | |||
| 2961 | return X86EMUL_CONTINUE; | 2955 | return X86EMUL_CONTINUE; |
| 2962 | } | 2956 | } |
| 2963 | 2957 | ||
| 2958 | #define FFL(x) bit(X86_FEATURE_##x) | ||
| 2959 | |||
| 2960 | static int em_movbe(struct x86_emulate_ctxt *ctxt) | ||
| 2961 | { | ||
| 2962 | u32 ebx, ecx, edx, eax = 1; | ||
| 2963 | u16 tmp; | ||
| 2964 | |||
| 2965 | /* | ||
| 2966 | * Check MOVBE is set in the guest-visible CPUID leaf. | ||
| 2967 | */ | ||
| 2968 | ctxt->ops->get_cpuid(ctxt, &eax, &ebx, &ecx, &edx); | ||
| 2969 | if (!(ecx & FFL(MOVBE))) | ||
| 2970 | return emulate_ud(ctxt); | ||
| 2971 | |||
| 2972 | switch (ctxt->op_bytes) { | ||
| 2973 | case 2: | ||
| 2974 | /* | ||
| 2975 | * From MOVBE definition: "...When the operand size is 16 bits, | ||
| 2976 | * the upper word of the destination register remains unchanged | ||
| 2977 | * ..." | ||
| 2978 | * | ||
| 2979 | * Both casting ->valptr and ->val to u16 breaks strict aliasing | ||
| 2980 | * rules so we have to do the operation almost per hand. | ||
| 2981 | */ | ||
| 2982 | tmp = (u16)ctxt->src.val; | ||
| 2983 | ctxt->dst.val &= ~0xffffUL; | ||
| 2984 | ctxt->dst.val |= (unsigned long)swab16(tmp); | ||
| 2985 | break; | ||
| 2986 | case 4: | ||
| 2987 | ctxt->dst.val = swab32((u32)ctxt->src.val); | ||
| 2988 | break; | ||
| 2989 | case 8: | ||
| 2990 | ctxt->dst.val = swab64(ctxt->src.val); | ||
| 2991 | break; | ||
| 2992 | default: | ||
| 2993 | return X86EMUL_PROPAGATE_FAULT; | ||
| 2994 | } | ||
| 2995 | return X86EMUL_CONTINUE; | ||
| 2996 | } | ||
| 2997 | |||
| 2964 | static int em_cr_write(struct x86_emulate_ctxt *ctxt) | 2998 | static int em_cr_write(struct x86_emulate_ctxt *ctxt) |
| 2965 | { | 2999 | { |
| 2966 | if (ctxt->ops->set_cr(ctxt, ctxt->modrm_reg, ctxt->src.val)) | 3000 | if (ctxt->ops->set_cr(ctxt, ctxt->modrm_reg, ctxt->src.val)) |
| @@ -3256,6 +3290,18 @@ static int em_cpuid(struct x86_emulate_ctxt *ctxt) | |||
| 3256 | return X86EMUL_CONTINUE; | 3290 | return X86EMUL_CONTINUE; |
| 3257 | } | 3291 | } |
| 3258 | 3292 | ||
| 3293 | static int em_sahf(struct x86_emulate_ctxt *ctxt) | ||
| 3294 | { | ||
| 3295 | u32 flags; | ||
| 3296 | |||
| 3297 | flags = EFLG_CF | EFLG_PF | EFLG_AF | EFLG_ZF | EFLG_SF; | ||
| 3298 | flags &= *reg_rmw(ctxt, VCPU_REGS_RAX) >> 8; | ||
| 3299 | |||
| 3300 | ctxt->eflags &= ~0xffUL; | ||
| 3301 | ctxt->eflags |= flags | X86_EFLAGS_FIXED; | ||
| 3302 | return X86EMUL_CONTINUE; | ||
| 3303 | } | ||
| 3304 | |||
| 3259 | static int em_lahf(struct x86_emulate_ctxt *ctxt) | 3305 | static int em_lahf(struct x86_emulate_ctxt *ctxt) |
| 3260 | { | 3306 | { |
| 3261 | *reg_rmw(ctxt, VCPU_REGS_RAX) &= ~0xff00UL; | 3307 | *reg_rmw(ctxt, VCPU_REGS_RAX) &= ~0xff00UL; |
| @@ -3502,7 +3548,7 @@ static const struct opcode group7_rm1[] = { | |||
| 3502 | 3548 | ||
| 3503 | static const struct opcode group7_rm3[] = { | 3549 | static const struct opcode group7_rm3[] = { |
| 3504 | DIP(SrcNone | Prot | Priv, vmrun, check_svme_pa), | 3550 | DIP(SrcNone | Prot | Priv, vmrun, check_svme_pa), |
| 3505 | II(SrcNone | Prot | VendorSpecific, em_vmmcall, vmmcall), | 3551 | II(SrcNone | Prot | EmulateOnUD, em_vmmcall, vmmcall), |
| 3506 | DIP(SrcNone | Prot | Priv, vmload, check_svme_pa), | 3552 | DIP(SrcNone | Prot | Priv, vmload, check_svme_pa), |
| 3507 | DIP(SrcNone | Prot | Priv, vmsave, check_svme_pa), | 3553 | DIP(SrcNone | Prot | Priv, vmsave, check_svme_pa), |
| 3508 | DIP(SrcNone | Prot | Priv, stgi, check_svme), | 3554 | DIP(SrcNone | Prot | Priv, stgi, check_svme), |
| @@ -3587,7 +3633,7 @@ static const struct group_dual group7 = { { | |||
| 3587 | II(SrcMem16 | Mov | Priv, em_lmsw, lmsw), | 3633 | II(SrcMem16 | Mov | Priv, em_lmsw, lmsw), |
| 3588 | II(SrcMem | ByteOp | Priv | NoAccess, em_invlpg, invlpg), | 3634 | II(SrcMem | ByteOp | Priv | NoAccess, em_invlpg, invlpg), |
| 3589 | }, { | 3635 | }, { |
| 3590 | I(SrcNone | Priv | VendorSpecific, em_vmcall), | 3636 | I(SrcNone | Priv | EmulateOnUD, em_vmcall), |
| 3591 | EXT(0, group7_rm1), | 3637 | EXT(0, group7_rm1), |
| 3592 | N, EXT(0, group7_rm3), | 3638 | N, EXT(0, group7_rm3), |
| 3593 | II(SrcNone | DstMem | Mov, em_smsw, smsw), N, | 3639 | II(SrcNone | DstMem | Mov, em_smsw, smsw), N, |
| @@ -3750,7 +3796,8 @@ static const struct opcode opcode_table[256] = { | |||
| 3750 | D(DstAcc | SrcNone), I(ImplicitOps | SrcAcc, em_cwd), | 3796 | D(DstAcc | SrcNone), I(ImplicitOps | SrcAcc, em_cwd), |
| 3751 | I(SrcImmFAddr | No64, em_call_far), N, | 3797 | I(SrcImmFAddr | No64, em_call_far), N, |
| 3752 | II(ImplicitOps | Stack, em_pushf, pushf), | 3798 | II(ImplicitOps | Stack, em_pushf, pushf), |
| 3753 | II(ImplicitOps | Stack, em_popf, popf), N, I(ImplicitOps, em_lahf), | 3799 | II(ImplicitOps | Stack, em_popf, popf), |
| 3800 | I(ImplicitOps, em_sahf), I(ImplicitOps, em_lahf), | ||
| 3754 | /* 0xA0 - 0xA7 */ | 3801 | /* 0xA0 - 0xA7 */ |
| 3755 | I2bv(DstAcc | SrcMem | Mov | MemAbs, em_mov), | 3802 | I2bv(DstAcc | SrcMem | Mov | MemAbs, em_mov), |
| 3756 | I2bv(DstMem | SrcAcc | Mov | MemAbs | PageTable, em_mov), | 3803 | I2bv(DstMem | SrcAcc | Mov | MemAbs | PageTable, em_mov), |
| @@ -3810,7 +3857,7 @@ static const struct opcode opcode_table[256] = { | |||
| 3810 | static const struct opcode twobyte_table[256] = { | 3857 | static const struct opcode twobyte_table[256] = { |
| 3811 | /* 0x00 - 0x0F */ | 3858 | /* 0x00 - 0x0F */ |
| 3812 | G(0, group6), GD(0, &group7), N, N, | 3859 | G(0, group6), GD(0, &group7), N, N, |
| 3813 | N, I(ImplicitOps | VendorSpecific, em_syscall), | 3860 | N, I(ImplicitOps | EmulateOnUD, em_syscall), |
| 3814 | II(ImplicitOps | Priv, em_clts, clts), N, | 3861 | II(ImplicitOps | Priv, em_clts, clts), N, |
| 3815 | DI(ImplicitOps | Priv, invd), DI(ImplicitOps | Priv, wbinvd), N, N, | 3862 | DI(ImplicitOps | Priv, invd), DI(ImplicitOps | Priv, wbinvd), N, N, |
| 3816 | N, D(ImplicitOps | ModRM), N, N, | 3863 | N, D(ImplicitOps | ModRM), N, N, |
| @@ -3830,8 +3877,8 @@ static const struct opcode twobyte_table[256] = { | |||
| 3830 | IIP(ImplicitOps, em_rdtsc, rdtsc, check_rdtsc), | 3877 | IIP(ImplicitOps, em_rdtsc, rdtsc, check_rdtsc), |
| 3831 | II(ImplicitOps | Priv, em_rdmsr, rdmsr), | 3878 | II(ImplicitOps | Priv, em_rdmsr, rdmsr), |
| 3832 | IIP(ImplicitOps, em_rdpmc, rdpmc, check_rdpmc), | 3879 | IIP(ImplicitOps, em_rdpmc, rdpmc, check_rdpmc), |
| 3833 | I(ImplicitOps | VendorSpecific, em_sysenter), | 3880 | I(ImplicitOps | EmulateOnUD, em_sysenter), |
| 3834 | I(ImplicitOps | Priv | VendorSpecific, em_sysexit), | 3881 | I(ImplicitOps | Priv | EmulateOnUD, em_sysexit), |
| 3835 | N, N, | 3882 | N, N, |
| 3836 | N, N, N, N, N, N, N, N, | 3883 | N, N, N, N, N, N, N, N, |
| 3837 | /* 0x40 - 0x4F */ | 3884 | /* 0x40 - 0x4F */ |
| @@ -3892,6 +3939,30 @@ static const struct opcode twobyte_table[256] = { | |||
| 3892 | N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N | 3939 | N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N |
| 3893 | }; | 3940 | }; |
| 3894 | 3941 | ||
| 3942 | static const struct gprefix three_byte_0f_38_f0 = { | ||
| 3943 | I(DstReg | SrcMem | Mov, em_movbe), N, N, N | ||
| 3944 | }; | ||
| 3945 | |||
| 3946 | static const struct gprefix three_byte_0f_38_f1 = { | ||
| 3947 | I(DstMem | SrcReg | Mov, em_movbe), N, N, N | ||
| 3948 | }; | ||
| 3949 | |||
| 3950 | /* | ||
| 3951 | * Insns below are selected by the prefix which indexed by the third opcode | ||
| 3952 | * byte. | ||
| 3953 | */ | ||
| 3954 | static const struct opcode opcode_map_0f_38[256] = { | ||
| 3955 | /* 0x00 - 0x7f */ | ||
| 3956 | X16(N), X16(N), X16(N), X16(N), X16(N), X16(N), X16(N), X16(N), | ||
| 3957 | /* 0x80 - 0xef */ | ||
| 3958 | X16(N), X16(N), X16(N), X16(N), X16(N), X16(N), X16(N), | ||
| 3959 | /* 0xf0 - 0xf1 */ | ||
| 3960 | GP(EmulateOnUD | ModRM | Prefix, &three_byte_0f_38_f0), | ||
| 3961 | GP(EmulateOnUD | ModRM | Prefix, &three_byte_0f_38_f1), | ||
| 3962 | /* 0xf2 - 0xff */ | ||
| 3963 | N, N, X4(N), X8(N) | ||
| 3964 | }; | ||
| 3965 | |||
| 3895 | #undef D | 3966 | #undef D |
| 3896 | #undef N | 3967 | #undef N |
| 3897 | #undef G | 3968 | #undef G |
| @@ -4040,7 +4111,8 @@ static int decode_operand(struct x86_emulate_ctxt *ctxt, struct operand *op, | |||
| 4040 | case OpMem8: | 4111 | case OpMem8: |
| 4041 | ctxt->memop.bytes = 1; | 4112 | ctxt->memop.bytes = 1; |
| 4042 | if (ctxt->memop.type == OP_REG) { | 4113 | if (ctxt->memop.type == OP_REG) { |
| 4043 | ctxt->memop.addr.reg = decode_register(ctxt, ctxt->modrm_rm, 1); | 4114 | ctxt->memop.addr.reg = decode_register(ctxt, |
| 4115 | ctxt->modrm_rm, true); | ||
| 4044 | fetch_register_operand(&ctxt->memop); | 4116 | fetch_register_operand(&ctxt->memop); |
| 4045 | } | 4117 | } |
| 4046 | goto mem_common; | 4118 | goto mem_common; |
| @@ -4126,6 +4198,7 @@ int x86_decode_insn(struct x86_emulate_ctxt *ctxt, void *insn, int insn_len) | |||
| 4126 | ctxt->_eip = ctxt->eip; | 4198 | ctxt->_eip = ctxt->eip; |
| 4127 | ctxt->fetch.start = ctxt->_eip; | 4199 | ctxt->fetch.start = ctxt->_eip; |
| 4128 | ctxt->fetch.end = ctxt->fetch.start + insn_len; | 4200 | ctxt->fetch.end = ctxt->fetch.start + insn_len; |
| 4201 | ctxt->opcode_len = 1; | ||
| 4129 | if (insn_len > 0) | 4202 | if (insn_len > 0) |
| 4130 | memcpy(ctxt->fetch.data, insn, insn_len); | 4203 | memcpy(ctxt->fetch.data, insn, insn_len); |
| 4131 | 4204 | ||
| @@ -4208,9 +4281,16 @@ done_prefixes: | |||
| 4208 | opcode = opcode_table[ctxt->b]; | 4281 | opcode = opcode_table[ctxt->b]; |
| 4209 | /* Two-byte opcode? */ | 4282 | /* Two-byte opcode? */ |
| 4210 | if (ctxt->b == 0x0f) { | 4283 | if (ctxt->b == 0x0f) { |
| 4211 | ctxt->twobyte = 1; | 4284 | ctxt->opcode_len = 2; |
| 4212 | ctxt->b = insn_fetch(u8, ctxt); | 4285 | ctxt->b = insn_fetch(u8, ctxt); |
| 4213 | opcode = twobyte_table[ctxt->b]; | 4286 | opcode = twobyte_table[ctxt->b]; |
| 4287 | |||
| 4288 | /* 0F_38 opcode map */ | ||
| 4289 | if (ctxt->b == 0x38) { | ||
| 4290 | ctxt->opcode_len = 3; | ||
| 4291 | ctxt->b = insn_fetch(u8, ctxt); | ||
| 4292 | opcode = opcode_map_0f_38[ctxt->b]; | ||
| 4293 | } | ||
| 4214 | } | 4294 | } |
| 4215 | ctxt->d = opcode.flags; | 4295 | ctxt->d = opcode.flags; |
| 4216 | 4296 | ||
| @@ -4267,7 +4347,7 @@ done_prefixes: | |||
| 4267 | if (ctxt->d == 0 || (ctxt->d & NotImpl)) | 4347 | if (ctxt->d == 0 || (ctxt->d & NotImpl)) |
| 4268 | return EMULATION_FAILED; | 4348 | return EMULATION_FAILED; |
| 4269 | 4349 | ||
| 4270 | if (!(ctxt->d & VendorSpecific) && ctxt->only_vendor_specific_insn) | 4350 | if (!(ctxt->d & EmulateOnUD) && ctxt->ud) |
| 4271 | return EMULATION_FAILED; | 4351 | return EMULATION_FAILED; |
| 4272 | 4352 | ||
| 4273 | if (mode == X86EMUL_MODE_PROT64 && (ctxt->d & Stack)) | 4353 | if (mode == X86EMUL_MODE_PROT64 && (ctxt->d & Stack)) |
| @@ -4540,8 +4620,10 @@ special_insn: | |||
| 4540 | goto writeback; | 4620 | goto writeback; |
| 4541 | } | 4621 | } |
| 4542 | 4622 | ||
| 4543 | if (ctxt->twobyte) | 4623 | if (ctxt->opcode_len == 2) |
| 4544 | goto twobyte_insn; | 4624 | goto twobyte_insn; |
| 4625 | else if (ctxt->opcode_len == 3) | ||
| 4626 | goto threebyte_insn; | ||
| 4545 | 4627 | ||
| 4546 | switch (ctxt->b) { | 4628 | switch (ctxt->b) { |
| 4547 | case 0x63: /* movsxd */ | 4629 | case 0x63: /* movsxd */ |
| @@ -4726,6 +4808,8 @@ twobyte_insn: | |||
| 4726 | goto cannot_emulate; | 4808 | goto cannot_emulate; |
| 4727 | } | 4809 | } |
| 4728 | 4810 | ||
| 4811 | threebyte_insn: | ||
| 4812 | |||
| 4729 | if (rc != X86EMUL_CONTINUE) | 4813 | if (rc != X86EMUL_CONTINUE) |
| 4730 | goto done; | 4814 | goto done; |
| 4731 | 4815 | ||
diff --git a/arch/x86/kvm/mmu.c b/arch/x86/kvm/mmu.c index dce0df8150df..40772ef0f2b1 100644 --- a/arch/x86/kvm/mmu.c +++ b/arch/x86/kvm/mmu.c | |||
| @@ -2570,11 +2570,6 @@ static void mmu_set_spte(struct kvm_vcpu *vcpu, u64 *sptep, | |||
| 2570 | kvm_release_pfn_clean(pfn); | 2570 | kvm_release_pfn_clean(pfn); |
| 2571 | } | 2571 | } |
| 2572 | 2572 | ||
| 2573 | static void nonpaging_new_cr3(struct kvm_vcpu *vcpu) | ||
| 2574 | { | ||
| 2575 | mmu_free_roots(vcpu); | ||
| 2576 | } | ||
| 2577 | |||
| 2578 | static pfn_t pte_prefetch_gfn_to_pfn(struct kvm_vcpu *vcpu, gfn_t gfn, | 2573 | static pfn_t pte_prefetch_gfn_to_pfn(struct kvm_vcpu *vcpu, gfn_t gfn, |
| 2579 | bool no_dirty_log) | 2574 | bool no_dirty_log) |
| 2580 | { | 2575 | { |
| @@ -3424,18 +3419,11 @@ out_unlock: | |||
| 3424 | return 0; | 3419 | return 0; |
| 3425 | } | 3420 | } |
| 3426 | 3421 | ||
| 3427 | static void nonpaging_free(struct kvm_vcpu *vcpu) | 3422 | static void nonpaging_init_context(struct kvm_vcpu *vcpu, |
| 3428 | { | 3423 | struct kvm_mmu *context) |
| 3429 | mmu_free_roots(vcpu); | ||
| 3430 | } | ||
| 3431 | |||
| 3432 | static int nonpaging_init_context(struct kvm_vcpu *vcpu, | ||
| 3433 | struct kvm_mmu *context) | ||
| 3434 | { | 3424 | { |
| 3435 | context->new_cr3 = nonpaging_new_cr3; | ||
| 3436 | context->page_fault = nonpaging_page_fault; | 3425 | context->page_fault = nonpaging_page_fault; |
| 3437 | context->gva_to_gpa = nonpaging_gva_to_gpa; | 3426 | context->gva_to_gpa = nonpaging_gva_to_gpa; |
| 3438 | context->free = nonpaging_free; | ||
| 3439 | context->sync_page = nonpaging_sync_page; | 3427 | context->sync_page = nonpaging_sync_page; |
| 3440 | context->invlpg = nonpaging_invlpg; | 3428 | context->invlpg = nonpaging_invlpg; |
| 3441 | context->update_pte = nonpaging_update_pte; | 3429 | context->update_pte = nonpaging_update_pte; |
| @@ -3444,7 +3432,6 @@ static int nonpaging_init_context(struct kvm_vcpu *vcpu, | |||
| 3444 | context->root_hpa = INVALID_PAGE; | 3432 | context->root_hpa = INVALID_PAGE; |
| 3445 | context->direct_map = true; | 3433 | context->direct_map = true; |
| 3446 | context->nx = false; | 3434 | context->nx = false; |
| 3447 | return 0; | ||
| 3448 | } | 3435 | } |
| 3449 | 3436 | ||
| 3450 | void kvm_mmu_flush_tlb(struct kvm_vcpu *vcpu) | 3437 | void kvm_mmu_flush_tlb(struct kvm_vcpu *vcpu) |
| @@ -3454,9 +3441,8 @@ void kvm_mmu_flush_tlb(struct kvm_vcpu *vcpu) | |||
| 3454 | } | 3441 | } |
| 3455 | EXPORT_SYMBOL_GPL(kvm_mmu_flush_tlb); | 3442 | EXPORT_SYMBOL_GPL(kvm_mmu_flush_tlb); |
| 3456 | 3443 | ||
| 3457 | static void paging_new_cr3(struct kvm_vcpu *vcpu) | 3444 | void kvm_mmu_new_cr3(struct kvm_vcpu *vcpu) |
| 3458 | { | 3445 | { |
| 3459 | pgprintk("%s: cr3 %lx\n", __func__, kvm_read_cr3(vcpu)); | ||
| 3460 | mmu_free_roots(vcpu); | 3446 | mmu_free_roots(vcpu); |
| 3461 | } | 3447 | } |
| 3462 | 3448 | ||
| @@ -3471,11 +3457,6 @@ static void inject_page_fault(struct kvm_vcpu *vcpu, | |||
| 3471 | vcpu->arch.mmu.inject_page_fault(vcpu, fault); | 3457 | vcpu->arch.mmu.inject_page_fault(vcpu, fault); |
| 3472 | } | 3458 | } |
| 3473 | 3459 | ||
| 3474 | static void paging_free(struct kvm_vcpu *vcpu) | ||
| 3475 | { | ||
| 3476 | nonpaging_free(vcpu); | ||
| 3477 | } | ||
| 3478 | |||
| 3479 | static bool sync_mmio_spte(struct kvm *kvm, u64 *sptep, gfn_t gfn, | 3460 | static bool sync_mmio_spte(struct kvm *kvm, u64 *sptep, gfn_t gfn, |
| 3480 | unsigned access, int *nr_present) | 3461 | unsigned access, int *nr_present) |
| 3481 | { | 3462 | { |
| @@ -3665,9 +3646,9 @@ static void update_last_pte_bitmap(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu) | |||
| 3665 | mmu->last_pte_bitmap = map; | 3646 | mmu->last_pte_bitmap = map; |
| 3666 | } | 3647 | } |
| 3667 | 3648 | ||
| 3668 | static int paging64_init_context_common(struct kvm_vcpu *vcpu, | 3649 | static void paging64_init_context_common(struct kvm_vcpu *vcpu, |
| 3669 | struct kvm_mmu *context, | 3650 | struct kvm_mmu *context, |
| 3670 | int level) | 3651 | int level) |
| 3671 | { | 3652 | { |
| 3672 | context->nx = is_nx(vcpu); | 3653 | context->nx = is_nx(vcpu); |
| 3673 | context->root_level = level; | 3654 | context->root_level = level; |
| @@ -3677,27 +3658,24 @@ static int paging64_init_context_common(struct kvm_vcpu *vcpu, | |||
| 3677 | update_last_pte_bitmap(vcpu, context); | 3658 | update_last_pte_bitmap(vcpu, context); |
| 3678 | 3659 | ||
| 3679 | ASSERT(is_pae(vcpu)); | 3660 | ASSERT(is_pae(vcpu)); |
| 3680 | context->new_cr3 = paging_new_cr3; | ||
| 3681 | context->page_fault = paging64_page_fault; | 3661 | context->page_fault = paging64_page_fault; |
| 3682 | context->gva_to_gpa = paging64_gva_to_gpa; | 3662 | context->gva_to_gpa = paging64_gva_to_gpa; |
| 3683 | context->sync_page = paging64_sync_page; | 3663 | context->sync_page = paging64_sync_page; |
| 3684 | context->invlpg = paging64_invlpg; | 3664 | context->invlpg = paging64_invlpg; |
| 3685 | context->update_pte = paging64_update_pte; | 3665 | context->update_pte = paging64_update_pte; |
| 3686 | context->free = paging_free; | ||
| 3687 | context->shadow_root_level = level; | 3666 | context->shadow_root_level = level; |
| 3688 | context->root_hpa = INVALID_PAGE; | 3667 | context->root_hpa = INVALID_PAGE; |
| 3689 | context->direct_map = false; | 3668 | context->direct_map = false; |
| 3690 | return 0; | ||
| 3691 | } | 3669 | } |
| 3692 | 3670 | ||
| 3693 | static int paging64_init_context(struct kvm_vcpu *vcpu, | 3671 | static void paging64_init_context(struct kvm_vcpu *vcpu, |
| 3694 | struct kvm_mmu *context) | 3672 | struct kvm_mmu *context) |
| 3695 | { | 3673 | { |
| 3696 | return paging64_init_context_common(vcpu, context, PT64_ROOT_LEVEL); | 3674 | paging64_init_context_common(vcpu, context, PT64_ROOT_LEVEL); |
| 3697 | } | 3675 | } |
| 3698 | 3676 | ||
| 3699 | static int paging32_init_context(struct kvm_vcpu *vcpu, | 3677 | static void paging32_init_context(struct kvm_vcpu *vcpu, |
| 3700 | struct kvm_mmu *context) | 3678 | struct kvm_mmu *context) |
| 3701 | { | 3679 | { |
| 3702 | context->nx = false; | 3680 | context->nx = false; |
| 3703 | context->root_level = PT32_ROOT_LEVEL; | 3681 | context->root_level = PT32_ROOT_LEVEL; |
| @@ -3706,33 +3684,28 @@ static int paging32_init_context(struct kvm_vcpu *vcpu, | |||
| 3706 | update_permission_bitmask(vcpu, context, false); | 3684 | update_permission_bitmask(vcpu, context, false); |
| 3707 | update_last_pte_bitmap(vcpu, context); | 3685 | update_last_pte_bitmap(vcpu, context); |
| 3708 | 3686 | ||
| 3709 | context->new_cr3 = paging_new_cr3; | ||
| 3710 | context->page_fault = paging32_page_fault; | 3687 | context->page_fault = paging32_page_fault; |
| 3711 | context->gva_to_gpa = paging32_gva_to_gpa; | 3688 | context->gva_to_gpa = paging32_gva_to_gpa; |
| 3712 | context->free = paging_free; | ||
| 3713 | context->sync_page = paging32_sync_page; | 3689 | context->sync_page = paging32_sync_page; |
| 3714 | context->invlpg = paging32_invlpg; | 3690 | context->invlpg = paging32_invlpg; |
| 3715 | context->update_pte = paging32_update_pte; | 3691 | context->update_pte = paging32_update_pte; |
| 3716 | context->shadow_root_level = PT32E_ROOT_LEVEL; | 3692 | context->shadow_root_level = PT32E_ROOT_LEVEL; |
| 3717 | context->root_hpa = INVALID_PAGE; | 3693 | context->root_hpa = INVALID_PAGE; |
| 3718 | context->direct_map = false; | 3694 | context->direct_map = false; |
| 3719 | return 0; | ||
| 3720 | } | 3695 | } |
| 3721 | 3696 | ||
| 3722 | static int paging32E_init_context(struct kvm_vcpu *vcpu, | 3697 | static void paging32E_init_context(struct kvm_vcpu *vcpu, |
| 3723 | struct kvm_mmu *context) | 3698 | struct kvm_mmu *context) |
| 3724 | { | 3699 | { |
| 3725 | return paging64_init_context_common(vcpu, context, PT32E_ROOT_LEVEL); | 3700 | paging64_init_context_common(vcpu, context, PT32E_ROOT_LEVEL); |
| 3726 | } | 3701 | } |
| 3727 | 3702 | ||
| 3728 | static int init_kvm_tdp_mmu(struct kvm_vcpu *vcpu) | 3703 | static void init_kvm_tdp_mmu(struct kvm_vcpu *vcpu) |
| 3729 | { | 3704 | { |
| 3730 | struct kvm_mmu *context = vcpu->arch.walk_mmu; | 3705 | struct kvm_mmu *context = vcpu->arch.walk_mmu; |
| 3731 | 3706 | ||
| 3732 | context->base_role.word = 0; | 3707 | context->base_role.word = 0; |
| 3733 | context->new_cr3 = nonpaging_new_cr3; | ||
| 3734 | context->page_fault = tdp_page_fault; | 3708 | context->page_fault = tdp_page_fault; |
| 3735 | context->free = nonpaging_free; | ||
| 3736 | context->sync_page = nonpaging_sync_page; | 3709 | context->sync_page = nonpaging_sync_page; |
| 3737 | context->invlpg = nonpaging_invlpg; | 3710 | context->invlpg = nonpaging_invlpg; |
| 3738 | context->update_pte = nonpaging_update_pte; | 3711 | context->update_pte = nonpaging_update_pte; |
| @@ -3767,37 +3740,32 @@ static int init_kvm_tdp_mmu(struct kvm_vcpu *vcpu) | |||
| 3767 | 3740 | ||
| 3768 | update_permission_bitmask(vcpu, context, false); | 3741 | update_permission_bitmask(vcpu, context, false); |
| 3769 | update_last_pte_bitmap(vcpu, context); | 3742 | update_last_pte_bitmap(vcpu, context); |
| 3770 | |||
| 3771 | return 0; | ||
| 3772 | } | 3743 | } |
| 3773 | 3744 | ||
| 3774 | int kvm_init_shadow_mmu(struct kvm_vcpu *vcpu, struct kvm_mmu *context) | 3745 | void kvm_init_shadow_mmu(struct kvm_vcpu *vcpu, struct kvm_mmu *context) |
| 3775 | { | 3746 | { |
| 3776 | int r; | ||
| 3777 | bool smep = kvm_read_cr4_bits(vcpu, X86_CR4_SMEP); | 3747 | bool smep = kvm_read_cr4_bits(vcpu, X86_CR4_SMEP); |
| 3778 | ASSERT(vcpu); | 3748 | ASSERT(vcpu); |
| 3779 | ASSERT(!VALID_PAGE(vcpu->arch.mmu.root_hpa)); | 3749 | ASSERT(!VALID_PAGE(vcpu->arch.mmu.root_hpa)); |
| 3780 | 3750 | ||
| 3781 | if (!is_paging(vcpu)) | 3751 | if (!is_paging(vcpu)) |
| 3782 | r = nonpaging_init_context(vcpu, context); | 3752 | nonpaging_init_context(vcpu, context); |
| 3783 | else if (is_long_mode(vcpu)) | 3753 | else if (is_long_mode(vcpu)) |
| 3784 | r = paging64_init_context(vcpu, context); | 3754 | paging64_init_context(vcpu, context); |
| 3785 | else if (is_pae(vcpu)) | 3755 | else if (is_pae(vcpu)) |
| 3786 | r = paging32E_init_context(vcpu, context); | 3756 | paging32E_init_context(vcpu, context); |
| 3787 | else | 3757 | else |
| 3788 | r = paging32_init_context(vcpu, context); | 3758 | paging32_init_context(vcpu, context); |
| 3789 | 3759 | ||
| 3790 | vcpu->arch.mmu.base_role.nxe = is_nx(vcpu); | 3760 | vcpu->arch.mmu.base_role.nxe = is_nx(vcpu); |
| 3791 | vcpu->arch.mmu.base_role.cr4_pae = !!is_pae(vcpu); | 3761 | vcpu->arch.mmu.base_role.cr4_pae = !!is_pae(vcpu); |
| 3792 | vcpu->arch.mmu.base_role.cr0_wp = is_write_protection(vcpu); | 3762 | vcpu->arch.mmu.base_role.cr0_wp = is_write_protection(vcpu); |
| 3793 | vcpu->arch.mmu.base_role.smep_andnot_wp | 3763 | vcpu->arch.mmu.base_role.smep_andnot_wp |
| 3794 | = smep && !is_write_protection(vcpu); | 3764 | = smep && !is_write_protection(vcpu); |
| 3795 | |||
| 3796 | return r; | ||
| 3797 | } | 3765 | } |
| 3798 | EXPORT_SYMBOL_GPL(kvm_init_shadow_mmu); | 3766 | EXPORT_SYMBOL_GPL(kvm_init_shadow_mmu); |
| 3799 | 3767 | ||
| 3800 | int kvm_init_shadow_ept_mmu(struct kvm_vcpu *vcpu, struct kvm_mmu *context, | 3768 | void kvm_init_shadow_ept_mmu(struct kvm_vcpu *vcpu, struct kvm_mmu *context, |
| 3801 | bool execonly) | 3769 | bool execonly) |
| 3802 | { | 3770 | { |
| 3803 | ASSERT(vcpu); | 3771 | ASSERT(vcpu); |
| @@ -3806,37 +3774,30 @@ int kvm_init_shadow_ept_mmu(struct kvm_vcpu *vcpu, struct kvm_mmu *context, | |||
| 3806 | context->shadow_root_level = kvm_x86_ops->get_tdp_level(); | 3774 | context->shadow_root_level = kvm_x86_ops->get_tdp_level(); |
| 3807 | 3775 | ||
| 3808 | context->nx = true; | 3776 | context->nx = true; |
| 3809 | context->new_cr3 = paging_new_cr3; | ||
| 3810 | context->page_fault = ept_page_fault; | 3777 | context->page_fault = ept_page_fault; |
| 3811 | context->gva_to_gpa = ept_gva_to_gpa; | 3778 | context->gva_to_gpa = ept_gva_to_gpa; |
| 3812 | context->sync_page = ept_sync_page; | 3779 | context->sync_page = ept_sync_page; |
| 3813 | context->invlpg = ept_invlpg; | 3780 | context->invlpg = ept_invlpg; |
| 3814 | context->update_pte = ept_update_pte; | 3781 | context->update_pte = ept_update_pte; |
| 3815 | context->free = paging_free; | ||
| 3816 | context->root_level = context->shadow_root_level; | 3782 | context->root_level = context->shadow_root_level; |
| 3817 | context->root_hpa = INVALID_PAGE; | 3783 | context->root_hpa = INVALID_PAGE; |
| 3818 | context->direct_map = false; | 3784 | context->direct_map = false; |
| 3819 | 3785 | ||
| 3820 | update_permission_bitmask(vcpu, context, true); | 3786 | update_permission_bitmask(vcpu, context, true); |
| 3821 | reset_rsvds_bits_mask_ept(vcpu, context, execonly); | 3787 | reset_rsvds_bits_mask_ept(vcpu, context, execonly); |
| 3822 | |||
| 3823 | return 0; | ||
| 3824 | } | 3788 | } |
| 3825 | EXPORT_SYMBOL_GPL(kvm_init_shadow_ept_mmu); | 3789 | EXPORT_SYMBOL_GPL(kvm_init_shadow_ept_mmu); |
| 3826 | 3790 | ||
| 3827 | static int init_kvm_softmmu(struct kvm_vcpu *vcpu) | 3791 | static void init_kvm_softmmu(struct kvm_vcpu *vcpu) |
| 3828 | { | 3792 | { |
| 3829 | int r = kvm_init_shadow_mmu(vcpu, vcpu->arch.walk_mmu); | 3793 | kvm_init_shadow_mmu(vcpu, vcpu->arch.walk_mmu); |
| 3830 | |||
| 3831 | vcpu->arch.walk_mmu->set_cr3 = kvm_x86_ops->set_cr3; | 3794 | vcpu->arch.walk_mmu->set_cr3 = kvm_x86_ops->set_cr3; |
| 3832 | vcpu->arch.walk_mmu->get_cr3 = get_cr3; | 3795 | vcpu->arch.walk_mmu->get_cr3 = get_cr3; |
| 3833 | vcpu->arch.walk_mmu->get_pdptr = kvm_pdptr_read; | 3796 | vcpu->arch.walk_mmu->get_pdptr = kvm_pdptr_read; |
| 3834 | vcpu->arch.walk_mmu->inject_page_fault = kvm_inject_page_fault; | 3797 | vcpu->arch.walk_mmu->inject_page_fault = kvm_inject_page_fault; |
| 3835 | |||
| 3836 | return r; | ||
| 3837 | } | 3798 | } |
| 3838 | 3799 | ||
| 3839 | static int init_kvm_nested_mmu(struct kvm_vcpu *vcpu) | 3800 | static void init_kvm_nested_mmu(struct kvm_vcpu *vcpu) |
| 3840 | { | 3801 | { |
| 3841 | struct kvm_mmu *g_context = &vcpu->arch.nested_mmu; | 3802 | struct kvm_mmu *g_context = &vcpu->arch.nested_mmu; |
| 3842 | 3803 | ||
| @@ -3873,11 +3834,9 @@ static int init_kvm_nested_mmu(struct kvm_vcpu *vcpu) | |||
| 3873 | 3834 | ||
| 3874 | update_permission_bitmask(vcpu, g_context, false); | 3835 | update_permission_bitmask(vcpu, g_context, false); |
| 3875 | update_last_pte_bitmap(vcpu, g_context); | 3836 | update_last_pte_bitmap(vcpu, g_context); |
| 3876 | |||
| 3877 | return 0; | ||
| 3878 | } | 3837 | } |
| 3879 | 3838 | ||
| 3880 | static int init_kvm_mmu(struct kvm_vcpu *vcpu) | 3839 | static void init_kvm_mmu(struct kvm_vcpu *vcpu) |
| 3881 | { | 3840 | { |
| 3882 | if (mmu_is_nested(vcpu)) | 3841 | if (mmu_is_nested(vcpu)) |
| 3883 | return init_kvm_nested_mmu(vcpu); | 3842 | return init_kvm_nested_mmu(vcpu); |
| @@ -3887,18 +3846,12 @@ static int init_kvm_mmu(struct kvm_vcpu *vcpu) | |||
| 3887 | return init_kvm_softmmu(vcpu); | 3846 | return init_kvm_softmmu(vcpu); |
| 3888 | } | 3847 | } |
| 3889 | 3848 | ||
| 3890 | static void destroy_kvm_mmu(struct kvm_vcpu *vcpu) | 3849 | void kvm_mmu_reset_context(struct kvm_vcpu *vcpu) |
| 3891 | { | 3850 | { |
| 3892 | ASSERT(vcpu); | 3851 | ASSERT(vcpu); |
| 3893 | if (VALID_PAGE(vcpu->arch.mmu.root_hpa)) | ||
| 3894 | /* mmu.free() should set root_hpa = INVALID_PAGE */ | ||
| 3895 | vcpu->arch.mmu.free(vcpu); | ||
| 3896 | } | ||
| 3897 | 3852 | ||
| 3898 | int kvm_mmu_reset_context(struct kvm_vcpu *vcpu) | 3853 | kvm_mmu_unload(vcpu); |
| 3899 | { | 3854 | init_kvm_mmu(vcpu); |
| 3900 | destroy_kvm_mmu(vcpu); | ||
| 3901 | return init_kvm_mmu(vcpu); | ||
| 3902 | } | 3855 | } |
| 3903 | EXPORT_SYMBOL_GPL(kvm_mmu_reset_context); | 3856 | EXPORT_SYMBOL_GPL(kvm_mmu_reset_context); |
| 3904 | 3857 | ||
| @@ -3923,6 +3876,7 @@ EXPORT_SYMBOL_GPL(kvm_mmu_load); | |||
| 3923 | void kvm_mmu_unload(struct kvm_vcpu *vcpu) | 3876 | void kvm_mmu_unload(struct kvm_vcpu *vcpu) |
| 3924 | { | 3877 | { |
| 3925 | mmu_free_roots(vcpu); | 3878 | mmu_free_roots(vcpu); |
| 3879 | WARN_ON(VALID_PAGE(vcpu->arch.mmu.root_hpa)); | ||
| 3926 | } | 3880 | } |
| 3927 | EXPORT_SYMBOL_GPL(kvm_mmu_unload); | 3881 | EXPORT_SYMBOL_GPL(kvm_mmu_unload); |
| 3928 | 3882 | ||
| @@ -4281,12 +4235,12 @@ int kvm_mmu_create(struct kvm_vcpu *vcpu) | |||
| 4281 | return alloc_mmu_pages(vcpu); | 4235 | return alloc_mmu_pages(vcpu); |
| 4282 | } | 4236 | } |
| 4283 | 4237 | ||
| 4284 | int kvm_mmu_setup(struct kvm_vcpu *vcpu) | 4238 | void kvm_mmu_setup(struct kvm_vcpu *vcpu) |
| 4285 | { | 4239 | { |
| 4286 | ASSERT(vcpu); | 4240 | ASSERT(vcpu); |
| 4287 | ASSERT(!VALID_PAGE(vcpu->arch.mmu.root_hpa)); | 4241 | ASSERT(!VALID_PAGE(vcpu->arch.mmu.root_hpa)); |
| 4288 | 4242 | ||
| 4289 | return init_kvm_mmu(vcpu); | 4243 | init_kvm_mmu(vcpu); |
| 4290 | } | 4244 | } |
| 4291 | 4245 | ||
| 4292 | void kvm_mmu_slot_remove_write_access(struct kvm *kvm, int slot) | 4246 | void kvm_mmu_slot_remove_write_access(struct kvm *kvm, int slot) |
| @@ -4428,7 +4382,7 @@ mmu_shrink_scan(struct shrinker *shrink, struct shrink_control *sc) | |||
| 4428 | int nr_to_scan = sc->nr_to_scan; | 4382 | int nr_to_scan = sc->nr_to_scan; |
| 4429 | unsigned long freed = 0; | 4383 | unsigned long freed = 0; |
| 4430 | 4384 | ||
| 4431 | raw_spin_lock(&kvm_lock); | 4385 | spin_lock(&kvm_lock); |
| 4432 | 4386 | ||
| 4433 | list_for_each_entry(kvm, &vm_list, vm_list) { | 4387 | list_for_each_entry(kvm, &vm_list, vm_list) { |
| 4434 | int idx; | 4388 | int idx; |
| @@ -4478,9 +4432,8 @@ unlock: | |||
| 4478 | break; | 4432 | break; |
| 4479 | } | 4433 | } |
| 4480 | 4434 | ||
| 4481 | raw_spin_unlock(&kvm_lock); | 4435 | spin_unlock(&kvm_lock); |
| 4482 | return freed; | 4436 | return freed; |
| 4483 | |||
| 4484 | } | 4437 | } |
| 4485 | 4438 | ||
| 4486 | static unsigned long | 4439 | static unsigned long |
| @@ -4574,7 +4527,7 @@ void kvm_mmu_destroy(struct kvm_vcpu *vcpu) | |||
| 4574 | { | 4527 | { |
| 4575 | ASSERT(vcpu); | 4528 | ASSERT(vcpu); |
| 4576 | 4529 | ||
| 4577 | destroy_kvm_mmu(vcpu); | 4530 | kvm_mmu_unload(vcpu); |
| 4578 | free_mmu_pages(vcpu); | 4531 | free_mmu_pages(vcpu); |
| 4579 | mmu_free_memory_caches(vcpu); | 4532 | mmu_free_memory_caches(vcpu); |
| 4580 | } | 4533 | } |
diff --git a/arch/x86/kvm/mmu.h b/arch/x86/kvm/mmu.h index 77e044a0f5f7..292615274358 100644 --- a/arch/x86/kvm/mmu.h +++ b/arch/x86/kvm/mmu.h | |||
| @@ -70,8 +70,8 @@ enum { | |||
| 70 | }; | 70 | }; |
| 71 | 71 | ||
| 72 | int handle_mmio_page_fault_common(struct kvm_vcpu *vcpu, u64 addr, bool direct); | 72 | int handle_mmio_page_fault_common(struct kvm_vcpu *vcpu, u64 addr, bool direct); |
| 73 | int kvm_init_shadow_mmu(struct kvm_vcpu *vcpu, struct kvm_mmu *context); | 73 | void kvm_init_shadow_mmu(struct kvm_vcpu *vcpu, struct kvm_mmu *context); |
| 74 | int kvm_init_shadow_ept_mmu(struct kvm_vcpu *vcpu, struct kvm_mmu *context, | 74 | void kvm_init_shadow_ept_mmu(struct kvm_vcpu *vcpu, struct kvm_mmu *context, |
| 75 | bool execonly); | 75 | bool execonly); |
| 76 | 76 | ||
| 77 | static inline unsigned int kvm_mmu_available_pages(struct kvm *kvm) | 77 | static inline unsigned int kvm_mmu_available_pages(struct kvm *kvm) |
diff --git a/arch/x86/kvm/svm.c b/arch/x86/kvm/svm.c index c0bc80391e40..c7168a5cff1b 100644 --- a/arch/x86/kvm/svm.c +++ b/arch/x86/kvm/svm.c | |||
| @@ -1959,11 +1959,9 @@ static void nested_svm_inject_npf_exit(struct kvm_vcpu *vcpu, | |||
| 1959 | nested_svm_vmexit(svm); | 1959 | nested_svm_vmexit(svm); |
| 1960 | } | 1960 | } |
| 1961 | 1961 | ||
| 1962 | static int nested_svm_init_mmu_context(struct kvm_vcpu *vcpu) | 1962 | static void nested_svm_init_mmu_context(struct kvm_vcpu *vcpu) |
| 1963 | { | 1963 | { |
| 1964 | int r; | 1964 | kvm_init_shadow_mmu(vcpu, &vcpu->arch.mmu); |
| 1965 | |||
| 1966 | r = kvm_init_shadow_mmu(vcpu, &vcpu->arch.mmu); | ||
| 1967 | 1965 | ||
| 1968 | vcpu->arch.mmu.set_cr3 = nested_svm_set_tdp_cr3; | 1966 | vcpu->arch.mmu.set_cr3 = nested_svm_set_tdp_cr3; |
| 1969 | vcpu->arch.mmu.get_cr3 = nested_svm_get_tdp_cr3; | 1967 | vcpu->arch.mmu.get_cr3 = nested_svm_get_tdp_cr3; |
| @@ -1971,8 +1969,6 @@ static int nested_svm_init_mmu_context(struct kvm_vcpu *vcpu) | |||
| 1971 | vcpu->arch.mmu.inject_page_fault = nested_svm_inject_npf_exit; | 1969 | vcpu->arch.mmu.inject_page_fault = nested_svm_inject_npf_exit; |
| 1972 | vcpu->arch.mmu.shadow_root_level = get_npt_level(); | 1970 | vcpu->arch.mmu.shadow_root_level = get_npt_level(); |
| 1973 | vcpu->arch.walk_mmu = &vcpu->arch.nested_mmu; | 1971 | vcpu->arch.walk_mmu = &vcpu->arch.nested_mmu; |
| 1974 | |||
| 1975 | return r; | ||
| 1976 | } | 1972 | } |
| 1977 | 1973 | ||
| 1978 | static void nested_svm_uninit_mmu_context(struct kvm_vcpu *vcpu) | 1974 | static void nested_svm_uninit_mmu_context(struct kvm_vcpu *vcpu) |
diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c index 2b2fce1b2009..b2fe1c252f35 100644 --- a/arch/x86/kvm/vmx.c +++ b/arch/x86/kvm/vmx.c | |||
| @@ -1498,7 +1498,7 @@ static void add_atomic_switch_msr(struct vcpu_vmx *vmx, unsigned msr, | |||
| 1498 | break; | 1498 | break; |
| 1499 | 1499 | ||
| 1500 | if (i == NR_AUTOLOAD_MSRS) { | 1500 | if (i == NR_AUTOLOAD_MSRS) { |
| 1501 | printk_once(KERN_WARNING"Not enough mst switch entries. " | 1501 | printk_once(KERN_WARNING "Not enough msr switch entries. " |
| 1502 | "Can't add msr %x\n", msr); | 1502 | "Can't add msr %x\n", msr); |
| 1503 | return; | 1503 | return; |
| 1504 | } else if (i == m->nr) { | 1504 | } else if (i == m->nr) { |
| @@ -1898,16 +1898,12 @@ static void skip_emulated_instruction(struct kvm_vcpu *vcpu) | |||
| 1898 | /* | 1898 | /* |
| 1899 | * KVM wants to inject page-faults which it got to the guest. This function | 1899 | * KVM wants to inject page-faults which it got to the guest. This function |
| 1900 | * checks whether in a nested guest, we need to inject them to L1 or L2. | 1900 | * checks whether in a nested guest, we need to inject them to L1 or L2. |
| 1901 | * This function assumes it is called with the exit reason in vmcs02 being | ||
| 1902 | * a #PF exception (this is the only case in which KVM injects a #PF when L2 | ||
| 1903 | * is running). | ||
| 1904 | */ | 1901 | */ |
| 1905 | static int nested_pf_handled(struct kvm_vcpu *vcpu) | 1902 | static int nested_vmx_check_exception(struct kvm_vcpu *vcpu, unsigned nr) |
| 1906 | { | 1903 | { |
| 1907 | struct vmcs12 *vmcs12 = get_vmcs12(vcpu); | 1904 | struct vmcs12 *vmcs12 = get_vmcs12(vcpu); |
| 1908 | 1905 | ||
| 1909 | /* TODO: also check PFEC_MATCH/MASK, not just EB.PF. */ | 1906 | if (!(vmcs12->exception_bitmap & (1u << nr))) |
| 1910 | if (!(vmcs12->exception_bitmap & (1u << PF_VECTOR))) | ||
| 1911 | return 0; | 1907 | return 0; |
| 1912 | 1908 | ||
| 1913 | nested_vmx_vmexit(vcpu); | 1909 | nested_vmx_vmexit(vcpu); |
| @@ -1921,8 +1917,8 @@ static void vmx_queue_exception(struct kvm_vcpu *vcpu, unsigned nr, | |||
| 1921 | struct vcpu_vmx *vmx = to_vmx(vcpu); | 1917 | struct vcpu_vmx *vmx = to_vmx(vcpu); |
| 1922 | u32 intr_info = nr | INTR_INFO_VALID_MASK; | 1918 | u32 intr_info = nr | INTR_INFO_VALID_MASK; |
| 1923 | 1919 | ||
| 1924 | if (nr == PF_VECTOR && is_guest_mode(vcpu) && | 1920 | if (!reinject && is_guest_mode(vcpu) && |
| 1925 | !vmx->nested.nested_run_pending && nested_pf_handled(vcpu)) | 1921 | nested_vmx_check_exception(vcpu, nr)) |
| 1926 | return; | 1922 | return; |
| 1927 | 1923 | ||
| 1928 | if (has_error_code) { | 1924 | if (has_error_code) { |
| @@ -2204,9 +2200,15 @@ static __init void nested_vmx_setup_ctls_msrs(void) | |||
| 2204 | #ifdef CONFIG_X86_64 | 2200 | #ifdef CONFIG_X86_64 |
| 2205 | VM_EXIT_HOST_ADDR_SPACE_SIZE | | 2201 | VM_EXIT_HOST_ADDR_SPACE_SIZE | |
| 2206 | #endif | 2202 | #endif |
| 2207 | VM_EXIT_LOAD_IA32_PAT | VM_EXIT_SAVE_IA32_PAT; | 2203 | VM_EXIT_LOAD_IA32_PAT | VM_EXIT_SAVE_IA32_PAT | |
| 2204 | VM_EXIT_SAVE_VMX_PREEMPTION_TIMER; | ||
| 2205 | if (!(nested_vmx_pinbased_ctls_high & PIN_BASED_VMX_PREEMPTION_TIMER) || | ||
| 2206 | !(nested_vmx_exit_ctls_high & VM_EXIT_SAVE_VMX_PREEMPTION_TIMER)) { | ||
| 2207 | nested_vmx_exit_ctls_high &= ~VM_EXIT_SAVE_VMX_PREEMPTION_TIMER; | ||
| 2208 | nested_vmx_pinbased_ctls_high &= ~PIN_BASED_VMX_PREEMPTION_TIMER; | ||
| 2209 | } | ||
| 2208 | nested_vmx_exit_ctls_high |= (VM_EXIT_ALWAYSON_WITHOUT_TRUE_MSR | | 2210 | nested_vmx_exit_ctls_high |= (VM_EXIT_ALWAYSON_WITHOUT_TRUE_MSR | |
| 2209 | VM_EXIT_LOAD_IA32_EFER); | 2211 | VM_EXIT_LOAD_IA32_EFER | VM_EXIT_SAVE_IA32_EFER); |
| 2210 | 2212 | ||
| 2211 | /* entry controls */ | 2213 | /* entry controls */ |
| 2212 | rdmsr(MSR_IA32_VMX_ENTRY_CTLS, | 2214 | rdmsr(MSR_IA32_VMX_ENTRY_CTLS, |
| @@ -2226,7 +2228,8 @@ static __init void nested_vmx_setup_ctls_msrs(void) | |||
| 2226 | nested_vmx_procbased_ctls_low, nested_vmx_procbased_ctls_high); | 2228 | nested_vmx_procbased_ctls_low, nested_vmx_procbased_ctls_high); |
| 2227 | nested_vmx_procbased_ctls_low = 0; | 2229 | nested_vmx_procbased_ctls_low = 0; |
| 2228 | nested_vmx_procbased_ctls_high &= | 2230 | nested_vmx_procbased_ctls_high &= |
| 2229 | CPU_BASED_VIRTUAL_INTR_PENDING | CPU_BASED_USE_TSC_OFFSETING | | 2231 | CPU_BASED_VIRTUAL_INTR_PENDING | |
| 2232 | CPU_BASED_VIRTUAL_NMI_PENDING | CPU_BASED_USE_TSC_OFFSETING | | ||
| 2230 | CPU_BASED_HLT_EXITING | CPU_BASED_INVLPG_EXITING | | 2233 | CPU_BASED_HLT_EXITING | CPU_BASED_INVLPG_EXITING | |
| 2231 | CPU_BASED_MWAIT_EXITING | CPU_BASED_CR3_LOAD_EXITING | | 2234 | CPU_BASED_MWAIT_EXITING | CPU_BASED_CR3_LOAD_EXITING | |
| 2232 | CPU_BASED_CR3_STORE_EXITING | | 2235 | CPU_BASED_CR3_STORE_EXITING | |
| @@ -2252,13 +2255,15 @@ static __init void nested_vmx_setup_ctls_msrs(void) | |||
| 2252 | nested_vmx_secondary_ctls_low = 0; | 2255 | nested_vmx_secondary_ctls_low = 0; |
| 2253 | nested_vmx_secondary_ctls_high &= | 2256 | nested_vmx_secondary_ctls_high &= |
| 2254 | SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES | | 2257 | SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES | |
| 2258 | SECONDARY_EXEC_UNRESTRICTED_GUEST | | ||
| 2255 | SECONDARY_EXEC_WBINVD_EXITING; | 2259 | SECONDARY_EXEC_WBINVD_EXITING; |
| 2256 | 2260 | ||
| 2257 | if (enable_ept) { | 2261 | if (enable_ept) { |
| 2258 | /* nested EPT: emulate EPT also to L1 */ | 2262 | /* nested EPT: emulate EPT also to L1 */ |
| 2259 | nested_vmx_secondary_ctls_high |= SECONDARY_EXEC_ENABLE_EPT; | 2263 | nested_vmx_secondary_ctls_high |= SECONDARY_EXEC_ENABLE_EPT; |
| 2260 | nested_vmx_ept_caps = VMX_EPT_PAGE_WALK_4_BIT | | 2264 | nested_vmx_ept_caps = VMX_EPT_PAGE_WALK_4_BIT | |
| 2261 | VMX_EPTP_WB_BIT | VMX_EPT_INVEPT_BIT; | 2265 | VMX_EPTP_WB_BIT | VMX_EPT_2MB_PAGE_BIT | |
| 2266 | VMX_EPT_INVEPT_BIT; | ||
| 2262 | nested_vmx_ept_caps &= vmx_capability.ept; | 2267 | nested_vmx_ept_caps &= vmx_capability.ept; |
| 2263 | /* | 2268 | /* |
| 2264 | * Since invept is completely emulated we support both global | 2269 | * Since invept is completely emulated we support both global |
| @@ -3380,8 +3385,10 @@ static void vmx_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3) | |||
| 3380 | if (enable_ept) { | 3385 | if (enable_ept) { |
| 3381 | eptp = construct_eptp(cr3); | 3386 | eptp = construct_eptp(cr3); |
| 3382 | vmcs_write64(EPT_POINTER, eptp); | 3387 | vmcs_write64(EPT_POINTER, eptp); |
| 3383 | guest_cr3 = is_paging(vcpu) ? kvm_read_cr3(vcpu) : | 3388 | if (is_paging(vcpu) || is_guest_mode(vcpu)) |
| 3384 | vcpu->kvm->arch.ept_identity_map_addr; | 3389 | guest_cr3 = kvm_read_cr3(vcpu); |
| 3390 | else | ||
| 3391 | guest_cr3 = vcpu->kvm->arch.ept_identity_map_addr; | ||
| 3385 | ept_load_pdptrs(vcpu); | 3392 | ept_load_pdptrs(vcpu); |
| 3386 | } | 3393 | } |
| 3387 | 3394 | ||
| @@ -4879,6 +4886,17 @@ vmx_patch_hypercall(struct kvm_vcpu *vcpu, unsigned char *hypercall) | |||
| 4879 | hypercall[2] = 0xc1; | 4886 | hypercall[2] = 0xc1; |
| 4880 | } | 4887 | } |
| 4881 | 4888 | ||
| 4889 | static bool nested_cr0_valid(struct vmcs12 *vmcs12, unsigned long val) | ||
| 4890 | { | ||
| 4891 | unsigned long always_on = VMXON_CR0_ALWAYSON; | ||
| 4892 | |||
| 4893 | if (nested_vmx_secondary_ctls_high & | ||
| 4894 | SECONDARY_EXEC_UNRESTRICTED_GUEST && | ||
| 4895 | nested_cpu_has2(vmcs12, SECONDARY_EXEC_UNRESTRICTED_GUEST)) | ||
| 4896 | always_on &= ~(X86_CR0_PE | X86_CR0_PG); | ||
| 4897 | return (val & always_on) == always_on; | ||
| 4898 | } | ||
| 4899 | |||
| 4882 | /* called to set cr0 as appropriate for a mov-to-cr0 exit. */ | 4900 | /* called to set cr0 as appropriate for a mov-to-cr0 exit. */ |
| 4883 | static int handle_set_cr0(struct kvm_vcpu *vcpu, unsigned long val) | 4901 | static int handle_set_cr0(struct kvm_vcpu *vcpu, unsigned long val) |
| 4884 | { | 4902 | { |
| @@ -4897,9 +4915,7 @@ static int handle_set_cr0(struct kvm_vcpu *vcpu, unsigned long val) | |||
| 4897 | val = (val & ~vmcs12->cr0_guest_host_mask) | | 4915 | val = (val & ~vmcs12->cr0_guest_host_mask) | |
| 4898 | (vmcs12->guest_cr0 & vmcs12->cr0_guest_host_mask); | 4916 | (vmcs12->guest_cr0 & vmcs12->cr0_guest_host_mask); |
| 4899 | 4917 | ||
| 4900 | /* TODO: will have to take unrestricted guest mode into | 4918 | if (!nested_cr0_valid(vmcs12, val)) |
| 4901 | * account */ | ||
| 4902 | if ((val & VMXON_CR0_ALWAYSON) != VMXON_CR0_ALWAYSON) | ||
| 4903 | return 1; | 4919 | return 1; |
| 4904 | 4920 | ||
| 4905 | if (kvm_set_cr0(vcpu, val)) | 4921 | if (kvm_set_cr0(vcpu, val)) |
| @@ -6627,6 +6643,9 @@ static bool nested_vmx_exit_handled(struct kvm_vcpu *vcpu) | |||
| 6627 | return 0; | 6643 | return 0; |
| 6628 | else if (is_page_fault(intr_info)) | 6644 | else if (is_page_fault(intr_info)) |
| 6629 | return enable_ept; | 6645 | return enable_ept; |
| 6646 | else if (is_no_device(intr_info) && | ||
| 6647 | !(nested_read_cr0(vmcs12) & X86_CR0_TS)) | ||
| 6648 | return 0; | ||
| 6630 | return vmcs12->exception_bitmap & | 6649 | return vmcs12->exception_bitmap & |
| 6631 | (1u << (intr_info & INTR_INFO_VECTOR_MASK)); | 6650 | (1u << (intr_info & INTR_INFO_VECTOR_MASK)); |
| 6632 | case EXIT_REASON_EXTERNAL_INTERRUPT: | 6651 | case EXIT_REASON_EXTERNAL_INTERRUPT: |
| @@ -6722,6 +6741,27 @@ static void vmx_get_exit_info(struct kvm_vcpu *vcpu, u64 *info1, u64 *info2) | |||
| 6722 | *info2 = vmcs_read32(VM_EXIT_INTR_INFO); | 6741 | *info2 = vmcs_read32(VM_EXIT_INTR_INFO); |
| 6723 | } | 6742 | } |
| 6724 | 6743 | ||
| 6744 | static void nested_adjust_preemption_timer(struct kvm_vcpu *vcpu) | ||
| 6745 | { | ||
| 6746 | u64 delta_tsc_l1; | ||
| 6747 | u32 preempt_val_l1, preempt_val_l2, preempt_scale; | ||
| 6748 | |||
| 6749 | if (!(get_vmcs12(vcpu)->pin_based_vm_exec_control & | ||
| 6750 | PIN_BASED_VMX_PREEMPTION_TIMER)) | ||
| 6751 | return; | ||
| 6752 | preempt_scale = native_read_msr(MSR_IA32_VMX_MISC) & | ||
| 6753 | MSR_IA32_VMX_MISC_PREEMPTION_TIMER_SCALE; | ||
| 6754 | preempt_val_l2 = vmcs_read32(VMX_PREEMPTION_TIMER_VALUE); | ||
| 6755 | delta_tsc_l1 = vmx_read_l1_tsc(vcpu, native_read_tsc()) | ||
| 6756 | - vcpu->arch.last_guest_tsc; | ||
| 6757 | preempt_val_l1 = delta_tsc_l1 >> preempt_scale; | ||
| 6758 | if (preempt_val_l2 <= preempt_val_l1) | ||
| 6759 | preempt_val_l2 = 0; | ||
| 6760 | else | ||
| 6761 | preempt_val_l2 -= preempt_val_l1; | ||
| 6762 | vmcs_write32(VMX_PREEMPTION_TIMER_VALUE, preempt_val_l2); | ||
| 6763 | } | ||
| 6764 | |||
| 6725 | /* | 6765 | /* |
| 6726 | * The guest has exited. See if we can fix it or if we need userspace | 6766 | * The guest has exited. See if we can fix it or if we need userspace |
| 6727 | * assistance. | 6767 | * assistance. |
| @@ -6736,20 +6776,6 @@ static int vmx_handle_exit(struct kvm_vcpu *vcpu) | |||
| 6736 | if (vmx->emulation_required) | 6776 | if (vmx->emulation_required) |
| 6737 | return handle_invalid_guest_state(vcpu); | 6777 | return handle_invalid_guest_state(vcpu); |
| 6738 | 6778 | ||
| 6739 | /* | ||
| 6740 | * the KVM_REQ_EVENT optimization bit is only on for one entry, and if | ||
| 6741 | * we did not inject a still-pending event to L1 now because of | ||
| 6742 | * nested_run_pending, we need to re-enable this bit. | ||
| 6743 | */ | ||
| 6744 | if (vmx->nested.nested_run_pending) | ||
| 6745 | kvm_make_request(KVM_REQ_EVENT, vcpu); | ||
| 6746 | |||
| 6747 | if (!is_guest_mode(vcpu) && (exit_reason == EXIT_REASON_VMLAUNCH || | ||
| 6748 | exit_reason == EXIT_REASON_VMRESUME)) | ||
| 6749 | vmx->nested.nested_run_pending = 1; | ||
| 6750 | else | ||
| 6751 | vmx->nested.nested_run_pending = 0; | ||
| 6752 | |||
| 6753 | if (is_guest_mode(vcpu) && nested_vmx_exit_handled(vcpu)) { | 6779 | if (is_guest_mode(vcpu) && nested_vmx_exit_handled(vcpu)) { |
| 6754 | nested_vmx_vmexit(vcpu); | 6780 | nested_vmx_vmexit(vcpu); |
| 6755 | return 1; | 6781 | return 1; |
| @@ -7061,9 +7087,9 @@ static void __vmx_complete_interrupts(struct kvm_vcpu *vcpu, | |||
| 7061 | case INTR_TYPE_HARD_EXCEPTION: | 7087 | case INTR_TYPE_HARD_EXCEPTION: |
| 7062 | if (idt_vectoring_info & VECTORING_INFO_DELIVER_CODE_MASK) { | 7088 | if (idt_vectoring_info & VECTORING_INFO_DELIVER_CODE_MASK) { |
| 7063 | u32 err = vmcs_read32(error_code_field); | 7089 | u32 err = vmcs_read32(error_code_field); |
| 7064 | kvm_queue_exception_e(vcpu, vector, err); | 7090 | kvm_requeue_exception_e(vcpu, vector, err); |
| 7065 | } else | 7091 | } else |
| 7066 | kvm_queue_exception(vcpu, vector); | 7092 | kvm_requeue_exception(vcpu, vector); |
| 7067 | break; | 7093 | break; |
| 7068 | case INTR_TYPE_SOFT_INTR: | 7094 | case INTR_TYPE_SOFT_INTR: |
| 7069 | vcpu->arch.event_exit_inst_len = vmcs_read32(instr_len_field); | 7095 | vcpu->arch.event_exit_inst_len = vmcs_read32(instr_len_field); |
| @@ -7146,6 +7172,8 @@ static void __noclone vmx_vcpu_run(struct kvm_vcpu *vcpu) | |||
| 7146 | atomic_switch_perf_msrs(vmx); | 7172 | atomic_switch_perf_msrs(vmx); |
| 7147 | debugctlmsr = get_debugctlmsr(); | 7173 | debugctlmsr = get_debugctlmsr(); |
| 7148 | 7174 | ||
| 7175 | if (is_guest_mode(vcpu) && !vmx->nested.nested_run_pending) | ||
| 7176 | nested_adjust_preemption_timer(vcpu); | ||
| 7149 | vmx->__launched = vmx->loaded_vmcs->launched; | 7177 | vmx->__launched = vmx->loaded_vmcs->launched; |
| 7150 | asm( | 7178 | asm( |
| 7151 | /* Store host registers */ | 7179 | /* Store host registers */ |
| @@ -7284,6 +7312,16 @@ static void __noclone vmx_vcpu_run(struct kvm_vcpu *vcpu) | |||
| 7284 | vmx->exit_reason = vmcs_read32(VM_EXIT_REASON); | 7312 | vmx->exit_reason = vmcs_read32(VM_EXIT_REASON); |
| 7285 | trace_kvm_exit(vmx->exit_reason, vcpu, KVM_ISA_VMX); | 7313 | trace_kvm_exit(vmx->exit_reason, vcpu, KVM_ISA_VMX); |
| 7286 | 7314 | ||
| 7315 | /* | ||
| 7316 | * the KVM_REQ_EVENT optimization bit is only on for one entry, and if | ||
| 7317 | * we did not inject a still-pending event to L1 now because of | ||
| 7318 | * nested_run_pending, we need to re-enable this bit. | ||
| 7319 | */ | ||
| 7320 | if (vmx->nested.nested_run_pending) | ||
| 7321 | kvm_make_request(KVM_REQ_EVENT, vcpu); | ||
| 7322 | |||
| 7323 | vmx->nested.nested_run_pending = 0; | ||
| 7324 | |||
| 7287 | vmx_complete_atomic_exit(vmx); | 7325 | vmx_complete_atomic_exit(vmx); |
| 7288 | vmx_recover_nmi_blocking(vmx); | 7326 | vmx_recover_nmi_blocking(vmx); |
| 7289 | vmx_complete_interrupts(vmx); | 7327 | vmx_complete_interrupts(vmx); |
| @@ -7410,8 +7448,7 @@ static u64 vmx_get_mt_mask(struct kvm_vcpu *vcpu, gfn_t gfn, bool is_mmio) | |||
| 7410 | */ | 7448 | */ |
| 7411 | if (is_mmio) | 7449 | if (is_mmio) |
| 7412 | ret = MTRR_TYPE_UNCACHABLE << VMX_EPT_MT_EPTE_SHIFT; | 7450 | ret = MTRR_TYPE_UNCACHABLE << VMX_EPT_MT_EPTE_SHIFT; |
| 7413 | else if (vcpu->kvm->arch.iommu_domain && | 7451 | else if (kvm_arch_has_noncoherent_dma(vcpu->kvm)) |
| 7414 | !(vcpu->kvm->arch.iommu_flags & KVM_IOMMU_CACHE_COHERENCY)) | ||
| 7415 | ret = kvm_get_guest_memory_type(vcpu, gfn) << | 7452 | ret = kvm_get_guest_memory_type(vcpu, gfn) << |
| 7416 | VMX_EPT_MT_EPTE_SHIFT; | 7453 | VMX_EPT_MT_EPTE_SHIFT; |
| 7417 | else | 7454 | else |
| @@ -7501,9 +7538,9 @@ static unsigned long nested_ept_get_cr3(struct kvm_vcpu *vcpu) | |||
| 7501 | return get_vmcs12(vcpu)->ept_pointer; | 7538 | return get_vmcs12(vcpu)->ept_pointer; |
| 7502 | } | 7539 | } |
| 7503 | 7540 | ||
| 7504 | static int nested_ept_init_mmu_context(struct kvm_vcpu *vcpu) | 7541 | static void nested_ept_init_mmu_context(struct kvm_vcpu *vcpu) |
| 7505 | { | 7542 | { |
| 7506 | int r = kvm_init_shadow_ept_mmu(vcpu, &vcpu->arch.mmu, | 7543 | kvm_init_shadow_ept_mmu(vcpu, &vcpu->arch.mmu, |
| 7507 | nested_vmx_ept_caps & VMX_EPT_EXECUTE_ONLY_BIT); | 7544 | nested_vmx_ept_caps & VMX_EPT_EXECUTE_ONLY_BIT); |
| 7508 | 7545 | ||
| 7509 | vcpu->arch.mmu.set_cr3 = vmx_set_cr3; | 7546 | vcpu->arch.mmu.set_cr3 = vmx_set_cr3; |
| @@ -7511,8 +7548,6 @@ static int nested_ept_init_mmu_context(struct kvm_vcpu *vcpu) | |||
| 7511 | vcpu->arch.mmu.inject_page_fault = nested_ept_inject_page_fault; | 7548 | vcpu->arch.mmu.inject_page_fault = nested_ept_inject_page_fault; |
| 7512 | 7549 | ||
| 7513 | vcpu->arch.walk_mmu = &vcpu->arch.nested_mmu; | 7550 | vcpu->arch.walk_mmu = &vcpu->arch.nested_mmu; |
| 7514 | |||
| 7515 | return r; | ||
| 7516 | } | 7551 | } |
| 7517 | 7552 | ||
| 7518 | static void nested_ept_uninit_mmu_context(struct kvm_vcpu *vcpu) | 7553 | static void nested_ept_uninit_mmu_context(struct kvm_vcpu *vcpu) |
| @@ -7520,6 +7555,20 @@ static void nested_ept_uninit_mmu_context(struct kvm_vcpu *vcpu) | |||
| 7520 | vcpu->arch.walk_mmu = &vcpu->arch.mmu; | 7555 | vcpu->arch.walk_mmu = &vcpu->arch.mmu; |
| 7521 | } | 7556 | } |
| 7522 | 7557 | ||
| 7558 | static void vmx_inject_page_fault_nested(struct kvm_vcpu *vcpu, | ||
| 7559 | struct x86_exception *fault) | ||
| 7560 | { | ||
| 7561 | struct vmcs12 *vmcs12 = get_vmcs12(vcpu); | ||
| 7562 | |||
| 7563 | WARN_ON(!is_guest_mode(vcpu)); | ||
| 7564 | |||
| 7565 | /* TODO: also check PFEC_MATCH/MASK, not just EB.PF. */ | ||
| 7566 | if (vmcs12->exception_bitmap & (1u << PF_VECTOR)) | ||
| 7567 | nested_vmx_vmexit(vcpu); | ||
| 7568 | else | ||
| 7569 | kvm_inject_page_fault(vcpu, fault); | ||
| 7570 | } | ||
| 7571 | |||
| 7523 | /* | 7572 | /* |
| 7524 | * prepare_vmcs02 is called when the L1 guest hypervisor runs its nested | 7573 | * prepare_vmcs02 is called when the L1 guest hypervisor runs its nested |
| 7525 | * L2 guest. L1 has a vmcs for L2 (vmcs12), and this function "merges" it | 7574 | * L2 guest. L1 has a vmcs for L2 (vmcs12), and this function "merges" it |
| @@ -7533,6 +7582,7 @@ static void prepare_vmcs02(struct kvm_vcpu *vcpu, struct vmcs12 *vmcs12) | |||
| 7533 | { | 7582 | { |
| 7534 | struct vcpu_vmx *vmx = to_vmx(vcpu); | 7583 | struct vcpu_vmx *vmx = to_vmx(vcpu); |
| 7535 | u32 exec_control; | 7584 | u32 exec_control; |
| 7585 | u32 exit_control; | ||
| 7536 | 7586 | ||
| 7537 | vmcs_write16(GUEST_ES_SELECTOR, vmcs12->guest_es_selector); | 7587 | vmcs_write16(GUEST_ES_SELECTOR, vmcs12->guest_es_selector); |
| 7538 | vmcs_write16(GUEST_CS_SELECTOR, vmcs12->guest_cs_selector); | 7588 | vmcs_write16(GUEST_CS_SELECTOR, vmcs12->guest_cs_selector); |
| @@ -7706,7 +7756,10 @@ static void prepare_vmcs02(struct kvm_vcpu *vcpu, struct vmcs12 *vmcs12) | |||
| 7706 | * we should use its exit controls. Note that VM_EXIT_LOAD_IA32_EFER | 7756 | * we should use its exit controls. Note that VM_EXIT_LOAD_IA32_EFER |
| 7707 | * bits are further modified by vmx_set_efer() below. | 7757 | * bits are further modified by vmx_set_efer() below. |
| 7708 | */ | 7758 | */ |
| 7709 | vmcs_write32(VM_EXIT_CONTROLS, vmcs_config.vmexit_ctrl); | 7759 | exit_control = vmcs_config.vmexit_ctrl; |
| 7760 | if (vmcs12->pin_based_vm_exec_control & PIN_BASED_VMX_PREEMPTION_TIMER) | ||
| 7761 | exit_control |= VM_EXIT_SAVE_VMX_PREEMPTION_TIMER; | ||
| 7762 | vmcs_write32(VM_EXIT_CONTROLS, exit_control); | ||
| 7710 | 7763 | ||
| 7711 | /* vmcs12's VM_ENTRY_LOAD_IA32_EFER and VM_ENTRY_IA32E_MODE are | 7764 | /* vmcs12's VM_ENTRY_LOAD_IA32_EFER and VM_ENTRY_IA32E_MODE are |
| 7712 | * emulated by vmx_set_efer(), below. | 7765 | * emulated by vmx_set_efer(), below. |
| @@ -7773,6 +7826,9 @@ static void prepare_vmcs02(struct kvm_vcpu *vcpu, struct vmcs12 *vmcs12) | |||
| 7773 | kvm_set_cr3(vcpu, vmcs12->guest_cr3); | 7826 | kvm_set_cr3(vcpu, vmcs12->guest_cr3); |
| 7774 | kvm_mmu_reset_context(vcpu); | 7827 | kvm_mmu_reset_context(vcpu); |
| 7775 | 7828 | ||
| 7829 | if (!enable_ept) | ||
| 7830 | vcpu->arch.walk_mmu->inject_page_fault = vmx_inject_page_fault_nested; | ||
| 7831 | |||
| 7776 | /* | 7832 | /* |
| 7777 | * L1 may access the L2's PDPTR, so save them to construct vmcs12 | 7833 | * L1 may access the L2's PDPTR, so save them to construct vmcs12 |
| 7778 | */ | 7834 | */ |
| @@ -7876,7 +7932,7 @@ static int nested_vmx_run(struct kvm_vcpu *vcpu, bool launch) | |||
| 7876 | return 1; | 7932 | return 1; |
| 7877 | } | 7933 | } |
| 7878 | 7934 | ||
| 7879 | if (((vmcs12->guest_cr0 & VMXON_CR0_ALWAYSON) != VMXON_CR0_ALWAYSON) || | 7935 | if (!nested_cr0_valid(vmcs12, vmcs12->guest_cr0) || |
| 7880 | ((vmcs12->guest_cr4 & VMXON_CR4_ALWAYSON) != VMXON_CR4_ALWAYSON)) { | 7936 | ((vmcs12->guest_cr4 & VMXON_CR4_ALWAYSON) != VMXON_CR4_ALWAYSON)) { |
| 7881 | nested_vmx_entry_failure(vcpu, vmcs12, | 7937 | nested_vmx_entry_failure(vcpu, vmcs12, |
| 7882 | EXIT_REASON_INVALID_STATE, ENTRY_FAIL_DEFAULT); | 7938 | EXIT_REASON_INVALID_STATE, ENTRY_FAIL_DEFAULT); |
| @@ -7938,6 +7994,8 @@ static int nested_vmx_run(struct kvm_vcpu *vcpu, bool launch) | |||
| 7938 | 7994 | ||
| 7939 | enter_guest_mode(vcpu); | 7995 | enter_guest_mode(vcpu); |
| 7940 | 7996 | ||
| 7997 | vmx->nested.nested_run_pending = 1; | ||
| 7998 | |||
| 7941 | vmx->nested.vmcs01_tsc_offset = vmcs_read64(TSC_OFFSET); | 7999 | vmx->nested.vmcs01_tsc_offset = vmcs_read64(TSC_OFFSET); |
| 7942 | 8000 | ||
| 7943 | cpu = get_cpu(); | 8001 | cpu = get_cpu(); |
| @@ -8005,7 +8063,7 @@ static void vmcs12_save_pending_event(struct kvm_vcpu *vcpu, | |||
| 8005 | u32 idt_vectoring; | 8063 | u32 idt_vectoring; |
| 8006 | unsigned int nr; | 8064 | unsigned int nr; |
| 8007 | 8065 | ||
| 8008 | if (vcpu->arch.exception.pending) { | 8066 | if (vcpu->arch.exception.pending && vcpu->arch.exception.reinject) { |
| 8009 | nr = vcpu->arch.exception.nr; | 8067 | nr = vcpu->arch.exception.nr; |
| 8010 | idt_vectoring = nr | VECTORING_INFO_VALID_MASK; | 8068 | idt_vectoring = nr | VECTORING_INFO_VALID_MASK; |
| 8011 | 8069 | ||
| @@ -8023,7 +8081,7 @@ static void vmcs12_save_pending_event(struct kvm_vcpu *vcpu, | |||
| 8023 | } | 8081 | } |
| 8024 | 8082 | ||
| 8025 | vmcs12->idt_vectoring_info_field = idt_vectoring; | 8083 | vmcs12->idt_vectoring_info_field = idt_vectoring; |
| 8026 | } else if (vcpu->arch.nmi_pending) { | 8084 | } else if (vcpu->arch.nmi_injected) { |
| 8027 | vmcs12->idt_vectoring_info_field = | 8085 | vmcs12->idt_vectoring_info_field = |
| 8028 | INTR_TYPE_NMI_INTR | INTR_INFO_VALID_MASK | NMI_VECTOR; | 8086 | INTR_TYPE_NMI_INTR | INTR_INFO_VALID_MASK | NMI_VECTOR; |
| 8029 | } else if (vcpu->arch.interrupt.pending) { | 8087 | } else if (vcpu->arch.interrupt.pending) { |
| @@ -8105,6 +8163,11 @@ static void prepare_vmcs12(struct kvm_vcpu *vcpu, struct vmcs12 *vmcs12) | |||
| 8105 | vmcs12->guest_pending_dbg_exceptions = | 8163 | vmcs12->guest_pending_dbg_exceptions = |
| 8106 | vmcs_readl(GUEST_PENDING_DBG_EXCEPTIONS); | 8164 | vmcs_readl(GUEST_PENDING_DBG_EXCEPTIONS); |
| 8107 | 8165 | ||
| 8166 | if ((vmcs12->pin_based_vm_exec_control & PIN_BASED_VMX_PREEMPTION_TIMER) && | ||
| 8167 | (vmcs12->vm_exit_controls & VM_EXIT_SAVE_VMX_PREEMPTION_TIMER)) | ||
| 8168 | vmcs12->vmx_preemption_timer_value = | ||
| 8169 | vmcs_read32(VMX_PREEMPTION_TIMER_VALUE); | ||
| 8170 | |||
| 8108 | /* | 8171 | /* |
| 8109 | * In some cases (usually, nested EPT), L2 is allowed to change its | 8172 | * In some cases (usually, nested EPT), L2 is allowed to change its |
| 8110 | * own CR3 without exiting. If it has changed it, we must keep it. | 8173 | * own CR3 without exiting. If it has changed it, we must keep it. |
| @@ -8130,6 +8193,8 @@ static void prepare_vmcs12(struct kvm_vcpu *vcpu, struct vmcs12 *vmcs12) | |||
| 8130 | vmcs12->guest_ia32_debugctl = vmcs_read64(GUEST_IA32_DEBUGCTL); | 8193 | vmcs12->guest_ia32_debugctl = vmcs_read64(GUEST_IA32_DEBUGCTL); |
| 8131 | if (vmcs12->vm_exit_controls & VM_EXIT_SAVE_IA32_PAT) | 8194 | if (vmcs12->vm_exit_controls & VM_EXIT_SAVE_IA32_PAT) |
| 8132 | vmcs12->guest_ia32_pat = vmcs_read64(GUEST_IA32_PAT); | 8195 | vmcs12->guest_ia32_pat = vmcs_read64(GUEST_IA32_PAT); |
| 8196 | if (vmcs12->vm_exit_controls & VM_EXIT_SAVE_IA32_EFER) | ||
| 8197 | vmcs12->guest_ia32_efer = vcpu->arch.efer; | ||
| 8133 | vmcs12->guest_sysenter_cs = vmcs_read32(GUEST_SYSENTER_CS); | 8198 | vmcs12->guest_sysenter_cs = vmcs_read32(GUEST_SYSENTER_CS); |
| 8134 | vmcs12->guest_sysenter_esp = vmcs_readl(GUEST_SYSENTER_ESP); | 8199 | vmcs12->guest_sysenter_esp = vmcs_readl(GUEST_SYSENTER_ESP); |
| 8135 | vmcs12->guest_sysenter_eip = vmcs_readl(GUEST_SYSENTER_EIP); | 8200 | vmcs12->guest_sysenter_eip = vmcs_readl(GUEST_SYSENTER_EIP); |
| @@ -8201,7 +8266,7 @@ static void load_vmcs12_host_state(struct kvm_vcpu *vcpu, | |||
| 8201 | * fpu_active (which may have changed). | 8266 | * fpu_active (which may have changed). |
| 8202 | * Note that vmx_set_cr0 refers to efer set above. | 8267 | * Note that vmx_set_cr0 refers to efer set above. |
| 8203 | */ | 8268 | */ |
| 8204 | kvm_set_cr0(vcpu, vmcs12->host_cr0); | 8269 | vmx_set_cr0(vcpu, vmcs12->host_cr0); |
| 8205 | /* | 8270 | /* |
| 8206 | * If we did fpu_activate()/fpu_deactivate() during L2's run, we need | 8271 | * If we did fpu_activate()/fpu_deactivate() during L2's run, we need |
| 8207 | * to apply the same changes to L1's vmcs. We just set cr0 correctly, | 8272 | * to apply the same changes to L1's vmcs. We just set cr0 correctly, |
| @@ -8224,6 +8289,9 @@ static void load_vmcs12_host_state(struct kvm_vcpu *vcpu, | |||
| 8224 | kvm_set_cr3(vcpu, vmcs12->host_cr3); | 8289 | kvm_set_cr3(vcpu, vmcs12->host_cr3); |
| 8225 | kvm_mmu_reset_context(vcpu); | 8290 | kvm_mmu_reset_context(vcpu); |
| 8226 | 8291 | ||
| 8292 | if (!enable_ept) | ||
| 8293 | vcpu->arch.walk_mmu->inject_page_fault = kvm_inject_page_fault; | ||
| 8294 | |||
| 8227 | if (enable_vpid) { | 8295 | if (enable_vpid) { |
| 8228 | /* | 8296 | /* |
| 8229 | * Trivially support vpid by letting L2s share their parent | 8297 | * Trivially support vpid by letting L2s share their parent |
diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c index e5ca72a5cdb6..21ef1ba184ae 100644 --- a/arch/x86/kvm/x86.c +++ b/arch/x86/kvm/x86.c | |||
| @@ -577,6 +577,7 @@ static void kvm_put_guest_xcr0(struct kvm_vcpu *vcpu) | |||
| 577 | int __kvm_set_xcr(struct kvm_vcpu *vcpu, u32 index, u64 xcr) | 577 | int __kvm_set_xcr(struct kvm_vcpu *vcpu, u32 index, u64 xcr) |
| 578 | { | 578 | { |
| 579 | u64 xcr0; | 579 | u64 xcr0; |
| 580 | u64 valid_bits; | ||
| 580 | 581 | ||
| 581 | /* Only support XCR_XFEATURE_ENABLED_MASK(xcr0) now */ | 582 | /* Only support XCR_XFEATURE_ENABLED_MASK(xcr0) now */ |
| 582 | if (index != XCR_XFEATURE_ENABLED_MASK) | 583 | if (index != XCR_XFEATURE_ENABLED_MASK) |
| @@ -586,8 +587,16 @@ int __kvm_set_xcr(struct kvm_vcpu *vcpu, u32 index, u64 xcr) | |||
| 586 | return 1; | 587 | return 1; |
| 587 | if ((xcr0 & XSTATE_YMM) && !(xcr0 & XSTATE_SSE)) | 588 | if ((xcr0 & XSTATE_YMM) && !(xcr0 & XSTATE_SSE)) |
| 588 | return 1; | 589 | return 1; |
| 589 | if (xcr0 & ~host_xcr0) | 590 | |
| 591 | /* | ||
| 592 | * Do not allow the guest to set bits that we do not support | ||
| 593 | * saving. However, xcr0 bit 0 is always set, even if the | ||
| 594 | * emulated CPU does not support XSAVE (see fx_init). | ||
| 595 | */ | ||
| 596 | valid_bits = vcpu->arch.guest_supported_xcr0 | XSTATE_FP; | ||
| 597 | if (xcr0 & ~valid_bits) | ||
| 590 | return 1; | 598 | return 1; |
| 599 | |||
| 591 | kvm_put_guest_xcr0(vcpu); | 600 | kvm_put_guest_xcr0(vcpu); |
| 592 | vcpu->arch.xcr0 = xcr0; | 601 | vcpu->arch.xcr0 = xcr0; |
| 593 | return 0; | 602 | return 0; |
| @@ -684,7 +693,7 @@ int kvm_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3) | |||
| 684 | 693 | ||
| 685 | vcpu->arch.cr3 = cr3; | 694 | vcpu->arch.cr3 = cr3; |
| 686 | __set_bit(VCPU_EXREG_CR3, (ulong *)&vcpu->arch.regs_avail); | 695 | __set_bit(VCPU_EXREG_CR3, (ulong *)&vcpu->arch.regs_avail); |
| 687 | vcpu->arch.mmu.new_cr3(vcpu); | 696 | kvm_mmu_new_cr3(vcpu); |
| 688 | return 0; | 697 | return 0; |
| 689 | } | 698 | } |
| 690 | EXPORT_SYMBOL_GPL(kvm_set_cr3); | 699 | EXPORT_SYMBOL_GPL(kvm_set_cr3); |
| @@ -2564,6 +2573,7 @@ int kvm_dev_ioctl_check_extension(long ext) | |||
| 2564 | case KVM_CAP_MMU_SHADOW_CACHE_CONTROL: | 2573 | case KVM_CAP_MMU_SHADOW_CACHE_CONTROL: |
| 2565 | case KVM_CAP_SET_TSS_ADDR: | 2574 | case KVM_CAP_SET_TSS_ADDR: |
| 2566 | case KVM_CAP_EXT_CPUID: | 2575 | case KVM_CAP_EXT_CPUID: |
| 2576 | case KVM_CAP_EXT_EMUL_CPUID: | ||
| 2567 | case KVM_CAP_CLOCKSOURCE: | 2577 | case KVM_CAP_CLOCKSOURCE: |
| 2568 | case KVM_CAP_PIT: | 2578 | case KVM_CAP_PIT: |
| 2569 | case KVM_CAP_NOP_IO_DELAY: | 2579 | case KVM_CAP_NOP_IO_DELAY: |
| @@ -2673,15 +2683,17 @@ long kvm_arch_dev_ioctl(struct file *filp, | |||
| 2673 | r = 0; | 2683 | r = 0; |
| 2674 | break; | 2684 | break; |
| 2675 | } | 2685 | } |
| 2676 | case KVM_GET_SUPPORTED_CPUID: { | 2686 | case KVM_GET_SUPPORTED_CPUID: |
| 2687 | case KVM_GET_EMULATED_CPUID: { | ||
| 2677 | struct kvm_cpuid2 __user *cpuid_arg = argp; | 2688 | struct kvm_cpuid2 __user *cpuid_arg = argp; |
| 2678 | struct kvm_cpuid2 cpuid; | 2689 | struct kvm_cpuid2 cpuid; |
| 2679 | 2690 | ||
| 2680 | r = -EFAULT; | 2691 | r = -EFAULT; |
| 2681 | if (copy_from_user(&cpuid, cpuid_arg, sizeof cpuid)) | 2692 | if (copy_from_user(&cpuid, cpuid_arg, sizeof cpuid)) |
| 2682 | goto out; | 2693 | goto out; |
| 2683 | r = kvm_dev_ioctl_get_supported_cpuid(&cpuid, | 2694 | |
| 2684 | cpuid_arg->entries); | 2695 | r = kvm_dev_ioctl_get_cpuid(&cpuid, cpuid_arg->entries, |
| 2696 | ioctl); | ||
| 2685 | if (r) | 2697 | if (r) |
| 2686 | goto out; | 2698 | goto out; |
| 2687 | 2699 | ||
| @@ -2715,8 +2727,7 @@ static void wbinvd_ipi(void *garbage) | |||
| 2715 | 2727 | ||
| 2716 | static bool need_emulate_wbinvd(struct kvm_vcpu *vcpu) | 2728 | static bool need_emulate_wbinvd(struct kvm_vcpu *vcpu) |
| 2717 | { | 2729 | { |
| 2718 | return vcpu->kvm->arch.iommu_domain && | 2730 | return kvm_arch_has_noncoherent_dma(vcpu->kvm); |
| 2719 | !(vcpu->kvm->arch.iommu_flags & KVM_IOMMU_CACHE_COHERENCY); | ||
| 2720 | } | 2731 | } |
| 2721 | 2732 | ||
| 2722 | void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) | 2733 | void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) |
| @@ -2984,11 +2995,13 @@ static int kvm_vcpu_ioctl_x86_set_debugregs(struct kvm_vcpu *vcpu, | |||
| 2984 | static void kvm_vcpu_ioctl_x86_get_xsave(struct kvm_vcpu *vcpu, | 2995 | static void kvm_vcpu_ioctl_x86_get_xsave(struct kvm_vcpu *vcpu, |
| 2985 | struct kvm_xsave *guest_xsave) | 2996 | struct kvm_xsave *guest_xsave) |
| 2986 | { | 2997 | { |
| 2987 | if (cpu_has_xsave) | 2998 | if (cpu_has_xsave) { |
| 2988 | memcpy(guest_xsave->region, | 2999 | memcpy(guest_xsave->region, |
| 2989 | &vcpu->arch.guest_fpu.state->xsave, | 3000 | &vcpu->arch.guest_fpu.state->xsave, |
| 2990 | xstate_size); | 3001 | vcpu->arch.guest_xstate_size); |
| 2991 | else { | 3002 | *(u64 *)&guest_xsave->region[XSAVE_HDR_OFFSET / sizeof(u32)] &= |
| 3003 | vcpu->arch.guest_supported_xcr0 | XSTATE_FPSSE; | ||
| 3004 | } else { | ||
| 2992 | memcpy(guest_xsave->region, | 3005 | memcpy(guest_xsave->region, |
| 2993 | &vcpu->arch.guest_fpu.state->fxsave, | 3006 | &vcpu->arch.guest_fpu.state->fxsave, |
| 2994 | sizeof(struct i387_fxsave_struct)); | 3007 | sizeof(struct i387_fxsave_struct)); |
| @@ -3003,10 +3016,19 @@ static int kvm_vcpu_ioctl_x86_set_xsave(struct kvm_vcpu *vcpu, | |||
| 3003 | u64 xstate_bv = | 3016 | u64 xstate_bv = |
| 3004 | *(u64 *)&guest_xsave->region[XSAVE_HDR_OFFSET / sizeof(u32)]; | 3017 | *(u64 *)&guest_xsave->region[XSAVE_HDR_OFFSET / sizeof(u32)]; |
| 3005 | 3018 | ||
| 3006 | if (cpu_has_xsave) | 3019 | if (cpu_has_xsave) { |
| 3020 | /* | ||
| 3021 | * Here we allow setting states that are not present in | ||
| 3022 | * CPUID leaf 0xD, index 0, EDX:EAX. This is for compatibility | ||
| 3023 | * with old userspace. | ||
| 3024 | */ | ||
| 3025 | if (xstate_bv & ~KVM_SUPPORTED_XCR0) | ||
| 3026 | return -EINVAL; | ||
| 3027 | if (xstate_bv & ~host_xcr0) | ||
| 3028 | return -EINVAL; | ||
| 3007 | memcpy(&vcpu->arch.guest_fpu.state->xsave, | 3029 | memcpy(&vcpu->arch.guest_fpu.state->xsave, |
| 3008 | guest_xsave->region, xstate_size); | 3030 | guest_xsave->region, vcpu->arch.guest_xstate_size); |
| 3009 | else { | 3031 | } else { |
| 3010 | if (xstate_bv & ~XSTATE_FPSSE) | 3032 | if (xstate_bv & ~XSTATE_FPSSE) |
| 3011 | return -EINVAL; | 3033 | return -EINVAL; |
| 3012 | memcpy(&vcpu->arch.guest_fpu.state->fxsave, | 3034 | memcpy(&vcpu->arch.guest_fpu.state->fxsave, |
| @@ -3042,9 +3064,9 @@ static int kvm_vcpu_ioctl_x86_set_xcrs(struct kvm_vcpu *vcpu, | |||
| 3042 | 3064 | ||
| 3043 | for (i = 0; i < guest_xcrs->nr_xcrs; i++) | 3065 | for (i = 0; i < guest_xcrs->nr_xcrs; i++) |
| 3044 | /* Only support XCR0 currently */ | 3066 | /* Only support XCR0 currently */ |
| 3045 | if (guest_xcrs->xcrs[0].xcr == XCR_XFEATURE_ENABLED_MASK) { | 3067 | if (guest_xcrs->xcrs[i].xcr == XCR_XFEATURE_ENABLED_MASK) { |
| 3046 | r = __kvm_set_xcr(vcpu, XCR_XFEATURE_ENABLED_MASK, | 3068 | r = __kvm_set_xcr(vcpu, XCR_XFEATURE_ENABLED_MASK, |
| 3047 | guest_xcrs->xcrs[0].value); | 3069 | guest_xcrs->xcrs[i].value); |
| 3048 | break; | 3070 | break; |
| 3049 | } | 3071 | } |
| 3050 | if (r) | 3072 | if (r) |
| @@ -4775,8 +4797,8 @@ static void inject_emulated_exception(struct kvm_vcpu *vcpu) | |||
| 4775 | 4797 | ||
| 4776 | static void init_decode_cache(struct x86_emulate_ctxt *ctxt) | 4798 | static void init_decode_cache(struct x86_emulate_ctxt *ctxt) |
| 4777 | { | 4799 | { |
| 4778 | memset(&ctxt->twobyte, 0, | 4800 | memset(&ctxt->opcode_len, 0, |
| 4779 | (void *)&ctxt->_regs - (void *)&ctxt->twobyte); | 4801 | (void *)&ctxt->_regs - (void *)&ctxt->opcode_len); |
| 4780 | 4802 | ||
| 4781 | ctxt->fetch.start = 0; | 4803 | ctxt->fetch.start = 0; |
| 4782 | ctxt->fetch.end = 0; | 4804 | ctxt->fetch.end = 0; |
| @@ -5094,8 +5116,7 @@ int x86_emulate_instruction(struct kvm_vcpu *vcpu, | |||
| 5094 | ctxt->have_exception = false; | 5116 | ctxt->have_exception = false; |
| 5095 | ctxt->perm_ok = false; | 5117 | ctxt->perm_ok = false; |
| 5096 | 5118 | ||
| 5097 | ctxt->only_vendor_specific_insn | 5119 | ctxt->ud = emulation_type & EMULTYPE_TRAP_UD; |
| 5098 | = emulation_type & EMULTYPE_TRAP_UD; | ||
| 5099 | 5120 | ||
| 5100 | r = x86_decode_insn(ctxt, insn, insn_len); | 5121 | r = x86_decode_insn(ctxt, insn, insn_len); |
| 5101 | 5122 | ||
| @@ -5263,7 +5284,7 @@ static int kvmclock_cpufreq_notifier(struct notifier_block *nb, unsigned long va | |||
| 5263 | 5284 | ||
| 5264 | smp_call_function_single(freq->cpu, tsc_khz_changed, freq, 1); | 5285 | smp_call_function_single(freq->cpu, tsc_khz_changed, freq, 1); |
| 5265 | 5286 | ||
| 5266 | raw_spin_lock(&kvm_lock); | 5287 | spin_lock(&kvm_lock); |
| 5267 | list_for_each_entry(kvm, &vm_list, vm_list) { | 5288 | list_for_each_entry(kvm, &vm_list, vm_list) { |
| 5268 | kvm_for_each_vcpu(i, vcpu, kvm) { | 5289 | kvm_for_each_vcpu(i, vcpu, kvm) { |
| 5269 | if (vcpu->cpu != freq->cpu) | 5290 | if (vcpu->cpu != freq->cpu) |
| @@ -5273,7 +5294,7 @@ static int kvmclock_cpufreq_notifier(struct notifier_block *nb, unsigned long va | |||
| 5273 | send_ipi = 1; | 5294 | send_ipi = 1; |
| 5274 | } | 5295 | } |
| 5275 | } | 5296 | } |
| 5276 | raw_spin_unlock(&kvm_lock); | 5297 | spin_unlock(&kvm_lock); |
| 5277 | 5298 | ||
| 5278 | if (freq->old < freq->new && send_ipi) { | 5299 | if (freq->old < freq->new && send_ipi) { |
| 5279 | /* | 5300 | /* |
| @@ -5426,12 +5447,12 @@ static void pvclock_gtod_update_fn(struct work_struct *work) | |||
| 5426 | struct kvm_vcpu *vcpu; | 5447 | struct kvm_vcpu *vcpu; |
| 5427 | int i; | 5448 | int i; |
| 5428 | 5449 | ||
| 5429 | raw_spin_lock(&kvm_lock); | 5450 | spin_lock(&kvm_lock); |
| 5430 | list_for_each_entry(kvm, &vm_list, vm_list) | 5451 | list_for_each_entry(kvm, &vm_list, vm_list) |
| 5431 | kvm_for_each_vcpu(i, vcpu, kvm) | 5452 | kvm_for_each_vcpu(i, vcpu, kvm) |
| 5432 | set_bit(KVM_REQ_MASTERCLOCK_UPDATE, &vcpu->requests); | 5453 | set_bit(KVM_REQ_MASTERCLOCK_UPDATE, &vcpu->requests); |
| 5433 | atomic_set(&kvm_guest_has_master_clock, 0); | 5454 | atomic_set(&kvm_guest_has_master_clock, 0); |
| 5434 | raw_spin_unlock(&kvm_lock); | 5455 | spin_unlock(&kvm_lock); |
| 5435 | } | 5456 | } |
| 5436 | 5457 | ||
| 5437 | static DECLARE_WORK(pvclock_gtod_work, pvclock_gtod_update_fn); | 5458 | static DECLARE_WORK(pvclock_gtod_work, pvclock_gtod_update_fn); |
| @@ -5945,10 +5966,12 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) | |||
| 5945 | 5966 | ||
| 5946 | vcpu->mode = IN_GUEST_MODE; | 5967 | vcpu->mode = IN_GUEST_MODE; |
| 5947 | 5968 | ||
| 5969 | srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); | ||
| 5970 | |||
| 5948 | /* We should set ->mode before check ->requests, | 5971 | /* We should set ->mode before check ->requests, |
| 5949 | * see the comment in make_all_cpus_request. | 5972 | * see the comment in make_all_cpus_request. |
| 5950 | */ | 5973 | */ |
| 5951 | smp_mb(); | 5974 | smp_mb__after_srcu_read_unlock(); |
| 5952 | 5975 | ||
| 5953 | local_irq_disable(); | 5976 | local_irq_disable(); |
| 5954 | 5977 | ||
| @@ -5958,12 +5981,11 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) | |||
| 5958 | smp_wmb(); | 5981 | smp_wmb(); |
| 5959 | local_irq_enable(); | 5982 | local_irq_enable(); |
| 5960 | preempt_enable(); | 5983 | preempt_enable(); |
| 5984 | vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); | ||
| 5961 | r = 1; | 5985 | r = 1; |
| 5962 | goto cancel_injection; | 5986 | goto cancel_injection; |
| 5963 | } | 5987 | } |
| 5964 | 5988 | ||
| 5965 | srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); | ||
| 5966 | |||
| 5967 | if (req_immediate_exit) | 5989 | if (req_immediate_exit) |
| 5968 | smp_send_reschedule(vcpu->cpu); | 5990 | smp_send_reschedule(vcpu->cpu); |
| 5969 | 5991 | ||
| @@ -6688,7 +6710,7 @@ int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) | |||
| 6688 | if (r) | 6710 | if (r) |
| 6689 | return r; | 6711 | return r; |
| 6690 | kvm_vcpu_reset(vcpu); | 6712 | kvm_vcpu_reset(vcpu); |
| 6691 | r = kvm_mmu_setup(vcpu); | 6713 | kvm_mmu_setup(vcpu); |
| 6692 | vcpu_put(vcpu); | 6714 | vcpu_put(vcpu); |
| 6693 | 6715 | ||
| 6694 | return r; | 6716 | return r; |
| @@ -6940,6 +6962,10 @@ int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) | |||
| 6940 | 6962 | ||
| 6941 | vcpu->arch.ia32_tsc_adjust_msr = 0x0; | 6963 | vcpu->arch.ia32_tsc_adjust_msr = 0x0; |
| 6942 | vcpu->arch.pv_time_enabled = false; | 6964 | vcpu->arch.pv_time_enabled = false; |
| 6965 | |||
| 6966 | vcpu->arch.guest_supported_xcr0 = 0; | ||
| 6967 | vcpu->arch.guest_xstate_size = XSAVE_HDR_SIZE + XSAVE_HDR_OFFSET; | ||
| 6968 | |||
| 6943 | kvm_async_pf_hash_reset(vcpu); | 6969 | kvm_async_pf_hash_reset(vcpu); |
| 6944 | kvm_pmu_init(vcpu); | 6970 | kvm_pmu_init(vcpu); |
| 6945 | 6971 | ||
| @@ -6981,6 +7007,7 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) | |||
| 6981 | INIT_LIST_HEAD(&kvm->arch.active_mmu_pages); | 7007 | INIT_LIST_HEAD(&kvm->arch.active_mmu_pages); |
| 6982 | INIT_LIST_HEAD(&kvm->arch.zapped_obsolete_pages); | 7008 | INIT_LIST_HEAD(&kvm->arch.zapped_obsolete_pages); |
| 6983 | INIT_LIST_HEAD(&kvm->arch.assigned_dev_head); | 7009 | INIT_LIST_HEAD(&kvm->arch.assigned_dev_head); |
| 7010 | atomic_set(&kvm->arch.noncoherent_dma_count, 0); | ||
| 6984 | 7011 | ||
| 6985 | /* Reserve bit 0 of irq_sources_bitmap for userspace irq source */ | 7012 | /* Reserve bit 0 of irq_sources_bitmap for userspace irq source */ |
| 6986 | set_bit(KVM_USERSPACE_IRQ_SOURCE_ID, &kvm->arch.irq_sources_bitmap); | 7013 | set_bit(KVM_USERSPACE_IRQ_SOURCE_ID, &kvm->arch.irq_sources_bitmap); |
| @@ -7065,7 +7092,7 @@ void kvm_arch_destroy_vm(struct kvm *kvm) | |||
| 7065 | kfree(rcu_dereference_check(kvm->arch.apic_map, 1)); | 7092 | kfree(rcu_dereference_check(kvm->arch.apic_map, 1)); |
| 7066 | } | 7093 | } |
| 7067 | 7094 | ||
| 7068 | void kvm_arch_free_memslot(struct kvm_memory_slot *free, | 7095 | void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free, |
| 7069 | struct kvm_memory_slot *dont) | 7096 | struct kvm_memory_slot *dont) |
| 7070 | { | 7097 | { |
| 7071 | int i; | 7098 | int i; |
| @@ -7086,7 +7113,8 @@ void kvm_arch_free_memslot(struct kvm_memory_slot *free, | |||
| 7086 | } | 7113 | } |
| 7087 | } | 7114 | } |
| 7088 | 7115 | ||
| 7089 | int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages) | 7116 | int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, |
| 7117 | unsigned long npages) | ||
| 7090 | { | 7118 | { |
| 7091 | int i; | 7119 | int i; |
| 7092 | 7120 | ||
| @@ -7283,7 +7311,7 @@ void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu, struct kvm_async_pf *work) | |||
| 7283 | int r; | 7311 | int r; |
| 7284 | 7312 | ||
| 7285 | if ((vcpu->arch.mmu.direct_map != work->arch.direct_map) || | 7313 | if ((vcpu->arch.mmu.direct_map != work->arch.direct_map) || |
| 7286 | is_error_page(work->page)) | 7314 | work->wakeup_all) |
| 7287 | return; | 7315 | return; |
| 7288 | 7316 | ||
| 7289 | r = kvm_mmu_reload(vcpu); | 7317 | r = kvm_mmu_reload(vcpu); |
| @@ -7393,7 +7421,7 @@ void kvm_arch_async_page_present(struct kvm_vcpu *vcpu, | |||
| 7393 | struct x86_exception fault; | 7421 | struct x86_exception fault; |
| 7394 | 7422 | ||
| 7395 | trace_kvm_async_pf_ready(work->arch.token, work->gva); | 7423 | trace_kvm_async_pf_ready(work->arch.token, work->gva); |
| 7396 | if (is_error_page(work->page)) | 7424 | if (work->wakeup_all) |
| 7397 | work->arch.token = ~0; /* broadcast wakeup */ | 7425 | work->arch.token = ~0; /* broadcast wakeup */ |
| 7398 | else | 7426 | else |
| 7399 | kvm_del_async_pf_gfn(vcpu, work->arch.gfn); | 7427 | kvm_del_async_pf_gfn(vcpu, work->arch.gfn); |
| @@ -7420,6 +7448,24 @@ bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu) | |||
| 7420 | kvm_x86_ops->interrupt_allowed(vcpu); | 7448 | kvm_x86_ops->interrupt_allowed(vcpu); |
| 7421 | } | 7449 | } |
| 7422 | 7450 | ||
| 7451 | void kvm_arch_register_noncoherent_dma(struct kvm *kvm) | ||
| 7452 | { | ||
| 7453 | atomic_inc(&kvm->arch.noncoherent_dma_count); | ||
| 7454 | } | ||
| 7455 | EXPORT_SYMBOL_GPL(kvm_arch_register_noncoherent_dma); | ||
| 7456 | |||
| 7457 | void kvm_arch_unregister_noncoherent_dma(struct kvm *kvm) | ||
| 7458 | { | ||
| 7459 | atomic_dec(&kvm->arch.noncoherent_dma_count); | ||
| 7460 | } | ||
| 7461 | EXPORT_SYMBOL_GPL(kvm_arch_unregister_noncoherent_dma); | ||
| 7462 | |||
| 7463 | bool kvm_arch_has_noncoherent_dma(struct kvm *kvm) | ||
| 7464 | { | ||
| 7465 | return atomic_read(&kvm->arch.noncoherent_dma_count); | ||
| 7466 | } | ||
| 7467 | EXPORT_SYMBOL_GPL(kvm_arch_has_noncoherent_dma); | ||
| 7468 | |||
| 7423 | EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_exit); | 7469 | EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_exit); |
| 7424 | EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_inj_virq); | 7470 | EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_inj_virq); |
| 7425 | EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_page_fault); | 7471 | EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_page_fault); |
diff --git a/arch/x86/kvm/x86.h b/arch/x86/kvm/x86.h index e224f7a671b6..587fb9ede436 100644 --- a/arch/x86/kvm/x86.h +++ b/arch/x86/kvm/x86.h | |||
| @@ -122,6 +122,7 @@ int kvm_write_guest_virt_system(struct x86_emulate_ctxt *ctxt, | |||
| 122 | gva_t addr, void *val, unsigned int bytes, | 122 | gva_t addr, void *val, unsigned int bytes, |
| 123 | struct x86_exception *exception); | 123 | struct x86_exception *exception); |
| 124 | 124 | ||
| 125 | #define KVM_SUPPORTED_XCR0 (XSTATE_FP | XSTATE_SSE | XSTATE_YMM) | ||
| 125 | extern u64 host_xcr0; | 126 | extern u64 host_xcr0; |
| 126 | 127 | ||
| 127 | extern struct static_key kvm_no_apic_vcpu; | 128 | extern struct static_key kvm_no_apic_vcpu; |
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h index 0fbbc7aa02cb..9523d2ad7535 100644 --- a/include/linux/kvm_host.h +++ b/include/linux/kvm_host.h | |||
| @@ -142,7 +142,7 @@ struct kvm; | |||
| 142 | struct kvm_vcpu; | 142 | struct kvm_vcpu; |
| 143 | extern struct kmem_cache *kvm_vcpu_cache; | 143 | extern struct kmem_cache *kvm_vcpu_cache; |
| 144 | 144 | ||
| 145 | extern raw_spinlock_t kvm_lock; | 145 | extern spinlock_t kvm_lock; |
| 146 | extern struct list_head vm_list; | 146 | extern struct list_head vm_list; |
| 147 | 147 | ||
| 148 | struct kvm_io_range { | 148 | struct kvm_io_range { |
| @@ -189,8 +189,7 @@ struct kvm_async_pf { | |||
| 189 | gva_t gva; | 189 | gva_t gva; |
| 190 | unsigned long addr; | 190 | unsigned long addr; |
| 191 | struct kvm_arch_async_pf arch; | 191 | struct kvm_arch_async_pf arch; |
| 192 | struct page *page; | 192 | bool wakeup_all; |
| 193 | bool done; | ||
| 194 | }; | 193 | }; |
| 195 | 194 | ||
| 196 | void kvm_clear_async_pf_completion_queue(struct kvm_vcpu *vcpu); | 195 | void kvm_clear_async_pf_completion_queue(struct kvm_vcpu *vcpu); |
| @@ -508,9 +507,10 @@ int kvm_set_memory_region(struct kvm *kvm, | |||
| 508 | struct kvm_userspace_memory_region *mem); | 507 | struct kvm_userspace_memory_region *mem); |
| 509 | int __kvm_set_memory_region(struct kvm *kvm, | 508 | int __kvm_set_memory_region(struct kvm *kvm, |
| 510 | struct kvm_userspace_memory_region *mem); | 509 | struct kvm_userspace_memory_region *mem); |
| 511 | void kvm_arch_free_memslot(struct kvm_memory_slot *free, | 510 | void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free, |
| 512 | struct kvm_memory_slot *dont); | 511 | struct kvm_memory_slot *dont); |
| 513 | int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages); | 512 | int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, |
| 513 | unsigned long npages); | ||
| 514 | void kvm_arch_memslots_updated(struct kvm *kvm); | 514 | void kvm_arch_memslots_updated(struct kvm *kvm); |
| 515 | int kvm_arch_prepare_memory_region(struct kvm *kvm, | 515 | int kvm_arch_prepare_memory_region(struct kvm *kvm, |
| 516 | struct kvm_memory_slot *memslot, | 516 | struct kvm_memory_slot *memslot, |
| @@ -671,6 +671,25 @@ static inline void kvm_arch_free_vm(struct kvm *kvm) | |||
| 671 | } | 671 | } |
| 672 | #endif | 672 | #endif |
| 673 | 673 | ||
| 674 | #ifdef __KVM_HAVE_ARCH_NONCOHERENT_DMA | ||
| 675 | void kvm_arch_register_noncoherent_dma(struct kvm *kvm); | ||
| 676 | void kvm_arch_unregister_noncoherent_dma(struct kvm *kvm); | ||
| 677 | bool kvm_arch_has_noncoherent_dma(struct kvm *kvm); | ||
| 678 | #else | ||
| 679 | static inline void kvm_arch_register_noncoherent_dma(struct kvm *kvm) | ||
| 680 | { | ||
| 681 | } | ||
| 682 | |||
| 683 | static inline void kvm_arch_unregister_noncoherent_dma(struct kvm *kvm) | ||
| 684 | { | ||
| 685 | } | ||
| 686 | |||
| 687 | static inline bool kvm_arch_has_noncoherent_dma(struct kvm *kvm) | ||
| 688 | { | ||
| 689 | return false; | ||
| 690 | } | ||
| 691 | #endif | ||
| 692 | |||
| 674 | static inline wait_queue_head_t *kvm_arch_vcpu_wq(struct kvm_vcpu *vcpu) | 693 | static inline wait_queue_head_t *kvm_arch_vcpu_wq(struct kvm_vcpu *vcpu) |
| 675 | { | 694 | { |
| 676 | #ifdef __KVM_HAVE_ARCH_WQP | 695 | #ifdef __KVM_HAVE_ARCH_WQP |
| @@ -747,9 +766,6 @@ void kvm_unregister_irq_ack_notifier(struct kvm *kvm, | |||
| 747 | int kvm_request_irq_source_id(struct kvm *kvm); | 766 | int kvm_request_irq_source_id(struct kvm *kvm); |
| 748 | void kvm_free_irq_source_id(struct kvm *kvm, int irq_source_id); | 767 | void kvm_free_irq_source_id(struct kvm *kvm, int irq_source_id); |
| 749 | 768 | ||
| 750 | /* For vcpu->arch.iommu_flags */ | ||
| 751 | #define KVM_IOMMU_CACHE_COHERENCY 0x1 | ||
| 752 | |||
| 753 | #ifdef CONFIG_KVM_DEVICE_ASSIGNMENT | 769 | #ifdef CONFIG_KVM_DEVICE_ASSIGNMENT |
| 754 | int kvm_iommu_map_pages(struct kvm *kvm, struct kvm_memory_slot *slot); | 770 | int kvm_iommu_map_pages(struct kvm *kvm, struct kvm_memory_slot *slot); |
| 755 | void kvm_iommu_unmap_pages(struct kvm *kvm, struct kvm_memory_slot *slot); | 771 | void kvm_iommu_unmap_pages(struct kvm *kvm, struct kvm_memory_slot *slot); |
| @@ -789,7 +805,7 @@ static inline void kvm_guest_enter(void) | |||
| 789 | 805 | ||
| 790 | /* KVM does not hold any references to rcu protected data when it | 806 | /* KVM does not hold any references to rcu protected data when it |
| 791 | * switches CPU into a guest mode. In fact switching to a guest mode | 807 | * switches CPU into a guest mode. In fact switching to a guest mode |
| 792 | * is very similar to exiting to userspase from rcu point of view. In | 808 | * is very similar to exiting to userspace from rcu point of view. In |
| 793 | * addition CPU may stay in a guest mode for quite a long time (up to | 809 | * addition CPU may stay in a guest mode for quite a long time (up to |
| 794 | * one time slice). Lets treat guest mode as quiescent state, just like | 810 | * one time slice). Lets treat guest mode as quiescent state, just like |
| 795 | * we do with user-mode execution. | 811 | * we do with user-mode execution. |
| @@ -842,13 +858,6 @@ static inline int memslot_id(struct kvm *kvm, gfn_t gfn) | |||
| 842 | return gfn_to_memslot(kvm, gfn)->id; | 858 | return gfn_to_memslot(kvm, gfn)->id; |
| 843 | } | 859 | } |
| 844 | 860 | ||
| 845 | static inline gfn_t gfn_to_index(gfn_t gfn, gfn_t base_gfn, int level) | ||
| 846 | { | ||
| 847 | /* KVM_HPAGE_GFN_SHIFT(PT_PAGE_TABLE_LEVEL) must be 0. */ | ||
| 848 | return (gfn >> KVM_HPAGE_GFN_SHIFT(level)) - | ||
| 849 | (base_gfn >> KVM_HPAGE_GFN_SHIFT(level)); | ||
| 850 | } | ||
| 851 | |||
| 852 | static inline gfn_t | 861 | static inline gfn_t |
| 853 | hva_to_gfn_memslot(unsigned long hva, struct kvm_memory_slot *slot) | 862 | hva_to_gfn_memslot(unsigned long hva, struct kvm_memory_slot *slot) |
| 854 | { | 863 | { |
| @@ -1066,6 +1075,7 @@ struct kvm_device *kvm_device_from_filp(struct file *filp); | |||
| 1066 | 1075 | ||
| 1067 | extern struct kvm_device_ops kvm_mpic_ops; | 1076 | extern struct kvm_device_ops kvm_mpic_ops; |
| 1068 | extern struct kvm_device_ops kvm_xics_ops; | 1077 | extern struct kvm_device_ops kvm_xics_ops; |
| 1078 | extern struct kvm_device_ops kvm_vfio_ops; | ||
| 1069 | 1079 | ||
| 1070 | #ifdef CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT | 1080 | #ifdef CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT |
| 1071 | 1081 | ||
diff --git a/include/linux/sched.h b/include/linux/sched.h index f7efc8604652..6f7ffa460089 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h | |||
| @@ -286,6 +286,14 @@ static inline void lockup_detector_init(void) | |||
| 286 | } | 286 | } |
| 287 | #endif | 287 | #endif |
| 288 | 288 | ||
| 289 | #ifdef CONFIG_DETECT_HUNG_TASK | ||
| 290 | void reset_hung_task_detector(void); | ||
| 291 | #else | ||
| 292 | static inline void reset_hung_task_detector(void) | ||
| 293 | { | ||
| 294 | } | ||
| 295 | #endif | ||
| 296 | |||
| 289 | /* Attach to any functions which should be ignored in wchan output. */ | 297 | /* Attach to any functions which should be ignored in wchan output. */ |
| 290 | #define __sched __attribute__((__section__(".sched.text"))) | 298 | #define __sched __attribute__((__section__(".sched.text"))) |
| 291 | 299 | ||
diff --git a/include/linux/srcu.h b/include/linux/srcu.h index c114614ed172..9b058eecd403 100644 --- a/include/linux/srcu.h +++ b/include/linux/srcu.h | |||
| @@ -237,4 +237,18 @@ static inline void srcu_read_unlock(struct srcu_struct *sp, int idx) | |||
| 237 | __srcu_read_unlock(sp, idx); | 237 | __srcu_read_unlock(sp, idx); |
| 238 | } | 238 | } |
| 239 | 239 | ||
| 240 | /** | ||
| 241 | * smp_mb__after_srcu_read_unlock - ensure full ordering after srcu_read_unlock | ||
| 242 | * | ||
| 243 | * Converts the preceding srcu_read_unlock into a two-way memory barrier. | ||
| 244 | * | ||
| 245 | * Call this after srcu_read_unlock, to guarantee that all memory operations | ||
| 246 | * that occur after smp_mb__after_srcu_read_unlock will appear to happen after | ||
| 247 | * the preceding srcu_read_unlock. | ||
| 248 | */ | ||
| 249 | static inline void smp_mb__after_srcu_read_unlock(void) | ||
| 250 | { | ||
| 251 | /* __srcu_read_unlock has smp_mb() internally so nothing to do here. */ | ||
| 252 | } | ||
| 253 | |||
| 240 | #endif | 254 | #endif |
diff --git a/include/trace/events/kvm.h b/include/trace/events/kvm.h index 7005d1109ec9..131a0bda7aec 100644 --- a/include/trace/events/kvm.h +++ b/include/trace/events/kvm.h | |||
| @@ -296,23 +296,21 @@ DEFINE_EVENT(kvm_async_pf_nopresent_ready, kvm_async_pf_ready, | |||
| 296 | 296 | ||
| 297 | TRACE_EVENT( | 297 | TRACE_EVENT( |
| 298 | kvm_async_pf_completed, | 298 | kvm_async_pf_completed, |
| 299 | TP_PROTO(unsigned long address, struct page *page, u64 gva), | 299 | TP_PROTO(unsigned long address, u64 gva), |
| 300 | TP_ARGS(address, page, gva), | 300 | TP_ARGS(address, gva), |
| 301 | 301 | ||
| 302 | TP_STRUCT__entry( | 302 | TP_STRUCT__entry( |
| 303 | __field(unsigned long, address) | 303 | __field(unsigned long, address) |
| 304 | __field(pfn_t, pfn) | ||
| 305 | __field(u64, gva) | 304 | __field(u64, gva) |
| 306 | ), | 305 | ), |
| 307 | 306 | ||
| 308 | TP_fast_assign( | 307 | TP_fast_assign( |
| 309 | __entry->address = address; | 308 | __entry->address = address; |
| 310 | __entry->pfn = page ? page_to_pfn(page) : 0; | ||
| 311 | __entry->gva = gva; | 309 | __entry->gva = gva; |
| 312 | ), | 310 | ), |
| 313 | 311 | ||
| 314 | TP_printk("gva %#llx address %#lx pfn %#llx", __entry->gva, | 312 | TP_printk("gva %#llx address %#lx", __entry->gva, |
| 315 | __entry->address, __entry->pfn) | 313 | __entry->address) |
| 316 | ); | 314 | ); |
| 317 | 315 | ||
| 318 | #endif | 316 | #endif |
diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h index 99c25338ede8..902f12461873 100644 --- a/include/uapi/linux/kvm.h +++ b/include/uapi/linux/kvm.h | |||
| @@ -518,6 +518,10 @@ struct kvm_ppc_smmu_info { | |||
| 518 | /* machine type bits, to be used as argument to KVM_CREATE_VM */ | 518 | /* machine type bits, to be used as argument to KVM_CREATE_VM */ |
| 519 | #define KVM_VM_S390_UCONTROL 1 | 519 | #define KVM_VM_S390_UCONTROL 1 |
| 520 | 520 | ||
| 521 | /* on ppc, 0 indicate default, 1 should force HV and 2 PR */ | ||
| 522 | #define KVM_VM_PPC_HV 1 | ||
| 523 | #define KVM_VM_PPC_PR 2 | ||
| 524 | |||
| 521 | #define KVM_S390_SIE_PAGE_OFFSET 1 | 525 | #define KVM_S390_SIE_PAGE_OFFSET 1 |
| 522 | 526 | ||
| 523 | /* | 527 | /* |
| @@ -541,6 +545,7 @@ struct kvm_ppc_smmu_info { | |||
| 541 | #define KVM_TRACE_ENABLE __KVM_DEPRECATED_MAIN_W_0x06 | 545 | #define KVM_TRACE_ENABLE __KVM_DEPRECATED_MAIN_W_0x06 |
| 542 | #define KVM_TRACE_PAUSE __KVM_DEPRECATED_MAIN_0x07 | 546 | #define KVM_TRACE_PAUSE __KVM_DEPRECATED_MAIN_0x07 |
| 543 | #define KVM_TRACE_DISABLE __KVM_DEPRECATED_MAIN_0x08 | 547 | #define KVM_TRACE_DISABLE __KVM_DEPRECATED_MAIN_0x08 |
| 548 | #define KVM_GET_EMULATED_CPUID _IOWR(KVMIO, 0x09, struct kvm_cpuid2) | ||
| 544 | 549 | ||
| 545 | /* | 550 | /* |
| 546 | * Extension capability list. | 551 | * Extension capability list. |
| @@ -668,6 +673,7 @@ struct kvm_ppc_smmu_info { | |||
| 668 | #define KVM_CAP_IRQ_XICS 92 | 673 | #define KVM_CAP_IRQ_XICS 92 |
| 669 | #define KVM_CAP_ARM_EL1_32BIT 93 | 674 | #define KVM_CAP_ARM_EL1_32BIT 93 |
| 670 | #define KVM_CAP_SPAPR_MULTITCE 94 | 675 | #define KVM_CAP_SPAPR_MULTITCE 94 |
| 676 | #define KVM_CAP_EXT_EMUL_CPUID 95 | ||
| 671 | 677 | ||
| 672 | #ifdef KVM_CAP_IRQ_ROUTING | 678 | #ifdef KVM_CAP_IRQ_ROUTING |
| 673 | 679 | ||
| @@ -843,6 +849,10 @@ struct kvm_device_attr { | |||
| 843 | #define KVM_DEV_TYPE_FSL_MPIC_20 1 | 849 | #define KVM_DEV_TYPE_FSL_MPIC_20 1 |
| 844 | #define KVM_DEV_TYPE_FSL_MPIC_42 2 | 850 | #define KVM_DEV_TYPE_FSL_MPIC_42 2 |
| 845 | #define KVM_DEV_TYPE_XICS 3 | 851 | #define KVM_DEV_TYPE_XICS 3 |
| 852 | #define KVM_DEV_TYPE_VFIO 4 | ||
| 853 | #define KVM_DEV_VFIO_GROUP 1 | ||
| 854 | #define KVM_DEV_VFIO_GROUP_ADD 1 | ||
| 855 | #define KVM_DEV_VFIO_GROUP_DEL 2 | ||
| 846 | 856 | ||
| 847 | /* | 857 | /* |
| 848 | * ioctls for VM fds | 858 | * ioctls for VM fds |
| @@ -1012,6 +1022,7 @@ struct kvm_s390_ucas_mapping { | |||
| 1012 | /* VM is being stopped by host */ | 1022 | /* VM is being stopped by host */ |
| 1013 | #define KVM_KVMCLOCK_CTRL _IO(KVMIO, 0xad) | 1023 | #define KVM_KVMCLOCK_CTRL _IO(KVMIO, 0xad) |
| 1014 | #define KVM_ARM_VCPU_INIT _IOW(KVMIO, 0xae, struct kvm_vcpu_init) | 1024 | #define KVM_ARM_VCPU_INIT _IOW(KVMIO, 0xae, struct kvm_vcpu_init) |
| 1025 | #define KVM_ARM_PREFERRED_TARGET _IOR(KVMIO, 0xaf, struct kvm_vcpu_init) | ||
| 1015 | #define KVM_GET_REG_LIST _IOWR(KVMIO, 0xb0, struct kvm_reg_list) | 1026 | #define KVM_GET_REG_LIST _IOWR(KVMIO, 0xb0, struct kvm_reg_list) |
| 1016 | 1027 | ||
| 1017 | #define KVM_DEV_ASSIGN_ENABLE_IOMMU (1 << 0) | 1028 | #define KVM_DEV_ASSIGN_ENABLE_IOMMU (1 << 0) |
diff --git a/kernel/hung_task.c b/kernel/hung_task.c index 8807061ca004..9328b80eaf14 100644 --- a/kernel/hung_task.c +++ b/kernel/hung_task.c | |||
| @@ -207,6 +207,14 @@ int proc_dohung_task_timeout_secs(struct ctl_table *table, int write, | |||
| 207 | return ret; | 207 | return ret; |
| 208 | } | 208 | } |
| 209 | 209 | ||
| 210 | static atomic_t reset_hung_task = ATOMIC_INIT(0); | ||
| 211 | |||
| 212 | void reset_hung_task_detector(void) | ||
| 213 | { | ||
| 214 | atomic_set(&reset_hung_task, 1); | ||
| 215 | } | ||
| 216 | EXPORT_SYMBOL_GPL(reset_hung_task_detector); | ||
| 217 | |||
| 210 | /* | 218 | /* |
| 211 | * kthread which checks for tasks stuck in D state | 219 | * kthread which checks for tasks stuck in D state |
| 212 | */ | 220 | */ |
| @@ -220,6 +228,9 @@ static int watchdog(void *dummy) | |||
| 220 | while (schedule_timeout_interruptible(timeout_jiffies(timeout))) | 228 | while (schedule_timeout_interruptible(timeout_jiffies(timeout))) |
| 221 | timeout = sysctl_hung_task_timeout_secs; | 229 | timeout = sysctl_hung_task_timeout_secs; |
| 222 | 230 | ||
| 231 | if (atomic_xchg(&reset_hung_task, 0)) | ||
| 232 | continue; | ||
| 233 | |||
| 223 | check_hung_uninterruptible_tasks(timeout); | 234 | check_hung_uninterruptible_tasks(timeout); |
| 224 | } | 235 | } |
| 225 | 236 | ||
diff --git a/virt/kvm/Kconfig b/virt/kvm/Kconfig index 779262f59e25..fbe1a48bd629 100644 --- a/virt/kvm/Kconfig +++ b/virt/kvm/Kconfig | |||
| @@ -27,3 +27,6 @@ config HAVE_KVM_MSI | |||
| 27 | 27 | ||
| 28 | config HAVE_KVM_CPU_RELAX_INTERCEPT | 28 | config HAVE_KVM_CPU_RELAX_INTERCEPT |
| 29 | bool | 29 | bool |
| 30 | |||
| 31 | config KVM_VFIO | ||
| 32 | bool | ||
diff --git a/virt/kvm/async_pf.c b/virt/kvm/async_pf.c index 8a39dda7a325..8631d9c14320 100644 --- a/virt/kvm/async_pf.c +++ b/virt/kvm/async_pf.c | |||
| @@ -56,7 +56,6 @@ void kvm_async_pf_vcpu_init(struct kvm_vcpu *vcpu) | |||
| 56 | 56 | ||
| 57 | static void async_pf_execute(struct work_struct *work) | 57 | static void async_pf_execute(struct work_struct *work) |
| 58 | { | 58 | { |
| 59 | struct page *page = NULL; | ||
| 60 | struct kvm_async_pf *apf = | 59 | struct kvm_async_pf *apf = |
| 61 | container_of(work, struct kvm_async_pf, work); | 60 | container_of(work, struct kvm_async_pf, work); |
| 62 | struct mm_struct *mm = apf->mm; | 61 | struct mm_struct *mm = apf->mm; |
| @@ -68,14 +67,12 @@ static void async_pf_execute(struct work_struct *work) | |||
| 68 | 67 | ||
| 69 | use_mm(mm); | 68 | use_mm(mm); |
| 70 | down_read(&mm->mmap_sem); | 69 | down_read(&mm->mmap_sem); |
| 71 | get_user_pages(current, mm, addr, 1, 1, 0, &page, NULL); | 70 | get_user_pages(current, mm, addr, 1, 1, 0, NULL, NULL); |
| 72 | up_read(&mm->mmap_sem); | 71 | up_read(&mm->mmap_sem); |
| 73 | unuse_mm(mm); | 72 | unuse_mm(mm); |
| 74 | 73 | ||
| 75 | spin_lock(&vcpu->async_pf.lock); | 74 | spin_lock(&vcpu->async_pf.lock); |
| 76 | list_add_tail(&apf->link, &vcpu->async_pf.done); | 75 | list_add_tail(&apf->link, &vcpu->async_pf.done); |
| 77 | apf->page = page; | ||
| 78 | apf->done = true; | ||
| 79 | spin_unlock(&vcpu->async_pf.lock); | 76 | spin_unlock(&vcpu->async_pf.lock); |
| 80 | 77 | ||
| 81 | /* | 78 | /* |
| @@ -83,7 +80,7 @@ static void async_pf_execute(struct work_struct *work) | |||
| 83 | * this point | 80 | * this point |
| 84 | */ | 81 | */ |
| 85 | 82 | ||
| 86 | trace_kvm_async_pf_completed(addr, page, gva); | 83 | trace_kvm_async_pf_completed(addr, gva); |
| 87 | 84 | ||
| 88 | if (waitqueue_active(&vcpu->wq)) | 85 | if (waitqueue_active(&vcpu->wq)) |
| 89 | wake_up_interruptible(&vcpu->wq); | 86 | wake_up_interruptible(&vcpu->wq); |
| @@ -99,9 +96,8 @@ void kvm_clear_async_pf_completion_queue(struct kvm_vcpu *vcpu) | |||
| 99 | struct kvm_async_pf *work = | 96 | struct kvm_async_pf *work = |
| 100 | list_entry(vcpu->async_pf.queue.next, | 97 | list_entry(vcpu->async_pf.queue.next, |
| 101 | typeof(*work), queue); | 98 | typeof(*work), queue); |
| 102 | cancel_work_sync(&work->work); | ||
| 103 | list_del(&work->queue); | 99 | list_del(&work->queue); |
| 104 | if (!work->done) { /* work was canceled */ | 100 | if (cancel_work_sync(&work->work)) { |
| 105 | mmdrop(work->mm); | 101 | mmdrop(work->mm); |
| 106 | kvm_put_kvm(vcpu->kvm); /* == work->vcpu->kvm */ | 102 | kvm_put_kvm(vcpu->kvm); /* == work->vcpu->kvm */ |
| 107 | kmem_cache_free(async_pf_cache, work); | 103 | kmem_cache_free(async_pf_cache, work); |
| @@ -114,8 +110,6 @@ void kvm_clear_async_pf_completion_queue(struct kvm_vcpu *vcpu) | |||
| 114 | list_entry(vcpu->async_pf.done.next, | 110 | list_entry(vcpu->async_pf.done.next, |
| 115 | typeof(*work), link); | 111 | typeof(*work), link); |
| 116 | list_del(&work->link); | 112 | list_del(&work->link); |
| 117 | if (!is_error_page(work->page)) | ||
| 118 | kvm_release_page_clean(work->page); | ||
| 119 | kmem_cache_free(async_pf_cache, work); | 113 | kmem_cache_free(async_pf_cache, work); |
| 120 | } | 114 | } |
| 121 | spin_unlock(&vcpu->async_pf.lock); | 115 | spin_unlock(&vcpu->async_pf.lock); |
| @@ -135,14 +129,11 @@ void kvm_check_async_pf_completion(struct kvm_vcpu *vcpu) | |||
| 135 | list_del(&work->link); | 129 | list_del(&work->link); |
| 136 | spin_unlock(&vcpu->async_pf.lock); | 130 | spin_unlock(&vcpu->async_pf.lock); |
| 137 | 131 | ||
| 138 | if (work->page) | 132 | kvm_arch_async_page_ready(vcpu, work); |
| 139 | kvm_arch_async_page_ready(vcpu, work); | ||
| 140 | kvm_arch_async_page_present(vcpu, work); | 133 | kvm_arch_async_page_present(vcpu, work); |
| 141 | 134 | ||
| 142 | list_del(&work->queue); | 135 | list_del(&work->queue); |
| 143 | vcpu->async_pf.queued--; | 136 | vcpu->async_pf.queued--; |
| 144 | if (!is_error_page(work->page)) | ||
| 145 | kvm_release_page_clean(work->page); | ||
| 146 | kmem_cache_free(async_pf_cache, work); | 137 | kmem_cache_free(async_pf_cache, work); |
| 147 | } | 138 | } |
| 148 | } | 139 | } |
| @@ -165,8 +156,7 @@ int kvm_setup_async_pf(struct kvm_vcpu *vcpu, gva_t gva, gfn_t gfn, | |||
| 165 | if (!work) | 156 | if (!work) |
| 166 | return 0; | 157 | return 0; |
| 167 | 158 | ||
| 168 | work->page = NULL; | 159 | work->wakeup_all = false; |
| 169 | work->done = false; | ||
| 170 | work->vcpu = vcpu; | 160 | work->vcpu = vcpu; |
| 171 | work->gva = gva; | 161 | work->gva = gva; |
| 172 | work->addr = gfn_to_hva(vcpu->kvm, gfn); | 162 | work->addr = gfn_to_hva(vcpu->kvm, gfn); |
| @@ -206,7 +196,7 @@ int kvm_async_pf_wakeup_all(struct kvm_vcpu *vcpu) | |||
| 206 | if (!work) | 196 | if (!work) |
| 207 | return -ENOMEM; | 197 | return -ENOMEM; |
| 208 | 198 | ||
| 209 | work->page = KVM_ERR_PTR_BAD_PAGE; | 199 | work->wakeup_all = true; |
| 210 | INIT_LIST_HEAD(&work->queue); /* for list_del to work */ | 200 | INIT_LIST_HEAD(&work->queue); /* for list_del to work */ |
| 211 | 201 | ||
| 212 | spin_lock(&vcpu->async_pf.lock); | 202 | spin_lock(&vcpu->async_pf.lock); |
diff --git a/virt/kvm/iommu.c b/virt/kvm/iommu.c index 72a130bc448a..0df7d4b34dfe 100644 --- a/virt/kvm/iommu.c +++ b/virt/kvm/iommu.c | |||
| @@ -79,7 +79,7 @@ int kvm_iommu_map_pages(struct kvm *kvm, struct kvm_memory_slot *slot) | |||
| 79 | flags = IOMMU_READ; | 79 | flags = IOMMU_READ; |
| 80 | if (!(slot->flags & KVM_MEM_READONLY)) | 80 | if (!(slot->flags & KVM_MEM_READONLY)) |
| 81 | flags |= IOMMU_WRITE; | 81 | flags |= IOMMU_WRITE; |
| 82 | if (kvm->arch.iommu_flags & KVM_IOMMU_CACHE_COHERENCY) | 82 | if (!kvm->arch.iommu_noncoherent) |
| 83 | flags |= IOMMU_CACHE; | 83 | flags |= IOMMU_CACHE; |
| 84 | 84 | ||
| 85 | 85 | ||
| @@ -103,6 +103,10 @@ int kvm_iommu_map_pages(struct kvm *kvm, struct kvm_memory_slot *slot) | |||
| 103 | while ((gfn << PAGE_SHIFT) & (page_size - 1)) | 103 | while ((gfn << PAGE_SHIFT) & (page_size - 1)) |
| 104 | page_size >>= 1; | 104 | page_size >>= 1; |
| 105 | 105 | ||
| 106 | /* Make sure hva is aligned to the page size we want to map */ | ||
| 107 | while (__gfn_to_hva_memslot(slot, gfn) & (page_size - 1)) | ||
| 108 | page_size >>= 1; | ||
| 109 | |||
| 106 | /* | 110 | /* |
| 107 | * Pin all pages we are about to map in memory. This is | 111 | * Pin all pages we are about to map in memory. This is |
| 108 | * important because we unmap and unpin in 4kb steps later. | 112 | * important because we unmap and unpin in 4kb steps later. |
| @@ -140,6 +144,9 @@ static int kvm_iommu_map_memslots(struct kvm *kvm) | |||
| 140 | struct kvm_memslots *slots; | 144 | struct kvm_memslots *slots; |
| 141 | struct kvm_memory_slot *memslot; | 145 | struct kvm_memory_slot *memslot; |
| 142 | 146 | ||
| 147 | if (kvm->arch.iommu_noncoherent) | ||
| 148 | kvm_arch_register_noncoherent_dma(kvm); | ||
| 149 | |||
| 143 | idx = srcu_read_lock(&kvm->srcu); | 150 | idx = srcu_read_lock(&kvm->srcu); |
| 144 | slots = kvm_memslots(kvm); | 151 | slots = kvm_memslots(kvm); |
| 145 | 152 | ||
| @@ -158,7 +165,8 @@ int kvm_assign_device(struct kvm *kvm, | |||
| 158 | { | 165 | { |
| 159 | struct pci_dev *pdev = NULL; | 166 | struct pci_dev *pdev = NULL; |
| 160 | struct iommu_domain *domain = kvm->arch.iommu_domain; | 167 | struct iommu_domain *domain = kvm->arch.iommu_domain; |
| 161 | int r, last_flags; | 168 | int r; |
| 169 | bool noncoherent; | ||
| 162 | 170 | ||
| 163 | /* check if iommu exists and in use */ | 171 | /* check if iommu exists and in use */ |
| 164 | if (!domain) | 172 | if (!domain) |
| @@ -174,15 +182,13 @@ int kvm_assign_device(struct kvm *kvm, | |||
| 174 | return r; | 182 | return r; |
| 175 | } | 183 | } |
| 176 | 184 | ||
| 177 | last_flags = kvm->arch.iommu_flags; | 185 | noncoherent = !iommu_domain_has_cap(kvm->arch.iommu_domain, |
| 178 | if (iommu_domain_has_cap(kvm->arch.iommu_domain, | 186 | IOMMU_CAP_CACHE_COHERENCY); |
| 179 | IOMMU_CAP_CACHE_COHERENCY)) | ||
| 180 | kvm->arch.iommu_flags |= KVM_IOMMU_CACHE_COHERENCY; | ||
| 181 | 187 | ||
| 182 | /* Check if need to update IOMMU page table for guest memory */ | 188 | /* Check if need to update IOMMU page table for guest memory */ |
| 183 | if ((last_flags ^ kvm->arch.iommu_flags) == | 189 | if (noncoherent != kvm->arch.iommu_noncoherent) { |
| 184 | KVM_IOMMU_CACHE_COHERENCY) { | ||
| 185 | kvm_iommu_unmap_memslots(kvm); | 190 | kvm_iommu_unmap_memslots(kvm); |
| 191 | kvm->arch.iommu_noncoherent = noncoherent; | ||
| 186 | r = kvm_iommu_map_memslots(kvm); | 192 | r = kvm_iommu_map_memslots(kvm); |
| 187 | if (r) | 193 | if (r) |
| 188 | goto out_unmap; | 194 | goto out_unmap; |
| @@ -190,11 +196,7 @@ int kvm_assign_device(struct kvm *kvm, | |||
| 190 | 196 | ||
| 191 | pdev->dev_flags |= PCI_DEV_FLAGS_ASSIGNED; | 197 | pdev->dev_flags |= PCI_DEV_FLAGS_ASSIGNED; |
| 192 | 198 | ||
| 193 | printk(KERN_DEBUG "assign device %x:%x:%x.%x\n", | 199 | dev_info(&pdev->dev, "kvm assign device\n"); |
| 194 | assigned_dev->host_segnr, | ||
| 195 | assigned_dev->host_busnr, | ||
| 196 | PCI_SLOT(assigned_dev->host_devfn), | ||
| 197 | PCI_FUNC(assigned_dev->host_devfn)); | ||
| 198 | 200 | ||
| 199 | return 0; | 201 | return 0; |
| 200 | out_unmap: | 202 | out_unmap: |
| @@ -220,11 +222,7 @@ int kvm_deassign_device(struct kvm *kvm, | |||
| 220 | 222 | ||
| 221 | pdev->dev_flags &= ~PCI_DEV_FLAGS_ASSIGNED; | 223 | pdev->dev_flags &= ~PCI_DEV_FLAGS_ASSIGNED; |
| 222 | 224 | ||
| 223 | printk(KERN_DEBUG "deassign device %x:%x:%x.%x\n", | 225 | dev_info(&pdev->dev, "kvm deassign device\n"); |
| 224 | assigned_dev->host_segnr, | ||
| 225 | assigned_dev->host_busnr, | ||
| 226 | PCI_SLOT(assigned_dev->host_devfn), | ||
| 227 | PCI_FUNC(assigned_dev->host_devfn)); | ||
| 228 | 226 | ||
| 229 | return 0; | 227 | return 0; |
| 230 | } | 228 | } |
| @@ -336,6 +334,9 @@ static int kvm_iommu_unmap_memslots(struct kvm *kvm) | |||
| 336 | 334 | ||
| 337 | srcu_read_unlock(&kvm->srcu, idx); | 335 | srcu_read_unlock(&kvm->srcu, idx); |
| 338 | 336 | ||
| 337 | if (kvm->arch.iommu_noncoherent) | ||
| 338 | kvm_arch_unregister_noncoherent_dma(kvm); | ||
| 339 | |||
| 339 | return 0; | 340 | return 0; |
| 340 | } | 341 | } |
| 341 | 342 | ||
| @@ -350,6 +351,7 @@ int kvm_iommu_unmap_guest(struct kvm *kvm) | |||
| 350 | mutex_lock(&kvm->slots_lock); | 351 | mutex_lock(&kvm->slots_lock); |
| 351 | kvm_iommu_unmap_memslots(kvm); | 352 | kvm_iommu_unmap_memslots(kvm); |
| 352 | kvm->arch.iommu_domain = NULL; | 353 | kvm->arch.iommu_domain = NULL; |
| 354 | kvm->arch.iommu_noncoherent = false; | ||
| 353 | mutex_unlock(&kvm->slots_lock); | 355 | mutex_unlock(&kvm->slots_lock); |
| 354 | 356 | ||
| 355 | iommu_domain_free(domain); | 357 | iommu_domain_free(domain); |
diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c index 1cf9ccb01013..662f34c3287e 100644 --- a/virt/kvm/kvm_main.c +++ b/virt/kvm/kvm_main.c | |||
| @@ -70,7 +70,8 @@ MODULE_LICENSE("GPL"); | |||
| 70 | * kvm->lock --> kvm->slots_lock --> kvm->irq_lock | 70 | * kvm->lock --> kvm->slots_lock --> kvm->irq_lock |
| 71 | */ | 71 | */ |
| 72 | 72 | ||
| 73 | DEFINE_RAW_SPINLOCK(kvm_lock); | 73 | DEFINE_SPINLOCK(kvm_lock); |
| 74 | static DEFINE_RAW_SPINLOCK(kvm_count_lock); | ||
| 74 | LIST_HEAD(vm_list); | 75 | LIST_HEAD(vm_list); |
| 75 | 76 | ||
| 76 | static cpumask_var_t cpus_hardware_enabled; | 77 | static cpumask_var_t cpus_hardware_enabled; |
| @@ -186,6 +187,7 @@ void kvm_flush_remote_tlbs(struct kvm *kvm) | |||
| 186 | ++kvm->stat.remote_tlb_flush; | 187 | ++kvm->stat.remote_tlb_flush; |
| 187 | cmpxchg(&kvm->tlbs_dirty, dirty_count, 0); | 188 | cmpxchg(&kvm->tlbs_dirty, dirty_count, 0); |
| 188 | } | 189 | } |
| 190 | EXPORT_SYMBOL_GPL(kvm_flush_remote_tlbs); | ||
| 189 | 191 | ||
| 190 | void kvm_reload_remote_mmus(struct kvm *kvm) | 192 | void kvm_reload_remote_mmus(struct kvm *kvm) |
| 191 | { | 193 | { |
| @@ -490,9 +492,9 @@ static struct kvm *kvm_create_vm(unsigned long type) | |||
| 490 | if (r) | 492 | if (r) |
| 491 | goto out_err; | 493 | goto out_err; |
| 492 | 494 | ||
| 493 | raw_spin_lock(&kvm_lock); | 495 | spin_lock(&kvm_lock); |
| 494 | list_add(&kvm->vm_list, &vm_list); | 496 | list_add(&kvm->vm_list, &vm_list); |
| 495 | raw_spin_unlock(&kvm_lock); | 497 | spin_unlock(&kvm_lock); |
| 496 | 498 | ||
| 497 | return kvm; | 499 | return kvm; |
| 498 | 500 | ||
| @@ -540,13 +542,13 @@ static void kvm_destroy_dirty_bitmap(struct kvm_memory_slot *memslot) | |||
| 540 | /* | 542 | /* |
| 541 | * Free any memory in @free but not in @dont. | 543 | * Free any memory in @free but not in @dont. |
| 542 | */ | 544 | */ |
| 543 | static void kvm_free_physmem_slot(struct kvm_memory_slot *free, | 545 | static void kvm_free_physmem_slot(struct kvm *kvm, struct kvm_memory_slot *free, |
| 544 | struct kvm_memory_slot *dont) | 546 | struct kvm_memory_slot *dont) |
| 545 | { | 547 | { |
| 546 | if (!dont || free->dirty_bitmap != dont->dirty_bitmap) | 548 | if (!dont || free->dirty_bitmap != dont->dirty_bitmap) |
| 547 | kvm_destroy_dirty_bitmap(free); | 549 | kvm_destroy_dirty_bitmap(free); |
| 548 | 550 | ||
| 549 | kvm_arch_free_memslot(free, dont); | 551 | kvm_arch_free_memslot(kvm, free, dont); |
| 550 | 552 | ||
| 551 | free->npages = 0; | 553 | free->npages = 0; |
| 552 | } | 554 | } |
| @@ -557,7 +559,7 @@ void kvm_free_physmem(struct kvm *kvm) | |||
| 557 | struct kvm_memory_slot *memslot; | 559 | struct kvm_memory_slot *memslot; |
| 558 | 560 | ||
| 559 | kvm_for_each_memslot(memslot, slots) | 561 | kvm_for_each_memslot(memslot, slots) |
| 560 | kvm_free_physmem_slot(memslot, NULL); | 562 | kvm_free_physmem_slot(kvm, memslot, NULL); |
| 561 | 563 | ||
| 562 | kfree(kvm->memslots); | 564 | kfree(kvm->memslots); |
| 563 | } | 565 | } |
| @@ -581,9 +583,9 @@ static void kvm_destroy_vm(struct kvm *kvm) | |||
| 581 | struct mm_struct *mm = kvm->mm; | 583 | struct mm_struct *mm = kvm->mm; |
| 582 | 584 | ||
| 583 | kvm_arch_sync_events(kvm); | 585 | kvm_arch_sync_events(kvm); |
| 584 | raw_spin_lock(&kvm_lock); | 586 | spin_lock(&kvm_lock); |
| 585 | list_del(&kvm->vm_list); | 587 | list_del(&kvm->vm_list); |
| 586 | raw_spin_unlock(&kvm_lock); | 588 | spin_unlock(&kvm_lock); |
| 587 | kvm_free_irq_routing(kvm); | 589 | kvm_free_irq_routing(kvm); |
| 588 | for (i = 0; i < KVM_NR_BUSES; i++) | 590 | for (i = 0; i < KVM_NR_BUSES; i++) |
| 589 | kvm_io_bus_destroy(kvm->buses[i]); | 591 | kvm_io_bus_destroy(kvm->buses[i]); |
| @@ -821,7 +823,7 @@ int __kvm_set_memory_region(struct kvm *kvm, | |||
| 821 | if (change == KVM_MR_CREATE) { | 823 | if (change == KVM_MR_CREATE) { |
| 822 | new.userspace_addr = mem->userspace_addr; | 824 | new.userspace_addr = mem->userspace_addr; |
| 823 | 825 | ||
| 824 | if (kvm_arch_create_memslot(&new, npages)) | 826 | if (kvm_arch_create_memslot(kvm, &new, npages)) |
| 825 | goto out_free; | 827 | goto out_free; |
| 826 | } | 828 | } |
| 827 | 829 | ||
| @@ -872,6 +874,19 @@ int __kvm_set_memory_region(struct kvm *kvm, | |||
| 872 | goto out_free; | 874 | goto out_free; |
| 873 | } | 875 | } |
| 874 | 876 | ||
| 877 | /* actual memory is freed via old in kvm_free_physmem_slot below */ | ||
| 878 | if (change == KVM_MR_DELETE) { | ||
| 879 | new.dirty_bitmap = NULL; | ||
| 880 | memset(&new.arch, 0, sizeof(new.arch)); | ||
| 881 | } | ||
| 882 | |||
| 883 | old_memslots = install_new_memslots(kvm, slots, &new); | ||
| 884 | |||
| 885 | kvm_arch_commit_memory_region(kvm, mem, &old, change); | ||
| 886 | |||
| 887 | kvm_free_physmem_slot(kvm, &old, &new); | ||
| 888 | kfree(old_memslots); | ||
| 889 | |||
| 875 | /* | 890 | /* |
| 876 | * IOMMU mapping: New slots need to be mapped. Old slots need to be | 891 | * IOMMU mapping: New slots need to be mapped. Old slots need to be |
| 877 | * un-mapped and re-mapped if their base changes. Since base change | 892 | * un-mapped and re-mapped if their base changes. Since base change |
| @@ -883,29 +898,15 @@ int __kvm_set_memory_region(struct kvm *kvm, | |||
| 883 | */ | 898 | */ |
| 884 | if ((change == KVM_MR_CREATE) || (change == KVM_MR_MOVE)) { | 899 | if ((change == KVM_MR_CREATE) || (change == KVM_MR_MOVE)) { |
| 885 | r = kvm_iommu_map_pages(kvm, &new); | 900 | r = kvm_iommu_map_pages(kvm, &new); |
| 886 | if (r) | 901 | return r; |
| 887 | goto out_slots; | ||
| 888 | } | ||
| 889 | |||
| 890 | /* actual memory is freed via old in kvm_free_physmem_slot below */ | ||
| 891 | if (change == KVM_MR_DELETE) { | ||
| 892 | new.dirty_bitmap = NULL; | ||
| 893 | memset(&new.arch, 0, sizeof(new.arch)); | ||
| 894 | } | 902 | } |
| 895 | 903 | ||
| 896 | old_memslots = install_new_memslots(kvm, slots, &new); | ||
| 897 | |||
| 898 | kvm_arch_commit_memory_region(kvm, mem, &old, change); | ||
| 899 | |||
| 900 | kvm_free_physmem_slot(&old, &new); | ||
| 901 | kfree(old_memslots); | ||
| 902 | |||
| 903 | return 0; | 904 | return 0; |
| 904 | 905 | ||
| 905 | out_slots: | 906 | out_slots: |
| 906 | kfree(slots); | 907 | kfree(slots); |
| 907 | out_free: | 908 | out_free: |
| 908 | kvm_free_physmem_slot(&new, &old); | 909 | kvm_free_physmem_slot(kvm, &new, &old); |
| 909 | out: | 910 | out: |
| 910 | return r; | 911 | return r; |
| 911 | } | 912 | } |
| @@ -964,6 +965,7 @@ int kvm_get_dirty_log(struct kvm *kvm, | |||
| 964 | out: | 965 | out: |
| 965 | return r; | 966 | return r; |
| 966 | } | 967 | } |
| 968 | EXPORT_SYMBOL_GPL(kvm_get_dirty_log); | ||
| 967 | 969 | ||
| 968 | bool kvm_largepages_enabled(void) | 970 | bool kvm_largepages_enabled(void) |
| 969 | { | 971 | { |
| @@ -1654,6 +1656,7 @@ void mark_page_dirty(struct kvm *kvm, gfn_t gfn) | |||
| 1654 | memslot = gfn_to_memslot(kvm, gfn); | 1656 | memslot = gfn_to_memslot(kvm, gfn); |
| 1655 | mark_page_dirty_in_slot(kvm, memslot, gfn); | 1657 | mark_page_dirty_in_slot(kvm, memslot, gfn); |
| 1656 | } | 1658 | } |
| 1659 | EXPORT_SYMBOL_GPL(mark_page_dirty); | ||
| 1657 | 1660 | ||
| 1658 | /* | 1661 | /* |
| 1659 | * The vCPU has executed a HLT instruction with in-kernel mode enabled. | 1662 | * The vCPU has executed a HLT instruction with in-kernel mode enabled. |
| @@ -1679,6 +1682,7 @@ void kvm_vcpu_block(struct kvm_vcpu *vcpu) | |||
| 1679 | 1682 | ||
| 1680 | finish_wait(&vcpu->wq, &wait); | 1683 | finish_wait(&vcpu->wq, &wait); |
| 1681 | } | 1684 | } |
| 1685 | EXPORT_SYMBOL_GPL(kvm_vcpu_block); | ||
| 1682 | 1686 | ||
| 1683 | #ifndef CONFIG_S390 | 1687 | #ifndef CONFIG_S390 |
| 1684 | /* | 1688 | /* |
| @@ -2271,6 +2275,11 @@ static int kvm_ioctl_create_device(struct kvm *kvm, | |||
| 2271 | ops = &kvm_xics_ops; | 2275 | ops = &kvm_xics_ops; |
| 2272 | break; | 2276 | break; |
| 2273 | #endif | 2277 | #endif |
| 2278 | #ifdef CONFIG_KVM_VFIO | ||
| 2279 | case KVM_DEV_TYPE_VFIO: | ||
| 2280 | ops = &kvm_vfio_ops; | ||
| 2281 | break; | ||
| 2282 | #endif | ||
| 2274 | default: | 2283 | default: |
| 2275 | return -ENODEV; | 2284 | return -ENODEV; |
| 2276 | } | 2285 | } |
| @@ -2519,44 +2528,12 @@ out: | |||
| 2519 | } | 2528 | } |
| 2520 | #endif | 2529 | #endif |
| 2521 | 2530 | ||
| 2522 | static int kvm_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf) | ||
| 2523 | { | ||
| 2524 | struct page *page[1]; | ||
| 2525 | unsigned long addr; | ||
| 2526 | int npages; | ||
| 2527 | gfn_t gfn = vmf->pgoff; | ||
| 2528 | struct kvm *kvm = vma->vm_file->private_data; | ||
| 2529 | |||
| 2530 | addr = gfn_to_hva(kvm, gfn); | ||
| 2531 | if (kvm_is_error_hva(addr)) | ||
| 2532 | return VM_FAULT_SIGBUS; | ||
| 2533 | |||
| 2534 | npages = get_user_pages(current, current->mm, addr, 1, 1, 0, page, | ||
| 2535 | NULL); | ||
| 2536 | if (unlikely(npages != 1)) | ||
| 2537 | return VM_FAULT_SIGBUS; | ||
| 2538 | |||
| 2539 | vmf->page = page[0]; | ||
| 2540 | return 0; | ||
| 2541 | } | ||
| 2542 | |||
| 2543 | static const struct vm_operations_struct kvm_vm_vm_ops = { | ||
| 2544 | .fault = kvm_vm_fault, | ||
| 2545 | }; | ||
| 2546 | |||
| 2547 | static int kvm_vm_mmap(struct file *file, struct vm_area_struct *vma) | ||
| 2548 | { | ||
| 2549 | vma->vm_ops = &kvm_vm_vm_ops; | ||
| 2550 | return 0; | ||
| 2551 | } | ||
| 2552 | |||
| 2553 | static struct file_operations kvm_vm_fops = { | 2531 | static struct file_operations kvm_vm_fops = { |
| 2554 | .release = kvm_vm_release, | 2532 | .release = kvm_vm_release, |
| 2555 | .unlocked_ioctl = kvm_vm_ioctl, | 2533 | .unlocked_ioctl = kvm_vm_ioctl, |
| 2556 | #ifdef CONFIG_COMPAT | 2534 | #ifdef CONFIG_COMPAT |
| 2557 | .compat_ioctl = kvm_vm_compat_ioctl, | 2535 | .compat_ioctl = kvm_vm_compat_ioctl, |
| 2558 | #endif | 2536 | #endif |
| 2559 | .mmap = kvm_vm_mmap, | ||
| 2560 | .llseek = noop_llseek, | 2537 | .llseek = noop_llseek, |
| 2561 | }; | 2538 | }; |
| 2562 | 2539 | ||
| @@ -2683,11 +2660,12 @@ static void hardware_enable_nolock(void *junk) | |||
| 2683 | } | 2660 | } |
| 2684 | } | 2661 | } |
| 2685 | 2662 | ||
| 2686 | static void hardware_enable(void *junk) | 2663 | static void hardware_enable(void) |
| 2687 | { | 2664 | { |
| 2688 | raw_spin_lock(&kvm_lock); | 2665 | raw_spin_lock(&kvm_count_lock); |
| 2689 | hardware_enable_nolock(junk); | 2666 | if (kvm_usage_count) |
| 2690 | raw_spin_unlock(&kvm_lock); | 2667 | hardware_enable_nolock(NULL); |
| 2668 | raw_spin_unlock(&kvm_count_lock); | ||
| 2691 | } | 2669 | } |
| 2692 | 2670 | ||
| 2693 | static void hardware_disable_nolock(void *junk) | 2671 | static void hardware_disable_nolock(void *junk) |
| @@ -2700,11 +2678,12 @@ static void hardware_disable_nolock(void *junk) | |||
| 2700 | kvm_arch_hardware_disable(NULL); | 2678 | kvm_arch_hardware_disable(NULL); |
| 2701 | } | 2679 | } |
| 2702 | 2680 | ||
| 2703 | static void hardware_disable(void *junk) | 2681 | static void hardware_disable(void) |
| 2704 | { | 2682 | { |
| 2705 | raw_spin_lock(&kvm_lock); | 2683 | raw_spin_lock(&kvm_count_lock); |
| 2706 | hardware_disable_nolock(junk); | 2684 | if (kvm_usage_count) |
| 2707 | raw_spin_unlock(&kvm_lock); | 2685 | hardware_disable_nolock(NULL); |
| 2686 | raw_spin_unlock(&kvm_count_lock); | ||
| 2708 | } | 2687 | } |
| 2709 | 2688 | ||
| 2710 | static void hardware_disable_all_nolock(void) | 2689 | static void hardware_disable_all_nolock(void) |
| @@ -2718,16 +2697,16 @@ static void hardware_disable_all_nolock(void) | |||
| 2718 | 2697 | ||
| 2719 | static void hardware_disable_all(void) | 2698 | static void hardware_disable_all(void) |
| 2720 | { | 2699 | { |
| 2721 | raw_spin_lock(&kvm_lock); | 2700 | raw_spin_lock(&kvm_count_lock); |
| 2722 | hardware_disable_all_nolock(); | 2701 | hardware_disable_all_nolock(); |
| 2723 | raw_spin_unlock(&kvm_lock); | 2702 | raw_spin_unlock(&kvm_count_lock); |
| 2724 | } | 2703 | } |
| 2725 | 2704 | ||
| 2726 | static int hardware_enable_all(void) | 2705 | static int hardware_enable_all(void) |
| 2727 | { | 2706 | { |
| 2728 | int r = 0; | 2707 | int r = 0; |
| 2729 | 2708 | ||
| 2730 | raw_spin_lock(&kvm_lock); | 2709 | raw_spin_lock(&kvm_count_lock); |
| 2731 | 2710 | ||
| 2732 | kvm_usage_count++; | 2711 | kvm_usage_count++; |
| 2733 | if (kvm_usage_count == 1) { | 2712 | if (kvm_usage_count == 1) { |
| @@ -2740,7 +2719,7 @@ static int hardware_enable_all(void) | |||
| 2740 | } | 2719 | } |
| 2741 | } | 2720 | } |
| 2742 | 2721 | ||
| 2743 | raw_spin_unlock(&kvm_lock); | 2722 | raw_spin_unlock(&kvm_count_lock); |
| 2744 | 2723 | ||
| 2745 | return r; | 2724 | return r; |
| 2746 | } | 2725 | } |
| @@ -2750,20 +2729,17 @@ static int kvm_cpu_hotplug(struct notifier_block *notifier, unsigned long val, | |||
| 2750 | { | 2729 | { |
| 2751 | int cpu = (long)v; | 2730 | int cpu = (long)v; |
| 2752 | 2731 | ||
| 2753 | if (!kvm_usage_count) | ||
| 2754 | return NOTIFY_OK; | ||
| 2755 | |||
| 2756 | val &= ~CPU_TASKS_FROZEN; | 2732 | val &= ~CPU_TASKS_FROZEN; |
| 2757 | switch (val) { | 2733 | switch (val) { |
| 2758 | case CPU_DYING: | 2734 | case CPU_DYING: |
| 2759 | printk(KERN_INFO "kvm: disabling virtualization on CPU%d\n", | 2735 | printk(KERN_INFO "kvm: disabling virtualization on CPU%d\n", |
| 2760 | cpu); | 2736 | cpu); |
| 2761 | hardware_disable(NULL); | 2737 | hardware_disable(); |
| 2762 | break; | 2738 | break; |
| 2763 | case CPU_STARTING: | 2739 | case CPU_STARTING: |
| 2764 | printk(KERN_INFO "kvm: enabling virtualization on CPU%d\n", | 2740 | printk(KERN_INFO "kvm: enabling virtualization on CPU%d\n", |
| 2765 | cpu); | 2741 | cpu); |
| 2766 | hardware_enable(NULL); | 2742 | hardware_enable(); |
| 2767 | break; | 2743 | break; |
| 2768 | } | 2744 | } |
| 2769 | return NOTIFY_OK; | 2745 | return NOTIFY_OK; |
| @@ -3056,10 +3032,10 @@ static int vm_stat_get(void *_offset, u64 *val) | |||
| 3056 | struct kvm *kvm; | 3032 | struct kvm *kvm; |
| 3057 | 3033 | ||
| 3058 | *val = 0; | 3034 | *val = 0; |
| 3059 | raw_spin_lock(&kvm_lock); | 3035 | spin_lock(&kvm_lock); |
| 3060 | list_for_each_entry(kvm, &vm_list, vm_list) | 3036 | list_for_each_entry(kvm, &vm_list, vm_list) |
| 3061 | *val += *(u32 *)((void *)kvm + offset); | 3037 | *val += *(u32 *)((void *)kvm + offset); |
| 3062 | raw_spin_unlock(&kvm_lock); | 3038 | spin_unlock(&kvm_lock); |
| 3063 | return 0; | 3039 | return 0; |
| 3064 | } | 3040 | } |
| 3065 | 3041 | ||
| @@ -3073,12 +3049,12 @@ static int vcpu_stat_get(void *_offset, u64 *val) | |||
| 3073 | int i; | 3049 | int i; |
| 3074 | 3050 | ||
| 3075 | *val = 0; | 3051 | *val = 0; |
| 3076 | raw_spin_lock(&kvm_lock); | 3052 | spin_lock(&kvm_lock); |
| 3077 | list_for_each_entry(kvm, &vm_list, vm_list) | 3053 | list_for_each_entry(kvm, &vm_list, vm_list) |
| 3078 | kvm_for_each_vcpu(i, vcpu, kvm) | 3054 | kvm_for_each_vcpu(i, vcpu, kvm) |
| 3079 | *val += *(u32 *)((void *)vcpu + offset); | 3055 | *val += *(u32 *)((void *)vcpu + offset); |
| 3080 | 3056 | ||
| 3081 | raw_spin_unlock(&kvm_lock); | 3057 | spin_unlock(&kvm_lock); |
| 3082 | return 0; | 3058 | return 0; |
| 3083 | } | 3059 | } |
| 3084 | 3060 | ||
| @@ -3133,7 +3109,7 @@ static int kvm_suspend(void) | |||
| 3133 | static void kvm_resume(void) | 3109 | static void kvm_resume(void) |
| 3134 | { | 3110 | { |
| 3135 | if (kvm_usage_count) { | 3111 | if (kvm_usage_count) { |
| 3136 | WARN_ON(raw_spin_is_locked(&kvm_lock)); | 3112 | WARN_ON(raw_spin_is_locked(&kvm_count_lock)); |
| 3137 | hardware_enable_nolock(NULL); | 3113 | hardware_enable_nolock(NULL); |
| 3138 | } | 3114 | } |
| 3139 | } | 3115 | } |
diff --git a/virt/kvm/vfio.c b/virt/kvm/vfio.c new file mode 100644 index 000000000000..ca4260e35037 --- /dev/null +++ b/virt/kvm/vfio.c | |||
| @@ -0,0 +1,264 @@ | |||
| 1 | /* | ||
| 2 | * VFIO-KVM bridge pseudo device | ||
| 3 | * | ||
| 4 | * Copyright (C) 2013 Red Hat, Inc. All rights reserved. | ||
| 5 | * Author: Alex Williamson <alex.williamson@redhat.com> | ||
| 6 | * | ||
| 7 | * This program is free software; you can redistribute it and/or modify | ||
| 8 | * it under the terms of the GNU General Public License version 2 as | ||
| 9 | * published by the Free Software Foundation. | ||
| 10 | */ | ||
| 11 | |||
| 12 | #include <linux/errno.h> | ||
| 13 | #include <linux/file.h> | ||
| 14 | #include <linux/kvm_host.h> | ||
| 15 | #include <linux/list.h> | ||
| 16 | #include <linux/module.h> | ||
| 17 | #include <linux/mutex.h> | ||
| 18 | #include <linux/slab.h> | ||
| 19 | #include <linux/uaccess.h> | ||
| 20 | #include <linux/vfio.h> | ||
| 21 | |||
| 22 | struct kvm_vfio_group { | ||
| 23 | struct list_head node; | ||
| 24 | struct vfio_group *vfio_group; | ||
| 25 | }; | ||
| 26 | |||
| 27 | struct kvm_vfio { | ||
| 28 | struct list_head group_list; | ||
| 29 | struct mutex lock; | ||
| 30 | bool noncoherent; | ||
| 31 | }; | ||
| 32 | |||
| 33 | static struct vfio_group *kvm_vfio_group_get_external_user(struct file *filep) | ||
| 34 | { | ||
| 35 | struct vfio_group *vfio_group; | ||
| 36 | struct vfio_group *(*fn)(struct file *); | ||
| 37 | |||
| 38 | fn = symbol_get(vfio_group_get_external_user); | ||
| 39 | if (!fn) | ||
| 40 | return ERR_PTR(-EINVAL); | ||
| 41 | |||
| 42 | vfio_group = fn(filep); | ||
| 43 | |||
| 44 | symbol_put(vfio_group_get_external_user); | ||
| 45 | |||
| 46 | return vfio_group; | ||
| 47 | } | ||
| 48 | |||
| 49 | static void kvm_vfio_group_put_external_user(struct vfio_group *vfio_group) | ||
| 50 | { | ||
| 51 | void (*fn)(struct vfio_group *); | ||
| 52 | |||
| 53 | fn = symbol_get(vfio_group_put_external_user); | ||
| 54 | if (!fn) | ||
| 55 | return; | ||
| 56 | |||
| 57 | fn(vfio_group); | ||
| 58 | |||
| 59 | symbol_put(vfio_group_put_external_user); | ||
| 60 | } | ||
| 61 | |||
| 62 | /* | ||
| 63 | * Groups can use the same or different IOMMU domains. If the same then | ||
| 64 | * adding a new group may change the coherency of groups we've previously | ||
| 65 | * been told about. We don't want to care about any of that so we retest | ||
| 66 | * each group and bail as soon as we find one that's noncoherent. This | ||
| 67 | * means we only ever [un]register_noncoherent_dma once for the whole device. | ||
| 68 | */ | ||
| 69 | static void kvm_vfio_update_coherency(struct kvm_device *dev) | ||
| 70 | { | ||
| 71 | struct kvm_vfio *kv = dev->private; | ||
| 72 | bool noncoherent = false; | ||
| 73 | struct kvm_vfio_group *kvg; | ||
| 74 | |||
| 75 | mutex_lock(&kv->lock); | ||
| 76 | |||
| 77 | list_for_each_entry(kvg, &kv->group_list, node) { | ||
| 78 | /* | ||
| 79 | * TODO: We need an interface to check the coherency of | ||
| 80 | * the IOMMU domain this group is using. For now, assume | ||
| 81 | * it's always noncoherent. | ||
| 82 | */ | ||
| 83 | noncoherent = true; | ||
| 84 | break; | ||
| 85 | } | ||
| 86 | |||
| 87 | if (noncoherent != kv->noncoherent) { | ||
| 88 | kv->noncoherent = noncoherent; | ||
| 89 | |||
| 90 | if (kv->noncoherent) | ||
| 91 | kvm_arch_register_noncoherent_dma(dev->kvm); | ||
| 92 | else | ||
| 93 | kvm_arch_unregister_noncoherent_dma(dev->kvm); | ||
| 94 | } | ||
| 95 | |||
| 96 | mutex_unlock(&kv->lock); | ||
| 97 | } | ||
| 98 | |||
| 99 | static int kvm_vfio_set_group(struct kvm_device *dev, long attr, u64 arg) | ||
| 100 | { | ||
| 101 | struct kvm_vfio *kv = dev->private; | ||
| 102 | struct vfio_group *vfio_group; | ||
| 103 | struct kvm_vfio_group *kvg; | ||
| 104 | void __user *argp = (void __user *)arg; | ||
| 105 | struct fd f; | ||
| 106 | int32_t fd; | ||
| 107 | int ret; | ||
| 108 | |||
| 109 | switch (attr) { | ||
| 110 | case KVM_DEV_VFIO_GROUP_ADD: | ||
| 111 | if (get_user(fd, (int32_t __user *)argp)) | ||
| 112 | return -EFAULT; | ||
| 113 | |||
| 114 | f = fdget(fd); | ||
| 115 | if (!f.file) | ||
| 116 | return -EBADF; | ||
| 117 | |||
| 118 | vfio_group = kvm_vfio_group_get_external_user(f.file); | ||
| 119 | fdput(f); | ||
| 120 | |||
| 121 | if (IS_ERR(vfio_group)) | ||
| 122 | return PTR_ERR(vfio_group); | ||
| 123 | |||
| 124 | mutex_lock(&kv->lock); | ||
| 125 | |||
| 126 | list_for_each_entry(kvg, &kv->group_list, node) { | ||
| 127 | if (kvg->vfio_group == vfio_group) { | ||
| 128 | mutex_unlock(&kv->lock); | ||
| 129 | kvm_vfio_group_put_external_user(vfio_group); | ||
| 130 | return -EEXIST; | ||
| 131 | } | ||
| 132 | } | ||
| 133 | |||
| 134 | kvg = kzalloc(sizeof(*kvg), GFP_KERNEL); | ||
| 135 | if (!kvg) { | ||
| 136 | mutex_unlock(&kv->lock); | ||
| 137 | kvm_vfio_group_put_external_user(vfio_group); | ||
| 138 | return -ENOMEM; | ||
| 139 | } | ||
| 140 | |||
| 141 | list_add_tail(&kvg->node, &kv->group_list); | ||
| 142 | kvg->vfio_group = vfio_group; | ||
| 143 | |||
| 144 | mutex_unlock(&kv->lock); | ||
| 145 | |||
| 146 | kvm_vfio_update_coherency(dev); | ||
| 147 | |||
| 148 | return 0; | ||
| 149 | |||
| 150 | case KVM_DEV_VFIO_GROUP_DEL: | ||
| 151 | if (get_user(fd, (int32_t __user *)argp)) | ||
| 152 | return -EFAULT; | ||
| 153 | |||
| 154 | f = fdget(fd); | ||
| 155 | if (!f.file) | ||
| 156 | return -EBADF; | ||
| 157 | |||
| 158 | vfio_group = kvm_vfio_group_get_external_user(f.file); | ||
| 159 | fdput(f); | ||
| 160 | |||
| 161 | if (IS_ERR(vfio_group)) | ||
| 162 | return PTR_ERR(vfio_group); | ||
| 163 | |||
| 164 | ret = -ENOENT; | ||
| 165 | |||
| 166 | mutex_lock(&kv->lock); | ||
| 167 | |||
| 168 | list_for_each_entry(kvg, &kv->group_list, node) { | ||
| 169 | if (kvg->vfio_group != vfio_group) | ||
| 170 | continue; | ||
| 171 | |||
| 172 | list_del(&kvg->node); | ||
| 173 | kvm_vfio_group_put_external_user(kvg->vfio_group); | ||
| 174 | kfree(kvg); | ||
| 175 | ret = 0; | ||
| 176 | break; | ||
| 177 | } | ||
| 178 | |||
| 179 | mutex_unlock(&kv->lock); | ||
| 180 | |||
| 181 | kvm_vfio_group_put_external_user(vfio_group); | ||
| 182 | |||
| 183 | kvm_vfio_update_coherency(dev); | ||
| 184 | |||
| 185 | return ret; | ||
| 186 | } | ||
| 187 | |||
| 188 | return -ENXIO; | ||
| 189 | } | ||
| 190 | |||
| 191 | static int kvm_vfio_set_attr(struct kvm_device *dev, | ||
| 192 | struct kvm_device_attr *attr) | ||
| 193 | { | ||
| 194 | switch (attr->group) { | ||
| 195 | case KVM_DEV_VFIO_GROUP: | ||
| 196 | return kvm_vfio_set_group(dev, attr->attr, attr->addr); | ||
| 197 | } | ||
| 198 | |||
| 199 | return -ENXIO; | ||
| 200 | } | ||
| 201 | |||
| 202 | static int kvm_vfio_has_attr(struct kvm_device *dev, | ||
| 203 | struct kvm_device_attr *attr) | ||
| 204 | { | ||
| 205 | switch (attr->group) { | ||
| 206 | case KVM_DEV_VFIO_GROUP: | ||
| 207 | switch (attr->attr) { | ||
| 208 | case KVM_DEV_VFIO_GROUP_ADD: | ||
| 209 | case KVM_DEV_VFIO_GROUP_DEL: | ||
| 210 | return 0; | ||
| 211 | } | ||
| 212 | |||
| 213 | break; | ||
| 214 | } | ||
| 215 | |||
| 216 | return -ENXIO; | ||
| 217 | } | ||
| 218 | |||
| 219 | static void kvm_vfio_destroy(struct kvm_device *dev) | ||
| 220 | { | ||
| 221 | struct kvm_vfio *kv = dev->private; | ||
| 222 | struct kvm_vfio_group *kvg, *tmp; | ||
| 223 | |||
| 224 | list_for_each_entry_safe(kvg, tmp, &kv->group_list, node) { | ||
| 225 | kvm_vfio_group_put_external_user(kvg->vfio_group); | ||
| 226 | list_del(&kvg->node); | ||
| 227 | kfree(kvg); | ||
| 228 | } | ||
| 229 | |||
| 230 | kvm_vfio_update_coherency(dev); | ||
| 231 | |||
| 232 | kfree(kv); | ||
| 233 | kfree(dev); /* alloc by kvm_ioctl_create_device, free by .destroy */ | ||
| 234 | } | ||
| 235 | |||
| 236 | static int kvm_vfio_create(struct kvm_device *dev, u32 type) | ||
| 237 | { | ||
| 238 | struct kvm_device *tmp; | ||
| 239 | struct kvm_vfio *kv; | ||
| 240 | |||
| 241 | /* Only one VFIO "device" per VM */ | ||
| 242 | list_for_each_entry(tmp, &dev->kvm->devices, vm_node) | ||
| 243 | if (tmp->ops == &kvm_vfio_ops) | ||
| 244 | return -EBUSY; | ||
| 245 | |||
| 246 | kv = kzalloc(sizeof(*kv), GFP_KERNEL); | ||
| 247 | if (!kv) | ||
| 248 | return -ENOMEM; | ||
| 249 | |||
| 250 | INIT_LIST_HEAD(&kv->group_list); | ||
| 251 | mutex_init(&kv->lock); | ||
| 252 | |||
| 253 | dev->private = kv; | ||
| 254 | |||
| 255 | return 0; | ||
| 256 | } | ||
| 257 | |||
| 258 | struct kvm_device_ops kvm_vfio_ops = { | ||
| 259 | .name = "kvm-vfio", | ||
| 260 | .create = kvm_vfio_create, | ||
| 261 | .destroy = kvm_vfio_destroy, | ||
| 262 | .set_attr = kvm_vfio_set_attr, | ||
| 263 | .has_attr = kvm_vfio_has_attr, | ||
| 264 | }; | ||
