[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
/*
|
|
|
|
* Kernel-based Virtual Machine driver for Linux
|
|
|
|
*
|
|
|
|
* This module enables machines with Intel VT-x extensions to run virtual
|
|
|
|
* machines without emulation or binary translation.
|
|
|
|
*
|
|
|
|
* MMU support
|
|
|
|
*
|
|
|
|
* Copyright (C) 2006 Qumranet, Inc.
|
2010-10-06 12:23:22 +00:00
|
|
|
* Copyright 2010 Red Hat, Inc. and/or its affiliates.
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Yaniv Kamay <yaniv@qumranet.com>
|
|
|
|
* Avi Kivity <avi@qumranet.com>
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2. See
|
|
|
|
* the COPYING file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need the mmu code to access both 32-bit and 64-bit guest ptes,
|
|
|
|
* so the code in this file is compiled twice, once per pte size.
|
|
|
|
*/
|
|
|
|
|
2013-08-05 08:07:12 +00:00
|
|
|
/*
|
|
|
|
* This is used to catch non optimized PT_GUEST_(DIRTY|ACCESS)_SHIFT macro
|
|
|
|
* uses for EPT without A/D paging type.
|
|
|
|
*/
|
|
|
|
extern u64 __pure __using_nonexistent_pte_bit(void)
|
|
|
|
__compiletime_error("wrong use of PT_GUEST_(DIRTY|ACCESS)_SHIFT");
|
|
|
|
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
#if PTTYPE == 64
|
|
|
|
#define pt_element_t u64
|
|
|
|
#define guest_walker guest_walker64
|
|
|
|
#define FNAME(name) paging##64_##name
|
|
|
|
#define PT_BASE_ADDR_MASK PT64_BASE_ADDR_MASK
|
2009-07-27 14:30:45 +00:00
|
|
|
#define PT_LVL_ADDR_MASK(lvl) PT64_LVL_ADDR_MASK(lvl)
|
|
|
|
#define PT_LVL_OFFSET_MASK(lvl) PT64_LVL_OFFSET_MASK(lvl)
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
#define PT_INDEX(addr, level) PT64_INDEX(addr, level)
|
KVM: Allow not-present guest page faults to bypass kvm
There are two classes of page faults trapped by kvm:
- host page faults, where the fault is needed to allow kvm to install
the shadow pte or update the guest accessed and dirty bits
- guest page faults, where the guest has faulted and kvm simply injects
the fault back into the guest to handle
The second class, guest page faults, is pure overhead. We can eliminate
some of it on vmx using the following evil trick:
- when we set up a shadow page table entry, if the corresponding guest pte
is not present, set up the shadow pte as not present
- if the guest pte _is_ present, mark the shadow pte as present but also
set one of the reserved bits in the shadow pte
- tell the vmx hardware not to trap faults which have the present bit clear
With this, normal page-not-present faults go directly to the guest,
bypassing kvm entirely.
Unfortunately, this trick only works on Intel hardware, as AMD lacks a
way to discriminate among page faults based on error code. It is also
a little risky since it uses reserved bits which might become unreserved
in the future, so a module parameter is provided to disable it.
Signed-off-by: Avi Kivity <avi@qumranet.com>
2007-09-16 16:58:32 +00:00
|
|
|
#define PT_LEVEL_BITS PT64_LEVEL_BITS
|
2013-08-05 08:07:10 +00:00
|
|
|
#define PT_GUEST_ACCESSED_MASK PT_ACCESSED_MASK
|
|
|
|
#define PT_GUEST_DIRTY_MASK PT_DIRTY_MASK
|
|
|
|
#define PT_GUEST_DIRTY_SHIFT PT_DIRTY_SHIFT
|
|
|
|
#define PT_GUEST_ACCESSED_SHIFT PT_ACCESSED_SHIFT
|
[PATCH] KVM: MMU: Shadow page table caching
Define a hashtable for caching shadow page tables. Look up the cache on
context switch (cr3 change) or during page faults.
The key to the cache is a combination of
- the guest page table frame number
- the number of paging levels in the guest
* we can cache real mode, 32-bit mode, pae, and long mode page
tables simultaneously. this is useful for smp bootup.
- the guest page table table
* some kernels use a page as both a page table and a page directory. this
allows multiple shadow pages to exist for that page, one per level
- the "quadrant"
* 32-bit mode page tables span 4MB, whereas a shadow page table spans
2MB. similarly, a 32-bit page directory spans 4GB, while a shadow
page directory spans 1GB. the quadrant allows caching up to 4 shadow page
tables for one guest page in one level.
- a "metaphysical" bit
* for real mode, and for pse pages, there is no guest page table, so set
the bit to avoid write protecting the page.
Signed-off-by: Avi Kivity <avi@qumranet.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2007-01-06 00:36:43 +00:00
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
#define PT_MAX_FULL_LEVELS 4
|
2007-12-07 12:56:58 +00:00
|
|
|
#define CMPXCHG cmpxchg
|
[PATCH] KVM: MMU: Shadow page table caching
Define a hashtable for caching shadow page tables. Look up the cache on
context switch (cr3 change) or during page faults.
The key to the cache is a combination of
- the guest page table frame number
- the number of paging levels in the guest
* we can cache real mode, 32-bit mode, pae, and long mode page
tables simultaneously. this is useful for smp bootup.
- the guest page table table
* some kernels use a page as both a page table and a page directory. this
allows multiple shadow pages to exist for that page, one per level
- the "quadrant"
* 32-bit mode page tables span 4MB, whereas a shadow page table spans
2MB. similarly, a 32-bit page directory spans 4GB, while a shadow
page directory spans 1GB. the quadrant allows caching up to 4 shadow page
tables for one guest page in one level.
- a "metaphysical" bit
* for real mode, and for pse pages, there is no guest page table, so set
the bit to avoid write protecting the page.
Signed-off-by: Avi Kivity <avi@qumranet.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2007-01-06 00:36:43 +00:00
|
|
|
#else
|
2007-12-07 12:56:58 +00:00
|
|
|
#define CMPXCHG cmpxchg64
|
[PATCH] KVM: MMU: Shadow page table caching
Define a hashtable for caching shadow page tables. Look up the cache on
context switch (cr3 change) or during page faults.
The key to the cache is a combination of
- the guest page table frame number
- the number of paging levels in the guest
* we can cache real mode, 32-bit mode, pae, and long mode page
tables simultaneously. this is useful for smp bootup.
- the guest page table table
* some kernels use a page as both a page table and a page directory. this
allows multiple shadow pages to exist for that page, one per level
- the "quadrant"
* 32-bit mode page tables span 4MB, whereas a shadow page table spans
2MB. similarly, a 32-bit page directory spans 4GB, while a shadow
page directory spans 1GB. the quadrant allows caching up to 4 shadow page
tables for one guest page in one level.
- a "metaphysical" bit
* for real mode, and for pse pages, there is no guest page table, so set
the bit to avoid write protecting the page.
Signed-off-by: Avi Kivity <avi@qumranet.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2007-01-06 00:36:43 +00:00
|
|
|
#define PT_MAX_FULL_LEVELS 2
|
|
|
|
#endif
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
#elif PTTYPE == 32
|
|
|
|
#define pt_element_t u32
|
|
|
|
#define guest_walker guest_walker32
|
|
|
|
#define FNAME(name) paging##32_##name
|
|
|
|
#define PT_BASE_ADDR_MASK PT32_BASE_ADDR_MASK
|
2009-07-27 14:30:45 +00:00
|
|
|
#define PT_LVL_ADDR_MASK(lvl) PT32_LVL_ADDR_MASK(lvl)
|
|
|
|
#define PT_LVL_OFFSET_MASK(lvl) PT32_LVL_OFFSET_MASK(lvl)
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
#define PT_INDEX(addr, level) PT32_INDEX(addr, level)
|
KVM: Allow not-present guest page faults to bypass kvm
There are two classes of page faults trapped by kvm:
- host page faults, where the fault is needed to allow kvm to install
the shadow pte or update the guest accessed and dirty bits
- guest page faults, where the guest has faulted and kvm simply injects
the fault back into the guest to handle
The second class, guest page faults, is pure overhead. We can eliminate
some of it on vmx using the following evil trick:
- when we set up a shadow page table entry, if the corresponding guest pte
is not present, set up the shadow pte as not present
- if the guest pte _is_ present, mark the shadow pte as present but also
set one of the reserved bits in the shadow pte
- tell the vmx hardware not to trap faults which have the present bit clear
With this, normal page-not-present faults go directly to the guest,
bypassing kvm entirely.
Unfortunately, this trick only works on Intel hardware, as AMD lacks a
way to discriminate among page faults based on error code. It is also
a little risky since it uses reserved bits which might become unreserved
in the future, so a module parameter is provided to disable it.
Signed-off-by: Avi Kivity <avi@qumranet.com>
2007-09-16 16:58:32 +00:00
|
|
|
#define PT_LEVEL_BITS PT32_LEVEL_BITS
|
[PATCH] KVM: MMU: Shadow page table caching
Define a hashtable for caching shadow page tables. Look up the cache on
context switch (cr3 change) or during page faults.
The key to the cache is a combination of
- the guest page table frame number
- the number of paging levels in the guest
* we can cache real mode, 32-bit mode, pae, and long mode page
tables simultaneously. this is useful for smp bootup.
- the guest page table table
* some kernels use a page as both a page table and a page directory. this
allows multiple shadow pages to exist for that page, one per level
- the "quadrant"
* 32-bit mode page tables span 4MB, whereas a shadow page table spans
2MB. similarly, a 32-bit page directory spans 4GB, while a shadow
page directory spans 1GB. the quadrant allows caching up to 4 shadow page
tables for one guest page in one level.
- a "metaphysical" bit
* for real mode, and for pse pages, there is no guest page table, so set
the bit to avoid write protecting the page.
Signed-off-by: Avi Kivity <avi@qumranet.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2007-01-06 00:36:43 +00:00
|
|
|
#define PT_MAX_FULL_LEVELS 2
|
2013-08-05 08:07:10 +00:00
|
|
|
#define PT_GUEST_ACCESSED_MASK PT_ACCESSED_MASK
|
|
|
|
#define PT_GUEST_DIRTY_MASK PT_DIRTY_MASK
|
|
|
|
#define PT_GUEST_DIRTY_SHIFT PT_DIRTY_SHIFT
|
|
|
|
#define PT_GUEST_ACCESSED_SHIFT PT_ACCESSED_SHIFT
|
2007-12-07 12:56:58 +00:00
|
|
|
#define CMPXCHG cmpxchg
|
2013-08-05 08:07:12 +00:00
|
|
|
#elif PTTYPE == PTTYPE_EPT
|
|
|
|
#define pt_element_t u64
|
|
|
|
#define guest_walker guest_walkerEPT
|
|
|
|
#define FNAME(name) ept_##name
|
|
|
|
#define PT_BASE_ADDR_MASK PT64_BASE_ADDR_MASK
|
|
|
|
#define PT_LVL_ADDR_MASK(lvl) PT64_LVL_ADDR_MASK(lvl)
|
|
|
|
#define PT_LVL_OFFSET_MASK(lvl) PT64_LVL_OFFSET_MASK(lvl)
|
|
|
|
#define PT_INDEX(addr, level) PT64_INDEX(addr, level)
|
|
|
|
#define PT_LEVEL_BITS PT64_LEVEL_BITS
|
|
|
|
#define PT_GUEST_ACCESSED_MASK 0
|
|
|
|
#define PT_GUEST_DIRTY_MASK 0
|
|
|
|
#define PT_GUEST_DIRTY_SHIFT __using_nonexistent_pte_bit()
|
|
|
|
#define PT_GUEST_ACCESSED_SHIFT __using_nonexistent_pte_bit()
|
|
|
|
#define CMPXCHG cmpxchg64
|
|
|
|
#define PT_MAX_FULL_LEVELS 4
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
#else
|
|
|
|
#error Invalid PTTYPE value
|
|
|
|
#endif
|
|
|
|
|
2009-07-27 14:30:45 +00:00
|
|
|
#define gpte_to_gfn_lvl FNAME(gpte_to_gfn_lvl)
|
|
|
|
#define gpte_to_gfn(pte) gpte_to_gfn_lvl((pte), PT_PAGE_TABLE_LEVEL)
|
2007-11-21 10:35:07 +00:00
|
|
|
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
/*
|
|
|
|
* The guest_walker structure emulates the behavior of the hardware page
|
|
|
|
* table walker.
|
|
|
|
*/
|
|
|
|
struct guest_walker {
|
|
|
|
int level;
|
2012-09-16 11:18:51 +00:00
|
|
|
unsigned max_level;
|
[PATCH] KVM: MMU: Shadow page table caching
Define a hashtable for caching shadow page tables. Look up the cache on
context switch (cr3 change) or during page faults.
The key to the cache is a combination of
- the guest page table frame number
- the number of paging levels in the guest
* we can cache real mode, 32-bit mode, pae, and long mode page
tables simultaneously. this is useful for smp bootup.
- the guest page table table
* some kernels use a page as both a page table and a page directory. this
allows multiple shadow pages to exist for that page, one per level
- the "quadrant"
* 32-bit mode page tables span 4MB, whereas a shadow page table spans
2MB. similarly, a 32-bit page directory spans 4GB, while a shadow
page directory spans 1GB. the quadrant allows caching up to 4 shadow page
tables for one guest page in one level.
- a "metaphysical" bit
* for real mode, and for pse pages, there is no guest page table, so set
the bit to avoid write protecting the page.
Signed-off-by: Avi Kivity <avi@qumranet.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2007-01-06 00:36:43 +00:00
|
|
|
gfn_t table_gfn[PT_MAX_FULL_LEVELS];
|
2007-12-12 00:12:27 +00:00
|
|
|
pt_element_t ptes[PT_MAX_FULL_LEVELS];
|
2010-08-22 11:13:33 +00:00
|
|
|
pt_element_t prefetch_ptes[PTE_PREFETCH_NUM];
|
2007-12-12 00:12:27 +00:00
|
|
|
gpa_t pte_gpa[PT_MAX_FULL_LEVELS];
|
2012-09-16 11:18:51 +00:00
|
|
|
pt_element_t __user *ptep_user[PT_MAX_FULL_LEVELS];
|
2013-09-09 11:52:33 +00:00
|
|
|
bool pte_writable[PT_MAX_FULL_LEVELS];
|
2007-12-09 14:15:46 +00:00
|
|
|
unsigned pt_access;
|
|
|
|
unsigned pte_access;
|
2007-01-06 00:36:44 +00:00
|
|
|
gfn_t gfn;
|
2010-11-22 15:53:27 +00:00
|
|
|
struct x86_exception fault;
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
};
|
|
|
|
|
2009-07-27 14:30:45 +00:00
|
|
|
static gfn_t gpte_to_gfn_lvl(pt_element_t gpte, int lvl)
|
2007-11-21 10:35:07 +00:00
|
|
|
{
|
2009-07-27 14:30:45 +00:00
|
|
|
return (gpte & PT_LVL_ADDR_MASK(lvl)) >> PAGE_SHIFT;
|
2007-11-21 10:35:07 +00:00
|
|
|
}
|
|
|
|
|
2013-08-05 08:07:09 +00:00
|
|
|
static inline void FNAME(protect_clean_gpte)(unsigned *access, unsigned gpte)
|
|
|
|
{
|
|
|
|
unsigned mask;
|
|
|
|
|
2013-08-05 08:07:11 +00:00
|
|
|
/* dirty bit is not supported, so no need to track it */
|
|
|
|
if (!PT_GUEST_DIRTY_MASK)
|
|
|
|
return;
|
|
|
|
|
2013-08-05 08:07:09 +00:00
|
|
|
BUILD_BUG_ON(PT_WRITABLE_MASK != ACC_WRITE_MASK);
|
|
|
|
|
|
|
|
mask = (unsigned)~ACC_WRITE_MASK;
|
|
|
|
/* Allow write access to dirty gptes */
|
2013-08-05 08:07:10 +00:00
|
|
|
mask |= (gpte >> (PT_GUEST_DIRTY_SHIFT - PT_WRITABLE_SHIFT)) &
|
|
|
|
PT_WRITABLE_MASK;
|
2013-08-05 08:07:09 +00:00
|
|
|
*access &= mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool FNAME(is_rsvd_bits_set)(struct kvm_mmu *mmu, u64 gpte, int level)
|
|
|
|
{
|
2013-08-06 09:00:32 +00:00
|
|
|
int bit7 = (gpte >> 7) & 1, low6 = gpte & 0x3f;
|
2013-08-05 08:07:09 +00:00
|
|
|
|
2013-08-06 09:00:32 +00:00
|
|
|
return (gpte & mmu->rsvd_bits_mask[bit7][level-1]) |
|
|
|
|
((mmu->bad_mt_xwr & (1ull << low6)) != 0);
|
2013-08-05 08:07:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int FNAME(is_present_gpte)(unsigned long pte)
|
|
|
|
{
|
2013-08-05 08:07:12 +00:00
|
|
|
#if PTTYPE != PTTYPE_EPT
|
2013-08-05 08:07:09 +00:00
|
|
|
return is_present_gpte(pte);
|
2013-08-05 08:07:12 +00:00
|
|
|
#else
|
|
|
|
return pte & 7;
|
|
|
|
#endif
|
2013-08-05 08:07:09 +00:00
|
|
|
}
|
|
|
|
|
2011-04-20 13:33:16 +00:00
|
|
|
static int FNAME(cmpxchg_gpte)(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu,
|
2011-05-01 05:33:07 +00:00
|
|
|
pt_element_t __user *ptep_user, unsigned index,
|
|
|
|
pt_element_t orig_pte, pt_element_t new_pte)
|
2007-12-07 12:56:58 +00:00
|
|
|
{
|
2011-05-01 05:33:07 +00:00
|
|
|
int npages;
|
2007-12-07 12:56:58 +00:00
|
|
|
pt_element_t ret;
|
|
|
|
pt_element_t *table;
|
|
|
|
struct page *page;
|
|
|
|
|
2011-05-01 05:33:07 +00:00
|
|
|
npages = get_user_pages_fast((unsigned long)ptep_user, 1, 1, &page);
|
|
|
|
/* Check if the user is doing something meaningless. */
|
|
|
|
if (unlikely(npages != 1))
|
2011-04-20 13:33:16 +00:00
|
|
|
return -EFAULT;
|
|
|
|
|
2011-11-25 15:14:17 +00:00
|
|
|
table = kmap_atomic(page);
|
2007-12-07 12:56:58 +00:00
|
|
|
ret = CMPXCHG(&table[index], orig_pte, new_pte);
|
2011-11-25 15:14:17 +00:00
|
|
|
kunmap_atomic(table);
|
2007-12-07 12:56:58 +00:00
|
|
|
|
|
|
|
kvm_release_page_dirty(page);
|
|
|
|
|
|
|
|
return (ret != orig_pte);
|
|
|
|
}
|
|
|
|
|
2013-08-05 08:07:09 +00:00
|
|
|
static bool FNAME(prefetch_invalid_gpte)(struct kvm_vcpu *vcpu,
|
|
|
|
struct kvm_mmu_page *sp, u64 *spte,
|
|
|
|
u64 gpte)
|
|
|
|
{
|
|
|
|
if (FNAME(is_rsvd_bits_set)(&vcpu->arch.mmu, gpte, PT_PAGE_TABLE_LEVEL))
|
|
|
|
goto no_present;
|
|
|
|
|
|
|
|
if (!FNAME(is_present_gpte)(gpte))
|
|
|
|
goto no_present;
|
|
|
|
|
2013-08-05 08:07:11 +00:00
|
|
|
/* if accessed bit is not supported prefetch non accessed gpte */
|
|
|
|
if (PT_GUEST_ACCESSED_MASK && !(gpte & PT_GUEST_ACCESSED_MASK))
|
2013-08-05 08:07:09 +00:00
|
|
|
goto no_present;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
no_present:
|
|
|
|
drop_spte(vcpu->kvm, spte);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned FNAME(gpte_access)(struct kvm_vcpu *vcpu, u64 gpte)
|
|
|
|
{
|
|
|
|
unsigned access;
|
2013-08-05 08:07:12 +00:00
|
|
|
#if PTTYPE == PTTYPE_EPT
|
|
|
|
access = ((gpte & VMX_EPT_WRITABLE_MASK) ? ACC_WRITE_MASK : 0) |
|
|
|
|
((gpte & VMX_EPT_EXECUTABLE_MASK) ? ACC_EXEC_MASK : 0) |
|
|
|
|
ACC_USER_MASK;
|
|
|
|
#else
|
2013-08-05 08:07:09 +00:00
|
|
|
access = (gpte & (PT_WRITABLE_MASK | PT_USER_MASK)) | ACC_EXEC_MASK;
|
|
|
|
access &= ~(gpte >> PT64_NX_SHIFT);
|
2013-08-05 08:07:12 +00:00
|
|
|
#endif
|
2013-08-05 08:07:09 +00:00
|
|
|
|
|
|
|
return access;
|
|
|
|
}
|
|
|
|
|
2012-09-16 11:18:51 +00:00
|
|
|
static int FNAME(update_accessed_dirty_bits)(struct kvm_vcpu *vcpu,
|
|
|
|
struct kvm_mmu *mmu,
|
|
|
|
struct guest_walker *walker,
|
|
|
|
int write_fault)
|
|
|
|
{
|
|
|
|
unsigned level, index;
|
|
|
|
pt_element_t pte, orig_pte;
|
|
|
|
pt_element_t __user *ptep_user;
|
|
|
|
gfn_t table_gfn;
|
|
|
|
int ret;
|
|
|
|
|
2013-08-05 08:07:11 +00:00
|
|
|
/* dirty/accessed bits are not supported, so no need to update them */
|
|
|
|
if (!PT_GUEST_DIRTY_MASK)
|
|
|
|
return 0;
|
|
|
|
|
2012-09-16 11:18:51 +00:00
|
|
|
for (level = walker->max_level; level >= walker->level; --level) {
|
|
|
|
pte = orig_pte = walker->ptes[level - 1];
|
|
|
|
table_gfn = walker->table_gfn[level - 1];
|
|
|
|
ptep_user = walker->ptep_user[level - 1];
|
|
|
|
index = offset_in_page(ptep_user) / sizeof(pt_element_t);
|
2013-08-05 08:07:10 +00:00
|
|
|
if (!(pte & PT_GUEST_ACCESSED_MASK)) {
|
2012-09-16 11:18:51 +00:00
|
|
|
trace_kvm_mmu_set_accessed_bit(table_gfn, index, sizeof(pte));
|
2013-08-05 08:07:10 +00:00
|
|
|
pte |= PT_GUEST_ACCESSED_MASK;
|
2012-09-16 11:18:51 +00:00
|
|
|
}
|
2013-08-05 08:07:09 +00:00
|
|
|
if (level == walker->level && write_fault &&
|
2013-08-05 08:07:10 +00:00
|
|
|
!(pte & PT_GUEST_DIRTY_MASK)) {
|
2012-09-16 11:18:51 +00:00
|
|
|
trace_kvm_mmu_set_dirty_bit(table_gfn, index, sizeof(pte));
|
2013-08-05 08:07:10 +00:00
|
|
|
pte |= PT_GUEST_DIRTY_MASK;
|
2012-09-16 11:18:51 +00:00
|
|
|
}
|
|
|
|
if (pte == orig_pte)
|
|
|
|
continue;
|
|
|
|
|
2013-09-09 11:52:33 +00:00
|
|
|
/*
|
|
|
|
* If the slot is read-only, simply do not process the accessed
|
|
|
|
* and dirty bits. This is the correct thing to do if the slot
|
|
|
|
* is ROM, and page tables in read-as-ROM/write-as-MMIO slots
|
|
|
|
* are only supported if the accessed and dirty bits are already
|
|
|
|
* set in the ROM (so that MMIO writes are never needed).
|
|
|
|
*
|
|
|
|
* Note that NPT does not allow this at all and faults, since
|
|
|
|
* it always wants nested page table entries for the guest
|
|
|
|
* page tables to be writable. And EPT works but will simply
|
|
|
|
* overwrite the read-only memory to set the accessed and dirty
|
|
|
|
* bits.
|
|
|
|
*/
|
|
|
|
if (unlikely(!walker->pte_writable[level - 1]))
|
|
|
|
continue;
|
|
|
|
|
2012-09-16 11:18:51 +00:00
|
|
|
ret = FNAME(cmpxchg_gpte)(vcpu, mmu, ptep_user, index, orig_pte, pte);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
mark_page_dirty(vcpu->kvm, table_gfn);
|
|
|
|
walker->ptes[level] = pte;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-01-06 00:36:40 +00:00
|
|
|
/*
|
|
|
|
* Fetch a guest pte for a guest virtual address
|
|
|
|
*/
|
2010-09-10 15:30:47 +00:00
|
|
|
static int FNAME(walk_addr_generic)(struct guest_walker *walker,
|
|
|
|
struct kvm_vcpu *vcpu, struct kvm_mmu *mmu,
|
2010-09-28 09:03:14 +00:00
|
|
|
gva_t addr, u32 access)
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
{
|
2012-09-16 11:18:51 +00:00
|
|
|
int ret;
|
2007-10-17 10:18:47 +00:00
|
|
|
pt_element_t pte;
|
2011-05-30 20:11:17 +00:00
|
|
|
pt_element_t __user *uninitialized_var(ptep_user);
|
[PATCH] KVM: MMU: Shadow page table caching
Define a hashtable for caching shadow page tables. Look up the cache on
context switch (cr3 change) or during page faults.
The key to the cache is a combination of
- the guest page table frame number
- the number of paging levels in the guest
* we can cache real mode, 32-bit mode, pae, and long mode page
tables simultaneously. this is useful for smp bootup.
- the guest page table table
* some kernels use a page as both a page table and a page directory. this
allows multiple shadow pages to exist for that page, one per level
- the "quadrant"
* 32-bit mode page tables span 4MB, whereas a shadow page table spans
2MB. similarly, a 32-bit page directory spans 4GB, while a shadow
page directory spans 1GB. the quadrant allows caching up to 4 shadow page
tables for one guest page in one level.
- a "metaphysical" bit
* for real mode, and for pse pages, there is no guest page table, so set
the bit to avoid write protecting the page.
Signed-off-by: Avi Kivity <avi@qumranet.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2007-01-06 00:36:43 +00:00
|
|
|
gfn_t table_gfn;
|
2013-01-08 08:49:00 +00:00
|
|
|
unsigned index, pt_access, pte_access, accessed_dirty;
|
2007-10-17 10:18:47 +00:00
|
|
|
gpa_t pte_gpa;
|
2011-06-30 16:34:56 +00:00
|
|
|
int offset;
|
|
|
|
const int write_fault = access & PFERR_WRITE_MASK;
|
|
|
|
const int user_fault = access & PFERR_USER_MASK;
|
|
|
|
const int fetch_fault = access & PFERR_FETCH_MASK;
|
|
|
|
u16 errcode = 0;
|
2012-09-12 12:12:09 +00:00
|
|
|
gpa_t real_gpa;
|
|
|
|
gfn_t gfn;
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
|
2012-06-20 08:00:00 +00:00
|
|
|
trace_kvm_mmu_pagetable_walk(addr, access);
|
2011-06-30 16:36:07 +00:00
|
|
|
retry_walk:
|
2010-09-10 15:30:47 +00:00
|
|
|
walker->level = mmu->root_level;
|
|
|
|
pte = mmu->get_cr3(vcpu);
|
|
|
|
|
2007-01-06 00:36:41 +00:00
|
|
|
#if PTTYPE == 64
|
2010-09-10 15:30:47 +00:00
|
|
|
if (walker->level == PT32E_ROOT_LEVEL) {
|
2011-07-28 08:36:17 +00:00
|
|
|
pte = mmu->get_pdptr(vcpu, (addr >> 30) & 3);
|
2009-07-06 09:21:32 +00:00
|
|
|
trace_kvm_mmu_paging_element(pte, walker->level);
|
2013-08-05 08:07:09 +00:00
|
|
|
if (!FNAME(is_present_gpte)(pte))
|
2010-07-06 13:20:43 +00:00
|
|
|
goto error;
|
2007-01-06 00:36:41 +00:00
|
|
|
--walker->level;
|
|
|
|
}
|
|
|
|
#endif
|
2012-09-16 11:18:51 +00:00
|
|
|
walker->max_level = walker->level;
|
2006-12-30 00:49:37 +00:00
|
|
|
ASSERT((!is_long_mode(vcpu) && is_pae(vcpu)) ||
|
2010-09-10 15:30:47 +00:00
|
|
|
(mmu->get_cr3(vcpu) & CR3_NONPAE_RESERVED_BITS) == 0);
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
|
2013-08-05 08:07:10 +00:00
|
|
|
accessed_dirty = PT_GUEST_ACCESSED_MASK;
|
2012-09-12 12:12:09 +00:00
|
|
|
pt_access = pte_access = ACC_ALL;
|
|
|
|
++walker->level;
|
2007-01-06 00:36:40 +00:00
|
|
|
|
2012-09-12 12:12:09 +00:00
|
|
|
do {
|
2011-04-21 15:34:44 +00:00
|
|
|
gfn_t real_gfn;
|
|
|
|
unsigned long host_addr;
|
|
|
|
|
2012-09-12 12:12:09 +00:00
|
|
|
pt_access &= pte_access;
|
|
|
|
--walker->level;
|
|
|
|
|
2007-10-17 10:18:47 +00:00
|
|
|
index = PT_INDEX(addr, walker->level);
|
2007-01-06 00:36:40 +00:00
|
|
|
|
2007-11-21 10:35:07 +00:00
|
|
|
table_gfn = gpte_to_gfn(pte);
|
2010-09-10 15:30:52 +00:00
|
|
|
offset = index * sizeof(pt_element_t);
|
|
|
|
pte_gpa = gfn_to_gpa(table_gfn) + offset;
|
2007-10-17 10:18:47 +00:00
|
|
|
walker->table_gfn[walker->level - 1] = table_gfn;
|
2007-12-12 00:12:27 +00:00
|
|
|
walker->pte_gpa[walker->level - 1] = pte_gpa;
|
2007-10-17 10:18:47 +00:00
|
|
|
|
2011-04-21 15:34:44 +00:00
|
|
|
real_gfn = mmu->translate_gpa(vcpu, gfn_to_gpa(table_gfn),
|
|
|
|
PFERR_USER_MASK|PFERR_WRITE_MASK);
|
2011-06-30 16:34:56 +00:00
|
|
|
if (unlikely(real_gfn == UNMAPPED_GVA))
|
|
|
|
goto error;
|
2011-04-21 15:34:44 +00:00
|
|
|
real_gfn = gpa_to_gfn(real_gfn);
|
|
|
|
|
2013-09-09 11:52:33 +00:00
|
|
|
host_addr = gfn_to_hva_prot(vcpu->kvm, real_gfn,
|
|
|
|
&walker->pte_writable[walker->level - 1]);
|
2011-06-30 16:34:56 +00:00
|
|
|
if (unlikely(kvm_is_error_hva(host_addr)))
|
|
|
|
goto error;
|
2011-04-21 15:34:44 +00:00
|
|
|
|
|
|
|
ptep_user = (pt_element_t __user *)((void *)host_addr + offset);
|
2011-06-30 16:34:56 +00:00
|
|
|
if (unlikely(__copy_from_user(&pte, ptep_user, sizeof(pte))))
|
|
|
|
goto error;
|
2012-09-16 11:18:51 +00:00
|
|
|
walker->ptep_user[walker->level - 1] = ptep_user;
|
2010-01-14 19:41:27 +00:00
|
|
|
|
2009-07-06 09:21:32 +00:00
|
|
|
trace_kvm_mmu_paging_element(pte, walker->level);
|
2007-10-17 10:18:47 +00:00
|
|
|
|
2013-08-05 08:07:09 +00:00
|
|
|
if (unlikely(!FNAME(is_present_gpte)(pte)))
|
2011-06-30 16:34:56 +00:00
|
|
|
goto error;
|
2007-01-26 08:56:41 +00:00
|
|
|
|
2013-08-05 08:07:09 +00:00
|
|
|
if (unlikely(FNAME(is_rsvd_bits_set)(mmu, pte,
|
|
|
|
walker->level))) {
|
2011-06-30 16:34:56 +00:00
|
|
|
errcode |= PFERR_RSVD_MASK | PFERR_PRESENT_MASK;
|
|
|
|
goto error;
|
2010-07-06 13:20:43 +00:00
|
|
|
}
|
2009-03-30 08:21:08 +00:00
|
|
|
|
2012-09-16 12:03:02 +00:00
|
|
|
accessed_dirty &= pte;
|
2013-08-05 08:07:09 +00:00
|
|
|
pte_access = pt_access & FNAME(gpte_access)(vcpu, pte);
|
2007-01-26 08:56:41 +00:00
|
|
|
|
2007-12-12 00:12:27 +00:00
|
|
|
walker->ptes[walker->level - 1] = pte;
|
2012-09-12 17:46:56 +00:00
|
|
|
} while (!is_last_gpte(mmu, walker->level, pte));
|
2007-10-17 10:18:47 +00:00
|
|
|
|
2012-09-16 11:49:15 +00:00
|
|
|
if (unlikely(permission_fault(mmu, pte_access, access))) {
|
2011-06-30 16:34:56 +00:00
|
|
|
errcode |= PFERR_PRESENT_MASK;
|
2010-07-06 13:20:43 +00:00
|
|
|
goto error;
|
2011-06-30 16:34:56 +00:00
|
|
|
}
|
2010-07-06 13:20:43 +00:00
|
|
|
|
2012-09-12 12:12:09 +00:00
|
|
|
gfn = gpte_to_gfn_lvl(pte, walker->level);
|
|
|
|
gfn += (addr & PT_LVL_OFFSET_MASK(walker->level)) >> PAGE_SHIFT;
|
|
|
|
|
|
|
|
if (PTTYPE == 32 && walker->level == PT_DIRECTORY_LEVEL && is_cpuid_PSE36())
|
|
|
|
gfn += pse36_gfn_delta(pte);
|
|
|
|
|
2012-09-19 16:33:48 +00:00
|
|
|
real_gpa = mmu->translate_gpa(vcpu, gfn_to_gpa(gfn), access);
|
2012-09-12 12:12:09 +00:00
|
|
|
if (real_gpa == UNMAPPED_GVA)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
walker->gfn = real_gpa >> PAGE_SHIFT;
|
|
|
|
|
2012-09-12 10:44:53 +00:00
|
|
|
if (!write_fault)
|
2013-08-05 08:07:09 +00:00
|
|
|
FNAME(protect_clean_gpte)(&pte_access, pte);
|
2012-12-27 12:44:58 +00:00
|
|
|
else
|
|
|
|
/*
|
2013-08-05 08:07:11 +00:00
|
|
|
* On a write fault, fold the dirty bit into accessed_dirty.
|
|
|
|
* For modes without A/D bits support accessed_dirty will be
|
|
|
|
* always clear.
|
2012-12-27 12:44:58 +00:00
|
|
|
*/
|
2013-08-05 08:07:10 +00:00
|
|
|
accessed_dirty &= pte >>
|
|
|
|
(PT_GUEST_DIRTY_SHIFT - PT_GUEST_ACCESSED_SHIFT);
|
2012-09-16 12:03:02 +00:00
|
|
|
|
|
|
|
if (unlikely(!accessed_dirty)) {
|
|
|
|
ret = FNAME(update_accessed_dirty_bits)(vcpu, mmu, walker, write_fault);
|
|
|
|
if (unlikely(ret < 0))
|
|
|
|
goto error;
|
|
|
|
else if (ret)
|
|
|
|
goto retry_walk;
|
|
|
|
}
|
2007-10-17 10:18:47 +00:00
|
|
|
|
2007-12-09 14:15:46 +00:00
|
|
|
walker->pt_access = pt_access;
|
|
|
|
walker->pte_access = pte_access;
|
|
|
|
pgprintk("%s: pte %llx pte_access %x pt_access %x\n",
|
2010-05-05 01:58:33 +00:00
|
|
|
__func__, (u64)pte, pte_access, pt_access);
|
2007-01-26 08:56:41 +00:00
|
|
|
return 1;
|
|
|
|
|
2010-07-06 13:20:43 +00:00
|
|
|
error:
|
2011-06-30 16:34:56 +00:00
|
|
|
errcode |= write_fault | user_fault;
|
2011-06-03 03:14:16 +00:00
|
|
|
if (fetch_fault && (mmu->nx ||
|
|
|
|
kvm_read_cr4_bits(vcpu, X86_CR4_SMEP)))
|
2011-06-30 16:34:56 +00:00
|
|
|
errcode |= PFERR_FETCH_MASK;
|
2010-09-10 15:30:46 +00:00
|
|
|
|
2011-06-30 16:34:56 +00:00
|
|
|
walker->fault.vector = PF_VECTOR;
|
|
|
|
walker->fault.error_code_valid = true;
|
|
|
|
walker->fault.error_code = errcode;
|
2013-08-06 09:00:32 +00:00
|
|
|
|
|
|
|
#if PTTYPE == PTTYPE_EPT
|
|
|
|
/*
|
|
|
|
* Use PFERR_RSVD_MASK in error_code to to tell if EPT
|
|
|
|
* misconfiguration requires to be injected. The detection is
|
|
|
|
* done by is_rsvd_bits_set() above.
|
|
|
|
*
|
|
|
|
* We set up the value of exit_qualification to inject:
|
|
|
|
* [2:0] - Derive from [2:0] of real exit_qualification at EPT violation
|
|
|
|
* [5:3] - Calculated by the page walk of the guest EPT page tables
|
|
|
|
* [7:8] - Derived from [7:8] of real exit_qualification
|
|
|
|
*
|
|
|
|
* The other bits are set to 0.
|
|
|
|
*/
|
|
|
|
if (!(errcode & PFERR_RSVD_MASK)) {
|
|
|
|
vcpu->arch.exit_qualification &= 0x187;
|
|
|
|
vcpu->arch.exit_qualification |= ((pt_access & pte) & 0x7) << 3;
|
|
|
|
}
|
|
|
|
#endif
|
2010-11-29 14:12:30 +00:00
|
|
|
walker->fault.address = addr;
|
|
|
|
walker->fault.nested_page_fault = mmu != vcpu->arch.walk_mmu;
|
2010-09-10 15:30:46 +00:00
|
|
|
|
2010-11-22 15:53:27 +00:00
|
|
|
trace_kvm_mmu_walker_error(walker->fault.error_code);
|
2007-07-23 06:51:39 +00:00
|
|
|
return 0;
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
}
|
|
|
|
|
2010-09-10 15:30:47 +00:00
|
|
|
static int FNAME(walk_addr)(struct guest_walker *walker,
|
2010-09-28 09:03:14 +00:00
|
|
|
struct kvm_vcpu *vcpu, gva_t addr, u32 access)
|
2010-09-10 15:30:47 +00:00
|
|
|
{
|
|
|
|
return FNAME(walk_addr_generic)(walker, vcpu, &vcpu->arch.mmu, addr,
|
2010-09-28 09:03:14 +00:00
|
|
|
access);
|
2010-09-10 15:30:47 +00:00
|
|
|
}
|
|
|
|
|
2013-08-05 08:07:12 +00:00
|
|
|
#if PTTYPE != PTTYPE_EPT
|
2010-09-10 15:30:50 +00:00
|
|
|
static int FNAME(walk_addr_nested)(struct guest_walker *walker,
|
|
|
|
struct kvm_vcpu *vcpu, gva_t addr,
|
2010-09-28 09:03:14 +00:00
|
|
|
u32 access)
|
2010-09-10 15:30:50 +00:00
|
|
|
{
|
|
|
|
return FNAME(walk_addr_generic)(walker, vcpu, &vcpu->arch.nested_mmu,
|
2010-09-28 09:03:14 +00:00
|
|
|
addr, access);
|
2010-09-10 15:30:50 +00:00
|
|
|
}
|
2013-08-05 08:07:12 +00:00
|
|
|
#endif
|
2010-09-10 15:30:50 +00:00
|
|
|
|
2012-10-16 12:10:12 +00:00
|
|
|
static bool
|
|
|
|
FNAME(prefetch_gpte)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp,
|
|
|
|
u64 *spte, pt_element_t gpte, bool no_dirty_log)
|
2007-05-01 13:53:31 +00:00
|
|
|
{
|
2007-12-09 15:00:02 +00:00
|
|
|
unsigned pte_access;
|
2012-10-16 12:10:12 +00:00
|
|
|
gfn_t gfn;
|
2008-04-02 19:46:56 +00:00
|
|
|
pfn_t pfn;
|
2007-05-01 13:53:31 +00:00
|
|
|
|
2013-08-05 08:07:09 +00:00
|
|
|
if (FNAME(prefetch_invalid_gpte)(vcpu, sp, spte, gpte))
|
2012-10-16 12:10:12 +00:00
|
|
|
return false;
|
2010-11-23 03:08:42 +00:00
|
|
|
|
2008-03-03 20:59:56 +00:00
|
|
|
pgprintk("%s: gpte %llx spte %p\n", __func__, (u64)gpte, spte);
|
2012-10-16 12:10:12 +00:00
|
|
|
|
|
|
|
gfn = gpte_to_gfn(gpte);
|
2013-08-05 08:07:09 +00:00
|
|
|
pte_access = sp->role.access & FNAME(gpte_access)(vcpu, gpte);
|
|
|
|
FNAME(protect_clean_gpte)(&pte_access, gpte);
|
2012-10-16 12:10:12 +00:00
|
|
|
pfn = pte_prefetch_gfn_to_pfn(vcpu, gfn,
|
|
|
|
no_dirty_log && (pte_access & ACC_WRITE_MASK));
|
2012-10-16 12:10:59 +00:00
|
|
|
if (is_error_pfn(pfn))
|
2012-10-16 12:10:12 +00:00
|
|
|
return false;
|
2011-03-09 07:43:51 +00:00
|
|
|
|
2009-09-23 18:47:17 +00:00
|
|
|
/*
|
2012-10-16 12:10:12 +00:00
|
|
|
* we call mmu_set_spte() with host_writable = true because
|
|
|
|
* pte_prefetch_gfn_to_pfn always gets a writable pfn.
|
2009-09-23 18:47:17 +00:00
|
|
|
*/
|
2013-02-05 07:27:27 +00:00
|
|
|
mmu_set_spte(vcpu, spte, pte_access, 0, NULL, PT_PAGE_TABLE_LEVEL,
|
|
|
|
gfn, pfn, true, true);
|
2012-10-16 12:10:12 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void FNAME(update_pte)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp,
|
|
|
|
u64 *spte, const void *pte)
|
|
|
|
{
|
|
|
|
pt_element_t gpte = *(const pt_element_t *)pte;
|
|
|
|
|
|
|
|
FNAME(prefetch_gpte)(vcpu, sp, spte, gpte, false);
|
2007-05-01 13:53:31 +00:00
|
|
|
}
|
|
|
|
|
2010-07-13 11:27:08 +00:00
|
|
|
static bool FNAME(gpte_changed)(struct kvm_vcpu *vcpu,
|
|
|
|
struct guest_walker *gw, int level)
|
|
|
|
{
|
|
|
|
pt_element_t curr_pte;
|
2010-08-22 11:13:33 +00:00
|
|
|
gpa_t base_gpa, pte_gpa = gw->pte_gpa[level - 1];
|
|
|
|
u64 mask;
|
|
|
|
int r, index;
|
|
|
|
|
|
|
|
if (level == PT_PAGE_TABLE_LEVEL) {
|
|
|
|
mask = PTE_PREFETCH_NUM * sizeof(pt_element_t) - 1;
|
|
|
|
base_gpa = pte_gpa & ~mask;
|
|
|
|
index = (pte_gpa - base_gpa) / sizeof(pt_element_t);
|
|
|
|
|
|
|
|
r = kvm_read_guest_atomic(vcpu->kvm, base_gpa,
|
|
|
|
gw->prefetch_ptes, sizeof(gw->prefetch_ptes));
|
|
|
|
curr_pte = gw->prefetch_ptes[index];
|
|
|
|
} else
|
|
|
|
r = kvm_read_guest_atomic(vcpu->kvm, pte_gpa,
|
2010-07-13 11:27:08 +00:00
|
|
|
&curr_pte, sizeof(curr_pte));
|
2010-08-22 11:13:33 +00:00
|
|
|
|
2010-07-13 11:27:08 +00:00
|
|
|
return r || curr_pte != gw->ptes[level - 1];
|
|
|
|
}
|
|
|
|
|
2010-08-22 11:13:33 +00:00
|
|
|
static void FNAME(pte_prefetch)(struct kvm_vcpu *vcpu, struct guest_walker *gw,
|
|
|
|
u64 *sptep)
|
2010-08-22 11:12:48 +00:00
|
|
|
{
|
|
|
|
struct kvm_mmu_page *sp;
|
2010-08-22 11:13:33 +00:00
|
|
|
pt_element_t *gptep = gw->prefetch_ptes;
|
2010-08-22 11:12:48 +00:00
|
|
|
u64 *spte;
|
2010-08-22 11:13:33 +00:00
|
|
|
int i;
|
2010-08-22 11:12:48 +00:00
|
|
|
|
|
|
|
sp = page_header(__pa(sptep));
|
|
|
|
|
|
|
|
if (sp->role.level > PT_PAGE_TABLE_LEVEL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (sp->role.direct)
|
|
|
|
return __direct_pte_prefetch(vcpu, sp, sptep);
|
|
|
|
|
|
|
|
i = (sptep - sp->spt) & ~(PTE_PREFETCH_NUM - 1);
|
|
|
|
spte = sp->spt + i;
|
|
|
|
|
|
|
|
for (i = 0; i < PTE_PREFETCH_NUM; i++, spte++) {
|
|
|
|
if (spte == sptep)
|
|
|
|
continue;
|
|
|
|
|
2011-07-11 19:28:04 +00:00
|
|
|
if (is_shadow_present_pte(*spte))
|
2010-08-22 11:12:48 +00:00
|
|
|
continue;
|
|
|
|
|
2012-10-16 12:10:12 +00:00
|
|
|
if (!FNAME(prefetch_gpte)(vcpu, sp, spte, gptep[i], true))
|
2010-08-22 11:12:48 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
/*
|
|
|
|
* Fetch a shadow pte for a specific level in the paging hierarchy.
|
2012-10-16 12:08:43 +00:00
|
|
|
* If the guest tries to write a write-protected page, we need to
|
|
|
|
* emulate this operation, return 1 to indicate this case.
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
*/
|
2012-10-16 12:08:43 +00:00
|
|
|
static int FNAME(fetch)(struct kvm_vcpu *vcpu, gva_t addr,
|
2008-12-25 13:10:50 +00:00
|
|
|
struct guest_walker *gw,
|
2013-01-08 06:36:04 +00:00
|
|
|
int write_fault, int hlevel,
|
2012-10-16 12:08:43 +00:00
|
|
|
pfn_t pfn, bool map_writable, bool prefault)
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
{
|
2010-07-13 11:27:10 +00:00
|
|
|
struct kvm_mmu_page *sp = NULL;
|
2010-07-13 11:27:11 +00:00
|
|
|
struct kvm_shadow_walk_iterator it;
|
2012-10-16 12:08:43 +00:00
|
|
|
unsigned direct_access, access = gw->pt_access;
|
|
|
|
int top_level, emulate = 0;
|
2008-08-22 16:11:39 +00:00
|
|
|
|
2011-07-11 19:25:19 +00:00
|
|
|
direct_access = gw->pte_access;
|
2010-06-30 08:05:00 +00:00
|
|
|
|
2010-07-13 11:27:10 +00:00
|
|
|
top_level = vcpu->arch.mmu.root_level;
|
|
|
|
if (top_level == PT32E_ROOT_LEVEL)
|
|
|
|
top_level = PT32_ROOT_LEVEL;
|
|
|
|
/*
|
|
|
|
* Verify that the top-level gpte is still there. Since the page
|
|
|
|
* is a root page, it is either write protected (and cannot be
|
|
|
|
* changed from now on) or it is invalid (in which case, we don't
|
|
|
|
* really care if it changes underneath us after this point).
|
|
|
|
*/
|
|
|
|
if (FNAME(gpte_changed)(vcpu, gw, top_level))
|
|
|
|
goto out_gpte_changed;
|
|
|
|
|
2014-01-03 19:09:32 +00:00
|
|
|
if (!VALID_PAGE(vcpu->arch.mmu.root_hpa))
|
|
|
|
goto out_gpte_changed;
|
|
|
|
|
2010-07-13 11:27:11 +00:00
|
|
|
for (shadow_walk_init(&it, vcpu, addr);
|
|
|
|
shadow_walk_okay(&it) && it.level > gw->level;
|
|
|
|
shadow_walk_next(&it)) {
|
2010-07-13 11:27:09 +00:00
|
|
|
gfn_t table_gfn;
|
|
|
|
|
KVM: MMU: improve write flooding detected
Detecting write-flooding does not work well, when we handle page written, if
the last speculative spte is not accessed, we treat the page is
write-flooding, however, we can speculative spte on many path, such as pte
prefetch, page synced, that means the last speculative spte may be not point
to the written page and the written page can be accessed via other sptes, so
depends on the Accessed bit of the last speculative spte is not enough
Instead of detected page accessed, we can detect whether the spte is accessed
after it is written, if the spte is not accessed but it is written frequently,
we treat is not a page table or it not used for a long time
Signed-off-by: Xiao Guangrong <xiaoguangrong@cn.fujitsu.com>
Signed-off-by: Avi Kivity <avi@redhat.com>
2011-09-22 08:58:36 +00:00
|
|
|
clear_sp_write_flooding_count(it.sptep);
|
2010-07-13 11:27:11 +00:00
|
|
|
drop_large_spte(vcpu, it.sptep);
|
2007-05-30 11:21:51 +00:00
|
|
|
|
2010-07-13 11:27:10 +00:00
|
|
|
sp = NULL;
|
2010-07-13 11:27:11 +00:00
|
|
|
if (!is_shadow_present_pte(*it.sptep)) {
|
|
|
|
table_gfn = gw->table_gfn[it.level - 2];
|
|
|
|
sp = kvm_mmu_get_page(vcpu, table_gfn, addr, it.level-1,
|
|
|
|
false, access, it.sptep);
|
2010-07-13 11:27:10 +00:00
|
|
|
}
|
2010-07-13 11:27:09 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Verify that the gpte in the page we've just write
|
|
|
|
* protected is still there.
|
|
|
|
*/
|
2010-07-13 11:27:11 +00:00
|
|
|
if (FNAME(gpte_changed)(vcpu, gw, it.level - 1))
|
2010-07-13 11:27:09 +00:00
|
|
|
goto out_gpte_changed;
|
2008-08-22 16:11:39 +00:00
|
|
|
|
2010-07-13 11:27:10 +00:00
|
|
|
if (sp)
|
2013-08-05 08:07:13 +00:00
|
|
|
link_shadow_page(it.sptep, sp, PT_GUEST_ACCESSED_MASK);
|
2008-12-25 13:10:50 +00:00
|
|
|
}
|
2007-11-21 12:11:49 +00:00
|
|
|
|
2010-07-13 11:27:09 +00:00
|
|
|
for (;
|
2010-07-13 11:27:11 +00:00
|
|
|
shadow_walk_okay(&it) && it.level > hlevel;
|
|
|
|
shadow_walk_next(&it)) {
|
2010-07-13 11:27:09 +00:00
|
|
|
gfn_t direct_gfn;
|
|
|
|
|
KVM: MMU: improve write flooding detected
Detecting write-flooding does not work well, when we handle page written, if
the last speculative spte is not accessed, we treat the page is
write-flooding, however, we can speculative spte on many path, such as pte
prefetch, page synced, that means the last speculative spte may be not point
to the written page and the written page can be accessed via other sptes, so
depends on the Accessed bit of the last speculative spte is not enough
Instead of detected page accessed, we can detect whether the spte is accessed
after it is written, if the spte is not accessed but it is written frequently,
we treat is not a page table or it not used for a long time
Signed-off-by: Xiao Guangrong <xiaoguangrong@cn.fujitsu.com>
Signed-off-by: Avi Kivity <avi@redhat.com>
2011-09-22 08:58:36 +00:00
|
|
|
clear_sp_write_flooding_count(it.sptep);
|
2010-07-13 11:27:11 +00:00
|
|
|
validate_direct_spte(vcpu, it.sptep, direct_access);
|
2010-07-13 11:27:09 +00:00
|
|
|
|
2010-07-13 11:27:11 +00:00
|
|
|
drop_large_spte(vcpu, it.sptep);
|
2010-07-13 11:27:09 +00:00
|
|
|
|
2010-07-13 11:27:11 +00:00
|
|
|
if (is_shadow_present_pte(*it.sptep))
|
2010-07-13 11:27:09 +00:00
|
|
|
continue;
|
|
|
|
|
2010-07-13 11:27:11 +00:00
|
|
|
direct_gfn = gw->gfn & ~(KVM_PAGES_PER_HPAGE(it.level) - 1);
|
2010-07-13 11:27:09 +00:00
|
|
|
|
2010-07-13 11:27:11 +00:00
|
|
|
sp = kvm_mmu_get_page(vcpu, direct_gfn, addr, it.level-1,
|
|
|
|
true, direct_access, it.sptep);
|
2013-08-05 08:07:13 +00:00
|
|
|
link_shadow_page(it.sptep, sp, PT_GUEST_ACCESSED_MASK);
|
2010-07-13 11:27:09 +00:00
|
|
|
}
|
|
|
|
|
KVM: MMU: improve write flooding detected
Detecting write-flooding does not work well, when we handle page written, if
the last speculative spte is not accessed, we treat the page is
write-flooding, however, we can speculative spte on many path, such as pte
prefetch, page synced, that means the last speculative spte may be not point
to the written page and the written page can be accessed via other sptes, so
depends on the Accessed bit of the last speculative spte is not enough
Instead of detected page accessed, we can detect whether the spte is accessed
after it is written, if the spte is not accessed but it is written frequently,
we treat is not a page table or it not used for a long time
Signed-off-by: Xiao Guangrong <xiaoguangrong@cn.fujitsu.com>
Signed-off-by: Avi Kivity <avi@redhat.com>
2011-09-22 08:58:36 +00:00
|
|
|
clear_sp_write_flooding_count(it.sptep);
|
2013-02-05 07:27:27 +00:00
|
|
|
mmu_set_spte(vcpu, it.sptep, gw->pte_access, write_fault, &emulate,
|
|
|
|
it.level, gw->gfn, pfn, prefault, map_writable);
|
2010-08-22 11:13:33 +00:00
|
|
|
FNAME(pte_prefetch)(vcpu, gw, it.sptep);
|
2010-07-13 11:27:09 +00:00
|
|
|
|
2012-10-16 12:08:43 +00:00
|
|
|
return emulate;
|
2010-07-13 11:27:09 +00:00
|
|
|
|
|
|
|
out_gpte_changed:
|
2010-07-13 11:27:10 +00:00
|
|
|
if (sp)
|
2010-07-13 11:27:11 +00:00
|
|
|
kvm_mmu_put_page(sp, it.sptep);
|
2010-07-13 11:27:09 +00:00
|
|
|
kvm_release_pfn_clean(pfn);
|
2012-10-16 12:08:43 +00:00
|
|
|
return 0;
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
}
|
|
|
|
|
2013-01-08 06:36:51 +00:00
|
|
|
/*
|
|
|
|
* To see whether the mapped gfn can write its page table in the current
|
|
|
|
* mapping.
|
|
|
|
*
|
|
|
|
* It is the helper function of FNAME(page_fault). When guest uses large page
|
|
|
|
* size to map the writable gfn which is used as current page table, we should
|
|
|
|
* force kvm to use small page size to map it because new shadow page will be
|
|
|
|
* created when kvm establishes shadow page table that stop kvm using large
|
|
|
|
* page size. Do it early can avoid unnecessary #PF and emulation.
|
|
|
|
*
|
2013-01-13 15:49:07 +00:00
|
|
|
* @write_fault_to_shadow_pgtable will return true if the fault gfn is
|
|
|
|
* currently used as its page table.
|
|
|
|
*
|
2013-01-08 06:36:51 +00:00
|
|
|
* Note: the PDPT page table is not checked for PAE-32 bit guest. It is ok
|
|
|
|
* since the PDPT is always shadowed, that means, we can not use large page
|
|
|
|
* size to map the gfn which is used as PDPT.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
FNAME(is_self_change_mapping)(struct kvm_vcpu *vcpu,
|
2013-01-13 15:49:07 +00:00
|
|
|
struct guest_walker *walker, int user_fault,
|
|
|
|
bool *write_fault_to_shadow_pgtable)
|
2013-01-08 06:36:51 +00:00
|
|
|
{
|
|
|
|
int level;
|
|
|
|
gfn_t mask = ~(KVM_PAGES_PER_HPAGE(walker->level) - 1);
|
2013-01-13 15:49:07 +00:00
|
|
|
bool self_changed = false;
|
2013-01-08 06:36:51 +00:00
|
|
|
|
|
|
|
if (!(walker->pte_access & ACC_WRITE_MASK ||
|
|
|
|
(!is_write_protection(vcpu) && !user_fault)))
|
|
|
|
return false;
|
|
|
|
|
2013-01-13 15:49:07 +00:00
|
|
|
for (level = walker->level; level <= walker->max_level; level++) {
|
|
|
|
gfn_t gfn = walker->gfn ^ walker->table_gfn[level - 1];
|
|
|
|
|
|
|
|
self_changed |= !(gfn & mask);
|
|
|
|
*write_fault_to_shadow_pgtable |= !gfn;
|
|
|
|
}
|
2013-01-08 06:36:51 +00:00
|
|
|
|
2013-01-13 15:49:07 +00:00
|
|
|
return self_changed;
|
2013-01-08 06:36:51 +00:00
|
|
|
}
|
|
|
|
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
/*
|
|
|
|
* Page fault handler. There are several causes for a page fault:
|
|
|
|
* - there is no shadow pte for the guest pte
|
|
|
|
* - write access through a shadow pte marked read only so that we can set
|
|
|
|
* the dirty bit
|
|
|
|
* - write access to a shadow pte marked read only so we can update the page
|
|
|
|
* dirty bitmap, when userspace requests it
|
|
|
|
* - mmio access; in this case we will never install a present shadow pte
|
|
|
|
* - normal guest page fault due to the guest pte marked not present, not
|
|
|
|
* writable, or not executable
|
|
|
|
*
|
2007-01-06 00:36:54 +00:00
|
|
|
* Returns: 1 if we need to emulate the instruction, 0 otherwise, or
|
|
|
|
* a negative value on error.
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
*/
|
2010-10-17 16:13:42 +00:00
|
|
|
static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gva_t addr, u32 error_code,
|
2010-12-07 02:48:06 +00:00
|
|
|
bool prefault)
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
{
|
|
|
|
int write_fault = error_code & PFERR_WRITE_MASK;
|
|
|
|
int user_fault = error_code & PFERR_USER_MASK;
|
|
|
|
struct guest_walker walker;
|
2007-01-06 00:36:54 +00:00
|
|
|
int r;
|
2008-04-02 19:46:56 +00:00
|
|
|
pfn_t pfn;
|
2009-07-27 14:30:46 +00:00
|
|
|
int level = PT_PAGE_TABLE_LEVEL;
|
2011-01-13 23:46:48 +00:00
|
|
|
int force_pt_level;
|
2008-07-25 14:24:52 +00:00
|
|
|
unsigned long mmu_seq;
|
2013-01-13 15:49:07 +00:00
|
|
|
bool map_writable, is_self_change_mapping;
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
|
2008-03-03 20:59:56 +00:00
|
|
|
pgprintk("%s: addr %lx err %x\n", __func__, addr, error_code);
|
2007-01-06 00:36:53 +00:00
|
|
|
|
2013-06-07 08:51:26 +00:00
|
|
|
if (unlikely(error_code & PFERR_RSVD_MASK)) {
|
|
|
|
r = handle_mmio_page_fault(vcpu, addr, error_code,
|
2011-07-11 19:33:44 +00:00
|
|
|
mmu_is_nested(vcpu));
|
2013-06-07 08:51:26 +00:00
|
|
|
if (likely(r != RET_MMIO_PF_INVALID))
|
|
|
|
return r;
|
|
|
|
};
|
2011-07-11 19:33:44 +00:00
|
|
|
|
2007-01-06 00:36:54 +00:00
|
|
|
r = mmu_topup_memory_caches(vcpu);
|
|
|
|
if (r)
|
|
|
|
return r;
|
2007-01-06 00:36:53 +00:00
|
|
|
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
/*
|
2009-03-26 07:28:40 +00:00
|
|
|
* Look up the guest pte for the faulting address.
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
*/
|
2010-09-28 09:03:14 +00:00
|
|
|
r = FNAME(walk_addr)(&walker, vcpu, addr, error_code);
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The page is not mapped by the guest. Let the guest handle it.
|
|
|
|
*/
|
2007-01-26 08:56:41 +00:00
|
|
|
if (!r) {
|
2008-03-03 20:59:56 +00:00
|
|
|
pgprintk("%s: guest page fault\n", __func__);
|
KVM: MMU: improve write flooding detected
Detecting write-flooding does not work well, when we handle page written, if
the last speculative spte is not accessed, we treat the page is
write-flooding, however, we can speculative spte on many path, such as pte
prefetch, page synced, that means the last speculative spte may be not point
to the written page and the written page can be accessed via other sptes, so
depends on the Accessed bit of the last speculative spte is not enough
Instead of detected page accessed, we can detect whether the spte is accessed
after it is written, if the spte is not accessed but it is written frequently,
we treat is not a page table or it not used for a long time
Signed-off-by: Xiao Guangrong <xiaoguangrong@cn.fujitsu.com>
Signed-off-by: Avi Kivity <avi@redhat.com>
2011-09-22 08:58:36 +00:00
|
|
|
if (!prefault)
|
2010-12-07 02:35:25 +00:00
|
|
|
inject_page_fault(vcpu, &walker.fault);
|
KVM: MMU: improve write flooding detected
Detecting write-flooding does not work well, when we handle page written, if
the last speculative spte is not accessed, we treat the page is
write-flooding, however, we can speculative spte on many path, such as pte
prefetch, page synced, that means the last speculative spte may be not point
to the written page and the written page can be accessed via other sptes, so
depends on the Accessed bit of the last speculative spte is not enough
Instead of detected page accessed, we can detect whether the spte is accessed
after it is written, if the spte is not accessed but it is written frequently,
we treat is not a page table or it not used for a long time
Signed-off-by: Xiao Guangrong <xiaoguangrong@cn.fujitsu.com>
Signed-off-by: Avi Kivity <avi@redhat.com>
2011-09-22 08:58:36 +00:00
|
|
|
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-01-13 15:49:07 +00:00
|
|
|
vcpu->arch.write_fault_to_shadow_pgtable = false;
|
|
|
|
|
|
|
|
is_self_change_mapping = FNAME(is_self_change_mapping)(vcpu,
|
|
|
|
&walker, user_fault, &vcpu->arch.write_fault_to_shadow_pgtable);
|
|
|
|
|
2011-01-13 23:46:48 +00:00
|
|
|
if (walker.level >= PT_DIRECTORY_LEVEL)
|
2013-01-08 06:36:51 +00:00
|
|
|
force_pt_level = mapping_level_dirty_bitmap(vcpu, walker.gfn)
|
2013-01-13 15:49:07 +00:00
|
|
|
|| is_self_change_mapping;
|
2011-01-13 23:46:48 +00:00
|
|
|
else
|
|
|
|
force_pt_level = 1;
|
|
|
|
if (!force_pt_level) {
|
2009-07-27 14:30:46 +00:00
|
|
|
level = min(walker.level, mapping_level(vcpu, walker.gfn));
|
|
|
|
walker.gfn = walker.gfn & ~(KVM_PAGES_PER_HPAGE(level) - 1);
|
2008-02-23 14:44:30 +00:00
|
|
|
}
|
2009-07-27 14:30:46 +00:00
|
|
|
|
2008-07-25 14:24:52 +00:00
|
|
|
mmu_seq = vcpu->kvm->mmu_notifier_seq;
|
2008-09-16 23:54:47 +00:00
|
|
|
smp_rmb();
|
2010-10-14 09:22:46 +00:00
|
|
|
|
2010-12-07 02:48:06 +00:00
|
|
|
if (try_async_pf(vcpu, prefault, walker.gfn, addr, &pfn, write_fault,
|
2010-10-22 16:18:18 +00:00
|
|
|
&map_writable))
|
2010-10-14 09:22:46 +00:00
|
|
|
return 0;
|
2007-12-30 10:29:05 +00:00
|
|
|
|
2011-07-11 19:29:38 +00:00
|
|
|
if (handle_abnormal_pfn(vcpu, mmu_is_nested(vcpu) ? 0 : addr,
|
|
|
|
walker.gfn, pfn, walker.pte_access, &r))
|
|
|
|
return r;
|
|
|
|
|
2013-01-08 06:36:04 +00:00
|
|
|
/*
|
|
|
|
* Do not change pte_access if the pfn is a mmio page, otherwise
|
|
|
|
* we will cache the incorrect access into mmio spte.
|
|
|
|
*/
|
|
|
|
if (write_fault && !(walker.pte_access & ACC_WRITE_MASK) &&
|
|
|
|
!is_write_protection(vcpu) && !user_fault &&
|
|
|
|
!is_noslot_pfn(pfn)) {
|
|
|
|
walker.pte_access |= ACC_WRITE_MASK;
|
|
|
|
walker.pte_access &= ~ACC_USER_MASK;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we converted a user page to a kernel page,
|
|
|
|
* so that the kernel can write to it when cr0.wp=0,
|
|
|
|
* then we should prevent the kernel from executing it
|
|
|
|
* if SMEP is enabled.
|
|
|
|
*/
|
|
|
|
if (kvm_read_cr4_bits(vcpu, X86_CR4_SMEP))
|
|
|
|
walker.pte_access &= ~ACC_EXEC_MASK;
|
|
|
|
}
|
|
|
|
|
2007-12-21 00:18:26 +00:00
|
|
|
spin_lock(&vcpu->kvm->mmu_lock);
|
2012-10-15 03:10:18 +00:00
|
|
|
if (mmu_notifier_retry(vcpu->kvm, mmu_seq))
|
2008-07-25 14:24:52 +00:00
|
|
|
goto out_unlock;
|
2010-08-28 11:22:46 +00:00
|
|
|
|
2011-11-28 12:41:00 +00:00
|
|
|
kvm_mmu_audit(vcpu, AUDIT_PRE_PAGE_FAULT);
|
2013-03-29 05:05:26 +00:00
|
|
|
make_mmu_pages_available(vcpu);
|
2011-01-13 23:46:48 +00:00
|
|
|
if (!force_pt_level)
|
|
|
|
transparent_hugepage_adjust(vcpu, &walker.gfn, &pfn, &level);
|
2013-01-08 06:36:04 +00:00
|
|
|
r = FNAME(fetch)(vcpu, addr, &walker, write_fault,
|
2012-10-16 12:08:43 +00:00
|
|
|
level, pfn, map_writable, prefault);
|
2007-04-19 14:27:43 +00:00
|
|
|
++vcpu->stat.pf_fixed;
|
2011-11-28 12:41:00 +00:00
|
|
|
kvm_mmu_audit(vcpu, AUDIT_POST_PAGE_FAULT);
|
2007-12-21 00:18:26 +00:00
|
|
|
spin_unlock(&vcpu->kvm->mmu_lock);
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
|
2012-10-16 12:08:43 +00:00
|
|
|
return r;
|
2008-07-25 14:24:52 +00:00
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
spin_unlock(&vcpu->kvm->mmu_lock);
|
|
|
|
kvm_release_pfn_clean(pfn);
|
|
|
|
return 0;
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
}
|
|
|
|
|
2011-09-22 08:56:06 +00:00
|
|
|
static gpa_t FNAME(get_level1_sp_gpa)(struct kvm_mmu_page *sp)
|
|
|
|
{
|
|
|
|
int offset = 0;
|
|
|
|
|
2012-04-18 10:24:29 +00:00
|
|
|
WARN_ON(sp->role.level != PT_PAGE_TABLE_LEVEL);
|
2011-09-22 08:56:06 +00:00
|
|
|
|
|
|
|
if (PTTYPE == 32)
|
|
|
|
offset = sp->role.quadrant << PT64_LEVEL_BITS;
|
|
|
|
|
|
|
|
return gfn_to_gpa(sp->gfn) + offset * sizeof(pt_element_t);
|
|
|
|
}
|
|
|
|
|
2008-12-25 13:19:00 +00:00
|
|
|
static void FNAME(invlpg)(struct kvm_vcpu *vcpu, gva_t gva)
|
2008-09-23 16:18:35 +00:00
|
|
|
{
|
2008-12-25 13:19:00 +00:00
|
|
|
struct kvm_shadow_walk_iterator iterator;
|
2010-05-15 10:53:35 +00:00
|
|
|
struct kvm_mmu_page *sp;
|
2008-12-25 13:19:00 +00:00
|
|
|
int level;
|
|
|
|
u64 *sptep;
|
|
|
|
|
2011-07-11 19:23:20 +00:00
|
|
|
vcpu_clear_mmio_info(vcpu, gva);
|
|
|
|
|
2011-09-22 08:56:39 +00:00
|
|
|
/*
|
|
|
|
* No need to check return value here, rmap_can_add() can
|
|
|
|
* help us to skip pte prefetch later.
|
|
|
|
*/
|
|
|
|
mmu_topup_memory_caches(vcpu);
|
2008-09-23 16:18:35 +00:00
|
|
|
|
2014-01-03 19:09:32 +00:00
|
|
|
if (!VALID_PAGE(vcpu->arch.mmu.root_hpa)) {
|
|
|
|
WARN_ON(1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-09-22 08:56:39 +00:00
|
|
|
spin_lock(&vcpu->kvm->mmu_lock);
|
2008-12-25 13:19:00 +00:00
|
|
|
for_each_shadow_entry(vcpu, gva, iterator) {
|
|
|
|
level = iterator.level;
|
|
|
|
sptep = iterator.sptep;
|
2008-12-02 00:32:05 +00:00
|
|
|
|
2010-05-15 10:53:35 +00:00
|
|
|
sp = page_header(__pa(sptep));
|
2010-04-28 03:55:15 +00:00
|
|
|
if (is_last_spte(*sptep, level)) {
|
2011-09-22 08:56:39 +00:00
|
|
|
pt_element_t gpte;
|
|
|
|
gpa_t pte_gpa;
|
|
|
|
|
2010-05-15 10:53:35 +00:00
|
|
|
if (!sp->unsync)
|
|
|
|
break;
|
|
|
|
|
2011-09-22 08:56:06 +00:00
|
|
|
pte_gpa = FNAME(get_level1_sp_gpa)(sp);
|
2010-03-15 11:59:57 +00:00
|
|
|
pte_gpa += (sptep - sp->spt) * sizeof(pt_element_t);
|
2008-12-25 13:19:00 +00:00
|
|
|
|
2011-09-22 08:56:06 +00:00
|
|
|
if (mmu_page_zap_pte(vcpu->kvm, sp, sptep))
|
|
|
|
kvm_flush_remote_tlbs(vcpu->kvm);
|
2011-09-22 08:56:39 +00:00
|
|
|
|
|
|
|
if (!rmap_can_add(vcpu))
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (kvm_read_guest_atomic(vcpu->kvm, pte_gpa, &gpte,
|
|
|
|
sizeof(pt_element_t)))
|
|
|
|
break;
|
|
|
|
|
|
|
|
FNAME(update_pte)(vcpu, sp, sptep, &gpte);
|
2008-12-22 20:49:30 +00:00
|
|
|
}
|
2008-09-23 16:18:35 +00:00
|
|
|
|
2010-05-15 10:53:35 +00:00
|
|
|
if (!is_shadow_present_pte(*sptep) || !sp->unsync_children)
|
2008-12-25 13:19:00 +00:00
|
|
|
break;
|
|
|
|
}
|
2008-12-02 00:32:05 +00:00
|
|
|
spin_unlock(&vcpu->kvm->mmu_lock);
|
2008-09-23 16:18:35 +00:00
|
|
|
}
|
|
|
|
|
2010-02-10 12:21:32 +00:00
|
|
|
static gpa_t FNAME(gva_to_gpa)(struct kvm_vcpu *vcpu, gva_t vaddr, u32 access,
|
2010-11-22 15:53:26 +00:00
|
|
|
struct x86_exception *exception)
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
{
|
|
|
|
struct guest_walker walker;
|
2007-02-12 08:54:36 +00:00
|
|
|
gpa_t gpa = UNMAPPED_GVA;
|
|
|
|
int r;
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
|
2010-09-28 09:03:14 +00:00
|
|
|
r = FNAME(walk_addr)(&walker, vcpu, vaddr, access);
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
|
2007-02-12 08:54:36 +00:00
|
|
|
if (r) {
|
2007-11-21 12:44:45 +00:00
|
|
|
gpa = gfn_to_gpa(walker.gfn);
|
2007-02-12 08:54:36 +00:00
|
|
|
gpa |= vaddr & ~PAGE_MASK;
|
2010-11-22 15:53:27 +00:00
|
|
|
} else if (exception)
|
|
|
|
*exception = walker.fault;
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
|
|
|
|
return gpa;
|
|
|
|
}
|
|
|
|
|
2013-08-05 08:07:12 +00:00
|
|
|
#if PTTYPE != PTTYPE_EPT
|
2010-09-10 15:30:50 +00:00
|
|
|
static gpa_t FNAME(gva_to_gpa_nested)(struct kvm_vcpu *vcpu, gva_t vaddr,
|
2010-11-22 15:53:26 +00:00
|
|
|
u32 access,
|
|
|
|
struct x86_exception *exception)
|
2010-09-10 15:30:50 +00:00
|
|
|
{
|
|
|
|
struct guest_walker walker;
|
|
|
|
gpa_t gpa = UNMAPPED_GVA;
|
|
|
|
int r;
|
|
|
|
|
2010-09-28 09:03:14 +00:00
|
|
|
r = FNAME(walk_addr_nested)(&walker, vcpu, vaddr, access);
|
2010-09-10 15:30:50 +00:00
|
|
|
|
|
|
|
if (r) {
|
|
|
|
gpa = gfn_to_gpa(walker.gfn);
|
|
|
|
gpa |= vaddr & ~PAGE_MASK;
|
2010-11-22 15:53:27 +00:00
|
|
|
} else if (exception)
|
|
|
|
*exception = walker.fault;
|
2010-09-10 15:30:50 +00:00
|
|
|
|
|
|
|
return gpa;
|
|
|
|
}
|
2013-08-05 08:07:12 +00:00
|
|
|
#endif
|
2010-09-10 15:30:50 +00:00
|
|
|
|
2008-09-23 16:18:33 +00:00
|
|
|
/*
|
|
|
|
* Using the cached information from sp->gfns is safe because:
|
|
|
|
* - The spte has a reference to the struct page, so the pfn for a given gfn
|
|
|
|
* can't change unless all sptes pointing to it are nuked first.
|
2010-11-23 03:13:00 +00:00
|
|
|
*
|
|
|
|
* Note:
|
|
|
|
* We should flush all tlbs if spte is dropped even though guest is
|
|
|
|
* responsible for it. Since if we don't, kvm_mmu_notifier_invalidate_page
|
|
|
|
* and kvm_mmu_notifier_invalidate_range_start detect the mapping page isn't
|
|
|
|
* used by guest then tlbs are not flushed, so guest is allowed to access the
|
|
|
|
* freed pages.
|
2014-02-18 08:22:47 +00:00
|
|
|
* We set tlbs_dirty to let the notifier know this change and delay the flush
|
|
|
|
* until such a case actually happens.
|
2008-09-23 16:18:33 +00:00
|
|
|
*/
|
2010-11-19 09:04:03 +00:00
|
|
|
static int FNAME(sync_page)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp)
|
2008-09-23 16:18:33 +00:00
|
|
|
{
|
2011-09-22 08:56:06 +00:00
|
|
|
int i, nr_present = 0;
|
2010-11-19 09:03:22 +00:00
|
|
|
bool host_writable;
|
2010-04-16 09:16:40 +00:00
|
|
|
gpa_t first_pte_gpa;
|
2008-09-23 16:18:33 +00:00
|
|
|
|
2010-05-26 08:49:59 +00:00
|
|
|
/* direct kvm_mmu_page can not be unsync. */
|
|
|
|
BUG_ON(sp->role.direct);
|
|
|
|
|
2011-09-22 08:56:06 +00:00
|
|
|
first_pte_gpa = FNAME(get_level1_sp_gpa)(sp);
|
2010-04-16 09:16:40 +00:00
|
|
|
|
2008-09-23 16:18:33 +00:00
|
|
|
for (i = 0; i < PT64_ENT_PER_PAGE; i++) {
|
|
|
|
unsigned pte_access;
|
|
|
|
pt_element_t gpte;
|
|
|
|
gpa_t pte_gpa;
|
2010-05-13 02:08:08 +00:00
|
|
|
gfn_t gfn;
|
2008-09-23 16:18:33 +00:00
|
|
|
|
2011-07-11 19:33:44 +00:00
|
|
|
if (!sp->spt[i])
|
2008-09-23 16:18:33 +00:00
|
|
|
continue;
|
|
|
|
|
2010-04-16 09:16:40 +00:00
|
|
|
pte_gpa = first_pte_gpa + i * sizeof(pt_element_t);
|
2008-09-23 16:18:33 +00:00
|
|
|
|
|
|
|
if (kvm_read_guest_atomic(vcpu->kvm, pte_gpa, &gpte,
|
|
|
|
sizeof(pt_element_t)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-08-05 08:07:09 +00:00
|
|
|
if (FNAME(prefetch_invalid_gpte)(vcpu, sp, &sp->spt[i], gpte)) {
|
2014-02-18 08:22:47 +00:00
|
|
|
vcpu->kvm->tlbs_dirty = true;
|
2010-11-23 03:08:42 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-07-11 19:33:44 +00:00
|
|
|
gfn = gpte_to_gfn(gpte);
|
|
|
|
pte_access = sp->role.access;
|
2013-08-05 08:07:09 +00:00
|
|
|
pte_access &= FNAME(gpte_access)(vcpu, gpte);
|
|
|
|
FNAME(protect_clean_gpte)(&pte_access, gpte);
|
2011-07-11 19:33:44 +00:00
|
|
|
|
2013-06-07 08:51:24 +00:00
|
|
|
if (sync_mmio_spte(vcpu->kvm, &sp->spt[i], gfn, pte_access,
|
|
|
|
&nr_present))
|
2011-07-11 19:33:44 +00:00
|
|
|
continue;
|
|
|
|
|
2010-11-23 03:08:42 +00:00
|
|
|
if (gfn != sp->gfns[i]) {
|
2011-07-11 19:28:04 +00:00
|
|
|
drop_spte(vcpu->kvm, &sp->spt[i]);
|
2014-02-18 08:22:47 +00:00
|
|
|
vcpu->kvm->tlbs_dirty = true;
|
2008-09-23 16:18:33 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
nr_present++;
|
2011-07-11 19:33:44 +00:00
|
|
|
|
2010-12-23 08:09:29 +00:00
|
|
|
host_writable = sp->spt[i] & SPTE_HOST_WRITEABLE;
|
|
|
|
|
2013-01-08 06:36:04 +00:00
|
|
|
set_spte(vcpu, &sp->spt[i], pte_access,
|
2011-07-11 19:24:39 +00:00
|
|
|
PT_PAGE_TABLE_LEVEL, gfn,
|
2009-09-23 18:47:17 +00:00
|
|
|
spte_to_pfn(sp->spt[i]), true, false,
|
2010-11-19 09:03:22 +00:00
|
|
|
host_writable);
|
2008-09-23 16:18:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return !nr_present;
|
|
|
|
}
|
|
|
|
|
[PATCH] kvm: userspace interface
web site: http://kvm.sourceforge.net
mailing list: kvm-devel@lists.sourceforge.net
(http://lists.sourceforge.net/lists/listinfo/kvm-devel)
The following patchset adds a driver for Intel's hardware virtualization
extensions to the x86 architecture. The driver adds a character device
(/dev/kvm) that exposes the virtualization capabilities to userspace. Using
this driver, a process can run a virtual machine (a "guest") in a fully
virtualized PC containing its own virtual hard disks, network adapters, and
display.
Using this driver, one can start multiple virtual machines on a host.
Each virtual machine is a process on the host; a virtual cpu is a thread in
that process. kill(1), nice(1), top(1) work as expected. In effect, the
driver adds a third execution mode to the existing two: we now have kernel
mode, user mode, and guest mode. Guest mode has its own address space mapping
guest physical memory (which is accessible to user mode by mmap()ing
/dev/kvm). Guest mode has no access to any I/O devices; any such access is
intercepted and directed to user mode for emulation.
The driver supports i386 and x86_64 hosts and guests. All combinations are
allowed except x86_64 guest on i386 host. For i386 guests and hosts, both pae
and non-pae paging modes are supported.
SMP hosts and UP guests are supported. At the moment only Intel
hardware is supported, but AMD virtualization support is being worked on.
Performance currently is non-stellar due to the naive implementation of the
mmu virtualization, which throws away most of the shadow page table entries
every context switch. We plan to address this in two ways:
- cache shadow page tables across tlb flushes
- wait until AMD and Intel release processors with nested page tables
Currently a virtual desktop is responsive but consumes a lot of CPU. Under
Windows I tried playing pinball and watching a few flash movies; with a recent
CPU one can hardly feel the virtualization. Linux/X is slower, probably due
to X being in a separate process.
In addition to the driver, you need a slightly modified qemu to provide I/O
device emulation and the BIOS.
Caveats (akpm: might no longer be true):
- The Windows install currently bluescreens due to a problem with the
virtual APIC. We are working on a fix. A temporary workaround is to
use an existing image or install through qemu
- Windows 64-bit does not work. That's also true for qemu, so it's
probably a problem with the device model.
[bero@arklinux.org: build fix]
[simon.kagstrom@bth.se: build fix, other fixes]
[uril@qumranet.com: KVM: Expose interrupt bitmap]
[akpm@osdl.org: i386 build fix]
[mingo@elte.hu: i386 fixes]
[rdreier@cisco.com: add log levels to all printks]
[randy.dunlap@oracle.com: Fix sparse NULL and C99 struct init warnings]
[anthony@codemonkey.ws: KVM: AMD SVM: 32-bit host support]
Signed-off-by: Yaniv Kamay <yaniv@qumranet.com>
Signed-off-by: Avi Kivity <avi@qumranet.com>
Cc: Simon Kagstrom <simon.kagstrom@bth.se>
Cc: Bernhard Rosenkraenzer <bero@arklinux.org>
Signed-off-by: Uri Lublin <uril@qumranet.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Anthony Liguori <anthony@codemonkey.ws>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-10 10:21:36 +00:00
|
|
|
#undef pt_element_t
|
|
|
|
#undef guest_walker
|
|
|
|
#undef FNAME
|
|
|
|
#undef PT_BASE_ADDR_MASK
|
|
|
|
#undef PT_INDEX
|
2009-07-27 14:30:45 +00:00
|
|
|
#undef PT_LVL_ADDR_MASK
|
|
|
|
#undef PT_LVL_OFFSET_MASK
|
KVM: Allow not-present guest page faults to bypass kvm
There are two classes of page faults trapped by kvm:
- host page faults, where the fault is needed to allow kvm to install
the shadow pte or update the guest accessed and dirty bits
- guest page faults, where the guest has faulted and kvm simply injects
the fault back into the guest to handle
The second class, guest page faults, is pure overhead. We can eliminate
some of it on vmx using the following evil trick:
- when we set up a shadow page table entry, if the corresponding guest pte
is not present, set up the shadow pte as not present
- if the guest pte _is_ present, mark the shadow pte as present but also
set one of the reserved bits in the shadow pte
- tell the vmx hardware not to trap faults which have the present bit clear
With this, normal page-not-present faults go directly to the guest,
bypassing kvm entirely.
Unfortunately, this trick only works on Intel hardware, as AMD lacks a
way to discriminate among page faults based on error code. It is also
a little risky since it uses reserved bits which might become unreserved
in the future, so a module parameter is provided to disable it.
Signed-off-by: Avi Kivity <avi@qumranet.com>
2007-09-16 16:58:32 +00:00
|
|
|
#undef PT_LEVEL_BITS
|
[PATCH] KVM: MMU: Shadow page table caching
Define a hashtable for caching shadow page tables. Look up the cache on
context switch (cr3 change) or during page faults.
The key to the cache is a combination of
- the guest page table frame number
- the number of paging levels in the guest
* we can cache real mode, 32-bit mode, pae, and long mode page
tables simultaneously. this is useful for smp bootup.
- the guest page table table
* some kernels use a page as both a page table and a page directory. this
allows multiple shadow pages to exist for that page, one per level
- the "quadrant"
* 32-bit mode page tables span 4MB, whereas a shadow page table spans
2MB. similarly, a 32-bit page directory spans 4GB, while a shadow
page directory spans 1GB. the quadrant allows caching up to 4 shadow page
tables for one guest page in one level.
- a "metaphysical" bit
* for real mode, and for pse pages, there is no guest page table, so set
the bit to avoid write protecting the page.
Signed-off-by: Avi Kivity <avi@qumranet.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2007-01-06 00:36:43 +00:00
|
|
|
#undef PT_MAX_FULL_LEVELS
|
2007-11-21 10:35:07 +00:00
|
|
|
#undef gpte_to_gfn
|
2009-07-27 14:30:45 +00:00
|
|
|
#undef gpte_to_gfn_lvl
|
2007-12-07 12:56:58 +00:00
|
|
|
#undef CMPXCHG
|
2013-08-05 08:07:10 +00:00
|
|
|
#undef PT_GUEST_ACCESSED_MASK
|
|
|
|
#undef PT_GUEST_DIRTY_MASK
|
|
|
|
#undef PT_GUEST_DIRTY_SHIFT
|
|
|
|
#undef PT_GUEST_ACCESSED_SHIFT
|