2008-07-23 03:27:11 +08:00
|
|
|
/*
|
2007-10-10 23:16:19 +08:00
|
|
|
* Kernel-based Virtual Machine driver for Linux
|
|
|
|
*
|
|
|
|
* This header defines architecture specific interfaces, x86 version
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2. See
|
|
|
|
* the COPYING file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2008-10-23 13:26:29 +08:00
|
|
|
#ifndef _ASM_X86_KVM_HOST_H
|
|
|
|
#define _ASM_X86_KVM_HOST_H
|
2007-10-10 23:16:19 +08:00
|
|
|
|
2007-10-20 15:34:38 +08:00
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/mm.h>
|
2008-07-25 22:24:52 +08:00
|
|
|
#include <linux/mmu_notifier.h>
|
2009-06-17 20:22:14 +08:00
|
|
|
#include <linux/tracepoint.h>
|
2010-06-30 12:25:15 +08:00
|
|
|
#include <linux/cpumask.h>
|
2011-11-10 20:57:22 +08:00
|
|
|
#include <linux/irq_work.h>
|
2007-10-20 15:34:38 +08:00
|
|
|
|
|
|
|
#include <linux/kvm.h>
|
|
|
|
#include <linux/kvm_para.h>
|
2007-12-16 17:02:48 +08:00
|
|
|
#include <linux/kvm_types.h>
|
2011-11-10 20:57:22 +08:00
|
|
|
#include <linux/perf_event.h>
|
2012-11-28 09:29:01 +08:00
|
|
|
#include <linux/pvclock_gtod.h>
|
|
|
|
#include <linux/clocksource.h>
|
2015-09-18 22:29:40 +08:00
|
|
|
#include <linux/irqbypass.h>
|
2015-11-10 20:36:34 +08:00
|
|
|
#include <linux/hyperv.h>
|
2007-10-20 15:34:38 +08:00
|
|
|
|
2016-06-16 06:23:45 +08:00
|
|
|
#include <asm/apic.h>
|
2008-06-03 22:17:31 +08:00
|
|
|
#include <asm/pvclock-abi.h>
|
2007-12-04 05:30:25 +08:00
|
|
|
#include <asm/desc.h>
|
2008-10-09 16:01:54 +08:00
|
|
|
#include <asm/mtrr.h>
|
2008-11-26 03:17:02 +08:00
|
|
|
#include <asm/msr-index.h>
|
2012-04-21 04:41:59 +08:00
|
|
|
#include <asm/asm.h>
|
KVM: page track: add the framework of guest page tracking
The array, gfn_track[mode][gfn], is introduced in memory slot for every
guest page, this is the tracking count for the gust page on different
modes. If the page is tracked then the count is increased, the page is
not tracked after the count reaches zero
We use 'unsigned short' as the tracking count which should be enough as
shadow page table only can use 2^14 (2^3 for level, 2^1 for cr4_pae, 2^2
for quadrant, 2^3 for access, 2^1 for nxe, 2^1 for cr0_wp, 2^1 for
smep_andnot_wp, 2^1 for smap_andnot_wp, and 2^1 for smm) at most, there
is enough room for other trackers
Two callbacks, kvm_page_track_create_memslot() and
kvm_page_track_free_memslot() are implemented in this patch, they are
internally used to initialize and reclaim the memory of the array
Currently, only write track mode is supported
Signed-off-by: Xiao Guangrong <guangrong.xiao@linux.intel.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-02-24 17:51:09 +08:00
|
|
|
#include <asm/kvm_page_track.h>
|
2007-12-04 05:30:25 +08:00
|
|
|
|
2016-07-13 04:09:29 +08:00
|
|
|
#define KVM_MAX_VCPUS 288
|
2016-07-13 04:09:17 +08:00
|
|
|
#define KVM_SOFT_MAX_VCPUS 240
|
2016-07-13 04:09:30 +08:00
|
|
|
#define KVM_MAX_VCPU_ID 1023
|
2014-11-06 23:52:47 +08:00
|
|
|
#define KVM_USER_MEM_SLOTS 509
|
2012-12-11 01:33:15 +08:00
|
|
|
/* memory slots that are not exposed to userspace */
|
|
|
|
#define KVM_PRIVATE_MEM_SLOTS 3
|
2012-12-11 01:33:09 +08:00
|
|
|
#define KVM_MEM_SLOTS_NUM (KVM_USER_MEM_SLOTS + KVM_PRIVATE_MEM_SLOTS)
|
2011-11-24 17:37:48 +08:00
|
|
|
|
2008-03-21 18:38:23 +08:00
|
|
|
#define KVM_PIO_PAGE_OFFSET 1
|
2008-05-30 22:05:55 +08:00
|
|
|
#define KVM_COALESCED_MMIO_PAGE_OFFSET 2
|
2016-03-29 23:56:57 +08:00
|
|
|
#define KVM_HALT_POLL_NS_DEFAULT 400000
|
2008-03-21 18:38:23 +08:00
|
|
|
|
2013-04-15 16:42:33 +08:00
|
|
|
#define KVM_IRQCHIP_NUM_PINS KVM_IOAPIC_NUM_PINS
|
|
|
|
|
2016-01-07 22:05:10 +08:00
|
|
|
/* x86-specific vcpu->requests bit members */
|
|
|
|
#define KVM_REQ_MIGRATE_TIMER 8
|
|
|
|
#define KVM_REQ_REPORT_TPR_ACCESS 9
|
|
|
|
#define KVM_REQ_TRIPLE_FAULT 10
|
|
|
|
#define KVM_REQ_MMU_SYNC 11
|
|
|
|
#define KVM_REQ_CLOCK_UPDATE 12
|
|
|
|
#define KVM_REQ_DEACTIVATE_FPU 13
|
|
|
|
#define KVM_REQ_EVENT 14
|
|
|
|
#define KVM_REQ_APF_HALT 15
|
|
|
|
#define KVM_REQ_STEAL_UPDATE 16
|
|
|
|
#define KVM_REQ_NMI 17
|
|
|
|
#define KVM_REQ_PMU 18
|
|
|
|
#define KVM_REQ_PMI 19
|
|
|
|
#define KVM_REQ_SMI 20
|
|
|
|
#define KVM_REQ_MASTERCLOCK_UPDATE 21
|
|
|
|
#define KVM_REQ_MCLOCK_INPROGRESS 22
|
|
|
|
#define KVM_REQ_SCAN_IOAPIC 23
|
|
|
|
#define KVM_REQ_GLOBAL_CLOCK_UPDATE 24
|
|
|
|
#define KVM_REQ_APIC_PAGE_RELOAD 25
|
|
|
|
#define KVM_REQ_HV_CRASH 26
|
|
|
|
#define KVM_REQ_IOAPIC_EOI_EXIT 27
|
|
|
|
#define KVM_REQ_HV_RESET 28
|
|
|
|
#define KVM_REQ_HV_EXIT 29
|
|
|
|
#define KVM_REQ_HV_STIMER 30
|
|
|
|
|
2011-04-04 18:39:28 +08:00
|
|
|
#define CR0_RESERVED_BITS \
|
|
|
|
(~(unsigned long)(X86_CR0_PE | X86_CR0_MP | X86_CR0_EM | X86_CR0_TS \
|
|
|
|
| X86_CR0_ET | X86_CR0_NE | X86_CR0_WP | X86_CR0_AM \
|
|
|
|
| X86_CR0_NW | X86_CR0_CD | X86_CR0_PG))
|
|
|
|
|
2014-04-18 08:35:09 +08:00
|
|
|
#define CR3_L_MODE_RESERVED_BITS 0xFFFFFF0000000000ULL
|
2015-01-15 16:44:56 +08:00
|
|
|
#define CR3_PCID_INVD BIT_64(63)
|
2011-04-04 18:39:28 +08:00
|
|
|
#define CR4_RESERVED_BITS \
|
|
|
|
(~(unsigned long)(X86_CR4_VME | X86_CR4_PVI | X86_CR4_TSD | X86_CR4_DE\
|
|
|
|
| X86_CR4_PSE | X86_CR4_PAE | X86_CR4_MCE \
|
2012-07-02 09:18:48 +08:00
|
|
|
| X86_CR4_PGE | X86_CR4_PCE | X86_CR4_OSFXSR | X86_CR4_PCIDE \
|
2013-04-28 07:37:47 +08:00
|
|
|
| X86_CR4_OSXSAVE | X86_CR4_SMEP | X86_CR4_FSGSBASE \
|
2016-03-22 16:51:21 +08:00
|
|
|
| X86_CR4_OSXMMEXCPT | X86_CR4_VMXE | X86_CR4_SMAP \
|
|
|
|
| X86_CR4_PKE))
|
2011-04-04 18:39:28 +08:00
|
|
|
|
|
|
|
#define CR8_RESERVED_BITS (~(unsigned long)X86_CR8_TPR)
|
|
|
|
|
|
|
|
|
2007-11-19 14:33:37 +08:00
|
|
|
|
|
|
|
#define INVALID_PAGE (~(hpa_t)0)
|
2010-07-03 16:02:42 +08:00
|
|
|
#define VALID_PAGE(x) ((x) != INVALID_PAGE)
|
|
|
|
|
2007-11-19 14:33:37 +08:00
|
|
|
#define UNMAPPED_GVA (~(gpa_t)0)
|
|
|
|
|
2009-06-19 21:16:23 +08:00
|
|
|
/* KVM Hugepage definitions for x86 */
|
2009-07-27 22:30:47 +08:00
|
|
|
#define KVM_NR_PAGE_SIZES 3
|
2010-07-01 22:00:11 +08:00
|
|
|
#define KVM_HPAGE_GFN_SHIFT(x) (((x) - 1) * 9)
|
|
|
|
#define KVM_HPAGE_SHIFT(x) (PAGE_SHIFT + KVM_HPAGE_GFN_SHIFT(x))
|
2009-06-19 21:16:23 +08:00
|
|
|
#define KVM_HPAGE_SIZE(x) (1UL << KVM_HPAGE_SHIFT(x))
|
|
|
|
#define KVM_HPAGE_MASK(x) (~(KVM_HPAGE_SIZE(x) - 1))
|
|
|
|
#define KVM_PAGES_PER_HPAGE(x) (KVM_HPAGE_SIZE(x) / PAGE_SIZE)
|
2008-02-23 22:44:30 +08:00
|
|
|
|
2013-10-03 05:22:28 +08:00
|
|
|
static inline gfn_t gfn_to_index(gfn_t gfn, gfn_t base_gfn, int level)
|
|
|
|
{
|
|
|
|
/* KVM_HPAGE_GFN_SHIFT(PT_PAGE_TABLE_LEVEL) must be 0. */
|
|
|
|
return (gfn >> KVM_HPAGE_GFN_SHIFT(level)) -
|
|
|
|
(base_gfn >> KVM_HPAGE_GFN_SHIFT(level));
|
|
|
|
}
|
|
|
|
|
2007-12-14 09:41:22 +08:00
|
|
|
#define KVM_PERMILLE_MMU_PAGES 20
|
|
|
|
#define KVM_MIN_ALLOC_MMU_PAGES 64
|
2008-01-07 19:20:25 +08:00
|
|
|
#define KVM_MMU_HASH_SHIFT 10
|
|
|
|
#define KVM_NUM_MMU_PAGES (1 << KVM_MMU_HASH_SHIFT)
|
2007-12-14 09:41:22 +08:00
|
|
|
#define KVM_MIN_FREE_MMU_PAGES 5
|
|
|
|
#define KVM_REFILL_PAGES 25
|
2010-12-01 19:17:44 +08:00
|
|
|
#define KVM_MAX_CPUID_ENTRIES 80
|
2008-10-09 16:01:54 +08:00
|
|
|
#define KVM_NR_FIXED_MTRR_REGION 88
|
2014-08-18 22:39:48 +08:00
|
|
|
#define KVM_NR_VAR_MTRR 8
|
2007-12-14 09:41:22 +08:00
|
|
|
|
2010-10-14 17:22:46 +08:00
|
|
|
#define ASYNC_PF_PER_VCPU 64
|
|
|
|
|
2008-06-28 01:58:02 +08:00
|
|
|
enum kvm_reg {
|
2007-11-19 14:56:05 +08:00
|
|
|
VCPU_REGS_RAX = 0,
|
|
|
|
VCPU_REGS_RCX = 1,
|
|
|
|
VCPU_REGS_RDX = 2,
|
|
|
|
VCPU_REGS_RBX = 3,
|
|
|
|
VCPU_REGS_RSP = 4,
|
|
|
|
VCPU_REGS_RBP = 5,
|
|
|
|
VCPU_REGS_RSI = 6,
|
|
|
|
VCPU_REGS_RDI = 7,
|
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
VCPU_REGS_R8 = 8,
|
|
|
|
VCPU_REGS_R9 = 9,
|
|
|
|
VCPU_REGS_R10 = 10,
|
|
|
|
VCPU_REGS_R11 = 11,
|
|
|
|
VCPU_REGS_R12 = 12,
|
|
|
|
VCPU_REGS_R13 = 13,
|
|
|
|
VCPU_REGS_R14 = 14,
|
|
|
|
VCPU_REGS_R15 = 15,
|
|
|
|
#endif
|
2008-06-28 01:58:02 +08:00
|
|
|
VCPU_REGS_RIP,
|
2007-11-19 14:56:05 +08:00
|
|
|
NR_VCPU_REGS
|
|
|
|
};
|
|
|
|
|
2009-06-01 03:58:47 +08:00
|
|
|
enum kvm_reg_ex {
|
|
|
|
VCPU_EXREG_PDPTR = NR_VCPU_REGS,
|
2010-12-06 00:56:11 +08:00
|
|
|
VCPU_EXREG_CR3,
|
2011-03-07 18:51:22 +08:00
|
|
|
VCPU_EXREG_RFLAGS,
|
2011-04-28 00:42:18 +08:00
|
|
|
VCPU_EXREG_SEGMENTS,
|
2009-06-01 03:58:47 +08:00
|
|
|
};
|
|
|
|
|
2007-11-19 14:56:05 +08:00
|
|
|
enum {
|
2008-05-27 21:26:01 +08:00
|
|
|
VCPU_SREG_ES,
|
2007-11-19 14:56:05 +08:00
|
|
|
VCPU_SREG_CS,
|
2008-05-27 21:26:01 +08:00
|
|
|
VCPU_SREG_SS,
|
2007-11-19 14:56:05 +08:00
|
|
|
VCPU_SREG_DS,
|
|
|
|
VCPU_SREG_FS,
|
|
|
|
VCPU_SREG_GS,
|
|
|
|
VCPU_SREG_TR,
|
|
|
|
VCPU_SREG_LDTR,
|
|
|
|
};
|
|
|
|
|
2009-08-12 20:04:37 +08:00
|
|
|
#include <asm/kvm_emulate.h>
|
2007-11-19 14:56:05 +08:00
|
|
|
|
2007-12-14 09:41:22 +08:00
|
|
|
#define KVM_NR_MEM_OBJS 40
|
|
|
|
|
2008-12-15 20:52:10 +08:00
|
|
|
#define KVM_NR_DB_REGS 4
|
|
|
|
|
|
|
|
#define DR6_BD (1 << 13)
|
|
|
|
#define DR6_BS (1 << 14)
|
2014-07-15 22:37:46 +08:00
|
|
|
#define DR6_RTM (1 << 16)
|
|
|
|
#define DR6_FIXED_1 0xfffe0ff0
|
|
|
|
#define DR6_INIT 0xffff0ff0
|
|
|
|
#define DR6_VOLATILE 0x0001e00f
|
2008-12-15 20:52:10 +08:00
|
|
|
|
|
|
|
#define DR7_BP_EN_MASK 0x000000ff
|
|
|
|
#define DR7_GE (1 << 9)
|
|
|
|
#define DR7_GD (1 << 13)
|
|
|
|
#define DR7_FIXED_1 0x00000400
|
2014-07-15 22:37:46 +08:00
|
|
|
#define DR7_VOLATILE 0xffff2bff
|
2008-12-15 20:52:10 +08:00
|
|
|
|
2014-12-25 08:52:16 +08:00
|
|
|
#define PFERR_PRESENT_BIT 0
|
|
|
|
#define PFERR_WRITE_BIT 1
|
|
|
|
#define PFERR_USER_BIT 2
|
|
|
|
#define PFERR_RSVD_BIT 3
|
|
|
|
#define PFERR_FETCH_BIT 4
|
2016-03-22 16:51:20 +08:00
|
|
|
#define PFERR_PK_BIT 5
|
2014-12-25 08:52:16 +08:00
|
|
|
|
|
|
|
#define PFERR_PRESENT_MASK (1U << PFERR_PRESENT_BIT)
|
|
|
|
#define PFERR_WRITE_MASK (1U << PFERR_WRITE_BIT)
|
|
|
|
#define PFERR_USER_MASK (1U << PFERR_USER_BIT)
|
|
|
|
#define PFERR_RSVD_MASK (1U << PFERR_RSVD_BIT)
|
|
|
|
#define PFERR_FETCH_MASK (1U << PFERR_FETCH_BIT)
|
2016-03-22 16:51:20 +08:00
|
|
|
#define PFERR_PK_MASK (1U << PFERR_PK_BIT)
|
2014-12-25 08:52:16 +08:00
|
|
|
|
2012-04-19 19:06:29 +08:00
|
|
|
/* apic attention bits */
|
|
|
|
#define KVM_APIC_CHECK_VAPIC 0
|
2012-06-25 00:25:07 +08:00
|
|
|
/*
|
|
|
|
* The following bit is set with PV-EOI, unset on EOI.
|
|
|
|
* We detect PV-EOI changes by guest by comparing
|
|
|
|
* this bit with PV-EOI in guest memory.
|
|
|
|
* See the implementation in apic_update_pv_eoi.
|
|
|
|
*/
|
|
|
|
#define KVM_APIC_PV_EOI_PENDING 1
|
2012-04-19 19:06:29 +08:00
|
|
|
|
2015-09-18 22:29:49 +08:00
|
|
|
struct kvm_kernel_irq_routing_entry;
|
|
|
|
|
2007-12-14 09:41:22 +08:00
|
|
|
/*
|
|
|
|
* We don't want allocation failures within the mmu code, so we preallocate
|
|
|
|
* enough memory for a single page fault in a cache.
|
|
|
|
*/
|
|
|
|
struct kvm_mmu_memory_cache {
|
|
|
|
int nobjs;
|
|
|
|
void *objects[KVM_NR_MEM_OBJS];
|
|
|
|
};
|
|
|
|
|
KVM: page track: add the framework of guest page tracking
The array, gfn_track[mode][gfn], is introduced in memory slot for every
guest page, this is the tracking count for the gust page on different
modes. If the page is tracked then the count is increased, the page is
not tracked after the count reaches zero
We use 'unsigned short' as the tracking count which should be enough as
shadow page table only can use 2^14 (2^3 for level, 2^1 for cr4_pae, 2^2
for quadrant, 2^3 for access, 2^1 for nxe, 2^1 for cr0_wp, 2^1 for
smep_andnot_wp, 2^1 for smap_andnot_wp, and 2^1 for smm) at most, there
is enough room for other trackers
Two callbacks, kvm_page_track_create_memslot() and
kvm_page_track_free_memslot() are implemented in this patch, they are
internally used to initialize and reclaim the memory of the array
Currently, only write track mode is supported
Signed-off-by: Xiao Guangrong <guangrong.xiao@linux.intel.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-02-24 17:51:09 +08:00
|
|
|
/*
|
|
|
|
* the pages used as guest page table on soft mmu are tracked by
|
|
|
|
* kvm_memory_slot.arch.gfn_track which is 16 bits, so the role bits used
|
|
|
|
* by indirect shadow page can not be more than 15 bits.
|
|
|
|
*
|
|
|
|
* Currently, we used 14 bits that are @level, @cr4_pae, @quadrant, @access,
|
|
|
|
* @nxe, @cr0_wp, @smep_andnot_wp and @smap_andnot_wp.
|
|
|
|
*/
|
2007-12-14 09:41:22 +08:00
|
|
|
union kvm_mmu_page_role {
|
|
|
|
unsigned word;
|
|
|
|
struct {
|
2008-03-23 16:02:34 +08:00
|
|
|
unsigned level:4;
|
2010-04-15 00:20:03 +08:00
|
|
|
unsigned cr4_pae:1;
|
2008-03-23 16:02:34 +08:00
|
|
|
unsigned quadrant:2;
|
2009-01-11 19:02:10 +08:00
|
|
|
unsigned direct:1;
|
2008-03-23 16:02:34 +08:00
|
|
|
unsigned access:3;
|
2008-02-21 03:47:24 +08:00
|
|
|
unsigned invalid:1;
|
2009-03-31 16:31:54 +08:00
|
|
|
unsigned nxe:1;
|
2010-05-12 16:48:18 +08:00
|
|
|
unsigned cr0_wp:1;
|
2011-06-06 21:11:54 +08:00
|
|
|
unsigned smep_andnot_wp:1;
|
2015-05-11 22:55:21 +08:00
|
|
|
unsigned smap_andnot_wp:1;
|
2015-05-18 21:03:39 +08:00
|
|
|
unsigned :8;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is left at the top of the word so that
|
|
|
|
* kvm_memslots_for_spte_role can extract it with a
|
|
|
|
* simple shift. While there is room, give it a whole
|
|
|
|
* byte so it is also faster to load it from memory.
|
|
|
|
*/
|
|
|
|
unsigned smm:8;
|
2007-12-14 09:41:22 +08:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2015-11-20 16:41:28 +08:00
|
|
|
struct kvm_rmap_head {
|
|
|
|
unsigned long val;
|
|
|
|
};
|
|
|
|
|
2007-12-14 09:41:22 +08:00
|
|
|
struct kvm_mmu_page {
|
|
|
|
struct list_head link;
|
|
|
|
struct hlist_node hash_link;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The following two entries are used to key the shadow page in the
|
|
|
|
* hash table.
|
|
|
|
*/
|
|
|
|
gfn_t gfn;
|
|
|
|
union kvm_mmu_page_role role;
|
|
|
|
|
|
|
|
u64 *spt;
|
|
|
|
/* hold the gfn of each spte inside spt */
|
|
|
|
gfn_t *gfns;
|
2008-09-24 00:18:39 +08:00
|
|
|
bool unsync;
|
2010-04-16 21:27:54 +08:00
|
|
|
int root_count; /* Currently serving as active root */
|
2008-12-02 08:32:02 +08:00
|
|
|
unsigned int unsync_children;
|
2015-11-20 16:41:28 +08:00
|
|
|
struct kvm_rmap_head parent_ptes; /* rmap pointers to parent sptes */
|
2013-06-19 17:09:24 +08:00
|
|
|
|
|
|
|
/* The page is obsolete if mmu_valid_gen != kvm->arch.mmu_valid_gen. */
|
2013-05-31 08:36:22 +08:00
|
|
|
unsigned long mmu_valid_gen;
|
2013-06-19 17:09:24 +08:00
|
|
|
|
2008-09-24 00:18:40 +08:00
|
|
|
DECLARE_BITMAP(unsync_child_bitmap, 512);
|
2011-07-12 03:32:13 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_X86_32
|
2013-06-19 17:09:20 +08:00
|
|
|
/*
|
|
|
|
* Used out of the mmu-lock to avoid reading spte values while an
|
|
|
|
* update is in progress; see the comments in __get_spte_lockless().
|
|
|
|
*/
|
2011-07-12 03:32:13 +08:00
|
|
|
int clear_spte_count;
|
|
|
|
#endif
|
|
|
|
|
2013-06-19 17:09:21 +08:00
|
|
|
/* Number of writes since the last time traversal visited this page. */
|
2016-02-24 17:51:12 +08:00
|
|
|
atomic_t write_flooding_count;
|
2007-12-14 09:41:22 +08:00
|
|
|
};
|
|
|
|
|
2009-01-04 18:39:07 +08:00
|
|
|
struct kvm_pio_request {
|
|
|
|
unsigned long count;
|
|
|
|
int in;
|
|
|
|
int port;
|
|
|
|
int size;
|
|
|
|
};
|
|
|
|
|
2015-08-05 12:04:21 +08:00
|
|
|
struct rsvd_bits_validate {
|
|
|
|
u64 rsvd_bits_mask[2][4];
|
|
|
|
u64 bad_mt_xwr;
|
|
|
|
};
|
|
|
|
|
2007-12-14 09:41:22 +08:00
|
|
|
/*
|
|
|
|
* x86 supports 3 paging modes (4-level 64-bit, 3-level 64-bit, and 2-level
|
|
|
|
* 32-bit). The kvm_mmu structure abstracts the details of the current mmu
|
|
|
|
* mode.
|
|
|
|
*/
|
|
|
|
struct kvm_mmu {
|
2010-09-10 23:30:40 +08:00
|
|
|
void (*set_cr3)(struct kvm_vcpu *vcpu, unsigned long root);
|
2010-09-10 23:30:42 +08:00
|
|
|
unsigned long (*get_cr3)(struct kvm_vcpu *vcpu);
|
2011-07-28 16:36:17 +08:00
|
|
|
u64 (*get_pdptr)(struct kvm_vcpu *vcpu, int index);
|
2010-12-07 10:48:06 +08:00
|
|
|
int (*page_fault)(struct kvm_vcpu *vcpu, gva_t gva, u32 err,
|
|
|
|
bool prefault);
|
2010-11-29 22:12:30 +08:00
|
|
|
void (*inject_page_fault)(struct kvm_vcpu *vcpu,
|
|
|
|
struct x86_exception *fault);
|
2010-02-10 20:21:32 +08:00
|
|
|
gpa_t (*gva_to_gpa)(struct kvm_vcpu *vcpu, gva_t gva, u32 access,
|
2010-11-22 23:53:26 +08:00
|
|
|
struct x86_exception *exception);
|
2014-09-02 19:23:06 +08:00
|
|
|
gpa_t (*translate_gpa)(struct kvm_vcpu *vcpu, gpa_t gpa, u32 access,
|
|
|
|
struct x86_exception *exception);
|
2008-09-24 00:18:33 +08:00
|
|
|
int (*sync_page)(struct kvm_vcpu *vcpu,
|
2010-11-19 17:04:03 +08:00
|
|
|
struct kvm_mmu_page *sp);
|
2008-09-24 00:18:35 +08:00
|
|
|
void (*invlpg)(struct kvm_vcpu *vcpu, gva_t gva);
|
2011-03-09 15:43:51 +08:00
|
|
|
void (*update_pte)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp,
|
2011-03-28 10:29:27 +08:00
|
|
|
u64 *spte, const void *pte);
|
2007-12-14 09:41:22 +08:00
|
|
|
hpa_t root_hpa;
|
|
|
|
int root_level;
|
|
|
|
int shadow_root_level;
|
2008-12-22 01:20:09 +08:00
|
|
|
union kvm_mmu_page_role base_role;
|
2010-09-10 23:30:39 +08:00
|
|
|
bool direct_map;
|
2007-12-14 09:41:22 +08:00
|
|
|
|
KVM: MMU: Optimize pte permission checks
walk_addr_generic() permission checks are a maze of branchy code, which is
performed four times per lookup. It depends on the type of access, efer.nxe,
cr0.wp, cr4.smep, and in the near future, cr4.smap.
Optimize this away by precalculating all variants and storing them in a
bitmap. The bitmap is recalculated when rarely-changing variables change
(cr0, cr4) and is indexed by the often-changing variables (page fault error
code, pte access permissions).
The permission check is moved to the end of the loop, otherwise an SMEP
fault could be reported as a false positive, when PDE.U=1 but PTE.U=0.
Noted by Xiao Guangrong.
The result is short, branch-free code.
Reviewed-by: Xiao Guangrong <xiaoguangrong@linux.vnet.ibm.com>
Signed-off-by: Avi Kivity <avi@redhat.com>
2012-09-12 19:52:00 +08:00
|
|
|
/*
|
|
|
|
* Bitmap; bit set = permission fault
|
|
|
|
* Byte index: page fault error code [4:1]
|
|
|
|
* Bit index: pte permissions in ACC_* format
|
|
|
|
*/
|
|
|
|
u8 permissions[16];
|
|
|
|
|
2016-03-22 16:51:19 +08:00
|
|
|
/*
|
|
|
|
* The pkru_mask indicates if protection key checks are needed. It
|
|
|
|
* consists of 16 domains indexed by page fault error code bits [4:1],
|
|
|
|
* with PFEC.RSVD replaced by ACC_USER_MASK from the page tables.
|
|
|
|
* Each domain has 2 bits which are ANDed with AD and WD from PKRU.
|
|
|
|
*/
|
|
|
|
u32 pkru_mask;
|
|
|
|
|
2007-12-14 09:41:22 +08:00
|
|
|
u64 *pae_root;
|
2010-09-10 23:31:00 +08:00
|
|
|
u64 *lm_root;
|
2015-08-05 12:04:24 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* check zero bits on shadow page table entries, these
|
|
|
|
* bits include not only hardware reserved bits but also
|
|
|
|
* the bits spte never used.
|
|
|
|
*/
|
|
|
|
struct rsvd_bits_validate shadow_zero_check;
|
|
|
|
|
2015-08-05 12:04:21 +08:00
|
|
|
struct rsvd_bits_validate guest_rsvd_check;
|
2010-09-10 23:30:57 +08:00
|
|
|
|
2016-02-23 19:51:19 +08:00
|
|
|
/* Can have large pages at levels 2..last_nonleaf_level-1. */
|
|
|
|
u8 last_nonleaf_level;
|
2012-09-13 01:46:56 +08:00
|
|
|
|
2010-09-10 23:31:01 +08:00
|
|
|
bool nx;
|
|
|
|
|
2010-09-10 23:30:57 +08:00
|
|
|
u64 pdptrs[4]; /* pae */
|
2007-12-14 09:41:22 +08:00
|
|
|
};
|
|
|
|
|
2011-11-10 20:57:22 +08:00
|
|
|
enum pmc_type {
|
|
|
|
KVM_PMC_GP = 0,
|
|
|
|
KVM_PMC_FIXED,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct kvm_pmc {
|
|
|
|
enum pmc_type type;
|
|
|
|
u8 idx;
|
|
|
|
u64 counter;
|
|
|
|
u64 eventsel;
|
|
|
|
struct perf_event *perf_event;
|
|
|
|
struct kvm_vcpu *vcpu;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct kvm_pmu {
|
|
|
|
unsigned nr_arch_gp_counters;
|
|
|
|
unsigned nr_arch_fixed_counters;
|
|
|
|
unsigned available_event_types;
|
|
|
|
u64 fixed_ctr_ctrl;
|
|
|
|
u64 global_ctrl;
|
|
|
|
u64 global_status;
|
|
|
|
u64 global_ovf_ctrl;
|
|
|
|
u64 counter_bitmask[2];
|
|
|
|
u64 global_ctrl_mask;
|
2013-07-19 06:57:02 +08:00
|
|
|
u64 reserved_bits;
|
2011-11-10 20:57:22 +08:00
|
|
|
u8 version;
|
2012-06-21 02:46:33 +08:00
|
|
|
struct kvm_pmc gp_counters[INTEL_PMC_MAX_GENERIC];
|
|
|
|
struct kvm_pmc fixed_counters[INTEL_PMC_MAX_FIXED];
|
2011-11-10 20:57:22 +08:00
|
|
|
struct irq_work irq_work;
|
|
|
|
u64 reprogram_pmi;
|
|
|
|
};
|
|
|
|
|
2015-06-19 21:45:05 +08:00
|
|
|
struct kvm_pmu_ops;
|
|
|
|
|
2014-02-21 16:55:56 +08:00
|
|
|
enum {
|
|
|
|
KVM_DEBUGREG_BP_ENABLED = 1,
|
2014-02-21 17:17:24 +08:00
|
|
|
KVM_DEBUGREG_WONT_EXIT = 2,
|
2015-04-02 08:10:37 +08:00
|
|
|
KVM_DEBUGREG_RELOAD = 4,
|
2014-02-21 16:55:56 +08:00
|
|
|
};
|
|
|
|
|
2015-06-15 16:55:27 +08:00
|
|
|
struct kvm_mtrr_range {
|
|
|
|
u64 base;
|
|
|
|
u64 mask;
|
2015-06-15 16:55:31 +08:00
|
|
|
struct list_head node;
|
2015-06-15 16:55:27 +08:00
|
|
|
};
|
|
|
|
|
2015-06-15 16:55:24 +08:00
|
|
|
struct kvm_mtrr {
|
2015-06-15 16:55:27 +08:00
|
|
|
struct kvm_mtrr_range var_ranges[KVM_NR_VAR_MTRR];
|
2015-06-15 16:55:24 +08:00
|
|
|
mtrr_type fixed_ranges[KVM_NR_FIXED_MTRR_REGION];
|
2015-06-15 16:55:26 +08:00
|
|
|
u64 deftype;
|
2015-06-15 16:55:31 +08:00
|
|
|
|
|
|
|
struct list_head head;
|
2015-06-15 16:55:24 +08:00
|
|
|
};
|
|
|
|
|
2015-12-01 00:22:21 +08:00
|
|
|
/* Hyper-V SynIC timer */
|
|
|
|
struct kvm_vcpu_hv_stimer {
|
|
|
|
struct hrtimer timer;
|
|
|
|
int index;
|
|
|
|
u64 config;
|
|
|
|
u64 count;
|
|
|
|
u64 exp_time;
|
|
|
|
struct hv_message msg;
|
|
|
|
bool msg_pending;
|
|
|
|
};
|
|
|
|
|
2015-11-10 20:36:34 +08:00
|
|
|
/* Hyper-V synthetic interrupt controller (SynIC)*/
|
|
|
|
struct kvm_vcpu_hv_synic {
|
|
|
|
u64 version;
|
|
|
|
u64 control;
|
|
|
|
u64 msg_page;
|
|
|
|
u64 evt_page;
|
|
|
|
atomic64_t sint[HV_SYNIC_SINT_COUNT];
|
|
|
|
atomic_t sint_to_gsi[HV_SYNIC_SINT_COUNT];
|
|
|
|
DECLARE_BITMAP(auto_eoi_bitmap, 256);
|
|
|
|
DECLARE_BITMAP(vec_bitmap, 256);
|
|
|
|
bool active;
|
|
|
|
};
|
|
|
|
|
2015-07-03 20:01:34 +08:00
|
|
|
/* Hyper-V per vcpu emulation context */
|
|
|
|
struct kvm_vcpu_hv {
|
|
|
|
u64 hv_vapic;
|
2015-09-16 17:29:50 +08:00
|
|
|
s64 runtime_offset;
|
2015-11-10 20:36:34 +08:00
|
|
|
struct kvm_vcpu_hv_synic synic;
|
2015-11-10 20:36:35 +08:00
|
|
|
struct kvm_hyperv_exit exit;
|
2015-12-01 00:22:21 +08:00
|
|
|
struct kvm_vcpu_hv_stimer stimer[HV_SYNIC_STIMER_COUNT];
|
|
|
|
DECLARE_BITMAP(stimer_pending_bitmap, HV_SYNIC_STIMER_COUNT);
|
2015-07-03 20:01:34 +08:00
|
|
|
};
|
|
|
|
|
2007-12-13 23:50:52 +08:00
|
|
|
struct kvm_vcpu_arch {
|
2008-06-28 01:58:02 +08:00
|
|
|
/*
|
|
|
|
* rip and regs accesses must go through
|
|
|
|
* kvm_{register,rip}_{read,write} functions.
|
|
|
|
*/
|
|
|
|
unsigned long regs[NR_VCPU_REGS];
|
|
|
|
u32 regs_avail;
|
|
|
|
u32 regs_dirty;
|
2007-10-20 15:34:38 +08:00
|
|
|
|
|
|
|
unsigned long cr0;
|
2009-12-30 00:43:06 +08:00
|
|
|
unsigned long cr0_guest_owned_bits;
|
2007-10-20 15:34:38 +08:00
|
|
|
unsigned long cr2;
|
|
|
|
unsigned long cr3;
|
|
|
|
unsigned long cr4;
|
2009-12-07 18:16:48 +08:00
|
|
|
unsigned long cr4_guest_owned_bits;
|
2007-10-20 15:34:38 +08:00
|
|
|
unsigned long cr8;
|
2008-11-26 03:17:04 +08:00
|
|
|
u32 hflags;
|
2010-01-21 21:31:50 +08:00
|
|
|
u64 efer;
|
2007-10-20 15:34:38 +08:00
|
|
|
u64 apic_base;
|
|
|
|
struct kvm_lapic *apic; /* kernel irqchip context */
|
2015-11-10 20:36:33 +08:00
|
|
|
bool apicv_active;
|
2015-11-10 20:36:32 +08:00
|
|
|
DECLARE_BITMAP(ioapic_handled_vectors, 256);
|
2012-04-19 19:06:29 +08:00
|
|
|
unsigned long apic_attention;
|
2009-03-05 22:34:59 +08:00
|
|
|
int32_t apic_arb_prio;
|
2007-10-20 15:34:38 +08:00
|
|
|
int mp_state;
|
|
|
|
u64 ia32_misc_enable_msr;
|
2015-05-07 17:36:11 +08:00
|
|
|
u64 smbase;
|
2007-10-22 22:50:39 +08:00
|
|
|
bool tpr_access_reporting;
|
2014-12-02 19:14:59 +08:00
|
|
|
u64 ia32_xss;
|
2007-10-20 15:34:38 +08:00
|
|
|
|
2010-09-10 23:30:49 +08:00
|
|
|
/*
|
|
|
|
* Paging state of the vcpu
|
|
|
|
*
|
|
|
|
* If the vcpu runs in guest mode with two level paging this still saves
|
|
|
|
* the paging mode of the l1 guest. This context is always used to
|
|
|
|
* handle faults.
|
|
|
|
*/
|
2007-10-20 15:34:38 +08:00
|
|
|
struct kvm_mmu mmu;
|
2010-09-10 23:30:46 +08:00
|
|
|
|
2010-09-10 23:30:50 +08:00
|
|
|
/*
|
|
|
|
* Paging state of an L2 guest (used for nested npt)
|
|
|
|
*
|
|
|
|
* This context will save all necessary information to walk page tables
|
|
|
|
* of the an L2 guest. This context is only initialized for page table
|
|
|
|
* walking and not for faulting since we never handle l2 page faults on
|
|
|
|
* the host.
|
|
|
|
*/
|
|
|
|
struct kvm_mmu nested_mmu;
|
|
|
|
|
2010-09-10 23:30:49 +08:00
|
|
|
/*
|
|
|
|
* Pointer to the mmu context currently used for
|
|
|
|
* gva_to_gpa translations.
|
|
|
|
*/
|
|
|
|
struct kvm_mmu *walk_mmu;
|
|
|
|
|
2011-05-15 23:26:20 +08:00
|
|
|
struct kvm_mmu_memory_cache mmu_pte_list_desc_cache;
|
2007-10-20 15:34:38 +08:00
|
|
|
struct kvm_mmu_memory_cache mmu_page_cache;
|
|
|
|
struct kvm_mmu_memory_cache mmu_page_header_cache;
|
|
|
|
|
2010-05-17 17:08:28 +08:00
|
|
|
struct fpu guest_fpu;
|
2010-06-10 11:27:12 +08:00
|
|
|
u64 xcr0;
|
2013-10-02 22:06:15 +08:00
|
|
|
u64 guest_supported_xcr0;
|
2013-10-02 22:06:16 +08:00
|
|
|
u32 guest_xstate_size;
|
2007-10-20 15:34:38 +08:00
|
|
|
|
|
|
|
struct kvm_pio_request pio;
|
|
|
|
void *pio_data;
|
|
|
|
|
2009-05-11 18:35:50 +08:00
|
|
|
u8 event_exit_inst_len;
|
|
|
|
|
2007-11-25 19:41:11 +08:00
|
|
|
struct kvm_queued_exception {
|
|
|
|
bool pending;
|
|
|
|
bool has_error_code;
|
2010-04-22 18:33:13 +08:00
|
|
|
bool reinject;
|
2007-11-25 19:41:11 +08:00
|
|
|
u8 nr;
|
|
|
|
u32 error_code;
|
|
|
|
} exception;
|
|
|
|
|
2008-07-03 20:17:01 +08:00
|
|
|
struct kvm_queued_interrupt {
|
|
|
|
bool pending;
|
2009-05-11 18:35:50 +08:00
|
|
|
bool soft;
|
2008-07-03 20:17:01 +08:00
|
|
|
u8 nr;
|
|
|
|
} interrupt;
|
|
|
|
|
2007-10-20 15:34:38 +08:00
|
|
|
int halt_request; /* real mode on Intel only */
|
|
|
|
|
|
|
|
int cpuid_nent;
|
2007-11-21 23:10:04 +08:00
|
|
|
struct kvm_cpuid_entry2 cpuid_entries[KVM_MAX_CPUID_ENTRIES];
|
2015-03-30 04:56:12 +08:00
|
|
|
|
|
|
|
int maxphyaddr;
|
|
|
|
|
2007-10-20 15:34:38 +08:00
|
|
|
/* emulate context */
|
|
|
|
|
|
|
|
struct x86_emulate_ctxt emulate_ctxt;
|
2011-03-31 18:06:41 +08:00
|
|
|
bool emulate_regs_need_sync_to_vcpu;
|
|
|
|
bool emulate_regs_need_sync_from_vcpu;
|
2012-09-03 20:24:26 +08:00
|
|
|
int (*complete_userspace_io)(struct kvm_vcpu *vcpu);
|
2008-02-16 03:52:47 +08:00
|
|
|
|
|
|
|
gpa_t time;
|
2008-06-03 22:17:31 +08:00
|
|
|
struct pvclock_vcpu_time_info hv_clock;
|
2010-08-20 16:07:23 +08:00
|
|
|
unsigned int hw_tsc_khz;
|
2013-02-21 06:48:10 +08:00
|
|
|
struct gfn_to_hva_cache pv_time;
|
|
|
|
bool pv_time_enabled;
|
2012-08-04 02:57:49 +08:00
|
|
|
/* set guest stopped flag in pvclock flags field */
|
|
|
|
bool pvclock_set_guest_stopped_request;
|
2011-07-12 03:28:14 +08:00
|
|
|
|
|
|
|
struct {
|
|
|
|
u64 msr_val;
|
|
|
|
u64 last_steal;
|
|
|
|
struct gfn_to_hva_cache stime;
|
|
|
|
struct kvm_steal_time steal;
|
|
|
|
} st;
|
|
|
|
|
2010-08-20 16:07:30 +08:00
|
|
|
u64 last_guest_tsc;
|
2012-02-04 01:43:54 +08:00
|
|
|
u64 last_host_tsc;
|
2012-02-04 01:43:56 +08:00
|
|
|
u64 tsc_offset_adjustment;
|
2012-02-04 01:43:57 +08:00
|
|
|
u64 this_tsc_nsec;
|
|
|
|
u64 this_tsc_write;
|
2014-06-24 15:42:43 +08:00
|
|
|
u64 this_tsc_generation;
|
2010-09-19 08:38:15 +08:00
|
|
|
bool tsc_catchup;
|
KVM: Infrastructure for software and hardware based TSC rate scaling
This requires some restructuring; rather than use 'virtual_tsc_khz'
to indicate whether hardware rate scaling is in effect, we consider
each VCPU to always have a virtual TSC rate. Instead, there is new
logic above the vendor-specific hardware scaling that decides whether
it is even necessary to use and updates all rate variables used by
common code. This means we can simply query the virtual rate at
any point, which is needed for software rate scaling.
There is also now a threshold added to the TSC rate scaling; minor
differences and variations of measured TSC rate can accidentally
provoke rate scaling to be used when it is not needed. Instead,
we have a tolerance variable called tsc_tolerance_ppm, which is
the maximum variation from user requested rate at which scaling
will be used. The default is 250ppm, which is the half the
threshold for NTP adjustment, allowing for some hardware variation.
In the event that hardware rate scaling is not available, we can
kludge a bit by forcing TSC catchup to turn on when a faster than
hardware speed has been requested, but there is nothing available
yet for the reverse case; this requires a trap and emulate software
implementation for RDTSC, which is still forthcoming.
[avi: fix 64-bit division on i386]
Signed-off-by: Zachary Amsden <zamsden@gmail.com>
Signed-off-by: Marcelo Tosatti <mtosatti@redhat.com>
Signed-off-by: Avi Kivity <avi@redhat.com>
2012-02-04 01:43:50 +08:00
|
|
|
bool tsc_always_catchup;
|
|
|
|
s8 virtual_tsc_shift;
|
|
|
|
u32 virtual_tsc_mult;
|
|
|
|
u32 virtual_tsc_khz;
|
2012-11-30 04:42:50 +08:00
|
|
|
s64 ia32_tsc_adjust_msr;
|
2015-10-20 15:39:02 +08:00
|
|
|
u64 tsc_scaling_ratio;
|
2008-05-15 09:52:48 +08:00
|
|
|
|
2011-09-20 18:43:14 +08:00
|
|
|
atomic_t nmi_queued; /* unprocessed asynchronous NMIs */
|
|
|
|
unsigned nmi_pending; /* NMI queued after currently running handler */
|
|
|
|
bool nmi_injected; /* Trying to inject an NMI this entry */
|
2015-04-01 21:06:40 +08:00
|
|
|
bool smi_pending; /* SMI queued after currently running handler */
|
2008-05-27 01:06:35 +08:00
|
|
|
|
2015-06-15 16:55:24 +08:00
|
|
|
struct kvm_mtrr mtrr_state;
|
2014-06-19 17:40:18 +08:00
|
|
|
u64 pat;
|
2008-12-15 20:52:10 +08:00
|
|
|
|
2014-02-21 16:55:56 +08:00
|
|
|
unsigned switch_db_regs;
|
2008-12-15 20:52:10 +08:00
|
|
|
unsigned long db[KVM_NR_DB_REGS];
|
|
|
|
unsigned long dr6;
|
|
|
|
unsigned long dr7;
|
|
|
|
unsigned long eff_db[KVM_NR_DB_REGS];
|
2012-09-21 11:42:55 +08:00
|
|
|
unsigned long guest_debug_dr7;
|
2009-05-11 16:48:15 +08:00
|
|
|
|
|
|
|
u64 mcg_cap;
|
|
|
|
u64 mcg_status;
|
|
|
|
u64 mcg_ctl;
|
2016-06-22 14:59:56 +08:00
|
|
|
u64 mcg_ext_ctl;
|
2009-05-11 16:48:15 +08:00
|
|
|
u64 *mce_banks;
|
2009-10-18 19:24:44 +08:00
|
|
|
|
2011-07-12 03:23:20 +08:00
|
|
|
/* Cache MMIO info */
|
|
|
|
u64 mmio_gva;
|
|
|
|
unsigned access;
|
|
|
|
gfn_t mmio_gfn;
|
2014-08-19 06:46:07 +08:00
|
|
|
u64 mmio_gen;
|
2011-07-12 03:23:20 +08:00
|
|
|
|
2011-11-10 20:57:22 +08:00
|
|
|
struct kvm_pmu pmu;
|
|
|
|
|
2009-10-18 19:24:44 +08:00
|
|
|
/* used for guest single stepping over the given code position */
|
|
|
|
unsigned long singlestep_rip;
|
2010-02-24 00:47:55 +08:00
|
|
|
|
2015-07-03 20:01:34 +08:00
|
|
|
struct kvm_vcpu_hv hyperv;
|
2010-06-30 12:25:15 +08:00
|
|
|
|
|
|
|
cpumask_var_t wbinvd_dirty_mask;
|
2010-10-14 17:22:46 +08:00
|
|
|
|
2011-09-22 17:02:48 +08:00
|
|
|
unsigned long last_retry_eip;
|
|
|
|
unsigned long last_retry_addr;
|
|
|
|
|
2010-10-14 17:22:46 +08:00
|
|
|
struct {
|
|
|
|
bool halted;
|
|
|
|
gfn_t gfns[roundup_pow_of_two(ASYNC_PF_PER_VCPU)];
|
2010-10-14 17:22:50 +08:00
|
|
|
struct gfn_to_hva_cache data;
|
|
|
|
u64 msr_val;
|
2010-10-14 17:22:53 +08:00
|
|
|
u32 id;
|
2010-10-14 17:22:55 +08:00
|
|
|
bool send_user_only;
|
2010-10-14 17:22:46 +08:00
|
|
|
} apf;
|
2012-01-10 03:00:35 +08:00
|
|
|
|
|
|
|
/* OSVW MSRs (AMD only) */
|
|
|
|
struct {
|
|
|
|
u64 length;
|
|
|
|
u64 status;
|
|
|
|
} osvw;
|
2012-06-25 00:25:07 +08:00
|
|
|
|
|
|
|
struct {
|
|
|
|
u64 msr_val;
|
|
|
|
struct gfn_to_hva_cache data;
|
|
|
|
} pv_eoi;
|
2013-01-13 23:49:07 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Indicate whether the access faults on its page table in guest
|
|
|
|
* which is set when fix page fault and used to detect unhandeable
|
|
|
|
* instruction.
|
|
|
|
*/
|
|
|
|
bool write_fault_to_shadow_pgtable;
|
2013-08-06 17:00:32 +08:00
|
|
|
|
|
|
|
/* set at EPT violation at this point */
|
|
|
|
unsigned long exit_qualification;
|
2013-08-26 16:48:34 +08:00
|
|
|
|
|
|
|
/* pv related host specific info */
|
|
|
|
struct {
|
|
|
|
bool pv_unhalted;
|
|
|
|
} pv;
|
2015-07-30 14:21:41 +08:00
|
|
|
|
|
|
|
int pending_ioapic_eoi;
|
KVM: x86: Add support for local interrupt requests from userspace
In order to enable userspace PIC support, the userspace PIC needs to
be able to inject local interrupts even when the APICs are in the
kernel.
KVM_INTERRUPT now supports sending local interrupts to an APIC when
APICs are in the kernel.
The ready_for_interrupt_request flag is now only set when the CPU/APIC
will immediately accept and inject an interrupt (i.e. APIC has not
masked the PIC).
When the PIC wishes to initiate an INTA cycle with, say, CPU0, it
kicks CPU0 out of the guest, and renedezvous with CPU0 once it arrives
in userspace.
When the CPU/APIC unmasks the PIC, a KVM_EXIT_IRQ_WINDOW_OPEN is
triggered, so that userspace has a chance to inject a PIC interrupt
if it had been pending.
Overall, this design can lead to a small number of spurious userspace
renedezvous. In particular, whenever the PIC transistions from low to
high while it is masked and whenever the PIC becomes unmasked while
it is low.
Note: this does not buffer more than one local interrupt in the
kernel, so the VMM needs to enter the guest in order to complete
interrupt injection before injecting an additional interrupt.
Compiles for x86.
Can pass the KVM Unit Tests.
Signed-off-by: Steve Rutherford <srutherford@google.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-07-30 17:27:16 +08:00
|
|
|
int pending_external_vector;
|
2007-10-20 15:34:38 +08:00
|
|
|
};
|
|
|
|
|
2012-02-08 12:02:18 +08:00
|
|
|
struct kvm_lpage_info {
|
2016-02-24 17:51:06 +08:00
|
|
|
int disallow_lpage;
|
2012-02-08 12:02:18 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct kvm_arch_memory_slot {
|
2015-11-20 16:41:28 +08:00
|
|
|
struct kvm_rmap_head *rmap[KVM_NR_PAGE_SIZES];
|
2012-02-08 12:02:18 +08:00
|
|
|
struct kvm_lpage_info *lpage_info[KVM_NR_PAGE_SIZES - 1];
|
KVM: page track: add the framework of guest page tracking
The array, gfn_track[mode][gfn], is introduced in memory slot for every
guest page, this is the tracking count for the gust page on different
modes. If the page is tracked then the count is increased, the page is
not tracked after the count reaches zero
We use 'unsigned short' as the tracking count which should be enough as
shadow page table only can use 2^14 (2^3 for level, 2^1 for cr4_pae, 2^2
for quadrant, 2^3 for access, 2^1 for nxe, 2^1 for cr0_wp, 2^1 for
smep_andnot_wp, 2^1 for smap_andnot_wp, and 2^1 for smm) at most, there
is enough room for other trackers
Two callbacks, kvm_page_track_create_memslot() and
kvm_page_track_free_memslot() are implemented in this patch, they are
internally used to initialize and reclaim the memory of the array
Currently, only write track mode is supported
Signed-off-by: Xiao Guangrong <guangrong.xiao@linux.intel.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-02-24 17:51:09 +08:00
|
|
|
unsigned short *gfn_track[KVM_PAGE_TRACK_MAX];
|
2012-02-08 12:02:18 +08:00
|
|
|
};
|
|
|
|
|
2015-02-13 02:41:33 +08:00
|
|
|
/*
|
|
|
|
* We use as the mode the number of bits allocated in the LDR for the
|
|
|
|
* logical processor ID. It happens that these are all powers of two.
|
|
|
|
* This makes it is very easy to detect cases where the APICs are
|
|
|
|
* configured for multiple modes; in that case, we cannot use the map and
|
|
|
|
* hence cannot use kvm_irq_delivery_to_apic_fast either.
|
|
|
|
*/
|
|
|
|
#define KVM_APIC_MODE_XAPIC_CLUSTER 4
|
|
|
|
#define KVM_APIC_MODE_XAPIC_FLAT 8
|
|
|
|
#define KVM_APIC_MODE_X2APIC 16
|
|
|
|
|
2012-09-13 22:19:24 +08:00
|
|
|
struct kvm_apic_map {
|
|
|
|
struct rcu_head rcu;
|
2015-02-13 02:41:33 +08:00
|
|
|
u8 mode;
|
2016-07-13 04:09:20 +08:00
|
|
|
u32 max_apic_id;
|
2016-07-13 04:09:19 +08:00
|
|
|
union {
|
|
|
|
struct kvm_lapic *xapic_flat_map[8];
|
|
|
|
struct kvm_lapic *xapic_cluster_map[16][4];
|
|
|
|
};
|
2016-07-13 04:09:20 +08:00
|
|
|
struct kvm_lapic *phys_map[];
|
2012-09-13 22:19:24 +08:00
|
|
|
};
|
|
|
|
|
2015-07-03 20:01:34 +08:00
|
|
|
/* Hyper-V emulation context */
|
|
|
|
struct kvm_hv {
|
|
|
|
u64 hv_guest_os_id;
|
|
|
|
u64 hv_hypercall;
|
|
|
|
u64 hv_tsc_page;
|
2015-07-03 20:01:37 +08:00
|
|
|
|
|
|
|
/* Hyper-v based guest crash (NT kernel bugcheck) parameters */
|
|
|
|
u64 hv_crash_param[HV_X64_MSR_CRASH_PARAMS];
|
|
|
|
u64 hv_crash_ctl;
|
2015-07-03 20:01:34 +08:00
|
|
|
};
|
|
|
|
|
2009-12-24 00:35:17 +08:00
|
|
|
struct kvm_arch {
|
2010-08-20 09:11:28 +08:00
|
|
|
unsigned int n_used_mmu_pages;
|
2007-12-14 10:01:48 +08:00
|
|
|
unsigned int n_requested_mmu_pages;
|
2010-08-20 09:11:14 +08:00
|
|
|
unsigned int n_max_mmu_pages;
|
2011-05-15 23:20:27 +08:00
|
|
|
unsigned int indirect_shadow_pages;
|
2013-05-31 08:36:22 +08:00
|
|
|
unsigned long mmu_valid_gen;
|
2007-12-14 10:01:48 +08:00
|
|
|
struct hlist_head mmu_page_hash[KVM_NUM_MMU_PAGES];
|
|
|
|
/*
|
|
|
|
* Hash table of struct kvm_mmu_page.
|
|
|
|
*/
|
|
|
|
struct list_head active_mmu_pages;
|
2013-05-31 08:36:29 +08:00
|
|
|
struct list_head zapped_obsolete_pages;
|
2016-02-24 17:51:16 +08:00
|
|
|
struct kvm_page_track_notifier_node mmu_sp_tracker;
|
2016-02-24 17:51:13 +08:00
|
|
|
struct kvm_page_track_notifier_head track_notifier_head;
|
2013-05-31 08:36:29 +08:00
|
|
|
|
2008-07-29 00:26:26 +08:00
|
|
|
struct list_head assigned_dev_head;
|
2008-12-03 21:43:34 +08:00
|
|
|
struct iommu_domain *iommu_domain;
|
2013-10-31 01:02:23 +08:00
|
|
|
bool iommu_noncoherent;
|
2013-10-31 01:02:30 +08:00
|
|
|
#define __KVM_HAVE_ARCH_NONCOHERENT_DMA
|
|
|
|
atomic_t noncoherent_dma_count;
|
2015-07-07 21:41:58 +08:00
|
|
|
#define __KVM_HAVE_ARCH_ASSIGNED_DEVICE
|
|
|
|
atomic_t assigned_device_count;
|
2007-12-14 10:17:34 +08:00
|
|
|
struct kvm_pic *vpic;
|
|
|
|
struct kvm_ioapic *vioapic;
|
2008-01-28 05:10:22 +08:00
|
|
|
struct kvm_pit *vpit;
|
2015-07-01 21:31:49 +08:00
|
|
|
atomic_t vapics_in_nmi_mode;
|
2012-09-13 22:19:24 +08:00
|
|
|
struct mutex apic_map_lock;
|
|
|
|
struct kvm_apic_map *apic_map;
|
2007-12-14 10:20:16 +08:00
|
|
|
|
|
|
|
unsigned int tss_addr;
|
2014-09-24 15:57:58 +08:00
|
|
|
bool apic_access_page_done;
|
2008-02-16 03:52:47 +08:00
|
|
|
|
|
|
|
gpa_t wall_clock;
|
2008-04-25 21:44:52 +08:00
|
|
|
|
|
|
|
bool ept_identity_pagetable_done;
|
2009-07-21 10:42:48 +08:00
|
|
|
gpa_t ept_identity_map_addr;
|
2008-10-15 20:15:06 +08:00
|
|
|
|
|
|
|
unsigned long irq_sources_bitmap;
|
2009-10-17 03:28:36 +08:00
|
|
|
s64 kvmclock_offset;
|
2011-02-04 17:49:11 +08:00
|
|
|
raw_spinlock_t tsc_write_lock;
|
2010-08-20 16:07:20 +08:00
|
|
|
u64 last_tsc_nsec;
|
|
|
|
u64 last_tsc_write;
|
KVM: Improve TSC offset matching
There are a few improvements that can be made to the TSC offset
matching code. First, we don't need to call the 128-bit multiply
(especially on a constant number), the code works much nicer to
do computation in nanosecond units.
Second, the way everything is setup with software TSC rate scaling,
we currently have per-cpu rates. Obviously this isn't too desirable
to use in practice, but if for some reason we do change the rate of
all VCPUs at runtime, then reset the TSCs, we will only want to
match offsets for VCPUs running at the same rate.
Finally, for the case where we have an unstable host TSC, but
rate scaling is being done in hardware, we should call the platform
code to compute the TSC offset, so the math is reorganized to recompute
the base instead, then transform the base into an offset using the
existing API.
[avi: fix 64-bit division on i386]
Signed-off-by: Zachary Amsden <zamsden@gmail.com>
Signed-off-by: Marcelo Tosatti <mtosatti@redhat.com>
KVM: Fix 64-bit division in kvm_write_tsc()
Breaks i386 build.
Signed-off-by: Avi Kivity <avi@redhat.com>
2012-02-04 01:43:51 +08:00
|
|
|
u32 last_tsc_khz;
|
2012-02-04 01:43:57 +08:00
|
|
|
u64 cur_tsc_nsec;
|
|
|
|
u64 cur_tsc_write;
|
|
|
|
u64 cur_tsc_offset;
|
2014-06-24 15:42:43 +08:00
|
|
|
u64 cur_tsc_generation;
|
2012-11-28 09:29:03 +08:00
|
|
|
int nr_vcpus_matched_tsc;
|
2009-10-16 06:21:43 +08:00
|
|
|
|
2012-11-28 09:29:01 +08:00
|
|
|
spinlock_t pvclock_gtod_sync_lock;
|
|
|
|
bool use_master_clock;
|
|
|
|
u64 master_kernel_ns;
|
|
|
|
cycle_t master_cycle_now;
|
2014-02-28 19:52:54 +08:00
|
|
|
struct delayed_work kvmclock_update_work;
|
2014-02-28 19:52:55 +08:00
|
|
|
struct delayed_work kvmclock_sync_work;
|
2012-11-28 09:29:01 +08:00
|
|
|
|
2009-10-16 06:21:43 +08:00
|
|
|
struct kvm_xen_hvm_config xen_hvm_config;
|
2010-01-17 21:51:22 +08:00
|
|
|
|
2014-11-20 20:45:31 +08:00
|
|
|
/* reads protected by irq_srcu, writes by irq_lock */
|
|
|
|
struct hlist_head mask_notifier_list;
|
|
|
|
|
2015-07-03 20:01:34 +08:00
|
|
|
struct kvm_hv hyperv;
|
2010-12-23 16:08:35 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_KVM_MMU_AUDIT
|
|
|
|
int audit_point;
|
|
|
|
#endif
|
2015-01-21 01:54:52 +08:00
|
|
|
|
|
|
|
bool boot_vcpu_runs_old_kvmclock;
|
2015-07-29 17:56:48 +08:00
|
|
|
u32 bsp_vcpu_id;
|
2015-04-13 06:53:41 +08:00
|
|
|
|
|
|
|
u64 disabled_quirks;
|
2015-07-30 14:21:40 +08:00
|
|
|
|
|
|
|
bool irqchip_split;
|
2015-07-30 14:32:35 +08:00
|
|
|
u8 nr_reserved_ioapic_pins;
|
2016-01-25 16:53:33 +08:00
|
|
|
|
|
|
|
bool disabled_lapic_found;
|
2016-05-05 03:09:46 +08:00
|
|
|
|
|
|
|
/* Struct members for AVIC */
|
2016-05-05 03:09:48 +08:00
|
|
|
u32 ldr_mode;
|
2016-05-05 03:09:46 +08:00
|
|
|
struct page *avic_logical_id_table_page;
|
|
|
|
struct page *avic_physical_id_table_page;
|
2016-07-13 04:09:27 +08:00
|
|
|
|
|
|
|
bool x2apic_format;
|
2016-07-13 04:09:28 +08:00
|
|
|
bool x2apic_broadcast_quirk_disabled;
|
2007-12-14 09:54:20 +08:00
|
|
|
};
|
|
|
|
|
2007-12-14 10:23:23 +08:00
|
|
|
struct kvm_vm_stat {
|
|
|
|
u32 mmu_shadow_zapped;
|
|
|
|
u32 mmu_pte_write;
|
|
|
|
u32 mmu_pte_updated;
|
|
|
|
u32 mmu_pde_zapped;
|
|
|
|
u32 mmu_flooded;
|
|
|
|
u32 mmu_recycled;
|
2007-12-19 01:47:18 +08:00
|
|
|
u32 mmu_cache_miss;
|
2008-09-24 00:18:39 +08:00
|
|
|
u32 mmu_unsync;
|
2007-12-14 10:23:23 +08:00
|
|
|
u32 remote_tlb_flush;
|
2008-02-23 22:44:30 +08:00
|
|
|
u32 lpages;
|
2007-12-14 10:23:23 +08:00
|
|
|
};
|
|
|
|
|
2007-12-14 09:49:26 +08:00
|
|
|
struct kvm_vcpu_stat {
|
|
|
|
u32 pf_fixed;
|
|
|
|
u32 pf_guest;
|
|
|
|
u32 tlb_flush;
|
|
|
|
u32 invlpg;
|
|
|
|
|
|
|
|
u32 exits;
|
|
|
|
u32 io_exits;
|
|
|
|
u32 mmio_exits;
|
|
|
|
u32 signal_exits;
|
|
|
|
u32 irq_window_exits;
|
2008-05-15 18:23:25 +08:00
|
|
|
u32 nmi_window_exits;
|
2007-12-14 09:49:26 +08:00
|
|
|
u32 halt_exits;
|
kvm: add halt_poll_ns module parameter
This patch introduces a new module parameter for the KVM module; when it
is present, KVM attempts a bit of polling on every HLT before scheduling
itself out via kvm_vcpu_block.
This parameter helps a lot for latency-bound workloads---in particular
I tested it with O_DSYNC writes with a battery-backed disk in the host.
In this case, writes are fast (because the data doesn't have to go all
the way to the platters) but they cannot be merged by either the host or
the guest. KVM's performance here is usually around 30% of bare metal,
or 50% if you use cache=directsync or cache=writethrough (these
parameters avoid that the guest sends pointless flush requests, and
at the same time they are not slow because of the battery-backed cache).
The bad performance happens because on every halt the host CPU decides
to halt itself too. When the interrupt comes, the vCPU thread is then
migrated to a new physical CPU, and in general the latency is horrible
because the vCPU thread has to be scheduled back in.
With this patch performance reaches 60-65% of bare metal and, more
important, 99% of what you get if you use idle=poll in the guest. This
means that the tunable gets rid of this particular bottleneck, and more
work can be done to improve performance in the kernel or QEMU.
Of course there is some price to pay; every time an otherwise idle vCPUs
is interrupted by an interrupt, it will poll unnecessarily and thus
impose a little load on the host. The above results were obtained with
a mostly random value of the parameter (500000), and the load was around
1.5-2.5% CPU usage on one of the host's core for each idle guest vCPU.
The patch also adds a new stat, /sys/kernel/debug/kvm/halt_successful_poll,
that can be used to tune the parameter. It counts how many HLT
instructions received an interrupt during the polling period; each
successful poll avoids that Linux schedules the VCPU thread out and back
in, and may also avoid a likely trip to C1 and back for the physical CPU.
While the VM is idle, a Linux 4 VCPU VM halts around 10 times per second.
Of these halts, almost all are failed polls. During the benchmark,
instead, basically all halts end within the polling period, except a more
or less constant stream of 50 per second coming from vCPUs that are not
running the benchmark. The wasted time is thus very low. Things may
be slightly different for Windows VMs, which have a ~10 ms timer tick.
The effect is also visible on Marcelo's recently-introduced latency
test for the TSC deadline timer. Though of course a non-RT kernel has
awful latency bounds, the latency of the timer is around 8000-10000 clock
cycles compared to 20000-120000 without setting halt_poll_ns. For the TSC
deadline timer, thus, the effect is both a smaller average latency and
a smaller variance.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-02-05 01:20:58 +08:00
|
|
|
u32 halt_successful_poll;
|
2015-09-16 00:27:57 +08:00
|
|
|
u32 halt_attempted_poll;
|
2016-05-13 18:16:35 +08:00
|
|
|
u32 halt_poll_invalid;
|
2007-12-14 09:49:26 +08:00
|
|
|
u32 halt_wakeup;
|
|
|
|
u32 request_irq_exits;
|
|
|
|
u32 irq_exits;
|
|
|
|
u32 host_state_reload;
|
|
|
|
u32 efer_reload;
|
|
|
|
u32 fpu_reload;
|
|
|
|
u32 insn_emulation;
|
|
|
|
u32 insn_emulation_fail;
|
2008-02-21 03:30:30 +08:00
|
|
|
u32 hypercalls;
|
2008-09-01 20:57:51 +08:00
|
|
|
u32 irq_injections;
|
2008-09-26 15:30:55 +08:00
|
|
|
u32 nmi_injections;
|
2007-12-14 09:49:26 +08:00
|
|
|
};
|
2007-12-13 23:50:52 +08:00
|
|
|
|
2011-04-04 18:39:27 +08:00
|
|
|
struct x86_instruction_info;
|
|
|
|
|
2012-11-30 04:42:12 +08:00
|
|
|
struct msr_data {
|
|
|
|
bool host_initiated;
|
|
|
|
u32 index;
|
|
|
|
u64 data;
|
|
|
|
};
|
|
|
|
|
2014-12-18 01:17:20 +08:00
|
|
|
struct kvm_lapic_irq {
|
|
|
|
u32 vector;
|
2015-04-21 20:57:05 +08:00
|
|
|
u16 delivery_mode;
|
|
|
|
u16 dest_mode;
|
|
|
|
bool level;
|
|
|
|
u16 trig_mode;
|
2014-12-18 01:17:20 +08:00
|
|
|
u32 shorthand;
|
|
|
|
u32 dest_id;
|
2015-03-19 09:26:03 +08:00
|
|
|
bool msi_redir_hint;
|
2014-12-18 01:17:20 +08:00
|
|
|
};
|
|
|
|
|
2007-11-19 14:40:47 +08:00
|
|
|
struct kvm_x86_ops {
|
|
|
|
int (*cpu_has_kvm_support)(void); /* __init */
|
|
|
|
int (*disabled_by_bios)(void); /* __init */
|
2014-08-28 21:13:03 +08:00
|
|
|
int (*hardware_enable)(void);
|
|
|
|
void (*hardware_disable)(void);
|
2007-11-19 14:40:47 +08:00
|
|
|
void (*check_processor_compatibility)(void *rtn);
|
|
|
|
int (*hardware_setup)(void); /* __init */
|
|
|
|
void (*hardware_unsetup)(void); /* __exit */
|
2007-12-26 19:57:04 +08:00
|
|
|
bool (*cpu_has_accelerated_tpr)(void);
|
2015-04-01 20:25:33 +08:00
|
|
|
bool (*cpu_has_high_real_mode_segbase)(void);
|
2009-12-18 16:48:46 +08:00
|
|
|
void (*cpuid_update)(struct kvm_vcpu *vcpu);
|
2007-11-19 14:40:47 +08:00
|
|
|
|
2016-05-05 03:09:42 +08:00
|
|
|
int (*vm_init)(struct kvm *kvm);
|
|
|
|
void (*vm_destroy)(struct kvm *kvm);
|
|
|
|
|
2007-11-19 14:40:47 +08:00
|
|
|
/* Create, but do not attach this VCPU */
|
|
|
|
struct kvm_vcpu *(*vcpu_create)(struct kvm *kvm, unsigned id);
|
|
|
|
void (*vcpu_free)(struct kvm_vcpu *vcpu);
|
KVM: x86: INIT and reset sequences are different
x86 architecture defines differences between the reset and INIT sequences.
INIT does not initialize the FPU (including MMX, XMM, YMM, etc.), TSC, PMU,
MSRs (in general), MTRRs machine-check, APIC ID, APIC arbitration ID and BSP.
References (from Intel SDM):
"If the MP protocol has completed and a BSP is chosen, subsequent INITs (either
to a specific processor or system wide) do not cause the MP protocol to be
repeated." [8.4.2: MP Initialization Protocol Requirements and Restrictions]
[Table 9-1. IA-32 Processor States Following Power-up, Reset, or INIT]
"If the processor is reset by asserting the INIT# pin, the x87 FPU state is not
changed." [9.2: X87 FPU INITIALIZATION]
"The state of the local APIC following an INIT reset is the same as it is after
a power-up or hardware reset, except that the APIC ID and arbitration ID
registers are not affected." [10.4.7.3: Local APIC State After an INIT Reset
("Wait-for-SIPI" State)]
Signed-off-by: Nadav Amit <namit@cs.technion.ac.il>
Message-Id: <1428924848-28212-1-git-send-email-namit@cs.technion.ac.il>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-04-13 19:34:08 +08:00
|
|
|
void (*vcpu_reset)(struct kvm_vcpu *vcpu, bool init_event);
|
2007-11-19 14:40:47 +08:00
|
|
|
|
|
|
|
void (*prepare_guest_switch)(struct kvm_vcpu *vcpu);
|
|
|
|
void (*vcpu_load)(struct kvm_vcpu *vcpu, int cpu);
|
|
|
|
void (*vcpu_put)(struct kvm_vcpu *vcpu);
|
|
|
|
|
2015-11-10 18:55:36 +08:00
|
|
|
void (*update_bp_intercept)(struct kvm_vcpu *vcpu);
|
2015-04-08 21:30:38 +08:00
|
|
|
int (*get_msr)(struct kvm_vcpu *vcpu, struct msr_data *msr);
|
2012-11-30 04:42:12 +08:00
|
|
|
int (*set_msr)(struct kvm_vcpu *vcpu, struct msr_data *msr);
|
2007-11-19 14:40:47 +08:00
|
|
|
u64 (*get_segment_base)(struct kvm_vcpu *vcpu, int seg);
|
|
|
|
void (*get_segment)(struct kvm_vcpu *vcpu,
|
|
|
|
struct kvm_segment *var, int seg);
|
2008-03-25 01:38:34 +08:00
|
|
|
int (*get_cpl)(struct kvm_vcpu *vcpu);
|
2007-11-19 14:40:47 +08:00
|
|
|
void (*set_segment)(struct kvm_vcpu *vcpu,
|
|
|
|
struct kvm_segment *var, int seg);
|
|
|
|
void (*get_cs_db_l_bits)(struct kvm_vcpu *vcpu, int *db, int *l);
|
2009-12-30 00:43:06 +08:00
|
|
|
void (*decache_cr0_guest_bits)(struct kvm_vcpu *vcpu);
|
2010-12-06 00:56:11 +08:00
|
|
|
void (*decache_cr3)(struct kvm_vcpu *vcpu);
|
2007-11-19 14:40:47 +08:00
|
|
|
void (*decache_cr4_guest_bits)(struct kvm_vcpu *vcpu);
|
|
|
|
void (*set_cr0)(struct kvm_vcpu *vcpu, unsigned long cr0);
|
|
|
|
void (*set_cr3)(struct kvm_vcpu *vcpu, unsigned long cr3);
|
2011-05-26 04:03:24 +08:00
|
|
|
int (*set_cr4)(struct kvm_vcpu *vcpu, unsigned long cr4);
|
2007-11-19 14:40:47 +08:00
|
|
|
void (*set_efer)(struct kvm_vcpu *vcpu, u64 efer);
|
2010-02-16 16:51:48 +08:00
|
|
|
void (*get_idt)(struct kvm_vcpu *vcpu, struct desc_ptr *dt);
|
|
|
|
void (*set_idt)(struct kvm_vcpu *vcpu, struct desc_ptr *dt);
|
|
|
|
void (*get_gdt)(struct kvm_vcpu *vcpu, struct desc_ptr *dt);
|
|
|
|
void (*set_gdt)(struct kvm_vcpu *vcpu, struct desc_ptr *dt);
|
2014-01-05 01:47:16 +08:00
|
|
|
u64 (*get_dr6)(struct kvm_vcpu *vcpu);
|
|
|
|
void (*set_dr6)(struct kvm_vcpu *vcpu, unsigned long value);
|
2014-02-21 17:17:24 +08:00
|
|
|
void (*sync_dirty_debug_regs)(struct kvm_vcpu *vcpu);
|
2010-04-13 15:05:23 +08:00
|
|
|
void (*set_dr7)(struct kvm_vcpu *vcpu, unsigned long value);
|
2008-06-28 01:58:02 +08:00
|
|
|
void (*cache_reg)(struct kvm_vcpu *vcpu, enum kvm_reg reg);
|
2007-11-19 14:40:47 +08:00
|
|
|
unsigned long (*get_rflags)(struct kvm_vcpu *vcpu);
|
|
|
|
void (*set_rflags)(struct kvm_vcpu *vcpu, unsigned long rflags);
|
2016-03-22 16:51:20 +08:00
|
|
|
u32 (*get_pkru)(struct kvm_vcpu *vcpu);
|
2015-05-20 17:33:43 +08:00
|
|
|
void (*fpu_activate)(struct kvm_vcpu *vcpu);
|
2009-12-30 18:40:26 +08:00
|
|
|
void (*fpu_deactivate)(struct kvm_vcpu *vcpu);
|
2007-11-19 14:40:47 +08:00
|
|
|
|
|
|
|
void (*tlb_flush)(struct kvm_vcpu *vcpu);
|
|
|
|
|
2009-08-24 16:10:17 +08:00
|
|
|
void (*run)(struct kvm_vcpu *vcpu);
|
|
|
|
int (*handle_exit)(struct kvm_vcpu *vcpu);
|
2007-11-19 14:40:47 +08:00
|
|
|
void (*skip_emulated_instruction)(struct kvm_vcpu *vcpu);
|
2009-05-13 04:21:05 +08:00
|
|
|
void (*set_interrupt_shadow)(struct kvm_vcpu *vcpu, int mask);
|
2014-05-20 20:29:47 +08:00
|
|
|
u32 (*get_interrupt_shadow)(struct kvm_vcpu *vcpu);
|
2007-11-19 14:40:47 +08:00
|
|
|
void (*patch_hypercall)(struct kvm_vcpu *vcpu,
|
|
|
|
unsigned char *hypercall_addr);
|
2009-05-11 18:35:50 +08:00
|
|
|
void (*set_irq)(struct kvm_vcpu *vcpu);
|
2009-04-21 22:45:08 +08:00
|
|
|
void (*set_nmi)(struct kvm_vcpu *vcpu);
|
2007-11-25 19:41:11 +08:00
|
|
|
void (*queue_exception)(struct kvm_vcpu *vcpu, unsigned nr,
|
2010-04-22 18:33:13 +08:00
|
|
|
bool has_error_code, u32 error_code,
|
|
|
|
bool reinject);
|
2010-07-20 20:06:17 +08:00
|
|
|
void (*cancel_injection)(struct kvm_vcpu *vcpu);
|
2009-03-23 18:12:11 +08:00
|
|
|
int (*interrupt_allowed)(struct kvm_vcpu *vcpu);
|
2009-04-21 22:45:08 +08:00
|
|
|
int (*nmi_allowed)(struct kvm_vcpu *vcpu);
|
2009-11-12 08:04:25 +08:00
|
|
|
bool (*get_nmi_mask)(struct kvm_vcpu *vcpu);
|
|
|
|
void (*set_nmi_mask)(struct kvm_vcpu *vcpu, bool masked);
|
2014-03-08 03:03:15 +08:00
|
|
|
void (*enable_nmi_window)(struct kvm_vcpu *vcpu);
|
|
|
|
void (*enable_irq_window)(struct kvm_vcpu *vcpu);
|
2009-04-21 22:45:08 +08:00
|
|
|
void (*update_cr8_intercept)(struct kvm_vcpu *vcpu, int tpr, int irr);
|
2015-11-10 20:36:33 +08:00
|
|
|
bool (*get_enable_apicv)(void);
|
|
|
|
void (*refresh_apicv_exec_ctrl)(struct kvm_vcpu *vcpu);
|
2013-01-25 10:18:51 +08:00
|
|
|
void (*hwapic_irr_update)(struct kvm_vcpu *vcpu, int max_irr);
|
2016-05-10 23:01:23 +08:00
|
|
|
void (*hwapic_isr_update)(struct kvm_vcpu *vcpu, int isr);
|
2015-11-10 20:36:32 +08:00
|
|
|
void (*load_eoi_exitmap)(struct kvm_vcpu *vcpu, u64 *eoi_exit_bitmap);
|
2013-01-25 10:18:50 +08:00
|
|
|
void (*set_virtual_x2apic_mode)(struct kvm_vcpu *vcpu, bool set);
|
2014-09-24 15:57:54 +08:00
|
|
|
void (*set_apic_access_page_addr)(struct kvm_vcpu *vcpu, hpa_t hpa);
|
2013-04-11 19:25:15 +08:00
|
|
|
void (*deliver_posted_interrupt)(struct kvm_vcpu *vcpu, int vector);
|
|
|
|
void (*sync_pir_to_irr)(struct kvm_vcpu *vcpu);
|
2007-11-19 14:40:47 +08:00
|
|
|
int (*set_tss_addr)(struct kvm *kvm, unsigned int addr);
|
2008-04-25 10:20:22 +08:00
|
|
|
int (*get_tdp_level)(void);
|
2009-04-27 20:35:42 +08:00
|
|
|
u64 (*get_mt_mask)(struct kvm_vcpu *vcpu, gfn_t gfn, bool is_mmio);
|
2010-01-05 19:02:27 +08:00
|
|
|
int (*get_lpage_level)(void);
|
2009-12-18 16:48:47 +08:00
|
|
|
bool (*rdtscp_supported)(void);
|
2012-07-02 09:18:48 +08:00
|
|
|
bool (*invpcid_supported)(void);
|
2015-10-20 15:39:06 +08:00
|
|
|
void (*adjust_tsc_offset_guest)(struct kvm_vcpu *vcpu, s64 adjustment);
|
2009-07-27 22:30:48 +08:00
|
|
|
|
2010-09-10 23:30:41 +08:00
|
|
|
void (*set_tdp_cr3)(struct kvm_vcpu *vcpu, unsigned long cr3);
|
|
|
|
|
2010-04-22 18:33:11 +08:00
|
|
|
void (*set_supported_cpuid)(u32 func, struct kvm_cpuid_entry2 *entry);
|
|
|
|
|
2010-06-30 12:25:15 +08:00
|
|
|
bool (*has_wbinvd_exit)(void);
|
|
|
|
|
2012-11-30 04:42:50 +08:00
|
|
|
u64 (*read_tsc_offset)(struct kvm_vcpu *vcpu);
|
2010-08-20 16:07:17 +08:00
|
|
|
void (*write_tsc_offset)(struct kvm_vcpu *vcpu, u64 offset);
|
|
|
|
|
2012-11-28 09:28:58 +08:00
|
|
|
u64 (*read_l1_tsc)(struct kvm_vcpu *vcpu, u64 host_tsc);
|
2011-03-25 16:44:50 +08:00
|
|
|
|
2010-11-18 19:09:54 +08:00
|
|
|
void (*get_exit_info)(struct kvm_vcpu *vcpu, u64 *info1, u64 *info2);
|
2011-04-04 18:39:27 +08:00
|
|
|
|
|
|
|
int (*check_intercept)(struct kvm_vcpu *vcpu,
|
|
|
|
struct x86_instruction_info *info,
|
|
|
|
enum x86_intercept_stage stage);
|
2013-04-11 19:25:10 +08:00
|
|
|
void (*handle_external_intr)(struct kvm_vcpu *vcpu);
|
2014-02-24 18:55:46 +08:00
|
|
|
bool (*mpx_supported)(void);
|
2014-12-02 19:21:30 +08:00
|
|
|
bool (*xsaves_supported)(void);
|
2014-03-08 03:03:12 +08:00
|
|
|
|
|
|
|
int (*check_nested_events)(struct kvm_vcpu *vcpu, bool external_intr);
|
2014-08-22 00:08:06 +08:00
|
|
|
|
|
|
|
void (*sched_in)(struct kvm_vcpu *kvm, int cpu);
|
2015-01-28 10:54:27 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Arch-specific dirty logging hooks. These hooks are only supposed to
|
|
|
|
* be valid if the specific arch has hardware-accelerated dirty logging
|
|
|
|
* mechanism. Currently only for PML on VMX.
|
|
|
|
*
|
|
|
|
* - slot_enable_log_dirty:
|
|
|
|
* called when enabling log dirty mode for the slot.
|
|
|
|
* - slot_disable_log_dirty:
|
|
|
|
* called when disabling log dirty mode for the slot.
|
|
|
|
* also called when slot is created with log dirty disabled.
|
|
|
|
* - flush_log_dirty:
|
|
|
|
* called before reporting dirty_bitmap to userspace.
|
|
|
|
* - enable_log_dirty_pt_masked:
|
|
|
|
* called when reenabling log dirty for the GFNs in the mask after
|
|
|
|
* corresponding bits are cleared in slot->dirty_bitmap.
|
|
|
|
*/
|
|
|
|
void (*slot_enable_log_dirty)(struct kvm *kvm,
|
|
|
|
struct kvm_memory_slot *slot);
|
|
|
|
void (*slot_disable_log_dirty)(struct kvm *kvm,
|
|
|
|
struct kvm_memory_slot *slot);
|
|
|
|
void (*flush_log_dirty)(struct kvm *kvm);
|
|
|
|
void (*enable_log_dirty_pt_masked)(struct kvm *kvm,
|
|
|
|
struct kvm_memory_slot *slot,
|
|
|
|
gfn_t offset, unsigned long mask);
|
2015-06-19 21:45:05 +08:00
|
|
|
/* pmu operations of sub-arch */
|
|
|
|
const struct kvm_pmu_ops *pmu_ops;
|
2015-09-18 22:29:51 +08:00
|
|
|
|
2015-09-18 22:29:55 +08:00
|
|
|
/*
|
|
|
|
* Architecture specific hooks for vCPU blocking due to
|
|
|
|
* HLT instruction.
|
|
|
|
* Returns for .pre_block():
|
|
|
|
* - 0 means continue to block the vCPU.
|
|
|
|
* - 1 means we cannot block the vCPU since some event
|
|
|
|
* happens during this period, such as, 'ON' bit in
|
|
|
|
* posted-interrupts descriptor is set.
|
|
|
|
*/
|
|
|
|
int (*pre_block)(struct kvm_vcpu *vcpu);
|
|
|
|
void (*post_block)(struct kvm_vcpu *vcpu);
|
2016-05-05 03:09:43 +08:00
|
|
|
|
|
|
|
void (*vcpu_blocking)(struct kvm_vcpu *vcpu);
|
|
|
|
void (*vcpu_unblocking)(struct kvm_vcpu *vcpu);
|
|
|
|
|
2015-09-18 22:29:51 +08:00
|
|
|
int (*update_pi_irte)(struct kvm *kvm, unsigned int host_irq,
|
|
|
|
uint32_t guest_irq, bool set);
|
2016-05-05 03:09:49 +08:00
|
|
|
void (*apicv_post_state_restore)(struct kvm_vcpu *vcpu);
|
2016-06-14 05:20:01 +08:00
|
|
|
|
|
|
|
int (*set_hv_timer)(struct kvm_vcpu *vcpu, u64 guest_deadline_tsc);
|
|
|
|
void (*cancel_hv_timer)(struct kvm_vcpu *vcpu);
|
2016-06-22 14:59:56 +08:00
|
|
|
|
|
|
|
void (*setup_mce)(struct kvm_vcpu *vcpu);
|
2007-11-19 14:40:47 +08:00
|
|
|
};
|
|
|
|
|
2010-10-14 17:22:46 +08:00
|
|
|
struct kvm_arch_async_pf {
|
2010-10-14 17:22:53 +08:00
|
|
|
u32 token;
|
2010-10-14 17:22:46 +08:00
|
|
|
gfn_t gfn;
|
2010-12-07 10:35:25 +08:00
|
|
|
unsigned long cr3;
|
2010-11-12 14:49:55 +08:00
|
|
|
bool direct_map;
|
2010-10-14 17:22:46 +08:00
|
|
|
};
|
|
|
|
|
2007-11-14 20:09:30 +08:00
|
|
|
extern struct kvm_x86_ops *kvm_x86_ops;
|
|
|
|
|
2007-11-19 15:24:28 +08:00
|
|
|
int kvm_mmu_module_init(void);
|
|
|
|
void kvm_mmu_module_exit(void);
|
|
|
|
|
|
|
|
void kvm_mmu_destroy(struct kvm_vcpu *vcpu);
|
|
|
|
int kvm_mmu_create(struct kvm_vcpu *vcpu);
|
2013-10-02 22:56:13 +08:00
|
|
|
void kvm_mmu_setup(struct kvm_vcpu *vcpu);
|
2016-02-24 17:51:16 +08:00
|
|
|
void kvm_mmu_init_vm(struct kvm *kvm);
|
|
|
|
void kvm_mmu_uninit_vm(struct kvm *kvm);
|
2008-04-25 21:13:50 +08:00
|
|
|
void kvm_mmu_set_mask_ptes(u64 user_mask, u64 accessed_mask,
|
2016-07-13 06:18:49 +08:00
|
|
|
u64 dirty_mask, u64 nx_mask, u64 x_mask, u64 p_mask);
|
2007-11-19 15:24:28 +08:00
|
|
|
|
2013-10-02 22:56:13 +08:00
|
|
|
void kvm_mmu_reset_context(struct kvm_vcpu *vcpu);
|
2015-01-28 10:54:26 +08:00
|
|
|
void kvm_mmu_slot_remove_write_access(struct kvm *kvm,
|
|
|
|
struct kvm_memory_slot *memslot);
|
2015-04-03 15:40:25 +08:00
|
|
|
void kvm_mmu_zap_collapsible_sptes(struct kvm *kvm,
|
2015-05-18 19:20:23 +08:00
|
|
|
const struct kvm_memory_slot *memslot);
|
2015-01-28 10:54:24 +08:00
|
|
|
void kvm_mmu_slot_leaf_clear_dirty(struct kvm *kvm,
|
|
|
|
struct kvm_memory_slot *memslot);
|
|
|
|
void kvm_mmu_slot_largepage_remove_write_access(struct kvm *kvm,
|
|
|
|
struct kvm_memory_slot *memslot);
|
|
|
|
void kvm_mmu_slot_set_dirty(struct kvm *kvm,
|
|
|
|
struct kvm_memory_slot *memslot);
|
|
|
|
void kvm_mmu_clear_dirty_pt_masked(struct kvm *kvm,
|
|
|
|
struct kvm_memory_slot *slot,
|
|
|
|
gfn_t gfn_offset, unsigned long mask);
|
2007-11-19 15:24:28 +08:00
|
|
|
void kvm_mmu_zap_all(struct kvm *kvm);
|
2015-04-08 21:39:23 +08:00
|
|
|
void kvm_mmu_invalidate_mmio_sptes(struct kvm *kvm, struct kvm_memslots *slots);
|
2007-11-20 13:11:38 +08:00
|
|
|
unsigned int kvm_mmu_calculate_mmu_pages(struct kvm *kvm);
|
2007-11-19 15:24:28 +08:00
|
|
|
void kvm_mmu_change_mmu_pages(struct kvm *kvm, unsigned int kvm_nr_mmu_pages);
|
|
|
|
|
2010-09-10 23:30:57 +08:00
|
|
|
int load_pdptrs(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu, unsigned long cr3);
|
2008-02-07 20:47:43 +08:00
|
|
|
|
2008-03-30 07:17:59 +08:00
|
|
|
int emulator_write_phys(struct kvm_vcpu *vcpu, gpa_t gpa,
|
2008-03-02 20:06:05 +08:00
|
|
|
const void *val, int bytes);
|
2008-02-23 01:21:37 +08:00
|
|
|
|
2014-11-20 20:45:31 +08:00
|
|
|
struct kvm_irq_mask_notifier {
|
|
|
|
void (*func)(struct kvm_irq_mask_notifier *kimn, bool masked);
|
|
|
|
int irq;
|
|
|
|
struct hlist_node link;
|
|
|
|
};
|
|
|
|
|
|
|
|
void kvm_register_irq_mask_notifier(struct kvm *kvm, int irq,
|
|
|
|
struct kvm_irq_mask_notifier *kimn);
|
|
|
|
void kvm_unregister_irq_mask_notifier(struct kvm *kvm, int irq,
|
|
|
|
struct kvm_irq_mask_notifier *kimn);
|
|
|
|
void kvm_fire_mask_notifiers(struct kvm *kvm, unsigned irqchip, unsigned pin,
|
|
|
|
bool mask);
|
|
|
|
|
2008-02-23 01:21:37 +08:00
|
|
|
extern bool tdp_enabled;
|
2008-03-02 20:06:05 +08:00
|
|
|
|
2011-09-22 16:55:52 +08:00
|
|
|
u64 vcpu_tsc_khz(struct kvm_vcpu *vcpu);
|
|
|
|
|
2011-03-25 16:44:51 +08:00
|
|
|
/* control of guest tsc rate supported? */
|
|
|
|
extern bool kvm_has_tsc_control;
|
|
|
|
/* maximum supported tsc_khz for guests */
|
|
|
|
extern u32 kvm_max_guest_tsc_khz;
|
2015-10-20 15:39:01 +08:00
|
|
|
/* number of bits of the fractional part of the TSC scaling ratio */
|
|
|
|
extern u8 kvm_tsc_scaling_ratio_frac_bits;
|
|
|
|
/* maximum allowed value of TSC scaling ratio */
|
|
|
|
extern u64 kvm_max_tsc_scaling_ratio;
|
2016-06-14 05:19:59 +08:00
|
|
|
/* 1ull << kvm_tsc_scaling_ratio_frac_bits */
|
|
|
|
extern u64 kvm_default_tsc_scaling_ratio;
|
2011-03-25 16:44:51 +08:00
|
|
|
|
2016-06-22 14:59:56 +08:00
|
|
|
extern u64 kvm_mce_cap_supported;
|
2011-03-25 16:44:51 +08:00
|
|
|
|
2007-11-19 15:24:28 +08:00
|
|
|
enum emulation_result {
|
2013-06-26 00:24:41 +08:00
|
|
|
EMULATE_DONE, /* no further processing */
|
|
|
|
EMULATE_USER_EXIT, /* kvm_run ready for userspace exit */
|
2007-11-19 15:24:28 +08:00
|
|
|
EMULATE_FAIL, /* can't emulate this instruction */
|
|
|
|
};
|
|
|
|
|
KVM: x86 emulator: Only allow VMCALL/VMMCALL trapped by #UD
When executing a test program called "crashme", we found the KVM guest cannot
survive more than ten seconds, then encounterd kernel panic. The basic concept
of "crashme" is generating random assembly code and trying to execute it.
After some fixes on emulator insn validity judgment, we found it's hard to
get the current emulator handle the invalid instructions correctly, for the
#UD trap for hypercall patching caused troubles. The problem is, if the opcode
itself was OK, but combination of opcode and modrm_reg was invalid, and one
operand of the opcode was memory (SrcMem or DstMem), the emulator will fetch
the memory operand first rather than checking the validity, and may encounter
an error there. For example, ".byte 0xfe, 0x34, 0xcd" has this problem.
In the patch, we simply check that if the invalid opcode wasn't vmcall/vmmcall,
then return from emulate_instruction() and inject a #UD to guest. With the
patch, the guest had been running for more than 12 hours.
Signed-off-by: Feng (Eric) Liu <eric.e.liu@intel.com>
Signed-off-by: Sheng Yang <sheng.yang@intel.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
2008-01-02 14:49:22 +08:00
|
|
|
#define EMULTYPE_NO_DECODE (1 << 0)
|
|
|
|
#define EMULTYPE_TRAP_UD (1 << 1)
|
2009-04-12 18:36:57 +08:00
|
|
|
#define EMULTYPE_SKIP (1 << 2)
|
2011-09-22 17:02:48 +08:00
|
|
|
#define EMULTYPE_RETRY (1 << 3)
|
2013-04-11 17:10:51 +08:00
|
|
|
#define EMULTYPE_NO_REEXECUTE (1 << 4)
|
2010-12-21 18:12:07 +08:00
|
|
|
int x86_emulate_instruction(struct kvm_vcpu *vcpu, unsigned long cr2,
|
|
|
|
int emulation_type, void *insn, int insn_len);
|
2010-12-21 18:12:02 +08:00
|
|
|
|
|
|
|
static inline int emulate_instruction(struct kvm_vcpu *vcpu,
|
|
|
|
int emulation_type)
|
|
|
|
{
|
2010-12-21 18:12:07 +08:00
|
|
|
return x86_emulate_instruction(vcpu, 0, emulation_type, NULL, 0);
|
2010-12-21 18:12:02 +08:00
|
|
|
}
|
|
|
|
|
2008-01-31 21:57:37 +08:00
|
|
|
void kvm_enable_efer_bits(u64);
|
2013-04-20 16:52:36 +08:00
|
|
|
bool kvm_valid_efer(struct kvm_vcpu *vcpu, u64 efer);
|
2015-04-08 21:30:38 +08:00
|
|
|
int kvm_get_msr(struct kvm_vcpu *vcpu, struct msr_data *msr);
|
2012-11-30 04:42:12 +08:00
|
|
|
int kvm_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr);
|
2007-11-19 15:24:28 +08:00
|
|
|
|
|
|
|
struct x86_emulate_ctxt;
|
|
|
|
|
2010-03-18 21:20:23 +08:00
|
|
|
int kvm_fast_pio_out(struct kvm_vcpu *vcpu, int size, unsigned short port);
|
2007-11-19 15:24:28 +08:00
|
|
|
void kvm_emulate_cpuid(struct kvm_vcpu *vcpu);
|
|
|
|
int kvm_emulate_halt(struct kvm_vcpu *vcpu);
|
2015-03-03 03:43:31 +08:00
|
|
|
int kvm_vcpu_halt(struct kvm_vcpu *vcpu);
|
2010-06-30 12:25:15 +08:00
|
|
|
int kvm_emulate_wbinvd(struct kvm_vcpu *vcpu);
|
2007-11-19 15:24:28 +08:00
|
|
|
|
2008-05-27 16:18:46 +08:00
|
|
|
void kvm_get_segment(struct kvm_vcpu *vcpu, struct kvm_segment *var, int seg);
|
2010-02-18 18:15:01 +08:00
|
|
|
int kvm_load_segment_descriptor(struct kvm_vcpu *vcpu, u16 selector, int seg);
|
2014-11-24 21:35:24 +08:00
|
|
|
void kvm_vcpu_deliver_sipi_vector(struct kvm_vcpu *vcpu, u8 vector);
|
2008-05-27 16:18:46 +08:00
|
|
|
|
2012-02-08 21:34:38 +08:00
|
|
|
int kvm_task_switch(struct kvm_vcpu *vcpu, u16 tss_selector, int idt_index,
|
|
|
|
int reason, bool has_error_code, u32 error_code);
|
2008-03-25 05:14:53 +08:00
|
|
|
|
2010-06-10 22:02:14 +08:00
|
|
|
int kvm_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0);
|
2010-06-10 22:02:16 +08:00
|
|
|
int kvm_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3);
|
2010-06-10 22:02:15 +08:00
|
|
|
int kvm_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4);
|
2010-12-21 18:12:00 +08:00
|
|
|
int kvm_set_cr8(struct kvm_vcpu *vcpu, unsigned long cr8);
|
2010-04-13 15:05:23 +08:00
|
|
|
int kvm_set_dr(struct kvm_vcpu *vcpu, int dr, unsigned long val);
|
|
|
|
int kvm_get_dr(struct kvm_vcpu *vcpu, int dr, unsigned long *val);
|
2008-02-24 17:20:43 +08:00
|
|
|
unsigned long kvm_get_cr8(struct kvm_vcpu *vcpu);
|
|
|
|
void kvm_lmsw(struct kvm_vcpu *vcpu, unsigned long msw);
|
2007-11-19 15:24:28 +08:00
|
|
|
void kvm_get_cs_db_l_bits(struct kvm_vcpu *vcpu, int *db, int *l);
|
2010-06-10 11:27:12 +08:00
|
|
|
int kvm_set_xcr(struct kvm_vcpu *vcpu, u32 index, u64 xcr);
|
2007-11-19 15:24:28 +08:00
|
|
|
|
2015-04-08 21:30:38 +08:00
|
|
|
int kvm_get_msr_common(struct kvm_vcpu *vcpu, struct msr_data *msr);
|
2012-11-30 04:42:12 +08:00
|
|
|
int kvm_set_msr_common(struct kvm_vcpu *vcpu, struct msr_data *msr);
|
2007-11-19 15:24:28 +08:00
|
|
|
|
2009-10-05 19:07:21 +08:00
|
|
|
unsigned long kvm_get_rflags(struct kvm_vcpu *vcpu);
|
|
|
|
void kvm_set_rflags(struct kvm_vcpu *vcpu, unsigned long rflags);
|
2011-11-10 20:57:23 +08:00
|
|
|
bool kvm_rdpmc(struct kvm_vcpu *vcpu);
|
2009-10-05 19:07:21 +08:00
|
|
|
|
2007-11-25 19:41:11 +08:00
|
|
|
void kvm_queue_exception(struct kvm_vcpu *vcpu, unsigned nr);
|
|
|
|
void kvm_queue_exception_e(struct kvm_vcpu *vcpu, unsigned nr, u32 error_code);
|
2010-04-22 18:33:13 +08:00
|
|
|
void kvm_requeue_exception(struct kvm_vcpu *vcpu, unsigned nr);
|
|
|
|
void kvm_requeue_exception_e(struct kvm_vcpu *vcpu, unsigned nr, u32 error_code);
|
2010-11-29 22:12:30 +08:00
|
|
|
void kvm_inject_page_fault(struct kvm_vcpu *vcpu, struct x86_exception *fault);
|
2010-09-10 23:30:51 +08:00
|
|
|
int kvm_read_guest_page_mmu(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu,
|
|
|
|
gfn_t gfn, void *data, int offset, int len,
|
|
|
|
u32 access);
|
2009-09-01 17:03:25 +08:00
|
|
|
bool kvm_require_cpl(struct kvm_vcpu *vcpu, int required_cpl);
|
2014-10-03 06:10:05 +08:00
|
|
|
bool kvm_require_dr(struct kvm_vcpu *vcpu, int dr);
|
2007-11-25 19:41:11 +08:00
|
|
|
|
2012-07-19 18:45:20 +08:00
|
|
|
static inline int __kvm_irq_line_state(unsigned long *irq_state,
|
|
|
|
int irq_source_id, int level)
|
|
|
|
{
|
|
|
|
/* Logical OR for level trig interrupt */
|
|
|
|
if (level)
|
|
|
|
__set_bit(irq_source_id, irq_state);
|
|
|
|
else
|
|
|
|
__clear_bit(irq_source_id, irq_state);
|
|
|
|
|
|
|
|
return !!(*irq_state);
|
|
|
|
}
|
|
|
|
|
|
|
|
int kvm_pic_set_irq(struct kvm_pic *pic, int irq, int irq_source_id, int level);
|
|
|
|
void kvm_pic_clear_all(struct kvm_pic *pic, int irq_source_id);
|
2008-10-06 13:48:45 +08:00
|
|
|
|
2008-05-15 09:52:48 +08:00
|
|
|
void kvm_inject_nmi(struct kvm_vcpu *vcpu);
|
|
|
|
|
2011-09-22 17:02:48 +08:00
|
|
|
int kvm_mmu_unprotect_page(struct kvm *kvm, gfn_t gfn);
|
2007-11-19 15:24:28 +08:00
|
|
|
int kvm_mmu_unprotect_page_virt(struct kvm_vcpu *vcpu, gva_t gva);
|
|
|
|
void __kvm_mmu_free_some_pages(struct kvm_vcpu *vcpu);
|
|
|
|
int kvm_mmu_load(struct kvm_vcpu *vcpu);
|
|
|
|
void kvm_mmu_unload(struct kvm_vcpu *vcpu);
|
2008-09-24 00:18:34 +08:00
|
|
|
void kvm_mmu_sync_roots(struct kvm_vcpu *vcpu);
|
2014-09-02 19:23:06 +08:00
|
|
|
gpa_t translate_nested_gpa(struct kvm_vcpu *vcpu, gpa_t gpa, u32 access,
|
|
|
|
struct x86_exception *exception);
|
2010-11-22 23:53:26 +08:00
|
|
|
gpa_t kvm_mmu_gva_to_gpa_read(struct kvm_vcpu *vcpu, gva_t gva,
|
|
|
|
struct x86_exception *exception);
|
|
|
|
gpa_t kvm_mmu_gva_to_gpa_fetch(struct kvm_vcpu *vcpu, gva_t gva,
|
|
|
|
struct x86_exception *exception);
|
|
|
|
gpa_t kvm_mmu_gva_to_gpa_write(struct kvm_vcpu *vcpu, gva_t gva,
|
|
|
|
struct x86_exception *exception);
|
|
|
|
gpa_t kvm_mmu_gva_to_gpa_system(struct kvm_vcpu *vcpu, gva_t gva,
|
|
|
|
struct x86_exception *exception);
|
2007-11-19 15:24:28 +08:00
|
|
|
|
2015-11-10 20:36:33 +08:00
|
|
|
void kvm_vcpu_deactivate_apicv(struct kvm_vcpu *vcpu);
|
|
|
|
|
2007-11-19 15:24:28 +08:00
|
|
|
int kvm_emulate_hypercall(struct kvm_vcpu *vcpu);
|
|
|
|
|
2010-12-21 18:12:07 +08:00
|
|
|
int kvm_mmu_page_fault(struct kvm_vcpu *vcpu, gva_t gva, u32 error_code,
|
|
|
|
void *insn, int insn_len);
|
2008-09-24 00:18:35 +08:00
|
|
|
void kvm_mmu_invlpg(struct kvm_vcpu *vcpu, gva_t gva);
|
2013-10-02 22:56:11 +08:00
|
|
|
void kvm_mmu_new_cr3(struct kvm_vcpu *vcpu);
|
2007-10-20 15:34:38 +08:00
|
|
|
|
2008-02-07 20:47:41 +08:00
|
|
|
void kvm_enable_tdp(void);
|
2008-07-15 02:36:36 +08:00
|
|
|
void kvm_disable_tdp(void);
|
2008-02-07 20:47:41 +08:00
|
|
|
|
2014-09-02 19:23:06 +08:00
|
|
|
static inline gpa_t translate_gpa(struct kvm_vcpu *vcpu, gpa_t gpa, u32 access,
|
|
|
|
struct x86_exception *exception)
|
2011-11-28 20:42:16 +08:00
|
|
|
{
|
|
|
|
return gpa;
|
|
|
|
}
|
|
|
|
|
2007-11-19 15:08:31 +08:00
|
|
|
static inline struct kvm_mmu_page *page_header(hpa_t shadow_page)
|
|
|
|
{
|
|
|
|
struct page *page = pfn_to_page(shadow_page >> PAGE_SHIFT);
|
|
|
|
|
|
|
|
return (struct kvm_mmu_page *)page_private(page);
|
|
|
|
}
|
|
|
|
|
2008-07-10 21:53:33 +08:00
|
|
|
static inline u16 kvm_read_ldt(void)
|
2007-11-19 15:08:31 +08:00
|
|
|
{
|
|
|
|
u16 ldt;
|
|
|
|
asm("sldt %0" : "=g"(ldt));
|
|
|
|
return ldt;
|
|
|
|
}
|
|
|
|
|
2008-07-10 21:53:33 +08:00
|
|
|
static inline void kvm_load_ldt(u16 sel)
|
2007-11-19 15:08:31 +08:00
|
|
|
{
|
|
|
|
asm("lldt %0" : : "rm"(sel));
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
static inline unsigned long read_msr(unsigned long msr)
|
|
|
|
{
|
|
|
|
u64 value;
|
|
|
|
|
|
|
|
rdmsrl(msr, value);
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static inline u32 get_rdx_init_val(void)
|
|
|
|
{
|
|
|
|
return 0x600; /* P6 family */
|
|
|
|
}
|
|
|
|
|
2007-11-25 20:12:03 +08:00
|
|
|
static inline void kvm_inject_gp(struct kvm_vcpu *vcpu, u32 error_code)
|
|
|
|
{
|
|
|
|
kvm_queue_exception_e(vcpu, GP_VECTOR, error_code);
|
|
|
|
}
|
|
|
|
|
KVM: x86: Check non-canonical addresses upon WRMSR
Upon WRMSR, the CPU should inject #GP if a non-canonical value (address) is
written to certain MSRs. The behavior is "almost" identical for AMD and Intel
(ignoring MSRs that are not implemented in either architecture since they would
anyhow #GP). However, IA32_SYSENTER_ESP and IA32_SYSENTER_EIP cause #GP if
non-canonical address is written on Intel but not on AMD (which ignores the top
32-bits).
Accordingly, this patch injects a #GP on the MSRs which behave identically on
Intel and AMD. To eliminate the differences between the architecutres, the
value which is written to IA32_SYSENTER_ESP and IA32_SYSENTER_EIP is turned to
canonical value before writing instead of injecting a #GP.
Some references from Intel and AMD manuals:
According to Intel SDM description of WRMSR instruction #GP is expected on
WRMSR "If the source register contains a non-canonical address and ECX
specifies one of the following MSRs: IA32_DS_AREA, IA32_FS_BASE, IA32_GS_BASE,
IA32_KERNEL_GS_BASE, IA32_LSTAR, IA32_SYSENTER_EIP, IA32_SYSENTER_ESP."
According to AMD manual instruction manual:
LSTAR/CSTAR (SYSCALL): "The WRMSR instruction loads the target RIP into the
LSTAR and CSTAR registers. If an RIP written by WRMSR is not in canonical
form, a general-protection exception (#GP) occurs."
IA32_GS_BASE and IA32_FS_BASE (WRFSBASE/WRGSBASE): "The address written to the
base field must be in canonical form or a #GP fault will occur."
IA32_KERNEL_GS_BASE (SWAPGS): "The address stored in the KernelGSbase MSR must
be in canonical form."
This patch fixes CVE-2014-3610.
Cc: stable@vger.kernel.org
Signed-off-by: Nadav Amit <namit@cs.technion.ac.il>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2014-09-16 08:24:05 +08:00
|
|
|
static inline u64 get_canonical(u64 la)
|
|
|
|
{
|
|
|
|
return ((int64_t)la << 16) >> 16;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool is_noncanonical_address(u64 la)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
return get_canonical(la) != la;
|
|
|
|
#else
|
|
|
|
return false;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2007-11-19 15:08:31 +08:00
|
|
|
#define TSS_IOPB_BASE_OFFSET 0x66
|
|
|
|
#define TSS_BASE_SIZE 0x68
|
|
|
|
#define TSS_IOPB_SIZE (65536 / 8)
|
|
|
|
#define TSS_REDIRECTION_SIZE (256 / 8)
|
2008-03-23 16:02:34 +08:00
|
|
|
#define RMODE_TSS_SIZE \
|
|
|
|
(TSS_BASE_SIZE + TSS_REDIRECTION_SIZE + TSS_IOPB_SIZE + 1)
|
2007-12-04 06:15:26 +08:00
|
|
|
|
2008-03-25 05:14:53 +08:00
|
|
|
enum {
|
|
|
|
TASK_SWITCH_CALL = 0,
|
|
|
|
TASK_SWITCH_IRET = 1,
|
|
|
|
TASK_SWITCH_JMP = 2,
|
|
|
|
TASK_SWITCH_GATE = 3,
|
|
|
|
};
|
|
|
|
|
2008-11-26 03:17:04 +08:00
|
|
|
#define HF_GIF_MASK (1 << 0)
|
2008-11-26 03:17:07 +08:00
|
|
|
#define HF_HIF_MASK (1 << 1)
|
|
|
|
#define HF_VINTR_MASK (1 << 2)
|
2009-04-21 22:45:08 +08:00
|
|
|
#define HF_NMI_MASK (1 << 3)
|
2009-05-11 18:35:52 +08:00
|
|
|
#define HF_IRET_MASK (1 << 4)
|
2010-11-30 00:51:47 +08:00
|
|
|
#define HF_GUEST_MASK (1 << 5) /* VCPU is in guest-mode */
|
2015-04-01 21:06:40 +08:00
|
|
|
#define HF_SMM_MASK (1 << 6)
|
|
|
|
#define HF_SMM_INSIDE_NMI_MASK (1 << 7)
|
2008-11-26 03:17:04 +08:00
|
|
|
|
2015-05-18 21:03:39 +08:00
|
|
|
#define __KVM_VCPU_MULTIPLE_ADDRESS_SPACE
|
|
|
|
#define KVM_ADDRESS_SPACE_NUM 2
|
|
|
|
|
|
|
|
#define kvm_arch_vcpu_memslots_id(vcpu) ((vcpu)->arch.hflags & HF_SMM_MASK ? 1 : 0)
|
|
|
|
#define kvm_memslots_for_spte_role(kvm, role) __kvm_memslots(kvm, (role).smm)
|
2008-11-26 03:17:04 +08:00
|
|
|
|
2008-05-13 18:23:38 +08:00
|
|
|
/*
|
|
|
|
* Hardware virtualization extension instructions may fault if a
|
|
|
|
* reboot turns off virtualization while processes are running.
|
|
|
|
* Trap the fault and ignore the instruction if that happens.
|
|
|
|
*/
|
2010-12-02 23:52:50 +08:00
|
|
|
asmlinkage void kvm_spurious_fault(void);
|
2008-05-13 18:23:38 +08:00
|
|
|
|
2011-05-15 22:13:12 +08:00
|
|
|
#define ____kvm_handle_fault_on_reboot(insn, cleanup_insn) \
|
2008-05-13 18:23:38 +08:00
|
|
|
"666: " insn "\n\t" \
|
2010-12-02 23:52:50 +08:00
|
|
|
"668: \n\t" \
|
2008-08-20 07:00:08 +08:00
|
|
|
".pushsection .fixup, \"ax\" \n" \
|
2008-05-13 18:23:38 +08:00
|
|
|
"667: \n\t" \
|
2011-05-15 22:13:12 +08:00
|
|
|
cleanup_insn "\n\t" \
|
2010-12-02 23:52:50 +08:00
|
|
|
"cmpb $0, kvm_rebooting \n\t" \
|
|
|
|
"jne 668b \n\t" \
|
2008-08-15 02:25:47 +08:00
|
|
|
__ASM_SIZE(push) " $666b \n\t" \
|
2010-12-02 23:52:50 +08:00
|
|
|
"call kvm_spurious_fault \n\t" \
|
2008-05-13 18:23:38 +08:00
|
|
|
".popsection \n\t" \
|
2012-04-21 04:41:59 +08:00
|
|
|
_ASM_EXTABLE(666b, 667b)
|
2008-05-13 18:23:38 +08:00
|
|
|
|
2011-05-15 22:13:12 +08:00
|
|
|
#define __kvm_handle_fault_on_reboot(insn) \
|
|
|
|
____kvm_handle_fault_on_reboot(insn, "")
|
|
|
|
|
2008-07-25 22:24:52 +08:00
|
|
|
#define KVM_ARCH_WANT_MMU_NOTIFIER
|
|
|
|
int kvm_unmap_hva(struct kvm *kvm, unsigned long hva);
|
2012-07-02 16:56:33 +08:00
|
|
|
int kvm_unmap_hva_range(struct kvm *kvm, unsigned long start, unsigned long end);
|
2014-09-23 05:54:42 +08:00
|
|
|
int kvm_age_hva(struct kvm *kvm, unsigned long start, unsigned long end);
|
2011-01-14 07:47:10 +08:00
|
|
|
int kvm_test_age_hva(struct kvm *kvm, unsigned long hva);
|
2009-09-24 02:47:18 +08:00
|
|
|
void kvm_set_spte_hva(struct kvm *kvm, unsigned long hva, pte_t pte);
|
2013-01-25 10:18:51 +08:00
|
|
|
int kvm_cpu_has_injectable_intr(struct kvm_vcpu *v);
|
2009-07-09 20:33:52 +08:00
|
|
|
int kvm_cpu_has_interrupt(struct kvm_vcpu *vcpu);
|
|
|
|
int kvm_arch_interrupt_allowed(struct kvm_vcpu *vcpu);
|
2009-07-09 20:33:53 +08:00
|
|
|
int kvm_cpu_get_interrupt(struct kvm_vcpu *v);
|
KVM: x86: INIT and reset sequences are different
x86 architecture defines differences between the reset and INIT sequences.
INIT does not initialize the FPU (including MMX, XMM, YMM, etc.), TSC, PMU,
MSRs (in general), MTRRs machine-check, APIC ID, APIC arbitration ID and BSP.
References (from Intel SDM):
"If the MP protocol has completed and a BSP is chosen, subsequent INITs (either
to a specific processor or system wide) do not cause the MP protocol to be
repeated." [8.4.2: MP Initialization Protocol Requirements and Restrictions]
[Table 9-1. IA-32 Processor States Following Power-up, Reset, or INIT]
"If the processor is reset by asserting the INIT# pin, the x87 FPU state is not
changed." [9.2: X87 FPU INITIALIZATION]
"The state of the local APIC following an INIT reset is the same as it is after
a power-up or hardware reset, except that the APIC ID and arbitration ID
registers are not affected." [10.4.7.3: Local APIC State After an INIT Reset
("Wait-for-SIPI" State)]
Signed-off-by: Nadav Amit <namit@cs.technion.ac.il>
Message-Id: <1428924848-28212-1-git-send-email-namit@cs.technion.ac.il>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-04-13 19:34:08 +08:00
|
|
|
void kvm_vcpu_reset(struct kvm_vcpu *vcpu, bool init_event);
|
2014-09-24 15:57:54 +08:00
|
|
|
void kvm_vcpu_reload_apic_access_page(struct kvm_vcpu *vcpu);
|
2014-09-24 15:57:57 +08:00
|
|
|
void kvm_arch_mmu_notifier_invalidate_page(struct kvm *kvm,
|
|
|
|
unsigned long address);
|
2008-07-25 22:24:52 +08:00
|
|
|
|
2009-09-07 16:12:18 +08:00
|
|
|
void kvm_define_shared_msr(unsigned index, u32 msr);
|
2014-08-28 02:16:44 +08:00
|
|
|
int kvm_set_shared_msr(unsigned index, u64 val, u64 mask);
|
2009-09-07 16:12:18 +08:00
|
|
|
|
2015-10-20 15:39:03 +08:00
|
|
|
u64 kvm_scale_tsc(struct kvm_vcpu *vcpu, u64 tsc);
|
2015-10-20 15:39:07 +08:00
|
|
|
u64 kvm_read_l1_tsc(struct kvm_vcpu *vcpu, u64 host_tsc);
|
2015-10-20 15:39:03 +08:00
|
|
|
|
2014-11-02 17:54:45 +08:00
|
|
|
unsigned long kvm_get_linear_rip(struct kvm_vcpu *vcpu);
|
2010-02-24 00:47:55 +08:00
|
|
|
bool kvm_is_linear_rip(struct kvm_vcpu *vcpu, unsigned long linear_rip);
|
|
|
|
|
2016-01-07 22:05:10 +08:00
|
|
|
void kvm_make_mclock_inprogress_request(struct kvm *kvm);
|
|
|
|
void kvm_make_scan_ioapic_request(struct kvm *kvm);
|
|
|
|
|
2010-10-14 17:22:46 +08:00
|
|
|
void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu,
|
|
|
|
struct kvm_async_pf *work);
|
|
|
|
void kvm_arch_async_page_present(struct kvm_vcpu *vcpu,
|
|
|
|
struct kvm_async_pf *work);
|
2010-10-18 00:13:42 +08:00
|
|
|
void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu,
|
|
|
|
struct kvm_async_pf *work);
|
2010-10-14 17:22:53 +08:00
|
|
|
bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu);
|
2010-10-14 17:22:46 +08:00
|
|
|
extern bool kvm_find_async_pf_gfn(struct kvm_vcpu *vcpu, gfn_t gfn);
|
|
|
|
|
2010-12-21 18:12:01 +08:00
|
|
|
void kvm_complete_insn_gp(struct kvm_vcpu *vcpu, int err);
|
|
|
|
|
2011-11-10 20:57:22 +08:00
|
|
|
int kvm_is_in_guest(void);
|
|
|
|
|
2015-10-12 19:38:32 +08:00
|
|
|
int __x86_set_memory_region(struct kvm *kvm, int id, gpa_t gpa, u32 size);
|
|
|
|
int x86_set_memory_region(struct kvm *kvm, int id, gpa_t gpa, u32 size);
|
2015-07-29 17:56:48 +08:00
|
|
|
bool kvm_vcpu_is_reset_bsp(struct kvm_vcpu *vcpu);
|
|
|
|
bool kvm_vcpu_is_bsp(struct kvm_vcpu *vcpu);
|
2011-11-10 20:57:22 +08:00
|
|
|
|
2015-09-18 22:29:47 +08:00
|
|
|
bool kvm_intr_is_single_vcpu(struct kvm *kvm, struct kvm_lapic_irq *irq,
|
|
|
|
struct kvm_vcpu **dest_vcpu);
|
|
|
|
|
2016-07-13 04:09:27 +08:00
|
|
|
void kvm_set_msi_irq(struct kvm *kvm, struct kvm_kernel_irq_routing_entry *e,
|
2015-09-18 22:29:49 +08:00
|
|
|
struct kvm_lapic_irq *irq);
|
KVM/ARM Changes for v4.4-rc1
Includes a number of fixes for the arch-timer, introducing proper
level-triggered semantics for the arch-timers, a series of patches to
synchronously halt a guest (prerequisite for IRQ forwarding), some tracepoint
improvements, a tweak for the EL2 panic handlers, some more VGIC cleanups
getting rid of redundant state, and finally a stylistic change that gets rid of
some ctags warnings.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1
iQEcBAABAgAGBQJWOhgAAAoJEEtpOizt6ddyKS8H/2ZHMTPjo6yChnrusNWy4Qbr
6laPDlzL+g45oMQRwNL7GnM1deRftaxvT2Wi+X84D/6Y/BD6MPds4HgtBfuWcSZ1
CyRJ0Ot/zrxenucSuJuOjq+a9gdizdAczkbB1MfYDULJH8fb6D+7RYLo3zgh4Xo4
pla3L9U6gSWe+YopBjZtZH43m3fwiwSM/v+uHOTIcXrsbR+fEgx/EFSKmA/DUCuo
P5cFO/ceUGu7nATCexu5V82TgR2hvurrsR7mqfwY8YcF6HRM+NEOoS29xWC77v5S
u/F08TKuKQLv0YTEFTyLETI/oEeuC0cHtrRQBNf4+9kXEOzKyXaae0wR/I6X2Ss=
=GMNk
-----END PGP SIGNATURE-----
Merge tag 'kvm-arm-for-4.4' of git://git.kernel.org/pub/scm/linux/kernel/git/kvmarm/kvmarm into HEAD
KVM/ARM Changes for v4.4-rc1
Includes a number of fixes for the arch-timer, introducing proper
level-triggered semantics for the arch-timers, a series of patches to
synchronously halt a guest (prerequisite for IRQ forwarding), some tracepoint
improvements, a tweak for the EL2 panic handlers, some more VGIC cleanups
getting rid of redundant state, and finally a stylistic change that gets rid of
some ctags warnings.
Conflicts:
arch/x86/include/asm/kvm_host.h
2015-11-04 23:24:17 +08:00
|
|
|
|
2016-05-05 03:09:43 +08:00
|
|
|
static inline void kvm_arch_vcpu_blocking(struct kvm_vcpu *vcpu)
|
|
|
|
{
|
|
|
|
if (kvm_x86_ops->vcpu_blocking)
|
|
|
|
kvm_x86_ops->vcpu_blocking(vcpu);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void kvm_arch_vcpu_unblocking(struct kvm_vcpu *vcpu)
|
|
|
|
{
|
|
|
|
if (kvm_x86_ops->vcpu_unblocking)
|
|
|
|
kvm_x86_ops->vcpu_unblocking(vcpu);
|
|
|
|
}
|
|
|
|
|
2016-05-13 18:16:35 +08:00
|
|
|
static inline void kvm_arch_vcpu_block_finish(struct kvm_vcpu *vcpu) {}
|
2015-08-27 22:41:15 +08:00
|
|
|
|
2016-06-16 06:23:45 +08:00
|
|
|
static inline int kvm_cpu_get_apicid(int mps_cpu)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_X86_LOCAL_APIC
|
|
|
|
return __default_cpu_present_to_apicid(mps_cpu);
|
|
|
|
#else
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
return BAD_APICID;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2008-10-23 13:26:29 +08:00
|
|
|
#endif /* _ASM_X86_KVM_HOST_H */
|