5 files changed, 0 insertions, 1801 deletions
diff --git a/Documentation/kvm/api.txt b/Documentation/kvm/api.txt
deleted file mode 100644
index 5f5b64982b1a..000000000000
--- a/Documentation/kvm/api.txt
+++ /dev/null
@@ -1,1220 +0,0 @@
-The Definitive KVM (Kernel-based Virtual Machine) API Documentation
-===================================================================
-1. General description
-The kvm API is a set of ioctls that are issued to control various aspects
-of a virtual machine.  The ioctls belong to three classes
- - System ioctls: These query and set global attributes which affect the
-   whole kvm subsystem.  In addition a system ioctl is used to create
-   virtual machines
- - VM ioctls: These query and set attributes that affect an entire virtual
-   machine, for example memory layout.  In addition a VM ioctl is used to
-   create virtual cpus (vcpus).
-   Only run VM ioctls from the same process (address space) that was used
-   to create the VM.
- - vcpu ioctls: These query and set attributes that control the operation
-   of a single virtual cpu.
-   Only run vcpu ioctls from the same thread that was used to create the
-   vcpu.
-2. File descriptors
-The kvm API is centered around file descriptors.  An initial
-open("/dev/kvm") obtains a handle to the kvm subsystem; this handle
-can be used to issue system ioctls.  A KVM_CREATE_VM ioctl on this
-handle will create a VM file descriptor which can be used to issue VM
-ioctls.  A KVM_CREATE_VCPU ioctl on a VM fd will create a virtual cpu
-and return a file descriptor pointing to it.  Finally, ioctls on a vcpu
-fd can be used to control the vcpu, including the important task of
-actually running guest code.
-In general file descriptors can be migrated among processes by means
-of fork() and the SCM_RIGHTS facility of unix domain socket.  These
-kinds of tricks are explicitly not supported by kvm.  While they will
-not cause harm to the host, their actual behavior is not guaranteed by
-the API.  The only supported use is one virtual machine per process,
-and one vcpu per thread.
-3. Extensions
-As of Linux 2.6.22, the KVM ABI has been stabilized: no backward
-incompatible change are allowed.  However, there is an extension
-facility that allows backward-compatible extensions to the API to be
-queried and used.
-The extension mechanism is not based on on the Linux version number.
-Instead, kvm defines extension identifiers and a facility to query
-whether a particular extension identifier is available.  If it is, a
-set of ioctls is available for application use.
-4. API description
-This section describes ioctls that can be used to control kvm guests.
-For each ioctl, the following information is provided along with a
-description:
-  Capability: which KVM extension provides this ioctl.  Can be 'basic',
-      which means that is will be provided by any kernel that supports
-      API version 12 (see section 4.1), or a KVM_CAP_xyz constant, which
-      means availability needs to be checked with KVM_CHECK_EXTENSION
-      (see section 4.4).
-  Architectures: which instruction set architectures provide this ioctl.
-      x86 includes both i386 and x86_64.
-  Type: system, vm, or vcpu.
-  Parameters: what parameters are accepted by the ioctl.
-  Returns: the return value.  General error numbers (EBADF, ENOMEM, EINVAL)
-      are not detailed, but errors with specific meanings are.
-4.1 KVM_GET_API_VERSION
-Capability: basic
-Architectures: all
-Type: system ioctl
-Parameters: none
-Returns: the constant KVM_API_VERSION (=12)
-This identifies the API version as the stable kvm API. It is not
-expected that this number will change.  However, Linux 2.6.20 and
-2.6.21 report earlier versions; these are not documented and not
-supported.  Applications should refuse to run if KVM_GET_API_VERSION
-returns a value other than 12.  If this check passes, all ioctls
-described as 'basic' will be available.
-4.2 KVM_CREATE_VM
-Capability: basic
-Architectures: all
-Type: system ioctl
-Parameters: none
-Returns: a VM fd that can be used to control the new virtual machine.
-The new VM has no virtual cpus and no memory.  An mmap() of a VM fd
-will access the virtual machine's physical address space; offset zero
-corresponds to guest physical address zero.  Use of mmap() on a VM fd
-is discouraged if userspace memory allocation (KVM_CAP_USER_MEMORY) is
-available.
-4.3 KVM_GET_MSR_INDEX_LIST
-Capability: basic
-Architectures: x86
-Type: system
-Parameters: struct kvm_msr_list (in/out)
-Returns: 0 on success; -1 on error
-Errors:
-  E2BIG:     the msr index list is to be to fit in the array specified by
-             the user.
-struct kvm_msr_list {
-        __u32 nmsrs; /* number of msrs in entries */
-        __u32 indices[0];
-};
-This ioctl returns the guest msrs that are supported.  The list varies
-by kvm version and host processor, but does not change otherwise.  The
-user fills in the size of the indices array in nmsrs, and in return
-kvm adjusts nmsrs to reflect the actual number of msrs and fills in
-the indices array with their numbers.
-Note: if kvm indicates supports MCE (KVM_CAP_MCE), then the MCE bank MSRs are
-not returned in the MSR list, as different vcpus can have a different number
-of banks, as set via the KVM_X86_SETUP_MCE ioctl.
-4.4 KVM_CHECK_EXTENSION
-Capability: basic
-Architectures: all
-Type: system ioctl
-Parameters: extension identifier (KVM_CAP_*)
-Returns: 0 if unsupported; 1 (or some other positive integer) if supported
-The API allows the application to query about extensions to the core
-kvm API.  Userspace passes an extension identifier (an integer) and
-receives an integer that describes the extension availability.
-Generally 0 means no and 1 means yes, but some extensions may report
-additional information in the integer return value.
-4.5 KVM_GET_VCPU_MMAP_SIZE
-Capability: basic
-Architectures: all
-Type: system ioctl
-Parameters: none
-Returns: size of vcpu mmap area, in bytes
-The KVM_RUN ioctl (cf.) communicates with userspace via a shared
-memory region.  This ioctl returns the size of that region.  See the
-KVM_RUN documentation for details.
-4.6 KVM_SET_MEMORY_REGION
-Capability: basic
-Architectures: all
-Type: vm ioctl
-Parameters: struct kvm_memory_region (in)
-Returns: 0 on success, -1 on error
-This ioctl is obsolete and has been removed.
-4.6 KVM_CREATE_VCPU
-Capability: basic
-Architectures: all
-Type: vm ioctl
-Parameters: vcpu id (apic id on x86)
-Returns: vcpu fd on success, -1 on error
-This API adds a vcpu to a virtual machine.  The vcpu id is a small integer
-in the range [0, max_vcpus).
-4.7 KVM_GET_DIRTY_LOG (vm ioctl)
-Capability: basic
-Architectures: x86
-Type: vm ioctl
-Parameters: struct kvm_dirty_log (in/out)
-Returns: 0 on success, -1 on error
-/* for KVM_GET_DIRTY_LOG */
-struct kvm_dirty_log {
-        __u32 slot;
-        __u32 padding;
-        union {
-                void __user *dirty_bitmap; /* one bit per page */
-                __u64 padding;
-        };
-};
-Given a memory slot, return a bitmap containing any pages dirtied
-since the last call to this ioctl.  Bit 0 is the first page in the
-memory slot.  Ensure the entire structure is cleared to avoid padding
-issues.
-4.8 KVM_SET_MEMORY_ALIAS
-Capability: basic
-Architectures: x86
-Type: vm ioctl
-Parameters: struct kvm_memory_alias (in)
-Returns: 0 (success), -1 (error)
-This ioctl is obsolete and has been removed.
-4.9 KVM_RUN
-Capability: basic
-Architectures: all
-Type: vcpu ioctl
-Parameters: none
-Returns: 0 on success, -1 on error
-Errors:
-  EINTR:     an unmasked signal is pending
-This ioctl is used to run a guest virtual cpu.  While there are no
-explicit parameters, there is an implicit parameter block that can be
-obtained by mmap()ing the vcpu fd at offset 0, with the size given by
-KVM_GET_VCPU_MMAP_SIZE.  The parameter block is formatted as a 'struct
-kvm_run' (see below).
-4.10 KVM_GET_REGS
-Capability: basic
-Architectures: all
-Type: vcpu ioctl
-Parameters: struct kvm_regs (out)
-Returns: 0 on success, -1 on error
-Reads the general purpose registers from the vcpu.
-/* x86 */
-struct kvm_regs {
-        /* out (KVM_GET_REGS) / in (KVM_SET_REGS) */
-        __u64 rax, rbx, rcx, rdx;
-        __u64 rsi, rdi, rsp, rbp;
-        __u64 r8,  r9,  r10, r11;
-        __u64 r12, r13, r14, r15;
-        __u64 rip, rflags;
-};
-4.11 KVM_SET_REGS
-Capability: basic
-Architectures: all
-Type: vcpu ioctl
-Parameters: struct kvm_regs (in)
-Returns: 0 on success, -1 on error
-Writes the general purpose registers into the vcpu.
-See KVM_GET_REGS for the data structure.
-4.12 KVM_GET_SREGS
-Capability: basic
-Architectures: x86
-Type: vcpu ioctl
-Parameters: struct kvm_sregs (out)
-Returns: 0 on success, -1 on error
-Reads special registers from the vcpu.
-/* x86 */
-struct kvm_sregs {
-        struct kvm_segment cs, ds, es, fs, gs, ss;
-        struct kvm_segment tr, ldt;
-        struct kvm_dtable gdt, idt;
-        __u64 cr0, cr2, cr3, cr4, cr8;
-        __u64 efer;
-        __u64 apic_base;
-        __u64 interrupt_bitmap[(KVM_NR_INTERRUPTS + 63) / 64];
-};
-interrupt_bitmap is a bitmap of pending external interrupts.  At most
-one bit may be set.  This interrupt has been acknowledged by the APIC
-but not yet injected into the cpu core.
-4.13 KVM_SET_SREGS
-Capability: basic
-Architectures: x86
-Type: vcpu ioctl
-Parameters: struct kvm_sregs (in)
-Returns: 0 on success, -1 on error
-Writes special registers into the vcpu.  See KVM_GET_SREGS for the
-data structures.
-4.14 KVM_TRANSLATE
-Capability: basic
-Architectures: x86
-Type: vcpu ioctl
-Parameters: struct kvm_translation (in/out)
-Returns: 0 on success, -1 on error
-Translates a virtual address according to the vcpu's current address
-translation mode.
-struct kvm_translation {
-        /* in */
-        __u64 linear_address;
-        /* out */
-        __u64 physical_address;
-        __u8  valid;
-        __u8  writeable;
-        __u8  usermode;
-        __u8  pad[5];
-};
-4.15 KVM_INTERRUPT
-Capability: basic
-Architectures: x86
-Type: vcpu ioctl
-Parameters: struct kvm_interrupt (in)
-Returns: 0 on success, -1 on error
-Queues a hardware interrupt vector to be injected.  This is only
-useful if in-kernel local APIC is not used.
-/* for KVM_INTERRUPT */
-struct kvm_interrupt {
-        /* in */
-        __u32 irq;
-};
-Note 'irq' is an interrupt vector, not an interrupt pin or line.
-4.16 KVM_DEBUG_GUEST
-Capability: basic
-Architectures: none
-Type: vcpu ioctl
-Parameters: none)
-Returns: -1 on error
-Support for this has been removed.  Use KVM_SET_GUEST_DEBUG instead.
-4.17 KVM_GET_MSRS
-Capability: basic
-Architectures: x86
-Type: vcpu ioctl
-Parameters: struct kvm_msrs (in/out)
-Returns: 0 on success, -1 on error
-Reads model-specific registers from the vcpu.  Supported msr indices can
-be obtained using KVM_GET_MSR_INDEX_LIST.
-struct kvm_msrs {
-        __u32 nmsrs; /* number of msrs in entries */
-        __u32 pad;
-        struct kvm_msr_entry entries[0];
-};
-struct kvm_msr_entry {
-        __u32 index;
-        __u32 reserved;
-        __u64 data;
-};
-Application code should set the 'nmsrs' member (which indicates the
-size of the entries array) and the 'index' member of each array entry.
-kvm will fill in the 'data' member.
-4.18 KVM_SET_MSRS
-Capability: basic
-Architectures: x86
-Type: vcpu ioctl
-Parameters: struct kvm_msrs (in)
-Returns: 0 on success, -1 on error
-Writes model-specific registers to the vcpu.  See KVM_GET_MSRS for the
-data structures.
-Application code should set the 'nmsrs' member (which indicates the
-size of the entries array), and the 'index' and 'data' members of each
-array entry.
-4.19 KVM_SET_CPUID
-Capability: basic
-Architectures: x86
-Type: vcpu ioctl
-Parameters: struct kvm_cpuid (in)
-Returns: 0 on success, -1 on error
-Defines the vcpu responses to the cpuid instruction.  Applications
-should use the KVM_SET_CPUID2 ioctl if available.
-struct kvm_cpuid_entry {
-        __u32 function;
-        __u32 eax;
-        __u32 ebx;
-        __u32 ecx;
-        __u32 edx;
-        __u32 padding;
-};
-/* for KVM_SET_CPUID */
-struct kvm_cpuid {
-        __u32 nent;
-        __u32 padding;
-        struct kvm_cpuid_entry entries[0];
-};
-4.20 KVM_SET_SIGNAL_MASK
-Capability: basic
-Architectures: x86
-Type: vcpu ioctl
-Parameters: struct kvm_signal_mask (in)
-Returns: 0 on success, -1 on error
-Defines which signals are blocked during execution of KVM_RUN.  This
-signal mask temporarily overrides the threads signal mask.  Any
-unblocked signal received (except SIGKILL and SIGSTOP, which retain
-their traditional behaviour) will cause KVM_RUN to return with -EINTR.
-Note the signal will only be delivered if not blocked by the original
-signal mask.
-/* for KVM_SET_SIGNAL_MASK */
-struct kvm_signal_mask {
-        __u32 len;
-        __u8  sigset[0];
-};
-4.21 KVM_GET_FPU
-Capability: basic
-Architectures: x86
-Type: vcpu ioctl
-Parameters: struct kvm_fpu (out)
-Returns: 0 on success, -1 on error
-Reads the floating point state from the vcpu.
-/* for KVM_GET_FPU and KVM_SET_FPU */
-struct kvm_fpu {
-        __u8  fpr[8][16];
-        __u16 fcw;
-        __u16 fsw;
-        __u8  ftwx;  /* in fxsave format */
-        __u8  pad1;
-        __u16 last_opcode;
-        __u64 last_ip;
-        __u64 last_dp;
-        __u8  xmm[16][16];
-        __u32 mxcsr;
-        __u32 pad2;
-};
-4.22 KVM_SET_FPU
-Capability: basic
-Architectures: x86
-Type: vcpu ioctl
-Parameters: struct kvm_fpu (in)
-Returns: 0 on success, -1 on error
-Writes the floating point state to the vcpu.
-/* for KVM_GET_FPU and KVM_SET_FPU */
-struct kvm_fpu {
-        __u8  fpr[8][16];
-        __u16 fcw;
-        __u16 fsw;
-        __u8  ftwx;  /* in fxsave format */
-        __u8  pad1;
-        __u16 last_opcode;
-        __u64 last_ip;
-        __u64 last_dp;
-        __u8  xmm[16][16];
-        __u32 mxcsr;
-        __u32 pad2;
-};
-4.23 KVM_CREATE_IRQCHIP
-Capability: KVM_CAP_IRQCHIP
-Architectures: x86, ia64
-Type: vm ioctl
-Parameters: none
-Returns: 0 on success, -1 on error
-Creates an interrupt controller model in the kernel.  On x86, creates a virtual
-ioapic, a virtual PIC (two PICs, nested), and sets up future vcpus to have a
-local APIC.  IRQ routing for GSIs 0-15 is set to both PIC and IOAPIC; GSI 16-23
-only go to the IOAPIC.  On ia64, a IOSAPIC is created.
-4.24 KVM_IRQ_LINE
-Capability: KVM_CAP_IRQCHIP
-Architectures: x86, ia64
-Type: vm ioctl
-Parameters: struct kvm_irq_level
-Returns: 0 on success, -1 on error
-Sets the level of a GSI input to the interrupt controller model in the kernel.
-Requires that an interrupt controller model has been previously created with
-KVM_CREATE_IRQCHIP.  Note that edge-triggered interrupts require the level
-to be set to 1 and then back to 0.
-struct kvm_irq_level {
-        union {
-                __u32 irq;     /* GSI */
-                __s32 status;  /* not used for KVM_IRQ_LEVEL */
-        };
-        __u32 level;           /* 0 or 1 */
-};
-4.25 KVM_GET_IRQCHIP
-Capability: KVM_CAP_IRQCHIP
-Architectures: x86, ia64
-Type: vm ioctl
-Parameters: struct kvm_irqchip (in/out)
-Returns: 0 on success, -1 on error
-Reads the state of a kernel interrupt controller created with
-KVM_CREATE_IRQCHIP into a buffer provided by the caller.
-struct kvm_irqchip {
-        __u32 chip_id;  /* 0 = PIC1, 1 = PIC2, 2 = IOAPIC */
-        __u32 pad;
-        union {
-                char dummy[512];  /* reserving space */
-                struct kvm_pic_state pic;
-                struct kvm_ioapic_state ioapic;
-        } chip;
-};
-4.26 KVM_SET_IRQCHIP
-Capability: KVM_CAP_IRQCHIP
-Architectures: x86, ia64
-Type: vm ioctl
-Parameters: struct kvm_irqchip (in)
-Returns: 0 on success, -1 on error
-Sets the state of a kernel interrupt controller created with
-KVM_CREATE_IRQCHIP from a buffer provided by the caller.
-struct kvm_irqchip {
-        __u32 chip_id;  /* 0 = PIC1, 1 = PIC2, 2 = IOAPIC */
-        __u32 pad;
-        union {
-                char dummy[512];  /* reserving space */
-                struct kvm_pic_state pic;
-                struct kvm_ioapic_state ioapic;
-        } chip;
-};
-4.27 KVM_XEN_HVM_CONFIG
-Capability: KVM_CAP_XEN_HVM
-Architectures: x86
-Type: vm ioctl
-Parameters: struct kvm_xen_hvm_config (in)
-Returns: 0 on success, -1 on error
-Sets the MSR that the Xen HVM guest uses to initialize its hypercall
-page, and provides the starting address and size of the hypercall
-blobs in userspace.  When the guest writes the MSR, kvm copies one
-page of a blob (32- or 64-bit, depending on the vcpu mode) to guest
-memory.
-struct kvm_xen_hvm_config {
-        __u32 flags;
-        __u32 msr;
-        __u64 blob_addr_32;
-        __u64 blob_addr_64;
-        __u8 blob_size_32;
-        __u8 blob_size_64;
-        __u8 pad2[30];
-};
-4.27 KVM_GET_CLOCK
-Capability: KVM_CAP_ADJUST_CLOCK
-Architectures: x86
-Type: vm ioctl
-Parameters: struct kvm_clock_data (out)
-Returns: 0 on success, -1 on error
-Gets the current timestamp of kvmclock as seen by the current guest. In
-conjunction with KVM_SET_CLOCK, it is used to ensure monotonicity on scenarios
-such as migration.
-struct kvm_clock_data {
-        __u64 clock;  /* kvmclock current value */
-        __u32 flags;
-        __u32 pad[9];
-};
-4.28 KVM_SET_CLOCK
-Capability: KVM_CAP_ADJUST_CLOCK
-Architectures: x86
-Type: vm ioctl
-Parameters: struct kvm_clock_data (in)
-Returns: 0 on success, -1 on error
-Sets the current timestamp of kvmclock to the value specified in its parameter.
-In conjunction with KVM_GET_CLOCK, it is used to ensure monotonicity on scenarios
-such as migration.
-struct kvm_clock_data {
-        __u64 clock;  /* kvmclock current value */
-        __u32 flags;
-        __u32 pad[9];
-};
-4.29 KVM_GET_VCPU_EVENTS
-Capability: KVM_CAP_VCPU_EVENTS
-Extended by: KVM_CAP_INTR_SHADOW
-Architectures: x86
-Type: vm ioctl
-Parameters: struct kvm_vcpu_event (out)
-Returns: 0 on success, -1 on error
-Gets currently pending exceptions, interrupts, and NMIs as well as related
-states of the vcpu.
-struct kvm_vcpu_events {
-        struct {
-                __u8 injected;
-                __u8 nr;
-                __u8 has_error_code;
-                __u8 pad;
-                __u32 error_code;
-        } exception;
-        struct {
-                __u8 injected;
-                __u8 nr;
-                __u8 soft;
-                __u8 shadow;
-        } interrupt;
-        struct {
-                __u8 injected;
-                __u8 pending;
-                __u8 masked;
-                __u8 pad;
-        } nmi;
-        __u32 sipi_vector;
-        __u32 flags;
-};
-KVM_VCPUEVENT_VALID_SHADOW may be set in the flags field to signal that
-interrupt.shadow contains a valid state. Otherwise, this field is undefined.
-4.30 KVM_SET_VCPU_EVENTS
-Capability: KVM_CAP_VCPU_EVENTS
-Extended by: KVM_CAP_INTR_SHADOW
-Architectures: x86
-Type: vm ioctl
-Parameters: struct kvm_vcpu_event (in)
-Returns: 0 on success, -1 on error
-Set pending exceptions, interrupts, and NMIs as well as related states of the
-vcpu.
-See KVM_GET_VCPU_EVENTS for the data structure.
-Fields that may be modified asynchronously by running VCPUs can be excluded
-from the update. These fields are nmi.pending and sipi_vector. Keep the
-corresponding bits in the flags field cleared to suppress overwriting the
-current in-kernel state. The bits are:
-KVM_VCPUEVENT_VALID_NMI_PENDING - transfer nmi.pending to the kernel
-KVM_VCPUEVENT_VALID_SIPI_VECTOR - transfer sipi_vector
-If KVM_CAP_INTR_SHADOW is available, KVM_VCPUEVENT_VALID_SHADOW can be set in
-the flags field to signal that interrupt.shadow contains a valid state and
-shall be written into the VCPU.
-4.32 KVM_GET_DEBUGREGS
-Capability: KVM_CAP_DEBUGREGS
-Architectures: x86
-Type: vm ioctl
-Parameters: struct kvm_debugregs (out)
-Returns: 0 on success, -1 on error
-Reads debug registers from the vcpu.
-struct kvm_debugregs {
-        __u64 db[4];
-        __u64 dr6;
-        __u64 dr7;
-        __u64 flags;
-        __u64 reserved[9];
-};
-4.33 KVM_SET_DEBUGREGS
-Capability: KVM_CAP_DEBUGREGS
-Architectures: x86
-Type: vm ioctl
-Parameters: struct kvm_debugregs (in)
-Returns: 0 on success, -1 on error
-Writes debug registers into the vcpu.
-See KVM_GET_DEBUGREGS for the data structure. The flags field is unused
-yet and must be cleared on entry.
-4.34 KVM_SET_USER_MEMORY_REGION
-Capability: KVM_CAP_USER_MEM
-Architectures: all
-Type: vm ioctl
-Parameters: struct kvm_userspace_memory_region (in)
-Returns: 0 on success, -1 on error
-struct kvm_userspace_memory_region {
-        __u32 slot;
-        __u32 flags;
-        __u64 guest_phys_addr;
-        __u64 memory_size; /* bytes */
-        __u64 userspace_addr; /* start of the userspace allocated memory */
-};
-/* for kvm_memory_region::flags */
-#define KVM_MEM_LOG_DIRTY_PAGES  1UL
-This ioctl allows the user to create or modify a guest physical memory
-slot.  When changing an existing slot, it may be moved in the guest
-physical memory space, or its flags may be modified.  It may not be
-resized.  Slots may not overlap in guest physical address space.
-Memory for the region is taken starting at the address denoted by the
-field userspace_addr, which must point at user addressable memory for
-the entire memory slot size.  Any object may back this memory, including
-anonymous memory, ordinary files, and hugetlbfs.
-It is recommended that the lower 21 bits of guest_phys_addr and userspace_addr
-be identical.  This allows large pages in the guest to be backed by large
-pages in the host.
-The flags field supports just one flag, KVM_MEM_LOG_DIRTY_PAGES, which
-instructs kvm to keep track of writes to memory within the slot.  See
-the KVM_GET_DIRTY_LOG ioctl.
-When the KVM_CAP_SYNC_MMU capability, changes in the backing of the memory
-region are automatically reflected into the guest.  For example, an mmap()
-that affects the region will be made visible immediately.  Another example
-is madvise(MADV_DROP).
-It is recommended to use this API instead of the KVM_SET_MEMORY_REGION ioctl.
-The KVM_SET_MEMORY_REGION does not allow fine grained control over memory
-allocation and is deprecated.
-4.35 KVM_SET_TSS_ADDR
-Capability: KVM_CAP_SET_TSS_ADDR
-Architectures: x86
-Type: vm ioctl
-Parameters: unsigned long tss_address (in)
-Returns: 0 on success, -1 on error
-This ioctl defines the physical address of a three-page region in the guest
-physical address space.  The region must be within the first 4GB of the
-guest physical address space and must not conflict with any memory slot
-or any mmio address.  The guest may malfunction if it accesses this memory
-region.
-This ioctl is required on Intel-based hosts.  This is needed on Intel hardware
-because of a quirk in the virtualization implementation (see the internals
-documentation when it pops into existence).
-4.36 KVM_ENABLE_CAP
-Capability: KVM_CAP_ENABLE_CAP
-Architectures: ppc
-Type: vcpu ioctl
-Parameters: struct kvm_enable_cap (in)
-Returns: 0 on success; -1 on error
-+Not all extensions are enabled by default. Using this ioctl the application
-can enable an extension, making it available to the guest.
-On systems that do not support this ioctl, it always fails. On systems that
-do support it, it only works for extensions that are supported for enablement.
-To check if a capability can be enabled, the KVM_CHECK_EXTENSION ioctl should
-be used.
-struct kvm_enable_cap {
-       /* in */
-       __u32 cap;
-The capability that is supposed to get enabled.
-       __u32 flags;
-A bitfield indicating future enhancements. Has to be 0 for now.
-       __u64 args[4];
-Arguments for enabling a feature. If a feature needs initial values to
-function properly, this is the place to put them.
-       __u8  pad[64];
-};
-4.37 KVM_GET_MP_STATE
-Capability: KVM_CAP_MP_STATE
-Architectures: x86, ia64
-Type: vcpu ioctl
-Parameters: struct kvm_mp_state (out)
-Returns: 0 on success; -1 on error
-struct kvm_mp_state {
-        __u32 mp_state;
-};
-Returns the vcpu's current "multiprocessing state" (though also valid on
-uniprocessor guests).
-Possible values are:
- - KVM_MP_STATE_RUNNABLE:        the vcpu is currently running
- - KVM_MP_STATE_UNINITIALIZED:   the vcpu is an application processor (AP)
-                                 which has not yet received an INIT signal
- - KVM_MP_STATE_INIT_RECEIVED:   the vcpu has received an INIT signal, and is
-                                 now ready for a SIPI
- - KVM_MP_STATE_HALTED:          the vcpu has executed a HLT instruction and
-                                 is waiting for an interrupt
- - KVM_MP_STATE_SIPI_RECEIVED:   the vcpu has just received a SIPI (vector
-                                 accesible via KVM_GET_VCPU_EVENTS)
-This ioctl is only useful after KVM_CREATE_IRQCHIP.  Without an in-kernel
-irqchip, the multiprocessing state must be maintained by userspace.
-4.38 KVM_SET_MP_STATE
-Capability: KVM_CAP_MP_STATE
-Architectures: x86, ia64
-Type: vcpu ioctl
-Parameters: struct kvm_mp_state (in)
-Returns: 0 on success; -1 on error
-Sets the vcpu's current "multiprocessing state"; see KVM_GET_MP_STATE for
-arguments.
-This ioctl is only useful after KVM_CREATE_IRQCHIP.  Without an in-kernel
-irqchip, the multiprocessing state must be maintained by userspace.
-4.39 KVM_SET_IDENTITY_MAP_ADDR
-Capability: KVM_CAP_SET_IDENTITY_MAP_ADDR
-Architectures: x86
-Type: vm ioctl
-Parameters: unsigned long identity (in)
-Returns: 0 on success, -1 on error
-This ioctl defines the physical address of a one-page region in the guest
-physical address space.  The region must be within the first 4GB of the
-guest physical address space and must not conflict with any memory slot
-or any mmio address.  The guest may malfunction if it accesses this memory
-region.
-This ioctl is required on Intel-based hosts.  This is needed on Intel hardware
-because of a quirk in the virtualization implementation (see the internals
-documentation when it pops into existence).
-4.40 KVM_SET_BOOT_CPU_ID
-Capability: KVM_CAP_SET_BOOT_CPU_ID
-Architectures: x86, ia64
-Type: vm ioctl
-Parameters: unsigned long vcpu_id
-Returns: 0 on success, -1 on error
-Define which vcpu is the Bootstrap Processor (BSP).  Values are the same
-as the vcpu id in KVM_CREATE_VCPU.  If this ioctl is not called, the default
-is vcpu 0.
-4.41 KVM_GET_XSAVE
-Capability: KVM_CAP_XSAVE
-Architectures: x86
-Type: vcpu ioctl
-Parameters: struct kvm_xsave (out)
-Returns: 0 on success, -1 on error
-struct kvm_xsave {
-        __u32 region[1024];
-};
-This ioctl would copy current vcpu's xsave struct to the userspace.
-4.42 KVM_SET_XSAVE
-Capability: KVM_CAP_XSAVE
-Architectures: x86
-Type: vcpu ioctl
-Parameters: struct kvm_xsave (in)
-Returns: 0 on success, -1 on error
-struct kvm_xsave {
-        __u32 region[1024];
-};
-This ioctl would copy userspace's xsave struct to the kernel.
-4.43 KVM_GET_XCRS
-Capability: KVM_CAP_XCRS
-Architectures: x86
-Type: vcpu ioctl
-Parameters: struct kvm_xcrs (out)
-Returns: 0 on success, -1 on error
-struct kvm_xcr {
-        __u32 xcr;
-        __u32 reserved;
-        __u64 value;
-};
-struct kvm_xcrs {
-        __u32 nr_xcrs;
-        __u32 flags;
-        struct kvm_xcr xcrs[KVM_MAX_XCRS];
-        __u64 padding[16];
-};
-This ioctl would copy current vcpu's xcrs to the userspace.
-4.44 KVM_SET_XCRS
-Capability: KVM_CAP_XCRS
-Architectures: x86
-Type: vcpu ioctl
-Parameters: struct kvm_xcrs (in)
-Returns: 0 on success, -1 on error
-struct kvm_xcr {
-        __u32 xcr;
-        __u32 reserved;
-        __u64 value;
-};
-struct kvm_xcrs {
-        __u32 nr_xcrs;
-        __u32 flags;
-        struct kvm_xcr xcrs[KVM_MAX_XCRS];
-        __u64 padding[16];
-};
-This ioctl would set vcpu's xcr to the value userspace specified.
-4.45 KVM_GET_SUPPORTED_CPUID
-Capability: KVM_CAP_EXT_CPUID
-Architectures: x86
-Type: system ioctl
-Parameters: struct kvm_cpuid2 (in/out)
-Returns: 0 on success, -1 on error
-struct kvm_cpuid2 {
-        __u32 nent;
-        __u32 padding;
-        struct kvm_cpuid_entry2 entries[0];
-};
-#define KVM_CPUID_FLAG_SIGNIFCANT_INDEX 1
-#define KVM_CPUID_FLAG_STATEFUL_FUNC    2
-#define KVM_CPUID_FLAG_STATE_READ_NEXT  4
-struct kvm_cpuid_entry2 {
-        __u32 function;
-        __u32 index;
-        __u32 flags;
-        __u32 eax;
-        __u32 ebx;
-        __u32 ecx;
-        __u32 edx;
-        __u32 padding[3];
-};
-This ioctl returns x86 cpuid features which are supported by both the hardware
-and kvm.  Userspace can use the information returned by this ioctl to
-construct cpuid information (for KVM_SET_CPUID2) that is consistent with
-hardware, kernel, and userspace capabilities, and with user requirements (for
-example, the user may wish to constrain cpuid to emulate older hardware,
-or for feature consistency across a cluster).
-Userspace invokes KVM_GET_SUPPORTED_CPUID by passing a kvm_cpuid2 structure
-with the 'nent' field indicating the number of entries in the variable-size
-array 'entries'.  If the number of entries is too low to describe the cpu
-capabilities, an error (E2BIG) is returned.  If the number is too high,
-the 'nent' field is adjusted and an error (ENOMEM) is returned.  If the
-number is just right, the 'nent' field is adjusted to the number of valid
-entries in the 'entries' array, which is then filled.
-The entries returned are the host cpuid as returned by the cpuid instruction,
-with unknown or unsupported features masked out.  The fields in each entry
-are defined as follows:
-  function: the eax value used to obtain the entry
-  index: the ecx value used to obtain the entry (for entries that are
-         affected by ecx)
-  flags: an OR of zero or more of the following:
-        KVM_CPUID_FLAG_SIGNIFCANT_INDEX:
-           if the index field is valid
-        KVM_CPUID_FLAG_STATEFUL_FUNC:
-           if cpuid for this function returns different values for successive
-           invocations; there will be several entries with the same function,
-           all with this flag set
-        KVM_CPUID_FLAG_STATE_READ_NEXT:
-           for KVM_CPUID_FLAG_STATEFUL_FUNC entries, set if this entry is
-           the first entry to be read by a cpu
-   eax, ebx, ecx, edx: the values returned by the cpuid instruction for
-         this function/index combination
-5. The kvm_run structure
-Application code obtains a pointer to the kvm_run structure by
-mmap()ing a vcpu fd.  From that point, application code can control
-execution by changing fields in kvm_run prior to calling the KVM_RUN
-ioctl, and obtain information about the reason KVM_RUN returned by
-looking up structure members.
-struct kvm_run {
-        /* in */
-        __u8 request_interrupt_window;
-Request that KVM_RUN return when it becomes possible to inject external
-interrupts into the guest.  Useful in conjunction with KVM_INTERRUPT.
-        __u8 padding1[7];
-        /* out */
-        __u32 exit_reason;
-When KVM_RUN has returned successfully (return value 0), this informs
-application code why KVM_RUN has returned.  Allowable values for this
-field are detailed below.
-        __u8 ready_for_interrupt_injection;
-If request_interrupt_window has been specified, this field indicates
-an interrupt can be injected now with KVM_INTERRUPT.
-        __u8 if_flag;
-The value of the current interrupt flag.  Only valid if in-kernel
-local APIC is not used.
-        __u8 padding2[2];
-        /* in (pre_kvm_run), out (post_kvm_run) */
-        __u64 cr8;
-The value of the cr8 register.  Only valid if in-kernel local APIC is
-not used.  Both input and output.
-        __u64 apic_base;
-The value of the APIC BASE msr.  Only valid if in-kernel local
-APIC is not used.  Both input and output.
-        union {
-                /* KVM_EXIT_UNKNOWN */
-                struct {
-                        __u64 hardware_exit_reason;
-                } hw;
-If exit_reason is KVM_EXIT_UNKNOWN, the vcpu has exited due to unknown
-reasons.  Further architecture-specific information is available in
-hardware_exit_reason.
-                /* KVM_EXIT_FAIL_ENTRY */
-                struct {
-                        __u64 hardware_entry_failure_reason;
-                } fail_entry;
-If exit_reason is KVM_EXIT_FAIL_ENTRY, the vcpu could not be run due
-to unknown reasons.  Further architecture-specific information is
-available in hardware_entry_failure_reason.
-                /* KVM_EXIT_EXCEPTION */
-                struct {
-                        __u32 exception;
-                        __u32 error_code;
-                } ex;
-Unused.
-                /* KVM_EXIT_IO */
-                struct {
-#define KVM_EXIT_IO_IN  0
-#define KVM_EXIT_IO_OUT 1
-                        __u8 direction;
-                        __u8 size; /* bytes */
-                        __u16 port;
-                        __u32 count;
-                        __u64 data_offset; /* relative to kvm_run start */
-                } io;
-If exit_reason is KVM_EXIT_IO, then the vcpu has
-executed a port I/O instruction which could not be satisfied by kvm.
-data_offset describes where the data is located (KVM_EXIT_IO_OUT) or
-where kvm expects application code to place the data for the next
-KVM_RUN invocation (KVM_EXIT_IO_IN).  Data format is a packed array.
-                struct {
-                        struct kvm_debug_exit_arch arch;
-                } debug;
-Unused.
-                /* KVM_EXIT_MMIO */
-                struct {
-                        __u64 phys_addr;
-                        __u8  data[8];
-                        __u32 len;
-                        __u8  is_write;
-                } mmio;
-If exit_reason is KVM_EXIT_MMIO, then the vcpu has
-executed a memory-mapped I/O instruction which could not be satisfied
-by kvm.  The 'data' member contains the written data if 'is_write' is
-true, and should be filled by application code otherwise.
-NOTE: For KVM_EXIT_IO, KVM_EXIT_MMIO and KVM_EXIT_OSI, the corresponding
-operations are complete (and guest state is consistent) only after userspace
-has re-entered the kernel with KVM_RUN.  The kernel side will first finish
-incomplete operations and then check for pending signals.  Userspace
-can re-enter the guest with an unmasked signal pending to complete
-pending operations.
-                /* KVM_EXIT_HYPERCALL */
-                struct {
-                        __u64 nr;
-                        __u64 args[6];
-                        __u64 ret;
-                        __u32 longmode;
-                        __u32 pad;
-                } hypercall;
-Unused.  This was once used for 'hypercall to userspace'.  To implement
-such functionality, use KVM_EXIT_IO (x86) or KVM_EXIT_MMIO (all except s390).
-Note KVM_EXIT_IO is significantly faster than KVM_EXIT_MMIO.
-                /* KVM_EXIT_TPR_ACCESS */
-                struct {
-                        __u64 rip;
-                        __u32 is_write;
-                        __u32 pad;
-                } tpr_access;
-To be documented (KVM_TPR_ACCESS_REPORTING).
-                /* KVM_EXIT_S390_SIEIC */
-                struct {
-                        __u8 icptcode;
-                        __u64 mask; /* psw upper half */
-                        __u64 addr; /* psw lower half */
-                        __u16 ipa;
-                        __u32 ipb;
-                } s390_sieic;
-s390 specific.
-                /* KVM_EXIT_S390_RESET */
-#define KVM_S390_RESET_POR       1
-#define KVM_S390_RESET_CLEAR     2
-#define KVM_S390_RESET_SUBSYSTEM 4
-#define KVM_S390_RESET_CPU_INIT  8
-#define KVM_S390_RESET_IPL       16
-                __u64 s390_reset_flags;
-s390 specific.
-                /* KVM_EXIT_DCR */
-                struct {
-                        __u32 dcrn;
-                        __u32 data;
-                        __u8  is_write;
-                } dcr;
-powerpc specific.
-                /* KVM_EXIT_OSI */
-                struct {
-                        __u64 gprs[32];
-                } osi;
-MOL uses a special hypercall interface it calls 'OSI'. To enable it, we catch
-hypercalls and exit with this exit struct that contains all the guest gprs.
-If exit_reason is KVM_EXIT_OSI, then the vcpu has triggered such a hypercall.
-Userspace can now handle the hypercall and when it's done modify the gprs as
-necessary. Upon guest entry all guest GPRs will then be replaced by the values
-in this struct.
-                /* Fix the size of the union. */
-                char padding[256];
-        };
-};
diff --git a/Documentation/kvm/cpuid.txt b/Documentation/kvm/cpuid.txt
deleted file mode 100644
index 14a12ea92b7f..000000000000
--- a/Documentation/kvm/cpuid.txt
+++ /dev/null
@@ -1,42 +0,0 @@
-KVM CPUID bits
-Glauber Costa <glommer@redhat.com>, Red Hat Inc, 2010
-=====================================================
-A guest running on a kvm host, can check some of its features using
-cpuid. This is not always guaranteed to work, since userspace can
-mask-out some, or even all KVM-related cpuid features before launching
-a guest.
-KVM cpuid functions are:
-function: KVM_CPUID_SIGNATURE (0x40000000)
-returns : eax = 0,
-          ebx = 0x4b4d564b,
-          ecx = 0x564b4d56,
-          edx = 0x4d.
-Note that this value in ebx, ecx and edx corresponds to the string "KVMKVMKVM".
-This function queries the presence of KVM cpuid leafs.
-function: define KVM_CPUID_FEATURES (0x40000001)
-returns : ebx, ecx, edx = 0
-          eax = and OR'ed group of (1 << flag), where each flags is:
-flag                               || value || meaning
-=============================================================================
-KVM_FEATURE_CLOCKSOURCE            ||     0 || kvmclock available at msrs
-                                   ||       || 0x11 and 0x12.
------------------------------------------------------------------------------
-KVM_FEATURE_NOP_IO_DELAY           ||     1 || not necessary to perform delays
-                                   ||       || on PIO operations.
------------------------------------------------------------------------------
-KVM_FEATURE_MMU_OP                 ||     2 || deprecated.
------------------------------------------------------------------------------
-KVM_FEATURE_CLOCKSOURCE2           ||     3 || kvmclock available at msrs
-                                   ||       || 0x4b564d00 and 0x4b564d01
------------------------------------------------------------------------------
-KVM_FEATURE_CLOCKSOURCE_STABLE_BIT ||    24 || host will warn if no guest-side
-                                   ||       || per-cpu warps are expected in
-                                   ||       || kvmclock.
------------------------------------------------------------------------------
diff --git a/Documentation/kvm/mmu.txt b/Documentation/kvm/mmu.txt
deleted file mode 100644
index 142cc5136650..000000000000
--- a/Documentation/kvm/mmu.txt
+++ /dev/null
@@ -1,348 +0,0 @@
-The x86 kvm shadow mmu
-======================
-The mmu (in arch/x86/kvm, files mmu.[ch] and paging_tmpl.h) is responsible
-for presenting a standard x86 mmu to the guest, while translating guest
-physical addresses to host physical addresses.
-The mmu code attempts to satisfy the following requirements:
- correctness: the guest should not be able to determine that it is running
-               on an emulated mmu except for timing (we attempt to comply
-               with the specification, not emulate the characteristics of
-               a particular implementation such as tlb size)
- security:    the guest must not be able to touch host memory not assigned
-               to it
- performance: minimize the performance penalty imposed by the mmu
- scaling:     need to scale to large memory and large vcpu guests
- hardware:    support the full range of x86 virtualization hardware
- integration: Linux memory management code must be in control of guest memory
-               so that swapping, page migration, page merging, transparent
-               hugepages, and similar features work without change
- dirty tracking: report writes to guest memory to enable live migration
-               and framebuffer-based displays
- footprint:   keep the amount of pinned kernel memory low (most memory
-               should be shrinkable)
- reliablity:  avoid multipage or GFP_ATOMIC allocations
-Acronyms
-========
-pfn   host page frame number
-hpa   host physical address
-hva   host virtual address
-gfn   guest frame number
-gpa   guest physical address
-gva   guest virtual address
-ngpa  nested guest physical address
-ngva  nested guest virtual address
-pte   page table entry (used also to refer generically to paging structure
-      entries)
-gpte  guest pte (referring to gfns)
-spte  shadow pte (referring to pfns)
-tdp   two dimensional paging (vendor neutral term for NPT and EPT)
-Virtual and real hardware supported
-===================================
-The mmu supports first-generation mmu hardware, which allows an atomic switch
-of the current paging mode and cr3 during guest entry, as well as
-two-dimensional paging (AMD's NPT and Intel's EPT).  The emulated hardware
-it exposes is the traditional 2/3/4 level x86 mmu, with support for global
-pages, pae, pse, pse36, cr0.wp, and 1GB pages.  Work is in progress to support
-exposing NPT capable hardware on NPT capable hosts.
-Translation
-===========
-The primary job of the mmu is to program the processor's mmu to translate
-addresses for the guest.  Different translations are required at different
-times:
- when guest paging is disabled, we translate guest physical addresses to
-  host physical addresses (gpa->hpa)
- when guest paging is enabled, we translate guest virtual addresses, to
-  guest physical addresses, to host physical addresses (gva->gpa->hpa)
- when the guest launches a guest of its own, we translate nested guest
-  virtual addresses, to nested guest physical addresses, to guest physical
-  addresses, to host physical addresses (ngva->ngpa->gpa->hpa)
-The primary challenge is to encode between 1 and 3 translations into hardware
-that support only 1 (traditional) and 2 (tdp) translations.  When the
-number of required translations matches the hardware, the mmu operates in
-direct mode; otherwise it operates in shadow mode (see below).
-Memory
-======
-Guest memory (gpa) is part of the user address space of the process that is
-using kvm.  Userspace defines the translation between guest addresses and user
-addresses (gpa->hva); note that two gpas may alias to the same hva, but not
-vice versa.
-These hvas may be backed using any method available to the host: anonymous
-memory, file backed memory, and device memory.  Memory might be paged by the
-host at any time.
-Events
-======
-The mmu is driven by events, some from the guest, some from the host.
-Guest generated events:
- writes to control registers (especially cr3)
- invlpg/invlpga instruction execution
- access to missing or protected translations
-Host generated events:
- changes in the gpa->hpa translation (either through gpa->hva changes or
-  through hva->hpa changes)
- memory pressure (the shrinker)
-Shadow pages
-============
-The principal data structure is the shadow page, 'struct kvm_mmu_page'.  A
-shadow page contains 512 sptes, which can be either leaf or nonleaf sptes.  A
-shadow page may contain a mix of leaf and nonleaf sptes.
-A nonleaf spte allows the hardware mmu to reach the leaf pages and
-is not related to a translation directly.  It points to other shadow pages.
-A leaf spte corresponds to either one or two translations encoded into
-one paging structure entry.  These are always the lowest level of the
-translation stack, with optional higher level translations left to NPT/EPT.
-Leaf ptes point at guest pages.
-The following table shows translations encoded by leaf ptes, with higher-level
-translations in parentheses:
- Non-nested guests:
-  nonpaging:     gpa->hpa
-  paging:        gva->gpa->hpa
-  paging, tdp:   (gva->)gpa->hpa
- Nested guests:
-  non-tdp:       ngva->gpa->hpa  (*)
-  tdp:           (ngva->)ngpa->gpa->hpa
-(*) the guest hypervisor will encode the ngva->gpa translation into its page
-    tables if npt is not present
-Shadow pages contain the following information:
-  role.level:
-    The level in the shadow paging hierarchy that this shadow page belongs to.
-    1=4k sptes, 2=2M sptes, 3=1G sptes, etc.
-  role.direct:
-    If set, leaf sptes reachable from this page are for a linear range.
-    Examples include real mode translation, large guest pages backed by small
-    host pages, and gpa->hpa translations when NPT or EPT is active.
-    The linear range starts at (gfn << PAGE_SHIFT) and its size is determined
-    by role.level (2MB for first level, 1GB for second level, 0.5TB for third
-    level, 256TB for fourth level)
-    If clear, this page corresponds to a guest page table denoted by the gfn
-    field.
-  role.quadrant:
-    When role.cr4_pae=0, the guest uses 32-bit gptes while the host uses 64-bit
-    sptes.  That means a guest page table contains more ptes than the host,
-    so multiple shadow pages are needed to shadow one guest page.
-    For first-level shadow pages, role.quadrant can be 0 or 1 and denotes the
-    first or second 512-gpte block in the guest page table.  For second-level
-    page tables, each 32-bit gpte is converted to two 64-bit sptes
-    (since each first-level guest page is shadowed by two first-level
-    shadow pages) so role.quadrant takes values in the range 0..3.  Each
-    quadrant maps 1GB virtual address space.
-  role.access:
-    Inherited guest access permissions in the form uwx.  Note execute
-    permission is positive, not negative.
-  role.invalid:
-    The page is invalid and should not be used.  It is a root page that is
-    currently pinned (by a cpu hardware register pointing to it); once it is
-    unpinned it will be destroyed.
-  role.cr4_pae:
-    Contains the value of cr4.pae for which the page is valid (e.g. whether
-    32-bit or 64-bit gptes are in use).
-  role.nxe:
-    Contains the value of efer.nxe for which the page is valid.
-  role.cr0_wp:
-    Contains the value of cr0.wp for which the page is valid.
-  gfn:
-    Either the guest page table containing the translations shadowed by this
-    page, or the base page frame for linear translations.  See role.direct.
-  spt:
-    A pageful of 64-bit sptes containing the translations for this page.
-    Accessed by both kvm and hardware.
-    The page pointed to by spt will have its page->private pointing back
-    at the shadow page structure.
-    sptes in spt point either at guest pages, or at lower-level shadow pages.
-    Specifically, if sp1 and sp2 are shadow pages, then sp1->spt[n] may point
-    at __pa(sp2->spt).  sp2 will point back at sp1 through parent_pte.
-    The spt array forms a DAG structure with the shadow page as a node, and
-    guest pages as leaves.
-  gfns:
-    An array of 512 guest frame numbers, one for each present pte.  Used to
-    perform a reverse map from a pte to a gfn. When role.direct is set, any
-    element of this array can be calculated from the gfn field when used, in
-    this case, the array of gfns is not allocated. See role.direct and gfn.
-  slot_bitmap:
-    A bitmap containing one bit per memory slot.  If the page contains a pte
-    mapping a page from memory slot n, then bit n of slot_bitmap will be set
-    (if a page is aliased among several slots, then it is not guaranteed that
-    all slots will be marked).
-    Used during dirty logging to avoid scanning a shadow page if none if its
-    pages need tracking.
-  root_count:
-    A counter keeping track of how many hardware registers (guest cr3 or
-    pdptrs) are now pointing at the page.  While this counter is nonzero, the
-    page cannot be destroyed.  See role.invalid.
-  multimapped:
-    Whether there exist multiple sptes pointing at this page.
-  parent_pte/parent_ptes:
-    If multimapped is zero, parent_pte points at the single spte that points at
-    this page's spt.  Otherwise, parent_ptes points at a data structure
-    with a list of parent_ptes.
-  unsync:
-    If true, then the translations in this page may not match the guest's
-    translation.  This is equivalent to the state of the tlb when a pte is
-    changed but before the tlb entry is flushed.  Accordingly, unsync ptes
-    are synchronized when the guest executes invlpg or flushes its tlb by
-    other means.  Valid for leaf pages.
-  unsync_children:
-    How many sptes in the page point at pages that are unsync (or have
-    unsynchronized children).
-  unsync_child_bitmap:
-    A bitmap indicating which sptes in spt point (directly or indirectly) at
-    pages that may be unsynchronized.  Used to quickly locate all unsychronized
-    pages reachable from a given page.
-Reverse map
-===========
-The mmu maintains a reverse mapping whereby all ptes mapping a page can be
-reached given its gfn.  This is used, for example, when swapping out a page.
-Synchronized and unsynchronized pages
-=====================================
-The guest uses two events to synchronize its tlb and page tables: tlb flushes
-and page invalidations (invlpg).
-A tlb flush means that we need to synchronize all sptes reachable from the
-guest's cr3.  This is expensive, so we keep all guest page tables write
-protected, and synchronize sptes to gptes when a gpte is written.
-A special case is when a guest page table is reachable from the current
-guest cr3.  In this case, the guest is obliged to issue an invlpg instruction
-before using the translation.  We take advantage of that by removing write
-protection from the guest page, and allowing the guest to modify it freely.
-We synchronize modified gptes when the guest invokes invlpg.  This reduces
-the amount of emulation we have to do when the guest modifies multiple gptes,
-or when the a guest page is no longer used as a page table and is used for
-random guest data.
-As a side effect we have to resynchronize all reachable unsynchronized shadow
-pages on a tlb flush.
-Reaction to events
-==================
- guest page fault (or npt page fault, or ept violation)
-This is the most complicated event.  The cause of a page fault can be:
-  - a true guest fault (the guest translation won't allow the access) (*)
-  - access to a missing translation
-  - access to a protected translation
-    - when logging dirty pages, memory is write protected
-    - synchronized shadow pages are write protected (*)
-  - access to untranslatable memory (mmio)
-  (*) not applicable in direct mode
-Handling a page fault is performed as follows:
- - if needed, walk the guest page tables to determine the guest translation
-   (gva->gpa or ngpa->gpa)
-   - if permissions are insufficient, reflect the fault back to the guest
- - determine the host page
-   - if this is an mmio request, there is no host page; call the emulator
-     to emulate the instruction instead
- - walk the shadow page table to find the spte for the translation,
-   instantiating missing intermediate page tables as necessary
- - try to unsynchronize the page
-   - if successful, we can let the guest continue and modify the gpte
- - emulate the instruction
-   - if failed, unshadow the page and let the guest continue
- - update any translations that were modified by the instruction
-invlpg handling:
-  - walk the shadow page hierarchy and drop affected translations
-  - try to reinstantiate the indicated translation in the hope that the
-    guest will use it in the near future
-Guest control register updates:
- mov to cr3
-  - look up new shadow roots
-  - synchronize newly reachable shadow pages
- mov to cr0/cr4/efer
-  - set up mmu context for new paging mode
-  - look up new shadow roots
-  - synchronize newly reachable shadow pages
-Host translation updates:
-  - mmu notifier called with updated hva
-  - look up affected sptes through reverse map
-  - drop (or update) translations
-Emulating cr0.wp
-================
-If tdp is not enabled, the host must keep cr0.wp=1 so page write protection
-works for the guest kernel, not guest guest userspace.  When the guest
-cr0.wp=1, this does not present a problem.  However when the guest cr0.wp=0,
-we cannot map the permissions for gpte.u=1, gpte.w=0 to any spte (the
-semantics require allowing any guest kernel access plus user read access).
-We handle this by mapping the permissions to two possible sptes, depending
-on fault type:
- kernel write fault: spte.u=0, spte.w=1 (allows full kernel access,
-  disallows user access)
- read fault: spte.u=1, spte.w=0 (allows full read access, disallows kernel
-  write access)
-(user write faults generate a #PF)
-Large pages
-===========
-The mmu supports all combinations of large and small guest and host pages.
-Supported page sizes include 4k, 2M, 4M, and 1G.  4M pages are treated as
-two separate 2M pages, on both guest and host, since the mmu always uses PAE
-paging.
-To instantiate a large spte, four constraints must be satisfied:
- the spte must point to a large host page
- the guest pte must be a large pte of at least equivalent size (if tdp is
-  enabled, there is no guest pte and this condition is satisified)
- if the spte will be writeable, the large page frame may not overlap any
-  write-protected pages
- the guest page must be wholly contained by a single memory slot
-To check the last two conditions, the mmu maintains a ->write_count set of
-arrays for each memory slot and large page size.  Every write protected page
-causes its write_count to be incremented, thus preventing instantiation of
-a large spte.  The frames at the end of an unaligned memory slot have
-artificically inflated ->write_counts so they can never be instantiated.
-Further reading
-===============
- NPT presentation from KVM Forum 2008
-  http://www.linux-kvm.org/wiki/images/c/c8/KvmForum2008%24kdf2008_21.pdf
diff --git a/Documentation/kvm/msr.txt b/Documentation/kvm/msr.txt
deleted file mode 100644
index 8ddcfe84c09a..000000000000
--- a/Documentation/kvm/msr.txt
+++ /dev/null
@@ -1,153 +0,0 @@
-KVM-specific MSRs.
-Glauber Costa <glommer@redhat.com>, Red Hat Inc, 2010
-=====================================================
-KVM makes use of some custom MSRs to service some requests.
-At present, this facility is only used by kvmclock.
-Custom MSRs have a range reserved for them, that goes from
-0x4b564d00 to 0x4b564dff. There are MSRs outside this area,
-but they are deprecated and their use is discouraged.
-Custom MSR list
--------
-The current supported Custom MSR list is:
-MSR_KVM_WALL_CLOCK_NEW:   0x4b564d00
-        data: 4-byte alignment physical address of a memory area which must be
-        in guest RAM. This memory is expected to hold a copy of the following
-        structure:
-        struct pvclock_wall_clock {
-                u32   version;
-                u32   sec;
-                u32   nsec;
-        } __attribute__((__packed__));
-        whose data will be filled in by the hypervisor. The hypervisor is only
-        guaranteed to update this data at the moment of MSR write.
-        Users that want to reliably query this information more than once have
-        to write more than once to this MSR. Fields have the following meanings:
-                version: guest has to check version before and after grabbing
-                time information and check that they are both equal and even.
-                An odd version indicates an in-progress update.
-                sec: number of seconds for wallclock.
-                nsec: number of nanoseconds for wallclock.
-        Note that although MSRs are per-CPU entities, the effect of this
-        particular MSR is global.
-        Availability of this MSR must be checked via bit 3 in 0x4000001 cpuid
-        leaf prior to usage.
-MSR_KVM_SYSTEM_TIME_NEW:  0x4b564d01
-        data: 4-byte aligned physical address of a memory area which must be in
-        guest RAM, plus an enable bit in bit 0. This memory is expected to hold
-        a copy of the following structure:
-        struct pvclock_vcpu_time_info {
-                u32   version;
-                u32   pad0;
-                u64   tsc_timestamp;
-                u64   system_time;
-                u32   tsc_to_system_mul;
-                s8    tsc_shift;
-                u8    flags;
-                u8    pad[2];
-        } __attribute__((__packed__)); /* 32 bytes */
-        whose data will be filled in by the hypervisor periodically. Only one
-        write, or registration, is needed for each VCPU. The interval between
-        updates of this structure is arbitrary and implementation-dependent.
-        The hypervisor may update this structure at any time it sees fit until
-        anything with bit0 == 0 is written to it.
-        Fields have the following meanings:
-                version: guest has to check version before and after grabbing
-                time information and check that they are both equal and even.
-                An odd version indicates an in-progress update.
-                tsc_timestamp: the tsc value at the current VCPU at the time
-                of the update of this structure. Guests can subtract this value
-                from current tsc to derive a notion of elapsed time since the
-                structure update.
-                system_time: a host notion of monotonic time, including sleep
-                time at the time this structure was last updated. Unit is
-                nanoseconds.
-                tsc_to_system_mul: a function of the tsc frequency. One has
-                to multiply any tsc-related quantity by this value to get
-                a value in nanoseconds, besides dividing by 2^tsc_shift
-                tsc_shift: cycle to nanosecond divider, as a power of two, to
-                allow for shift rights. One has to shift right any tsc-related
-                quantity by this value to get a value in nanoseconds, besides
-                multiplying by tsc_to_system_mul.
-                With this information, guests can derive per-CPU time by
-                doing:
-                        time = (current_tsc - tsc_timestamp)
-                        time = (time * tsc_to_system_mul) >> tsc_shift
-                        time = time + system_time
-                flags: bits in this field indicate extended capabilities
-                coordinated between the guest and the hypervisor. Availability
-                of specific flags has to be checked in 0x40000001 cpuid leaf.
-                Current flags are:
-                 flag bit   | cpuid bit    | meaning
-                -------------------------------------------------------------
-                            |              | time measures taken across
-                     0      |      24      | multiple cpus are guaranteed to
-                            |              | be monotonic
-                -------------------------------------------------------------
-        Availability of this MSR must be checked via bit 3 in 0x4000001 cpuid
-        leaf prior to usage.
-MSR_KVM_WALL_CLOCK:  0x11
-        data and functioning: same as MSR_KVM_WALL_CLOCK_NEW. Use that instead.
-        This MSR falls outside the reserved KVM range and may be removed in the
-        future. Its usage is deprecated.
-        Availability of this MSR must be checked via bit 0 in 0x4000001 cpuid
-        leaf prior to usage.
-MSR_KVM_SYSTEM_TIME: 0x12
-        data and functioning: same as MSR_KVM_SYSTEM_TIME_NEW. Use that instead.
-        This MSR falls outside the reserved KVM range and may be removed in the
-        future. Its usage is deprecated.
-        Availability of this MSR must be checked via bit 0 in 0x4000001 cpuid
-        leaf prior to usage.
-        The suggested algorithm for detecting kvmclock presence is then:
-                if (!kvm_para_available())    /* refer to cpuid.txt */
-                        return NON_PRESENT;
-                flags = cpuid_eax(0x40000001);
-                if (flags & 3) {
-                        msr_kvm_system_time = MSR_KVM_SYSTEM_TIME_NEW;
-                        msr_kvm_wall_clock = MSR_KVM_WALL_CLOCK_NEW;
-                        return PRESENT;
-                } else if (flags & 0) {
-                        msr_kvm_system_time = MSR_KVM_SYSTEM_TIME;
-                        msr_kvm_wall_clock = MSR_KVM_WALL_CLOCK;
-                        return PRESENT;
-                } else
-                        return NON_PRESENT;
diff --git a/Documentation/kvm/review-checklist.txt b/Documentation/kvm/review-checklist.txt
deleted file mode 100644
index 730475ae1b8d..000000000000
--- a/Documentation/kvm/review-checklist.txt
+++ /dev/null
@@ -1,38 +0,0 @@
-Review checklist for kvm patches
-================================
-1.  The patch must follow Documentation/CodingStyle and
-    Documentation/SubmittingPatches.
-2.  Patches should be against kvm.git master branch.
-3.  If the patch introduces or modifies a new userspace API:
-    - the API must be documented in Documentation/kvm/api.txt
-    - the API must be discoverable using KVM_CHECK_EXTENSION
-4.  New state must include support for save/restore.
-5.  New features must default to off (userspace should explicitly request them).
-    Performance improvements can and should default to on.
-6.  New cpu features should be exposed via KVM_GET_SUPPORTED_CPUID2
-7.  Emulator changes should be accompanied by unit tests for qemu-kvm.git
-    kvm/test directory.
-8.  Changes should be vendor neutral when possible.  Changes to common code
-    are better than duplicating changes to vendor code.
-9.  Similarly, prefer changes to arch independent code than to arch dependent
-    code.
-10. User/kernel interfaces and guest/host interfaces must be 64-bit clean
-    (all variables and sizes naturally aligned on 64-bit; use specific types
-    only - u64 rather than ulong).
-11. New guest visible features must either be documented in a hardware manual
-    or be accompanied by documentation.
-12. Features must be robust against reset and kexec - for example, shared
-    host/guest memory must be unshared to prevent the host from writing to
-    guest memory that the guest has not reserved for this purpose.