Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a875dafc authored by Christoffer Dall's avatar Christoffer Dall
Browse files

Merge remote-tracking branch 'kvm/next' into queue 

Conflicts:
	arch/arm64/include/asm/kvm_host.h
	virt/kvm/arm/vgic.c
parents 0ba09511 f51770ed

Documentation/virtual/kvm/api.txt

+117 −69
Original line number Diff line number Diff line
@@ -2565,6 +2565,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 +2975,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/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_host.h

+8 −5
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,7 +42,6 @@ 


#include <kvm/arm_vgic.h>



struct kvm_vcpu;

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

int __attribute_const__ kvm_target_cpu(void);

int kvm_reset_vcpu(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);
@@ -187,7 +185,6 @@ 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 +230,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__ */

arch/arm/kvm/arm.c

+1 −20
Original line number Diff line number Diff line
@@ -87,7 +87,7 @@ struct kvm_vcpu * __percpu *kvm_get_running_vcpus(void) 
	return &kvm_arm_running_vcpu;

}



int kvm_arch_hardware_enable(void *garbage)

int kvm_arch_hardware_enable(void)

{

	return 0;

}
@@ -97,27 +97,16 @@ int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu) 
	return kvm_vcpu_exiting_guest_mode(vcpu) == IN_GUEST_MODE;

}



void kvm_arch_hardware_disable(void *garbage)

{

}



int kvm_arch_hardware_setup(void)

{

	return 0;

}



void kvm_arch_hardware_unsetup(void)

{

}



void kvm_arch_check_processor_compat(void *rtn)

{

	*(int *)rtn = 0;

}



void kvm_arch_sync_events(struct kvm *kvm)

{

}



/**

 * kvm_arch_init_vm - initializes a VM data structure
@@ -285,14 +274,6 @@ int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 
	return 0;

}



void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)

{

}



void kvm_arch_sched_in(struct kvm_vcpu *vcpu, int cpu)

{

}



void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)

{

	vcpu->cpu = cpu;

arch/arm64/include/asm/kvm_host.h

+8 −4
Original line number Diff line number Diff line
@@ -22,6 +22,8 @@ 
#ifndef __ARM64_KVM_HOST_H__

#define __ARM64_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>
@@ -41,7 +43,6 @@ 


#define KVM_VCPU_MAX_FEATURES 3



struct kvm_vcpu;

int __attribute_const__ kvm_target_cpu(void);

int kvm_reset_vcpu(struct kvm_vcpu *vcpu);

int kvm_arch_dev_ioctl_check_extension(long ext);
@@ -164,18 +165,15 @@ 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);



#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);
@@ -244,4 +242,10 @@ static inline void vgic_arch_setup(const struct vgic_params *vgic) 
	}

}



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 /* __ARM64_KVM_HOST_H__ */