Merge tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm (90036013) · Commits · e / devices / android_kernel_fairphone_FP4

Documentation/virtual/kvm/api.txt

+330 −5

Original line number	Original line	Diff line number	Diff line
	@@ -997,7 +997,7 @@ for vm-wide capabilities.
	4.38 KVM_GET_MP_STATE		4.38 KVM_GET_MP_STATE

	Capability: KVM_CAP_MP_STATE		Capability: KVM_CAP_MP_STATE
	Architectures: x86, s390		Architectures: x86, s390, arm, arm64
	Type: vcpu ioctl		Type: vcpu ioctl
	Parameters: struct kvm_mp_state (out)		Parameters: struct kvm_mp_state (out)
	Returns: 0 on success; -1 on error		Returns: 0 on success; -1 on error
	@@ -1011,7 +1011,7 @@ uniprocessor guests).

	Possible values are:		Possible values are:

	- KVM_MP_STATE_RUNNABLE: the vcpu is currently running [x86]		- KVM_MP_STATE_RUNNABLE: the vcpu is currently running [x86,arm/arm64]
	- KVM_MP_STATE_UNINITIALIZED: the vcpu is an application processor (AP)		- KVM_MP_STATE_UNINITIALIZED: the vcpu is an application processor (AP)
	which has not yet received an INIT signal [x86]		which has not yet received an INIT signal [x86]
	- KVM_MP_STATE_INIT_RECEIVED: the vcpu has received an INIT signal, and is		- KVM_MP_STATE_INIT_RECEIVED: the vcpu has received an INIT signal, and is
	@@ -1020,7 +1020,7 @@ Possible values are:
	is waiting for an interrupt [x86]		is waiting for an interrupt [x86]
	- KVM_MP_STATE_SIPI_RECEIVED: the vcpu has just received a SIPI (vector		- KVM_MP_STATE_SIPI_RECEIVED: the vcpu has just received a SIPI (vector
	accessible via KVM_GET_VCPU_EVENTS) [x86]		accessible via KVM_GET_VCPU_EVENTS) [x86]
	- KVM_MP_STATE_STOPPED: the vcpu is stopped [s390]		- KVM_MP_STATE_STOPPED: the vcpu is stopped [s390,arm/arm64]
	- KVM_MP_STATE_CHECK_STOP: the vcpu is in a special error state [s390]		- KVM_MP_STATE_CHECK_STOP: the vcpu is in a special error state [s390]
	- KVM_MP_STATE_OPERATING: the vcpu is operating (running or halted)		- KVM_MP_STATE_OPERATING: the vcpu is operating (running or halted)
	[s390]		[s390]
	@@ -1031,11 +1031,15 @@ On x86, this ioctl is only useful after KVM_CREATE_IRQCHIP. Without an
	in-kernel irqchip, the multiprocessing state must be maintained by userspace on		in-kernel irqchip, the multiprocessing state must be maintained by userspace on
	these architectures.		these architectures.

			For arm/arm64:

			The only states that are valid are KVM_MP_STATE_STOPPED and
			KVM_MP_STATE_RUNNABLE which reflect if the vcpu is paused or not.

	4.39 KVM_SET_MP_STATE		4.39 KVM_SET_MP_STATE

	Capability: KVM_CAP_MP_STATE		Capability: KVM_CAP_MP_STATE
	Architectures: x86, s390		Architectures: x86, s390, arm, arm64
	Type: vcpu ioctl		Type: vcpu ioctl
	Parameters: struct kvm_mp_state (in)		Parameters: struct kvm_mp_state (in)
	Returns: 0 on success; -1 on error		Returns: 0 on success; -1 on error
	@@ -1047,6 +1051,10 @@ On x86, this ioctl is only useful after KVM_CREATE_IRQCHIP. Without an
	in-kernel irqchip, the multiprocessing state must be maintained by userspace on		in-kernel irqchip, the multiprocessing state must be maintained by userspace on
	these architectures.		these architectures.

			For arm/arm64:

			The only states that are valid are KVM_MP_STATE_STOPPED and
			KVM_MP_STATE_RUNNABLE which reflect if the vcpu should be paused or not.

	4.40 KVM_SET_IDENTITY_MAP_ADDR		4.40 KVM_SET_IDENTITY_MAP_ADDR

	@@ -1967,15 +1975,25 @@ registers, find a list below:
	MIPS \| KVM_REG_MIPS_CP0_STATUS \| 32		MIPS \| KVM_REG_MIPS_CP0_STATUS \| 32
	MIPS \| KVM_REG_MIPS_CP0_CAUSE \| 32		MIPS \| KVM_REG_MIPS_CP0_CAUSE \| 32
	MIPS \| KVM_REG_MIPS_CP0_EPC \| 64		MIPS \| KVM_REG_MIPS_CP0_EPC \| 64
			MIPS \| KVM_REG_MIPS_CP0_PRID \| 32
	MIPS \| KVM_REG_MIPS_CP0_CONFIG \| 32		MIPS \| KVM_REG_MIPS_CP0_CONFIG \| 32
	MIPS \| KVM_REG_MIPS_CP0_CONFIG1 \| 32		MIPS \| KVM_REG_MIPS_CP0_CONFIG1 \| 32
	MIPS \| KVM_REG_MIPS_CP0_CONFIG2 \| 32		MIPS \| KVM_REG_MIPS_CP0_CONFIG2 \| 32
	MIPS \| KVM_REG_MIPS_CP0_CONFIG3 \| 32		MIPS \| KVM_REG_MIPS_CP0_CONFIG3 \| 32
			MIPS \| KVM_REG_MIPS_CP0_CONFIG4 \| 32
			MIPS \| KVM_REG_MIPS_CP0_CONFIG5 \| 32
	MIPS \| KVM_REG_MIPS_CP0_CONFIG7 \| 32		MIPS \| KVM_REG_MIPS_CP0_CONFIG7 \| 32
	MIPS \| KVM_REG_MIPS_CP0_ERROREPC \| 64		MIPS \| KVM_REG_MIPS_CP0_ERROREPC \| 64
	MIPS \| KVM_REG_MIPS_COUNT_CTL \| 64		MIPS \| KVM_REG_MIPS_COUNT_CTL \| 64
	MIPS \| KVM_REG_MIPS_COUNT_RESUME \| 64		MIPS \| KVM_REG_MIPS_COUNT_RESUME \| 64
	MIPS \| KVM_REG_MIPS_COUNT_HZ \| 64		MIPS \| KVM_REG_MIPS_COUNT_HZ \| 64
			MIPS \| KVM_REG_MIPS_FPR_32(0..31) \| 32
			MIPS \| KVM_REG_MIPS_FPR_64(0..31) \| 64
			MIPS \| KVM_REG_MIPS_VEC_128(0..31) \| 128
			MIPS \| KVM_REG_MIPS_FCR_IR \| 32
			MIPS \| KVM_REG_MIPS_FCR_CSR \| 32
			MIPS \| KVM_REG_MIPS_MSA_IR \| 32
			MIPS \| KVM_REG_MIPS_MSA_CSR \| 32

	ARM registers are mapped using the lower 32 bits. The upper 16 of that		ARM registers are mapped using the lower 32 bits. The upper 16 of that
	is the register group type, or coprocessor number:		is the register group type, or coprocessor number:
	@@ -2029,6 +2047,25 @@ patterns depending on whether they're 32-bit or 64-bit registers:
	MIPS KVM control registers (see above) have the following id bit patterns:		MIPS KVM control registers (see above) have the following id bit patterns:
	0x7030 0000 0002 <reg:16>		0x7030 0000 0002 <reg:16>

			MIPS FPU registers (see KVM_REG_MIPS_FPR_{32,64}() above) have the following
			id bit patterns depending on the size of the register being accessed. They are
			always accessed according to the current guest FPU mode (Status.FR and
			Config5.FRE), i.e. as the guest would see them, and they become unpredictable
			if the guest FPU mode is changed. MIPS SIMD Architecture (MSA) vector
			registers (see KVM_REG_MIPS_VEC_128() above) have similar patterns as they
			overlap the FPU registers:
			0x7020 0000 0003 00 <0:3> <reg:5> (32-bit FPU registers)
			0x7030 0000 0003 00 <0:3> <reg:5> (64-bit FPU registers)
			0x7040 0000 0003 00 <0:3> <reg:5> (128-bit MSA vector registers)

			MIPS FPU control registers (see KVM_REG_MIPS_FCR_{IR,CSR} above) have the
			following id bit patterns:
			0x7020 0000 0003 01 <0:3> <reg:5>

			MIPS MSA control registers (see KVM_REG_MIPS_MSA_{IR,CSR} above) have the
			following id bit patterns:
			0x7020 0000 0003 02 <0:3> <reg:5>


	4.69 KVM_GET_ONE_REG		4.69 KVM_GET_ONE_REG

	@@ -2234,7 +2271,7 @@ into the hash PTE second double word).
	4.75 KVM_IRQFD		4.75 KVM_IRQFD

	Capability: KVM_CAP_IRQFD		Capability: KVM_CAP_IRQFD
	Architectures: x86 s390		Architectures: x86 s390 arm arm64
	Type: vm ioctl		Type: vm ioctl
	Parameters: struct kvm_irqfd (in)		Parameters: struct kvm_irqfd (in)
	Returns: 0 on success, -1 on error		Returns: 0 on success, -1 on error
	@@ -2260,6 +2297,10 @@ Note that closing the resamplefd is not sufficient to disable the
	irqfd. The KVM_IRQFD_FLAG_RESAMPLE is only necessary on assignment		irqfd. The KVM_IRQFD_FLAG_RESAMPLE is only necessary on assignment
	and need not be specified with KVM_IRQFD_FLAG_DEASSIGN.		and need not be specified with KVM_IRQFD_FLAG_DEASSIGN.

			On ARM/ARM64, the gsi field in the kvm_irqfd struct specifies the Shared
			Peripheral Interrupt (SPI) index, such that the GIC interrupt ID is
			given by gsi + 32.

	4.76 KVM_PPC_ALLOCATE_HTAB		4.76 KVM_PPC_ALLOCATE_HTAB

	Capability: KVM_CAP_PPC_ALLOC_HTAB		Capability: KVM_CAP_PPC_ALLOC_HTAB
	@@ -2716,6 +2757,227 @@ The fields in each entry are defined as follows:
	eax, ebx, ecx, edx: the values returned by the cpuid instruction for		eax, ebx, ecx, edx: the values returned by the cpuid instruction for
	this function/index combination		this function/index combination

			4.89 KVM_S390_MEM_OP

			Capability: KVM_CAP_S390_MEM_OP
			Architectures: s390
			Type: vcpu ioctl
			Parameters: struct kvm_s390_mem_op (in)
			Returns: = 0 on success,
			< 0 on generic error (e.g. -EFAULT or -ENOMEM),
			> 0 if an exception occurred while walking the page tables

			Read or write data from/to the logical (virtual) memory of a VPCU.

			Parameters are specified via the following structure:

			struct kvm_s390_mem_op {
			__u64 gaddr; /* the guest address */
			__u64 flags; /* flags */
			__u32 size; /* amount of bytes */
			__u32 op; /* type of operation */
			__u64 buf; /* buffer in userspace */
			__u8 ar; /* the access register number */
			__u8 reserved[31]; /* should be set to 0 */
			};

			The type of operation is specified in the "op" field. It is either
			KVM_S390_MEMOP_LOGICAL_READ for reading from logical memory space or
			KVM_S390_MEMOP_LOGICAL_WRITE for writing to logical memory space. The
			KVM_S390_MEMOP_F_CHECK_ONLY flag can be set in the "flags" field to check
			whether the corresponding memory access would create an access exception
			(without touching the data in the memory at the destination). In case an
			access exception occurred while walking the MMU tables of the guest, the
			ioctl returns a positive error number to indicate the type of exception.
			This exception is also raised directly at the corresponding VCPU if the
			flag KVM_S390_MEMOP_F_INJECT_EXCEPTION is set in the "flags" field.

			The start address of the memory region has to be specified in the "gaddr"
			field, and the length of the region in the "size" field. "buf" is the buffer
			supplied by the userspace application where the read data should be written
			to for KVM_S390_MEMOP_LOGICAL_READ, or where the data that should be written
			is stored for a KVM_S390_MEMOP_LOGICAL_WRITE. "buf" is unused and can be NULL
			when KVM_S390_MEMOP_F_CHECK_ONLY is specified. "ar" designates the access
			register number to be used.

			The "reserved" field is meant for future extensions. It is not used by
			KVM with the currently defined set of flags.

			4.90 KVM_S390_GET_SKEYS

			Capability: KVM_CAP_S390_SKEYS
			Architectures: s390
			Type: vm ioctl
			Parameters: struct kvm_s390_skeys
			Returns: 0 on success, KVM_S390_GET_KEYS_NONE if guest is not using storage
			keys, negative value on error

			This ioctl is used to get guest storage key values on the s390
			architecture. The ioctl takes parameters via the kvm_s390_skeys struct.

			struct kvm_s390_skeys {
			__u64 start_gfn;
			__u64 count;
			__u64 skeydata_addr;
			__u32 flags;
			__u32 reserved[9];
			};

			The start_gfn field is the number of the first guest frame whose storage keys
			you want to get.

			The count field is the number of consecutive frames (starting from start_gfn)
			whose storage keys to get. The count field must be at least 1 and the maximum
			allowed value is defined as KVM_S390_SKEYS_ALLOC_MAX. Values outside this range
			will cause the ioctl to return -EINVAL.

			The skeydata_addr field is the address to a buffer large enough to hold count
			bytes. This buffer will be filled with storage key data by the ioctl.

			4.91 KVM_S390_SET_SKEYS

			Capability: KVM_CAP_S390_SKEYS
			Architectures: s390
			Type: vm ioctl
			Parameters: struct kvm_s390_skeys
			Returns: 0 on success, negative value on error

			This ioctl is used to set guest storage key values on the s390
			architecture. The ioctl takes parameters via the kvm_s390_skeys struct.
			See section on KVM_S390_GET_SKEYS for struct definition.

			The start_gfn field is the number of the first guest frame whose storage keys
			you want to set.

			The count field is the number of consecutive frames (starting from start_gfn)
			whose storage keys to get. The count field must be at least 1 and the maximum
			allowed value is defined as KVM_S390_SKEYS_ALLOC_MAX. Values outside this range
			will cause the ioctl to return -EINVAL.

			The skeydata_addr field is the address to a buffer containing count bytes of
			storage keys. Each byte in the buffer will be set as the storage key for a
			single frame starting at start_gfn for count frames.

			Note: If any architecturally invalid key value is found in the given data then
			the ioctl will return -EINVAL.

			4.92 KVM_S390_IRQ

			Capability: KVM_CAP_S390_INJECT_IRQ
			Architectures: s390
			Type: vcpu ioctl
			Parameters: struct kvm_s390_irq (in)
			Returns: 0 on success, -1 on error
			Errors:
			EINVAL: interrupt type is invalid
			type is KVM_S390_SIGP_STOP and flag parameter is invalid value
			type is KVM_S390_INT_EXTERNAL_CALL and code is bigger
			than the maximum of VCPUs
			EBUSY: type is KVM_S390_SIGP_SET_PREFIX and vcpu is not stopped
			type is KVM_S390_SIGP_STOP and a stop irq is already pending
			type is KVM_S390_INT_EXTERNAL_CALL and an external call interrupt
			is already pending

			Allows to inject an interrupt to the guest.

			Using struct kvm_s390_irq as a parameter allows
			to inject additional payload which is not
			possible via KVM_S390_INTERRUPT.

			Interrupt parameters are passed via kvm_s390_irq:

			struct kvm_s390_irq {
			__u64 type;
			union {
			struct kvm_s390_io_info io;
			struct kvm_s390_ext_info ext;
			struct kvm_s390_pgm_info pgm;
			struct kvm_s390_emerg_info emerg;
			struct kvm_s390_extcall_info extcall;
			struct kvm_s390_prefix_info prefix;
			struct kvm_s390_stop_info stop;
			struct kvm_s390_mchk_info mchk;
			char reserved[64];
			} u;
			};

			type can be one of the following:

			KVM_S390_SIGP_STOP - sigp stop; parameter in .stop
			KVM_S390_PROGRAM_INT - program check; parameters in .pgm
			KVM_S390_SIGP_SET_PREFIX - sigp set prefix; parameters in .prefix
			KVM_S390_RESTART - restart; no parameters
			KVM_S390_INT_CLOCK_COMP - clock comparator interrupt; no parameters
			KVM_S390_INT_CPU_TIMER - CPU timer interrupt; no parameters
			KVM_S390_INT_EMERGENCY - sigp emergency; parameters in .emerg
			KVM_S390_INT_EXTERNAL_CALL - sigp external call; parameters in .extcall
			KVM_S390_MCHK - machine check interrupt; parameters in .mchk


			Note that the vcpu ioctl is asynchronous to vcpu execution.

			4.94 KVM_S390_GET_IRQ_STATE

			Capability: KVM_CAP_S390_IRQ_STATE
			Architectures: s390
			Type: vcpu ioctl
			Parameters: struct kvm_s390_irq_state (out)
			Returns: >= number of bytes copied into buffer,
			-EINVAL if buffer size is 0,
			-ENOBUFS if buffer size is too small to fit all pending interrupts,
			-EFAULT if the buffer address was invalid

			This ioctl allows userspace to retrieve the complete state of all currently
			pending interrupts in a single buffer. Use cases include migration
			and introspection. The parameter structure contains the address of a
			userspace buffer and its length:

			struct kvm_s390_irq_state {
			__u64 buf;
			__u32 flags;
			__u32 len;
			__u32 reserved[4];
			};

			Userspace passes in the above struct and for each pending interrupt a
			struct kvm_s390_irq is copied to the provided buffer.

			If -ENOBUFS is returned the buffer provided was too small and userspace
			may retry with a bigger buffer.

			4.95 KVM_S390_SET_IRQ_STATE

			Capability: KVM_CAP_S390_IRQ_STATE
			Architectures: s390
			Type: vcpu ioctl
			Parameters: struct kvm_s390_irq_state (in)
			Returns: 0 on success,
			-EFAULT if the buffer address was invalid,
			-EINVAL for an invalid buffer length (see below),
			-EBUSY if there were already interrupts pending,
			errors occurring when actually injecting the
			interrupt. See KVM_S390_IRQ.

			This ioctl allows userspace to set the complete state of all cpu-local
			interrupts currently pending for the vcpu. It is intended for restoring
			interrupt state after a migration. The input parameter is a userspace buffer
			containing a struct kvm_s390_irq_state:

			struct kvm_s390_irq_state {
			__u64 buf;
			__u32 len;
			__u32 pad;
			};

			The userspace memory referenced by buf contains a struct kvm_s390_irq
			for each interrupt to be injected into the guest.
			If one of the interrupts could not be injected for some reason the
			ioctl aborts.

			len must be a multiple of sizeof(struct kvm_s390_irq). It must be > 0
			and it must not exceed (max_vcpus + 32) * sizeof(struct kvm_s390_irq),
			which is the maximum number of possibly pending cpu-local interrupts.

	5. The kvm_run structure		5. The kvm_run structure
	------------------------		------------------------

	@@ -3189,6 +3451,31 @@ Parameters: none
	This capability enables the in-kernel irqchip for s390. Please refer to		This capability enables the in-kernel irqchip for s390. Please refer to
	"4.24 KVM_CREATE_IRQCHIP" for details.		"4.24 KVM_CREATE_IRQCHIP" for details.

			6.9 KVM_CAP_MIPS_FPU

			Architectures: mips
			Target: vcpu
			Parameters: args[0] is reserved for future use (should be 0).

			This capability allows the use of the host Floating Point Unit by the guest. It
			allows the Config1.FP bit to be set to enable the FPU in the guest. Once this is
			done the KVM_REG_MIPS_FPR_* and KVM_REG_MIPS_FCR_* registers can be accessed
			(depending on the current guest FPU register mode), and the Status.FR,
			Config5.FRE bits are accessible via the KVM API and also from the guest,
			depending on them being supported by the FPU.

			6.10 KVM_CAP_MIPS_MSA

			Architectures: mips
			Target: vcpu
			Parameters: args[0] is reserved for future use (should be 0).

			This capability allows the use of the MIPS SIMD Architecture (MSA) by the guest.
			It allows the Config3.MSAP bit to be set to enable the use of MSA by the guest.
			Once this is done the KVM_REG_MIPS_VEC_* and KVM_REG_MIPS_MSA_* registers can be
			accessed, and the Config5.MSAEn bit is accessible via the KVM API and also from
			the guest.

	7. Capabilities that can be enabled on VMs		7. Capabilities that can be enabled on VMs
	------------------------------------------		------------------------------------------

	@@ -3248,3 +3535,41 @@ All other orders will be handled completely in user space.
	Only privileged operation exceptions will be checked for in the kernel (or even		Only privileged operation exceptions will be checked for in the kernel (or even
	in the hardware prior to interception). If this capability is not enabled, the		in the hardware prior to interception). If this capability is not enabled, the
	old way of handling SIGP orders is used (partially in kernel and user space).		old way of handling SIGP orders is used (partially in kernel and user space).

			7.3 KVM_CAP_S390_VECTOR_REGISTERS

			Architectures: s390
			Parameters: none
			Returns: 0 on success, negative value on error

			Allows use of the vector registers introduced with z13 processor, and
			provides for the synchronization between host and user space. Will
			return -EINVAL if the machine does not support vectors.

			7.4 KVM_CAP_S390_USER_STSI

			Architectures: s390
			Parameters: none

			This capability allows post-handlers for the STSI instruction. After
			initial handling in the kernel, KVM exits to user space with
			KVM_EXIT_S390_STSI to allow user space to insert further data.

			Before exiting to userspace, kvm handlers should fill in s390_stsi field of
			vcpu->run:
			struct {
			__u64 addr;
			__u8 ar;
			__u8 reserved;
			__u8 fc;
			__u8 sel1;
			__u16 sel2;
			} s390_stsi;

			@addr - guest address of STSI SYSIB
			@fc - function code
			@sel1 - selector 1
			@sel2 - selector 2
			@ar - access register number

			KVM handlers should exit to userspace with rc = -EREMOTE.

Documentation/virtual/kvm/devices/s390_flic.txt

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -27,6 +27,9 @@ Groups:
	Copies all floating interrupts into a buffer provided by userspace.		Copies all floating interrupts into a buffer provided by userspace.
	When the buffer is too small it returns -ENOMEM, which is the indication		When the buffer is too small it returns -ENOMEM, which is the indication
	for userspace to try again with a bigger buffer.		for userspace to try again with a bigger buffer.
			-ENOBUFS is returned when the allocation of a kernelspace buffer has
			failed.
			-EFAULT is returned when copying data to userspace failed.
	All interrupts remain pending, i.e. are not deleted from the list of		All interrupts remain pending, i.e. are not deleted from the list of
	currently pending interrupts.		currently pending interrupts.
	attr->addr contains the userspace address of the buffer into which all		attr->addr contains the userspace address of the buffer into which all

MAINTAINERS

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -5591,6 +5591,8 @@ S: Supported
	F: Documentation//kvm.txt		F: Documentation//kvm.txt
	F: Documentation/virtual/kvm/		F: Documentation/virtual/kvm/
	F: arch/*/kvm/		F: arch/*/kvm/
			F: arch/x86/kernel/kvm.c
			F: arch/x86/kernel/kvmclock.c
	F: arch//include/asm/kvm		F: arch//include/asm/kvm
	F: include/linux/kvm*		F: include/linux/kvm*
	F: include/uapi/linux/kvm*		F: include/uapi/linux/kvm*

arch/arm/include/asm/kvm_arm.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -185,6 +185,7 @@
	#define HSR_COND (0xfU << HSR_COND_SHIFT)		#define HSR_COND (0xfU << HSR_COND_SHIFT)

	#define FSC_FAULT (0x04)		#define FSC_FAULT (0x04)
			#define FSC_ACCESS (0x08)
	#define FSC_PERM (0x0c)		#define FSC_PERM (0x0c)

	/* Hyp Prefetch Fault Address Register (HPFAR/HDFAR) */		/* Hyp Prefetch Fault Address Register (HPFAR/HDFAR) */

arch/arm/include/asm/kvm_host.h

+4 −11

Original line number	Original line	Diff line number	Diff line
	@@ -27,6 +27,8 @@
	#include <asm/fpstate.h>		#include <asm/fpstate.h>
	#include <kvm/arm_arch_timer.h>		#include <kvm/arm_arch_timer.h>

			#define __KVM_HAVE_ARCH_INTC_INITIALIZED

	#if defined(CONFIG_KVM_ARM_MAX_VCPUS)		#if defined(CONFIG_KVM_ARM_MAX_VCPUS)
	#define KVM_MAX_VCPUS CONFIG_KVM_ARM_MAX_VCPUS		#define KVM_MAX_VCPUS CONFIG_KVM_ARM_MAX_VCPUS
	#else		#else
	@@ -165,19 +167,10 @@ void kvm_set_spte_hva(struct kvm *kvm, unsigned long hva, pte_t pte);

	unsigned long kvm_arm_num_regs(struct kvm_vcpu *vcpu);		unsigned long kvm_arm_num_regs(struct kvm_vcpu *vcpu);
	int kvm_arm_copy_reg_indices(struct kvm_vcpu vcpu, u64 __user indices);		int kvm_arm_copy_reg_indices(struct kvm_vcpu vcpu, u64 __user indices);
			int kvm_age_hva(struct kvm *kvm, unsigned long start, unsigned long end);
			int kvm_test_age_hva(struct kvm *kvm, unsigned long hva);

	/* We do not have shadow page tables, hence the empty hooks */		/* We do not have shadow page tables, hence the empty hooks */
	static inline int kvm_age_hva(struct kvm *kvm, unsigned long start,
	unsigned long end)
	{
	return 0;
	}

	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,		static inline void kvm_arch_mmu_notifier_invalidate_page(struct kvm *kvm,
	unsigned long address)		unsigned long address)
	{		{