From nobody Fri Dec 19 12:06:28 2025 Received: from galois.linutronix.de (Galois.linutronix.de [193.142.43.55]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E8074198A19; Tue, 27 Aug 2024 08:48:10 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=193.142.43.55 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1724748493; cv=none; b=OLi7ls1UGOLmABCfdg/JpLBBVgfXYkV23KBvtlmSHgOKmC0vm9jGlqoWTIsva0vaM7yF1Ty+qNnrNfx5ViyU0werzMRBgVHXoeDGlJL33nOV7TNCkzk1TU22/zFNdIbX3VN12sq84AvdEBT+k+LGUHvWtRI7RU5avlLoJ/PnmlE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1724748493; c=relaxed/simple; bh=OQt3l3HSNEhkzerObWrTrvl+xtVMXlAM6oqG9sTvi2k=; h=Date:From:To:Subject:Cc:In-Reply-To:References:MIME-Version: Message-ID:Content-Type; b=K7bDsRzjTCJQNNfJD2juMSx+0ZgJwM9qgqN8uJ4Kxnml1eYUXBT2tdDFqyY83jBNkNqSKJ5g6zD55klnU5Q/2KgUqFZfiTCBlFeEa3PJbtRYelzqrBfyq8TSjbFyK82EbpCvlK2RzuIR5QBw0tOjdDMdxIpr5pMxxxQCt81HIZk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linutronix.de; spf=pass smtp.mailfrom=linutronix.de; dkim=pass (2048-bit key) header.d=linutronix.de header.i=@linutronix.de header.b=xwb8EgPs; dkim=permerror (0-bit key) header.d=linutronix.de header.i=@linutronix.de header.b=NSU+Anj6; arc=none smtp.client-ip=193.142.43.55 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linutronix.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linutronix.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=linutronix.de header.i=@linutronix.de header.b="xwb8EgPs"; dkim=permerror (0-bit key) header.d=linutronix.de header.i=@linutronix.de header.b="NSU+Anj6" Date: Tue, 27 Aug 2024 08:48:06 -0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linutronix.de; s=2020; t=1724748487; h=from:from:sender:sender:reply-to:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=z5+AodQvcTFgRHSwvGq3SbBE0HF8l9wqhEXbjBZRIA4=; b=xwb8EgPsBc/io4uORR+dsMBK21/FWL4PqlRvJzXavuahpj8PGQzunmkPHQty/xYdp2412S R/vm5XSIXpklJ6ErSFFggSH4xvzpnhYnXUC4jaJpS5RTS2OlfStSykKaZctr7oT/73BLZ1 gFlAi1poj1ZIAfdPMp9N/dHlEnLMJDBOqj5yVCM2GFyQ6zdmrWJuoGs+Yvy2cr6xoR9wXW kOBNskO2lUFGA5BP6L54paVYEp9qFwuYcDPPFPSpDlyNsd1XuU1RlDhBxS5mvdXQ7ZfSfG dIJ1IdiHQ0VOl2UTeYXg3g8fetQGE7g0h40KXHK+l9Y/CUF97G9V04wSy03syA== DKIM-Signature: v=1; a=ed25519-sha256; c=relaxed/relaxed; d=linutronix.de; s=2020e; t=1724748487; h=from:from:sender:sender:reply-to:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=z5+AodQvcTFgRHSwvGq3SbBE0HF8l9wqhEXbjBZRIA4=; b=NSU+Anj6wU1MOhL3f7S03jTT6w5f+6jXAWEbMzsXEx+Uq28QjlrTI8mMSTdsNQMhIRqhQC fstYtK9IBSmK+FAw== From: "tip-bot2 for Nikunj A Dadhania" Sender: tip-bot2@linutronix.de Reply-to: linux-kernel@vger.kernel.org To: linux-tip-commits@vger.kernel.org Subject: [tip: x86/sev] virt: sev-guest: Rename local guest message variables Cc: Nikunj A Dadhania , "Borislav Petkov (AMD)" , x86@kernel.org, linux-kernel@vger.kernel.org In-Reply-To: <20240731150811.156771-3-nikunj@amd.com> References: <20240731150811.156771-3-nikunj@amd.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-ID: <172474848691.2215.233187575965682163.tip-bot2@tip-bot2> Robot-ID: Robot-Unsubscribe: Contact to get blacklisted from these emails Precedence: bulk Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable The following commit has been merged into the x86/sev branch of tip: Commit-ID: a1bbb2236bb97c0afee4cdf8fd732ff5f9cd60ac Gitweb: https://git.kernel.org/tip/a1bbb2236bb97c0afee4cdf8fd732ff5f= 9cd60ac Author: Nikunj A Dadhania AuthorDate: Wed, 31 Jul 2024 20:37:53 +05:30 Committer: Borislav Petkov (AMD) CommitterDate: Tue, 27 Aug 2024 10:34:41 +02:00 virt: sev-guest: Rename local guest message variables Rename local guest message variables for more clarity. No functional change. Signed-off-by: Nikunj A Dadhania Signed-off-by: Borislav Petkov (AMD) Link: https://lore.kernel.org/r/20240731150811.156771-3-nikunj@amd.com --- drivers/virt/coco/sev-guest/sev-guest.c | 117 +++++++++++------------ 1 file changed, 59 insertions(+), 58 deletions(-) diff --git a/drivers/virt/coco/sev-guest/sev-guest.c b/drivers/virt/coco/se= v-guest/sev-guest.c index 7d343f2..a72fe1e 100644 --- a/drivers/virt/coco/sev-guest/sev-guest.c +++ b/drivers/virt/coco/sev-guest/sev-guest.c @@ -291,45 +291,45 @@ static int dec_payload(struct snp_guest_dev *snp_dev,= struct snp_guest_msg *msg, static int verify_and_dec_payload(struct snp_guest_dev *snp_dev, void *pay= load, u32 sz) { struct snp_guest_crypto *crypto =3D snp_dev->crypto; - struct snp_guest_msg *resp =3D &snp_dev->secret_response; - struct snp_guest_msg *req =3D &snp_dev->secret_request; - struct snp_guest_msg_hdr *req_hdr =3D &req->hdr; - struct snp_guest_msg_hdr *resp_hdr =3D &resp->hdr; + struct snp_guest_msg *resp_msg =3D &snp_dev->secret_response; + struct snp_guest_msg *req_msg =3D &snp_dev->secret_request; + struct snp_guest_msg_hdr *req_msg_hdr =3D &req_msg->hdr; + struct snp_guest_msg_hdr *resp_msg_hdr =3D &resp_msg->hdr; =20 pr_debug("response [seqno %lld type %d version %d sz %d]\n", - resp_hdr->msg_seqno, resp_hdr->msg_type, resp_hdr->msg_version, - resp_hdr->msg_sz); + resp_msg_hdr->msg_seqno, resp_msg_hdr->msg_type, resp_msg_hdr->msg_vers= ion, + resp_msg_hdr->msg_sz); =20 /* Copy response from shared memory to encrypted memory. */ - memcpy(resp, snp_dev->response, sizeof(*resp)); + memcpy(resp_msg, snp_dev->response, sizeof(*resp_msg)); =20 /* Verify that the sequence counter is incremented by 1 */ - if (unlikely(resp_hdr->msg_seqno !=3D (req_hdr->msg_seqno + 1))) + if (unlikely(resp_msg_hdr->msg_seqno !=3D (req_msg_hdr->msg_seqno + 1))) return -EBADMSG; =20 /* Verify response message type and version number. */ - if (resp_hdr->msg_type !=3D (req_hdr->msg_type + 1) || - resp_hdr->msg_version !=3D req_hdr->msg_version) + if (resp_msg_hdr->msg_type !=3D (req_msg_hdr->msg_type + 1) || + resp_msg_hdr->msg_version !=3D req_msg_hdr->msg_version) return -EBADMSG; =20 /* * If the message size is greater than our buffer length then return * an error. */ - if (unlikely((resp_hdr->msg_sz + crypto->a_len) > sz)) + if (unlikely((resp_msg_hdr->msg_sz + crypto->a_len) > sz)) return -EBADMSG; =20 /* Decrypt the payload */ - return dec_payload(snp_dev, resp, payload, resp_hdr->msg_sz + crypto->a_l= en); + return dec_payload(snp_dev, resp_msg, payload, resp_msg_hdr->msg_sz + cry= pto->a_len); } =20 static int enc_payload(struct snp_guest_dev *snp_dev, u64 seqno, int versi= on, u8 type, void *payload, size_t sz) { - struct snp_guest_msg *req =3D &snp_dev->secret_request; - struct snp_guest_msg_hdr *hdr =3D &req->hdr; + struct snp_guest_msg *msg =3D &snp_dev->secret_request; + struct snp_guest_msg_hdr *hdr =3D &msg->hdr; =20 - memset(req, 0, sizeof(*req)); + memset(msg, 0, sizeof(*msg)); =20 hdr->algo =3D SNP_AEAD_AES_256_GCM; hdr->hdr_version =3D MSG_HDR_VER; @@ -347,7 +347,7 @@ static int enc_payload(struct snp_guest_dev *snp_dev, u= 64 seqno, int version, u8 pr_debug("request [seqno %lld type %d version %d sz %d]\n", hdr->msg_seqno, hdr->msg_type, hdr->msg_version, hdr->msg_sz); =20 - return __enc_payload(snp_dev, req, payload, sz); + return __enc_payload(snp_dev, msg, payload, sz); } =20 static int __handle_guest_request(struct snp_guest_dev *snp_dev, u64 exit_= code, @@ -496,8 +496,8 @@ struct snp_req_resp { static int get_report(struct snp_guest_dev *snp_dev, struct snp_guest_requ= est_ioctl *arg) { struct snp_guest_crypto *crypto =3D snp_dev->crypto; - struct snp_report_req *req =3D &snp_dev->req.report; - struct snp_report_resp *resp; + struct snp_report_req *report_req =3D &snp_dev->req.report; + struct snp_report_resp *report_resp; int rc, resp_len; =20 lockdep_assert_held(&snp_cmd_mutex); @@ -505,7 +505,7 @@ static int get_report(struct snp_guest_dev *snp_dev, st= ruct snp_guest_request_io if (!arg->req_data || !arg->resp_data) return -EINVAL; =20 - if (copy_from_user(req, (void __user *)arg->req_data, sizeof(*req))) + if (copy_from_user(report_req, (void __user *)arg->req_data, sizeof(*repo= rt_req))) return -EFAULT; =20 /* @@ -513,30 +513,29 @@ static int get_report(struct snp_guest_dev *snp_dev, = struct snp_guest_request_io * response payload. Make sure that it has enough space to cover the * authtag. */ - resp_len =3D sizeof(resp->data) + crypto->a_len; - resp =3D kzalloc(resp_len, GFP_KERNEL_ACCOUNT); - if (!resp) + resp_len =3D sizeof(report_resp->data) + crypto->a_len; + report_resp =3D kzalloc(resp_len, GFP_KERNEL_ACCOUNT); + if (!report_resp) return -ENOMEM; =20 - rc =3D handle_guest_request(snp_dev, SVM_VMGEXIT_GUEST_REQUEST, arg, - SNP_MSG_REPORT_REQ, req, sizeof(*req), resp->data, - resp_len); + rc =3D handle_guest_request(snp_dev, SVM_VMGEXIT_GUEST_REQUEST, arg, SNP_= MSG_REPORT_REQ, + report_req, sizeof(*report_req), report_resp->data, resp_len); if (rc) goto e_free; =20 - if (copy_to_user((void __user *)arg->resp_data, resp, sizeof(*resp))) + if (copy_to_user((void __user *)arg->resp_data, report_resp, sizeof(*repo= rt_resp))) rc =3D -EFAULT; =20 e_free: - kfree(resp); + kfree(report_resp); return rc; } =20 static int get_derived_key(struct snp_guest_dev *snp_dev, struct snp_guest= _request_ioctl *arg) { - struct snp_derived_key_req *req =3D &snp_dev->req.derived_key; + struct snp_derived_key_req *derived_key_req =3D &snp_dev->req.derived_key; struct snp_guest_crypto *crypto =3D snp_dev->crypto; - struct snp_derived_key_resp resp =3D {0}; + struct snp_derived_key_resp derived_key_resp =3D {0}; int rc, resp_len; /* Response data is 64 bytes and max authsize for GCM is 16 bytes. */ u8 buf[64 + 16]; @@ -551,25 +550,27 @@ static int get_derived_key(struct snp_guest_dev *snp_= dev, struct snp_guest_reque * response payload. Make sure that it has enough space to cover the * authtag. */ - resp_len =3D sizeof(resp.data) + crypto->a_len; + resp_len =3D sizeof(derived_key_resp.data) + crypto->a_len; if (sizeof(buf) < resp_len) return -ENOMEM; =20 - if (copy_from_user(req, (void __user *)arg->req_data, sizeof(*req))) + if (copy_from_user(derived_key_req, (void __user *)arg->req_data, + sizeof(*derived_key_req))) return -EFAULT; =20 - rc =3D handle_guest_request(snp_dev, SVM_VMGEXIT_GUEST_REQUEST, arg, - SNP_MSG_KEY_REQ, req, sizeof(*req), buf, resp_len); + rc =3D handle_guest_request(snp_dev, SVM_VMGEXIT_GUEST_REQUEST, arg, SNP_= MSG_KEY_REQ, + derived_key_req, sizeof(*derived_key_req), buf, resp_len); if (rc) return rc; =20 - memcpy(resp.data, buf, sizeof(resp.data)); - if (copy_to_user((void __user *)arg->resp_data, &resp, sizeof(resp))) + memcpy(derived_key_resp.data, buf, sizeof(derived_key_resp.data)); + if (copy_to_user((void __user *)arg->resp_data, &derived_key_resp, + sizeof(derived_key_resp))) rc =3D -EFAULT; =20 /* The response buffer contains the sensitive data, explicitly clear it. = */ memzero_explicit(buf, sizeof(buf)); - memzero_explicit(&resp, sizeof(resp)); + memzero_explicit(&derived_key_resp, sizeof(derived_key_resp)); return rc; } =20 @@ -577,9 +578,9 @@ static int get_ext_report(struct snp_guest_dev *snp_dev= , struct snp_guest_reques struct snp_req_resp *io) =20 { - struct snp_ext_report_req *req =3D &snp_dev->req.ext_report; + struct snp_ext_report_req *report_req =3D &snp_dev->req.ext_report; struct snp_guest_crypto *crypto =3D snp_dev->crypto; - struct snp_report_resp *resp; + struct snp_report_resp *report_resp; int ret, npages =3D 0, resp_len; sockptr_t certs_address; =20 @@ -588,22 +589,22 @@ static int get_ext_report(struct snp_guest_dev *snp_d= ev, struct snp_guest_reques if (sockptr_is_null(io->req_data) || sockptr_is_null(io->resp_data)) return -EINVAL; =20 - if (copy_from_sockptr(req, io->req_data, sizeof(*req))) + if (copy_from_sockptr(report_req, io->req_data, sizeof(*report_req))) return -EFAULT; =20 /* caller does not want certificate data */ - if (!req->certs_len || !req->certs_address) + if (!report_req->certs_len || !report_req->certs_address) goto cmd; =20 - if (req->certs_len > SEV_FW_BLOB_MAX_SIZE || - !IS_ALIGNED(req->certs_len, PAGE_SIZE)) + if (report_req->certs_len > SEV_FW_BLOB_MAX_SIZE || + !IS_ALIGNED(report_req->certs_len, PAGE_SIZE)) return -EINVAL; =20 if (sockptr_is_kernel(io->resp_data)) { - certs_address =3D KERNEL_SOCKPTR((void *)req->certs_address); + certs_address =3D KERNEL_SOCKPTR((void *)report_req->certs_address); } else { - certs_address =3D USER_SOCKPTR((void __user *)req->certs_address); - if (!access_ok(certs_address.user, req->certs_len)) + certs_address =3D USER_SOCKPTR((void __user *)report_req->certs_address); + if (!access_ok(certs_address.user, report_req->certs_len)) return -EFAULT; } =20 @@ -613,45 +614,45 @@ static int get_ext_report(struct snp_guest_dev *snp_d= ev, struct snp_guest_reques * the host. If host does not supply any certs in it, then copy * zeros to indicate that certificate data was not provided. */ - memset(snp_dev->certs_data, 0, req->certs_len); - npages =3D req->certs_len >> PAGE_SHIFT; + memset(snp_dev->certs_data, 0, report_req->certs_len); + npages =3D report_req->certs_len >> PAGE_SHIFT; cmd: /* * The intermediate response buffer is used while decrypting the * response payload. Make sure that it has enough space to cover the * authtag. */ - resp_len =3D sizeof(resp->data) + crypto->a_len; - resp =3D kzalloc(resp_len, GFP_KERNEL_ACCOUNT); - if (!resp) + resp_len =3D sizeof(report_resp->data) + crypto->a_len; + report_resp =3D kzalloc(resp_len, GFP_KERNEL_ACCOUNT); + if (!report_resp) return -ENOMEM; =20 snp_dev->input.data_npages =3D npages; - ret =3D handle_guest_request(snp_dev, SVM_VMGEXIT_EXT_GUEST_REQUEST, arg, - SNP_MSG_REPORT_REQ, &req->data, - sizeof(req->data), resp->data, resp_len); + ret =3D handle_guest_request(snp_dev, SVM_VMGEXIT_EXT_GUEST_REQUEST, arg,= SNP_MSG_REPORT_REQ, + &report_req->data, sizeof(report_req->data), + report_resp->data, resp_len); =20 /* If certs length is invalid then copy the returned length */ if (arg->vmm_error =3D=3D SNP_GUEST_VMM_ERR_INVALID_LEN) { - req->certs_len =3D snp_dev->input.data_npages << PAGE_SHIFT; + report_req->certs_len =3D snp_dev->input.data_npages << PAGE_SHIFT; =20 - if (copy_to_sockptr(io->req_data, req, sizeof(*req))) + if (copy_to_sockptr(io->req_data, report_req, sizeof(*report_req))) ret =3D -EFAULT; } =20 if (ret) goto e_free; =20 - if (npages && copy_to_sockptr(certs_address, snp_dev->certs_data, req->ce= rts_len)) { + if (npages && copy_to_sockptr(certs_address, snp_dev->certs_data, report_= req->certs_len)) { ret =3D -EFAULT; goto e_free; } =20 - if (copy_to_sockptr(io->resp_data, resp, sizeof(*resp))) + if (copy_to_sockptr(io->resp_data, report_resp, sizeof(*report_resp))) ret =3D -EFAULT; =20 e_free: - kfree(resp); + kfree(report_resp); return ret; }