Commit d3d1af85 authored by Brijesh Singh's avatar Brijesh Singh Committed by Paolo Bonzini
Browse files

KVM: SVM: Add KVM_SEND_UPDATE_DATA command 



The command is used for encrypting the guest memory region using the encryption
context created with KVM_SEV_SEND_START.

Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Paolo Bonzini <pbonzini@redhat.com>
Cc: Joerg Roedel <joro@8bytes.org>
Cc: Borislav Petkov <bp@suse.de>
Cc: Tom Lendacky <thomas.lendacky@amd.com>
Cc: x86@kernel.org
Cc: kvm@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Reviewed-by : Steve Rutherford <srutherford@google.com>
Signed-off-by: default avatarBrijesh Singh <brijesh.singh@amd.com>
Signed-off-by: default avatarAshish Kalra <ashish.kalra@amd.com>
Message-Id: <d6a6ea740b0c668b30905ae31eac5ad7da048bb3.1618498113.git.ashish.kalra@amd.com>
Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent 4cfdd47d

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

+28 −0
Original line number Diff line number Diff line
@@ -320,6 +320,34 @@ Returns: 0 on success, -negative on error 
                __u32 session_len;

        };



12. KVM_SEV_SEND_UPDATE_DATA

----------------------------



The KVM_SEV_SEND_UPDATE_DATA command can be used by the hypervisor to encrypt the

outgoing guest memory region with the encryption context creating using

KVM_SEV_SEND_START.



If hdr_len or trans_len are zero on entry, the length of the packet header and

transport region are written to hdr_len and trans_len respectively, and all

other fields are not used.



Parameters (in): struct kvm_sev_send_update_data



Returns: 0 on success, -negative on error



::



        struct kvm_sev_launch_send_update_data {

                __u64 hdr_uaddr;        /* userspace address containing the packet header */

                __u32 hdr_len;



                __u64 guest_uaddr;      /* the source memory region to be encrypted */

                __u32 guest_len;



                __u64 trans_uaddr;      /* the destination memory region  */

                __u32 trans_len;

        };



References

==========

arch/x86/kvm/svm/sev.c

+125 −0
Original line number Diff line number Diff line
@@ -34,6 +34,7 @@ static DECLARE_RWSEM(sev_deactivate_lock); 
static DEFINE_MUTEX(sev_bitmap_lock);

unsigned int max_sev_asid;

static unsigned int min_sev_asid;

static unsigned long sev_me_mask;

static unsigned long *sev_asid_bitmap;

static unsigned long *sev_reclaim_asid_bitmap;
@@ -1236,6 +1237,126 @@ static int sev_send_start(struct kvm *kvm, struct kvm_sev_cmd *argp) 
	return ret;

}



/* Userspace wants to query either header or trans length. */

static int

__sev_send_update_data_query_lengths(struct kvm *kvm, struct kvm_sev_cmd *argp,

				     struct kvm_sev_send_update_data *params)

{

	struct kvm_sev_info *sev = &to_kvm_svm(kvm)->sev_info;

	struct sev_data_send_update_data *data;

	int ret;



	data = kzalloc(sizeof(*data), GFP_KERNEL_ACCOUNT);

	if (!data)

		return -ENOMEM;



	data->handle = sev->handle;

	ret = sev_issue_cmd(kvm, SEV_CMD_SEND_UPDATE_DATA, data, &argp->error);

	if (ret < 0)

		goto out;



	params->hdr_len = data->hdr_len;

	params->trans_len = data->trans_len;



	if (copy_to_user((void __user *)(uintptr_t)argp->data, params,

			 sizeof(struct kvm_sev_send_update_data)))

		ret = -EFAULT;



out:

	kfree(data);

	return ret;

}



static int sev_send_update_data(struct kvm *kvm, struct kvm_sev_cmd *argp)

{

	struct kvm_sev_info *sev = &to_kvm_svm(kvm)->sev_info;

	struct sev_data_send_update_data *data;

	struct kvm_sev_send_update_data params;

	void *hdr, *trans_data;

	struct page **guest_page;

	unsigned long n;

	int ret, offset;



	if (!sev_guest(kvm))

		return -ENOTTY;



	if (copy_from_user(&params, (void __user *)(uintptr_t)argp->data,

			sizeof(struct kvm_sev_send_update_data)))

		return -EFAULT;



	/* userspace wants to query either header or trans length */

	if (!params.trans_len || !params.hdr_len)

		return __sev_send_update_data_query_lengths(kvm, argp, &params);



	if (!params.trans_uaddr || !params.guest_uaddr ||

	    !params.guest_len || !params.hdr_uaddr)

		return -EINVAL;



	/* Check if we are crossing the page boundary */

	offset = params.guest_uaddr & (PAGE_SIZE - 1);

	if ((params.guest_len + offset > PAGE_SIZE))

		return -EINVAL;



	/* Pin guest memory */

	guest_page = sev_pin_memory(kvm, params.guest_uaddr & PAGE_MASK,

				    PAGE_SIZE, &n, 0);

	if (!guest_page)

		return -EFAULT;



	/* allocate memory for header and transport buffer */

	ret = -ENOMEM;

	hdr = kmalloc(params.hdr_len, GFP_KERNEL_ACCOUNT);

	if (!hdr)

		goto e_unpin;



	trans_data = kmalloc(params.trans_len, GFP_KERNEL_ACCOUNT);

	if (!trans_data)

		goto e_free_hdr;



	data = kzalloc(sizeof(*data), GFP_KERNEL);

	if (!data)

		goto e_free_trans_data;



	data->hdr_address = __psp_pa(hdr);

	data->hdr_len = params.hdr_len;

	data->trans_address = __psp_pa(trans_data);

	data->trans_len = params.trans_len;



	/* The SEND_UPDATE_DATA command requires C-bit to be always set. */

	data->guest_address = (page_to_pfn(guest_page[0]) << PAGE_SHIFT) +

				offset;

	data->guest_address |= sev_me_mask;

	data->guest_len = params.guest_len;

	data->handle = sev->handle;



	ret = sev_issue_cmd(kvm, SEV_CMD_SEND_UPDATE_DATA, data, &argp->error);



	if (ret)

		goto e_free;



	/* copy transport buffer to user space */

	if (copy_to_user((void __user *)(uintptr_t)params.trans_uaddr,

			 trans_data, params.trans_len)) {

		ret = -EFAULT;

		goto e_free;

	}



	/* Copy packet header to userspace. */

	ret = copy_to_user((void __user *)(uintptr_t)params.hdr_uaddr, hdr,

				params.hdr_len);



e_free:

	kfree(data);

e_free_trans_data:

	kfree(trans_data);

e_free_hdr:

	kfree(hdr);

e_unpin:

	sev_unpin_memory(kvm, guest_page, n);



	return ret;

}



int svm_mem_enc_op(struct kvm *kvm, void __user *argp)

{

	struct kvm_sev_cmd sev_cmd;
@@ -1301,6 +1422,9 @@ int svm_mem_enc_op(struct kvm *kvm, void __user *argp) 
	case KVM_SEV_SEND_START:

		r = sev_send_start(kvm, &sev_cmd);

		break;

	case KVM_SEV_SEND_UPDATE_DATA:

		r = sev_send_update_data(kvm, &sev_cmd);

		break;

	default:

		r = -EINVAL;

		goto out;
@@ -1559,6 +1683,7 @@ void __init sev_hardware_setup(void) 


	/* Minimum ASID value that should be used for SEV guest */

	min_sev_asid = edx;

	sev_me_mask = 1UL << (ebx & 0x3f);



	/* Initialize SEV ASID bitmaps */

	sev_asid_bitmap = bitmap_zalloc(max_sev_asid, GFP_KERNEL);

include/uapi/linux/kvm.h

+9 −0
Original line number Diff line number Diff line
@@ -1744,6 +1744,15 @@ struct kvm_sev_send_start { 
	__u32 session_len;

};



struct kvm_sev_send_update_data {

	__u64 hdr_uaddr;

	__u32 hdr_len;

	__u64 guest_uaddr;

	__u32 guest_len;

	__u64 trans_uaddr;

	__u32 trans_len;

};



#define KVM_DEV_ASSIGN_ENABLE_IOMMU	(1 << 0)

#define KVM_DEV_ASSIGN_PCI_2_3		(1 << 1)

#define KVM_DEV_ASSIGN_MASK_INTX	(1 << 2)