Commit e4e65676 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm 

Pull KVM updates from Paolo Bonzini:
 "Fixes and features for 3.18.

  Apart from the usual cleanups, here is the summary of new features:

   - s390 moves closer towards host large page support

   - PowerPC has improved support for debugging (both inside the guest
     and via gdbstub) and support for e6500 processors

   - ARM/ARM64 support read-only memory (which is necessary to put
     firmware in emulated NOR flash)

   - x86 has the usual emulator fixes and nested virtualization
     improvements (including improved Windows support on Intel and
     Jailhouse hypervisor support on AMD), adaptive PLE which helps
     overcommitting of huge guests.  Also included are some patches that
     make KVM more friendly to memory hot-unplug, and fixes for rare
     caching bugs.

  Two patches have trivial mm/ parts that were acked by Rik and Andrew.

  Note: I will soon switch to a subkey for signing purposes"

* tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm: (157 commits)
  kvm: do not handle APIC access page if in-kernel irqchip is not in use
  KVM: s390: count vcpu wakeups in stat.halt_wakeup
  KVM: s390/facilities: allow TOD-CLOCK steering facility bit
  KVM: PPC: BOOK3S: HV: CMA: Reserve cma region only in hypervisor mode
  arm/arm64: KVM: Report correct FSC for unsupported fault types
  arm/arm64: KVM: Fix VTTBR_BADDR_MASK and pgd alloc
  kvm: Fix kvm_get_page_retry_io __gup retval check
  arm/arm64: KVM: Fix set_clear_sgi_pend_reg offset
  kvm: x86: Unpin and remove kvm_arch->apic_access_page
  kvm: vmx: Implement set_apic_access_page_addr
  kvm: x86: Add request bit to reload APIC access page address
  kvm: Add arch specific mmu notifier for page invalidation
  kvm: Rename make_all_cpus_request() to kvm_make_all_cpus_request() and make it non-static
  kvm: Fix page ageing bugs
  kvm/x86/mmu: Pass gfn and level to rmapp callback.
  x86: kvm: use alternatives for VMCALL vs. VMMCALL if kernel text is read-only
  kvm: x86: use macros to compute bank MSRs
  KVM: x86: Remove debug assertion of non-PAE reserved bits
  kvm: don't take vcpu mutex for obviously invalid vcpu ioctls
  kvm: Faults which trigger IO release the mmap_sem
  ...
parents f89f4a06 f439ed27

Documentation/virtual/kvm/api.txt

+119 −69
Original line number Diff line number Diff line
@@ -1901,6 +1901,8 @@ registers, find a list below: 
  PPC   | KVM_REG_PPC_ARCH_COMPAT       | 32

  PPC   | KVM_REG_PPC_DABRX             | 32

  PPC   | KVM_REG_PPC_WORT              | 64

  PPC	| KVM_REG_PPC_SPRG9             | 64

  PPC	| KVM_REG_PPC_DBSR              | 32

  PPC   | KVM_REG_PPC_TM_GPR0           | 64

          ...

  PPC   | KVM_REG_PPC_TM_GPR31          | 64
@@ -2565,6 +2567,120 @@ associated with the service will be forgotten, and subsequent RTAS 
calls by the guest for that service will be passed to userspace to be

handled.



4.87 KVM_SET_GUEST_DEBUG



Capability: KVM_CAP_SET_GUEST_DEBUG

Architectures: x86, s390, ppc

Type: vcpu ioctl

Parameters: struct kvm_guest_debug (in)

Returns: 0 on success; -1 on error



struct kvm_guest_debug {

       __u32 control;

       __u32 pad;

       struct kvm_guest_debug_arch arch;

};



Set up the processor specific debug registers and configure vcpu for

handling guest debug events. There are two parts to the structure, the

first a control bitfield indicates the type of debug events to handle

when running. Common control bits are:



  - KVM_GUESTDBG_ENABLE:        guest debugging is enabled

  - KVM_GUESTDBG_SINGLESTEP:    the next run should single-step



The top 16 bits of the control field are architecture specific control

flags which can include the following:



  - KVM_GUESTDBG_USE_SW_BP:     using software breakpoints [x86]

  - KVM_GUESTDBG_USE_HW_BP:     using hardware breakpoints [x86, s390]

  - KVM_GUESTDBG_INJECT_DB:     inject DB type exception [x86]

  - KVM_GUESTDBG_INJECT_BP:     inject BP type exception [x86]

  - KVM_GUESTDBG_EXIT_PENDING:  trigger an immediate guest exit [s390]



For example KVM_GUESTDBG_USE_SW_BP indicates that software breakpoints

are enabled in memory so we need to ensure breakpoint exceptions are

correctly trapped and the KVM run loop exits at the breakpoint and not

running off into the normal guest vector. For KVM_GUESTDBG_USE_HW_BP

we need to ensure the guest vCPUs architecture specific registers are

updated to the correct (supplied) values.



The second part of the structure is architecture specific and

typically contains a set of debug registers.



When debug events exit the main run loop with the reason

KVM_EXIT_DEBUG with the kvm_debug_exit_arch part of the kvm_run

structure containing architecture specific debug information.



4.88 KVM_GET_EMULATED_CPUID



Capability: KVM_CAP_EXT_EMUL_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 flags;

	struct kvm_cpuid_entry2 entries[0];

};



The member 'flags' is used for passing flags from userspace.



#define KVM_CPUID_FLAG_SIGNIFCANT_INDEX		BIT(0)

#define KVM_CPUID_FLAG_STATEFUL_FUNC		BIT(1)

#define KVM_CPUID_FLAG_STATE_READ_NEXT		BIT(2)



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 emulated by

kvm.Userspace can use the information returned by this ioctl to query

which features are emulated by kvm instead of being present natively.



Userspace invokes KVM_GET_EMULATED_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 set CPUID bits of the respective features

which kvm emulates, as returned by the CPUID instruction, with unknown

or unsupported feature bits cleared.



Features like x2apic, for example, may not be present in the host cpu

but are exposed by kvm in KVM_GET_SUPPORTED_CPUID because they can be

emulated efficiently and thus not included here.



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

------------------------
@@ -2861,78 +2977,12 @@ kvm_valid_regs for specific bits. These bits are architecture specific 
and usually define the validity of a groups of registers. (e.g. one bit

 for general purpose registers)



};





4.81 KVM_GET_EMULATED_CPUID



Capability: KVM_CAP_EXT_EMUL_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 flags;

	struct kvm_cpuid_entry2 entries[0];

};



The member 'flags' is used for passing flags from userspace.



#define KVM_CPUID_FLAG_SIGNIFCANT_INDEX		BIT(0)

#define KVM_CPUID_FLAG_STATEFUL_FUNC		BIT(1)

#define KVM_CPUID_FLAG_STATE_READ_NEXT		BIT(2)

Please note that the kernel is allowed to use the kvm_run structure as the

primary storage for certain register types. Therefore, the kernel may use the

values in kvm_run even if the corresponding bit in kvm_dirty_regs is not set.



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 emulated by

kvm.Userspace can use the information returned by this ioctl to query

which features are emulated by kvm instead of being present natively.



Userspace invokes KVM_GET_EMULATED_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 set CPUID bits of the respective features

which kvm emulates, as returned by the CPUID instruction, with unknown

or unsupported feature bits cleared.



Features like x2apic, for example, may not be present in the host cpu

but are exposed by kvm in KVM_GET_SUPPORTED_CPUID because they can be

emulated efficiently and thus not included here.



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





6. Capabilities that can be enabled on vCPUs

Documentation/virtual/kvm/devices/arm-vgic.txt

+10 −0
Original line number Diff line number Diff line
@@ -71,3 +71,13 @@ Groups: 
  Errors:

    -ENODEV: Getting or setting this register is not yet supported

    -EBUSY: One or more VCPUs are running



  KVM_DEV_ARM_VGIC_GRP_NR_IRQS

  Attributes:

    A value describing the number of interrupts (SGI, PPI and SPI) for

    this GIC instance, ranging from 64 to 1024, in increments of 32.



  Errors:

    -EINVAL: Value set is out of the expected range

    -EBUSY: Value has already be set, or GIC has already been initialized

            with default values.

Documentation/virtual/kvm/mmu.txt

+14 −0
Original line number Diff line number Diff line
@@ -425,6 +425,20 @@ fault through the slow path. 
Since only 19 bits are used to store generation-number on mmio spte, all

pages are zapped when there is an overflow.



Unfortunately, a single memory access might access kvm_memslots(kvm) multiple

times, the last one happening when the generation number is retrieved and

stored into the MMIO spte.  Thus, the MMIO spte might be created based on

out-of-date information, but with an up-to-date generation number.



To avoid this, the generation number is incremented again after synchronize_srcu

returns; thus, the low bit of kvm_memslots(kvm)->generation is only 1 during a

memslot update, while some SRCU readers might be using the old copy.  We do not

want to use an MMIO sptes created with an odd generation number, and we can do

this without losing a bit in the MMIO spte.  The low bit of the generation

is not stored in MMIO spte, and presumed zero when it is extracted out of the

spte.  If KVM is unlucky and creates an MMIO spte while the low bit is 1,

the next access to the spte will always be a cache miss.





Further reading

===============

arch/arm/include/asm/kvm_emulate.h

+5 −0
Original line number Diff line number Diff line
@@ -148,6 +148,11 @@ static inline bool kvm_vcpu_trap_is_iabt(struct kvm_vcpu *vcpu) 
}



static inline u8 kvm_vcpu_trap_get_fault(struct kvm_vcpu *vcpu)

{

	return kvm_vcpu_get_hsr(vcpu) & HSR_FSC;

}



static inline u8 kvm_vcpu_trap_get_fault_type(struct kvm_vcpu *vcpu)

{

	return kvm_vcpu_get_hsr(vcpu) & HSR_FSC_TYPE;

}

arch/arm/include/asm/kvm_host.h

+16 −7
Original line number Diff line number Diff line
@@ -19,6 +19,8 @@ 
#ifndef __ARM_KVM_HOST_H__

#define __ARM_KVM_HOST_H__



#include <linux/types.h>

#include <linux/kvm_types.h>

#include <asm/kvm.h>

#include <asm/kvm_asm.h>

#include <asm/kvm_mmio.h>
@@ -40,9 +42,8 @@ 


#include <kvm/arm_vgic.h>



struct kvm_vcpu;

u32 *kvm_vcpu_reg(struct kvm_vcpu *vcpu, u8 reg_num, u32 mode);

int kvm_target_cpu(void);

int __attribute_const__ kvm_target_cpu(void);

int kvm_reset_vcpu(struct kvm_vcpu *vcpu);

void kvm_reset_coprocs(struct kvm_vcpu *vcpu);
@@ -149,20 +150,17 @@ struct kvm_vcpu_stat { 
	u32 halt_wakeup;

};



struct kvm_vcpu_init;

int kvm_vcpu_set_target(struct kvm_vcpu *vcpu,

			const struct kvm_vcpu_init *init);

int kvm_vcpu_preferred_target(struct kvm_vcpu_init *init);

unsigned long kvm_arm_num_regs(struct kvm_vcpu *vcpu);

int kvm_arm_copy_reg_indices(struct kvm_vcpu *vcpu, u64 __user *indices);

struct kvm_one_reg;

int kvm_arm_get_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg);

int kvm_arm_set_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg);

u64 kvm_call_hyp(void *hypfn, ...);

void force_vm_exit(const cpumask_t *mask);



#define KVM_ARCH_WANT_MMU_NOTIFIER

struct kvm;

int kvm_unmap_hva(struct kvm *kvm, unsigned long hva);

int kvm_unmap_hva_range(struct kvm *kvm,

			unsigned long start, unsigned long end);
@@ -172,7 +170,8 @@ unsigned long kvm_arm_num_regs(struct kvm_vcpu *vcpu); 
int kvm_arm_copy_reg_indices(struct kvm_vcpu *vcpu, u64 __user *indices);



/* We do not have shadow page tables, hence the empty hooks */

static inline int kvm_age_hva(struct kvm *kvm, unsigned long hva)

static inline int kvm_age_hva(struct kvm *kvm, unsigned long start,

			      unsigned long end)

{

	return 0;

}
@@ -182,12 +181,16 @@ static inline int kvm_test_age_hva(struct kvm *kvm, unsigned long hva) 
	return 0;

}



static inline void kvm_arch_mmu_notifier_invalidate_page(struct kvm *kvm,

							 unsigned long address)

{

}



struct kvm_vcpu *kvm_arm_get_running_vcpu(void);

struct kvm_vcpu __percpu **kvm_get_running_vcpus(void);



int kvm_arm_copy_coproc_indices(struct kvm_vcpu *vcpu, u64 __user *uindices);

unsigned long kvm_arm_num_coproc_regs(struct kvm_vcpu *vcpu);

struct kvm_one_reg;

int kvm_arm_coproc_get_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *);

int kvm_arm_coproc_set_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *);
@@ -233,4 +236,10 @@ static inline void vgic_arch_setup(const struct vgic_params *vgic) 
int kvm_perf_init(void);

int kvm_perf_teardown(void);



static inline void kvm_arch_hardware_disable(void) {}

static inline void kvm_arch_hardware_unsetup(void) {}

static inline void kvm_arch_sync_events(struct kvm *kvm) {}

static inline void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) {}

static inline void kvm_arch_sched_in(struct kvm_vcpu *vcpu, int cpu) {}



#endif /* __ARM_KVM_HOST_H__ */

CRA Git | Maintained and supported by SUSTech CRA and CCSE