Merge branch 'sev-v9-p2' of https://github.com/codomania/kvm (65e38583) · Commits · 戴 / test

Documentation/virtual/kvm/00-INDEX

+3 −0

Original line number	Diff line number	Diff line
		@@ -26,3 +26,6 @@ s390-diag.txt
		- Diagnose hypercall description (for IBM S/390)
		timekeeping.txt
		- timekeeping virtualization for x86-based architectures.
		amd-memory-encryption.txt
		- notes on AMD Secure Encrypted Virtualization feature and SEV firmware
		command description

Documentation/virtual/kvm/amd-memory-encryption.rst

0 → 100644

+247 −0

Original line number	Diff line number	Diff line
		======================================
		Secure Encrypted Virtualization (SEV)
		======================================

		Overview
		========

		Secure Encrypted Virtualization (SEV) is a feature found on AMD processors.

		SEV is an extension to the AMD-V architecture which supports running
		virtual machines (VMs) under the control of a hypervisor. When enabled,
		the memory contents of a VM will be transparently encrypted with a key
		unique to that VM.

		The hypervisor can determine the SEV support through the CPUID
		instruction. The CPUID function 0x8000001f reports information related
		to SEV::

		0x8000001f[eax]:
		Bit[1] indicates support for SEV
		...
		[ecx]:
		Bits[31:0] Number of encrypted guests supported simultaneously

		If support for SEV is present, MSR 0xc001_0010 (MSR_K8_SYSCFG) and MSR 0xc001_0015
		(MSR_K7_HWCR) can be used to determine if it can be enabled::

		0xc001_0010:
		Bit[23] 1 = memory encryption can be enabled
		0 = memory encryption can not be enabled

		0xc001_0015:
		Bit[0] 1 = memory encryption can be enabled
		0 = memory encryption can not be enabled

		When SEV support is available, it can be enabled in a specific VM by
		setting the SEV bit before executing VMRUN.::

		VMCB[0x90]:
		Bit[1] 1 = SEV is enabled
		0 = SEV is disabled

		SEV hardware uses ASIDs to associate a memory encryption key with a VM.
		Hence, the ASID for the SEV-enabled guests must be from 1 to a maximum value
		defined in the CPUID 0x8000001f[ecx] field.

		SEV Key Management
		==================

		The SEV guest key management is handled by a separate processor called the AMD
		Secure Processor (AMD-SP). Firmware running inside the AMD-SP provides a secure
		key management interface to perform common hypervisor activities such as
		encrypting bootstrap code, snapshot, migrating and debugging the guest. For more
		information, see the SEV Key Management spec [api-spec]_

		KVM implements the following commands to support common lifecycle events of SEV
		guests, such as launching, running, snapshotting, migrating and decommissioning.

		1. KVM_SEV_INIT
		---------------

		The KVM_SEV_INIT command is used by the hypervisor to initialize the SEV platform
		context. In a typical workflow, this command should be the first command issued.

		Returns: 0 on success, -negative on error

		2. KVM_SEV_LAUNCH_START
		-----------------------

		The KVM_SEV_LAUNCH_START command is used for creating the memory encryption
		context. To create the encryption context, user must provide a guest policy,
		the owner's public Diffie-Hellman (PDH) key and session information.

		Parameters: struct kvm_sev_launch_start (in/out)

		Returns: 0 on success, -negative on error

		::

		struct kvm_sev_launch_start {
		__u32 handle; /* if zero then firmware creates a new handle */
		__u32 policy; /* guest's policy */

		__u64 dh_uaddr; /* userspace address pointing to the guest owner's PDH key */
		__u32 dh_len;

		__u64 session_addr; /* userspace address which points to the guest session information */
		__u32 session_len;
		};

		On success, the 'handle' field contains a new handle and on error, a negative value.

		For more details, see SEV spec Section 6.2.

		3. KVM_SEV_LAUNCH_UPDATE_DATA
		-----------------------------

		The KVM_SEV_LAUNCH_UPDATE_DATA is used for encrypting a memory region. It also
		calculates a measurement of the memory contents. The measurement is a signature
		of the memory contents that can be sent to the guest owner as an attestation
		that the memory was encrypted correctly by the firmware.

		Parameters (in): struct kvm_sev_launch_update_data

		Returns: 0 on success, -negative on error

		::

		struct kvm_sev_launch_update {
		__u64 uaddr; /* userspace address to be encrypted (must be 16-byte aligned) */
		__u32 len; /* length of the data to be encrypted (must be 16-byte aligned) */
		};

		For more details, see SEV spec Section 6.3.

		4. KVM_SEV_LAUNCH_MEASURE
		-------------------------

		The KVM_SEV_LAUNCH_MEASURE command is used to retrieve the measurement of the
		data encrypted by the KVM_SEV_LAUNCH_UPDATE_DATA command. The guest owner may
		wait to provide the guest with confidential information until it can verify the
		measurement. Since the guest owner knows the initial contents of the guest at
		boot, the measurement can be verified by comparing it to what the guest owner
		expects.

		Parameters (in): struct kvm_sev_launch_measure

		Returns: 0 on success, -negative on error

		::

		struct kvm_sev_launch_measure {
		__u64 uaddr; /* where to copy the measurement */
		__u32 len; /* length of measurement blob */
		};

		For more details on the measurement verification flow, see SEV spec Section 6.4.

		5. KVM_SEV_LAUNCH_FINISH
		------------------------

		After completion of the launch flow, the KVM_SEV_LAUNCH_FINISH command can be
		issued to make the guest ready for the execution.

		Returns: 0 on success, -negative on error

		6. KVM_SEV_GUEST_STATUS
		-----------------------

		The KVM_SEV_GUEST_STATUS command is used to retrieve status information about a
		SEV-enabled guest.

		Parameters (out): struct kvm_sev_guest_status

		Returns: 0 on success, -negative on error

		::

		struct kvm_sev_guest_status {
		__u32 handle; /* guest handle */
		__u32 policy; /* guest policy */
		__u8 state; /* guest state (see enum below) */
		};

		SEV guest state:

		::

		enum {
		SEV_STATE_INVALID = 0;
		SEV_STATE_LAUNCHING, /* guest is currently being launched */
		SEV_STATE_SECRET, /* guest is being launched and ready to accept the ciphertext data */
		SEV_STATE_RUNNING, /* guest is fully launched and running */
		SEV_STATE_RECEIVING, /* guest is being migrated in from another SEV machine */
		SEV_STATE_SENDING /* guest is getting migrated out to another SEV machine */
		};

		7. KVM_SEV_DBG_DECRYPT
		----------------------

		The KVM_SEV_DEBUG_DECRYPT command can be used by the hypervisor to request the
		firmware to decrypt the data at the given memory region.

		Parameters (in): struct kvm_sev_dbg

		Returns: 0 on success, -negative on error

		::

		struct kvm_sev_dbg {
		__u64 src_uaddr; /* userspace address of data to decrypt */
		__u64 dst_uaddr; /* userspace address of destination */
		__u32 len; /* length of memory region to decrypt */
		};

		The command returns an error if the guest policy does not allow debugging.

		8. KVM_SEV_DBG_ENCRYPT
		----------------------

		The KVM_SEV_DEBUG_ENCRYPT command can be used by the hypervisor to request the
		firmware to encrypt the data at the given memory region.

		Parameters (in): struct kvm_sev_dbg

		Returns: 0 on success, -negative on error

		::

		struct kvm_sev_dbg {
		__u64 src_uaddr; /* userspace address of data to encrypt */
		__u64 dst_uaddr; /* userspace address of destination */
		__u32 len; /* length of memory region to encrypt */
		};

		The command returns an error if the guest policy does not allow debugging.

		9. KVM_SEV_LAUNCH_SECRET
		------------------------

		The KVM_SEV_LAUNCH_SECRET command can be used by the hypervisor to inject secret
		data after the measurement has been validated by the guest owner.

		Parameters (in): struct kvm_sev_launch_secret

		Returns: 0 on success, -negative on error

		::

		struct kvm_sev_launch_secret {
		__u64 hdr_uaddr; /* userspace address containing the packet header */
		__u32 hdr_len;

		__u64 guest_uaddr; /* the guest memory region where the secret should be injected */
		__u32 guest_len;

		__u64 trans_uaddr; /* the hypervisor memory region which contains the secret */
		__u32 trans_len;
		};

		References
		==========

		.. [white-paper] http://amd-dev.wpengine.netdna-cdn.com/wordpress/media/2013/12/AMD_Memory_Encryption_Whitepaper_v7-Public.pdf
		.. [api-spec] http://support.amd.com/TechDocs/55766_SEV-KM%20API_Specification.pdf
		.. [amd-apm] http://support.amd.com/TechDocs/24593.pdf (section 15.34)
		.. [kvm-forum] http://www.linux-kvm.org/images/7/74/02x08A-Thomas_Lendacky-AMDs_Virtualizatoin_Memory_Encryption_Technology.pdf

Documentation/virtual/kvm/api.txt

+50 −0

Original line number	Diff line number	Diff line
		@@ -3403,6 +3403,56 @@ invalid, if invalid pages are written to (e.g. after the end of memory)
		or if no page table is present for the addresses (e.g. when using
		hugepages).

		4.109 KVM_MEMORY_ENCRYPT_OP

		Capability: basic
		Architectures: x86
		Type: system
		Parameters: an opaque platform specific structure (in/out)
		Returns: 0 on success; -1 on error

		If the platform supports creating encrypted VMs then this ioctl can be used
		for issuing platform-specific memory encryption commands to manage those
		encrypted VMs.

		Currently, this ioctl is used for issuing Secure Encrypted Virtualization
		(SEV) commands on AMD Processors. The SEV commands are defined in
		Documentation/virtual/kvm/amd-memory-encryption.txt.

		4.110 KVM_MEMORY_ENCRYPT_REG_REGION

		Capability: basic
		Architectures: x86
		Type: system
		Parameters: struct kvm_enc_region (in)
		Returns: 0 on success; -1 on error

		This ioctl can be used to register a guest memory region which may
		contain encrypted data (e.g. guest RAM, SMRAM etc).

		It is used in the SEV-enabled guest. When encryption is enabled, a guest
		memory region may contain encrypted data. The SEV memory encryption
		engine uses a tweak such that two identical plaintext pages, each at
		different locations will have differing ciphertexts. So swapping or
		moving ciphertext of those pages will not result in plaintext being
		swapped. So relocating (or migrating) physical backing pages for the SEV
		guest will require some additional steps.

		Note: The current SEV key management spec does not provide commands to
		swap or migrate (move) ciphertext pages. Hence, for now we pin the guest
		memory region registered with the ioctl.

		4.111 KVM_MEMORY_ENCRYPT_UNREG_REGION

		Capability: basic
		Architectures: x86
		Type: system
		Parameters: struct kvm_enc_region (in)
		Returns: 0 on success; -1 on error

		This ioctl can be used to unregister the guest memory region registered
		with KVM_MEMORY_ENCRYPT_REG_REGION ioctl above.

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

arch/x86/include/asm/cpufeatures.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -201,6 +201,7 @@
		#define X86_FEATURE_HW_PSTATE ( 732+ 8) / AMD HW-PState */
		#define X86_FEATURE_PROC_FEEDBACK ( 732+ 9) / AMD ProcFeedbackInterface */
		#define X86_FEATURE_SME ( 732+10) / AMD Secure Memory Encryption */
		#define X86_FEATURE_SEV ( 732+11) / AMD Secure Encrypted Virtualization */

		#define X86_FEATURE_INTEL_PPIN ( 732+14) / Intel Processor Inventory Number */
		#define X86_FEATURE_INTEL_PT ( 732+15) / Intel Processor Trace */

arch/x86/include/asm/kvm_host.h

+15 −0

Original line number	Diff line number	Diff line
		@@ -761,6 +761,15 @@ enum kvm_irqchip_mode {
		KVM_IRQCHIP_SPLIT, /* created with KVM_CAP_SPLIT_IRQCHIP */
		};

		struct kvm_sev_info {
		bool active; /* SEV enabled guest */
		unsigned int asid; /* ASID used for this guest */
		unsigned int handle; /* SEV firmware handle */
		int fd; /* SEV device fd */
		unsigned long pages_locked; /* Number of pages locked */
		struct list_head regions_list; /* List of registered regions */
		};

		struct kvm_arch {
		unsigned int n_used_mmu_pages;
		unsigned int n_requested_mmu_pages;
		@@ -848,6 +857,8 @@ struct kvm_arch {

		bool x2apic_format;
		bool x2apic_broadcast_quirk_disabled;

		struct kvm_sev_info sev_info;
		};

		struct kvm_vm_stat {
		@@ -1081,6 +1092,10 @@ struct kvm_x86_ops {
		int (pre_enter_smm)(struct kvm_vcpu vcpu, char *smstate);
		int (pre_leave_smm)(struct kvm_vcpu vcpu, u64 smbase);
		int (enable_smi_window)(struct kvm_vcpu vcpu);

		int (mem_enc_op)(struct kvm kvm, void __user *argp);
		int (mem_enc_reg_region)(struct kvm kvm, struct kvm_enc_region *argp);
		int (mem_enc_unreg_region)(struct kvm kvm, struct kvm_enc_region *argp);
		};

		struct kvm_arch_async_pf {

Original line number	Diff line number	Diff line
		@@ -201,6 +201,7 @@
		#define X86_FEATURE_HW_PSTATE ( 732+ 8) / AMD HW-PState */
		#define X86_FEATURE_PROC_FEEDBACK ( 732+ 9) / AMD ProcFeedbackInterface */
		#define X86_FEATURE_SME ( 732+10) / AMD Secure Memory Encryption */
		#define X86_FEATURE_SEV ( 732+11) / AMD Secure Encrypted Virtualization */

		#define X86_FEATURE_INTEL_PPIN ( 732+14) / Intel Processor Inventory Number */
		#define X86_FEATURE_INTEL_PT ( 732+15) / Intel Processor Trace */

Admin message