Lines Matching defs:data
299 static int __sev_issue_cmd(int fd, int id, void *data, int *error)
308 ret = sev_issue_cmd_external_user(f.file, id, data, error);
314 static int sev_issue_cmd(struct kvm *kvm, int id, void *data, int *error)
318 return __sev_issue_cmd(sev->fd, id, data, error);
333 if (copy_from_user(¶ms, (void __user *)(uintptr_t)argp->data, sizeof(params)))
377 if (copy_to_user((void __user *)(uintptr_t)argp->data, ¶ms, sizeof(params))) {
509 struct sev_data_launch_update_data data;
516 if (copy_from_user(¶ms, (void __user *)(uintptr_t)argp->data, sizeof(params)))
530 * place; the cache may contain the data that was written unencrypted.
534 data.reserved = 0;
535 data.handle = sev->handle;
551 data.len = len;
552 data.address = __sme_page_pa(inpages[i]) + offset;
553 ret = sev_issue_cmd(kvm, SEV_CMD_LAUNCH_UPDATE_DATA, &data, &argp->error);
686 void __user *measure = (void __user *)(uintptr_t)argp->data;
688 struct sev_data_launch_measure data;
700 memset(&data, 0, sizeof(data));
715 data.address = __psp_pa(blob);
716 data.len = params.len;
720 data.handle = sev->handle;
721 ret = sev_issue_cmd(kvm, SEV_CMD_LAUNCH_MEASURE, &data, &argp->error);
724 * If we query the session length, FW responded with expected data.
738 params.len = data.len;
749 struct sev_data_launch_finish data;
754 data.handle = sev->handle;
755 return sev_issue_cmd(kvm, SEV_CMD_LAUNCH_FINISH, &data, &argp->error);
762 struct sev_data_guest_status data;
768 memset(&data, 0, sizeof(data));
770 data.handle = sev->handle;
771 ret = sev_issue_cmd(kvm, SEV_CMD_GUEST_STATUS, &data, &argp->error);
775 params.policy = data.policy;
776 params.state = data.state;
777 params.handle = data.handle;
779 if (copy_to_user((void __user *)(uintptr_t)argp->data, ¶ms, sizeof(params)))
790 struct sev_data_dbg data;
792 data.reserved = 0;
793 data.handle = sev->handle;
794 data.dst_addr = dst;
795 data.src_addr = src;
796 data.len = size;
800 &data, error);
944 if (copy_from_user(&debug, (void __user *)(uintptr_t)argp->data, sizeof(debug)))
974 * see stale data.
1018 struct sev_data_launch_secret data;
1028 if (copy_from_user(¶ms, (void __user *)(uintptr_t)argp->data, sizeof(params)))
1037 * place; the cache may contain the data that was written unencrypted.
1050 memset(&data, 0, sizeof(data));
1053 data.guest_address = __sme_page_pa(pages[0]) + offset;
1054 data.guest_len = params.guest_len;
1062 data.trans_address = __psp_pa(blob);
1063 data.trans_len = params.trans_len;
1070 data.hdr_address = __psp_pa(hdr);
1071 data.hdr_len = params.hdr_len;
1073 data.handle = sev->handle;
1074 ret = sev_issue_cmd(kvm, SEV_CMD_LAUNCH_UPDATE_SECRET, &data, &argp->error);
1092 void __user *report = (void __user *)(uintptr_t)argp->data;
1094 struct sev_data_attestation_report data;
1103 if (copy_from_user(¶ms, (void __user *)(uintptr_t)argp->data, sizeof(params)))
1106 memset(&data, 0, sizeof(data));
1121 data.address = __psp_pa(blob);
1122 data.len = params.len;
1123 memcpy(data.mnonce, params.mnonce, sizeof(params.mnonce));
1126 data.handle = sev->handle;
1127 ret = sev_issue_cmd(kvm, SEV_CMD_ATTESTATION_REPORT, &data, &argp->error);
1129 * If we query the session length, FW responded with expected data.
1143 params.len = data.len;
1157 struct sev_data_send_start data;
1160 memset(&data, 0, sizeof(data));
1161 data.handle = sev->handle;
1162 ret = sev_issue_cmd(kvm, SEV_CMD_SEND_START, &data, &argp->error);
1164 params->session_len = data.session_len;
1165 if (copy_to_user((void __user *)(uintptr_t)argp->data, params,
1175 struct sev_data_send_start data;
1184 if (copy_from_user(¶ms, (void __user *)(uintptr_t)argp->data,
1198 /* allocate the memory to hold the session data blob */
1226 memset(&data, 0, sizeof(data));
1227 data.pdh_cert_address = __psp_pa(pdh_cert);
1228 data.pdh_cert_len = params.pdh_cert_len;
1229 data.plat_certs_address = __psp_pa(plat_certs);
1230 data.plat_certs_len = params.plat_certs_len;
1231 data.amd_certs_address = __psp_pa(amd_certs);
1232 data.amd_certs_len = params.amd_certs_len;
1233 data.session_address = __psp_pa(session_data);
1234 data.session_len = params.session_len;
1235 data.handle = sev->handle;
1237 ret = sev_issue_cmd(kvm, SEV_CMD_SEND_START, &data, &argp->error);
1245 params.policy = data.policy;
1246 params.session_len = data.session_len;
1247 if (copy_to_user((void __user *)(uintptr_t)argp->data, ¶ms,
1268 struct sev_data_send_update_data data;
1271 memset(&data, 0, sizeof(data));
1272 data.handle = sev->handle;
1273 ret = sev_issue_cmd(kvm, SEV_CMD_SEND_UPDATE_DATA, &data, &argp->error);
1275 params->hdr_len = data.hdr_len;
1276 params->trans_len = data.trans_len;
1278 if (copy_to_user((void __user *)(uintptr_t)argp->data, params,
1288 struct sev_data_send_update_data data;
1298 if (copy_from_user(¶ms, (void __user *)(uintptr_t)argp->data,
1331 memset(&data, 0, sizeof(data));
1332 data.hdr_address = __psp_pa(hdr);
1333 data.hdr_len = params.hdr_len;
1334 data.trans_address = __psp_pa(trans_data);
1335 data.trans_len = params.trans_len;
1338 data.guest_address = (page_to_pfn(guest_page[0]) << PAGE_SHIFT) + offset;
1339 data.guest_address |= sev_me_mask;
1340 data.guest_len = params.guest_len;
1341 data.handle = sev->handle;
1343 ret = sev_issue_cmd(kvm, SEV_CMD_SEND_UPDATE_DATA, &data, &argp->error);
1373 struct sev_data_send_finish data;
1378 data.handle = sev->handle;
1379 return sev_issue_cmd(kvm, SEV_CMD_SEND_FINISH, &data, &argp->error);
1385 struct sev_data_send_cancel data;
1390 data.handle = sev->handle;
1391 return sev_issue_cmd(kvm, SEV_CMD_SEND_CANCEL, &data, &argp->error);
1408 if (copy_from_user(¶ms, (void __user *)(uintptr_t)argp->data,
1450 if (copy_to_user((void __user *)(uintptr_t)argp->data,
1472 struct sev_data_receive_update_data data;
1481 if (copy_from_user(¶ms, (void __user *)(uintptr_t)argp->data,
1505 memset(&data, 0, sizeof(data));
1506 data.hdr_address = __psp_pa(hdr);
1507 data.hdr_len = params.hdr_len;
1508 data.trans_address = __psp_pa(trans);
1509 data.trans_len = params.trans_len;
1521 * encrypts the written data with the guest's key, and the cache may
1522 * contain dirty, unencrypted data.
1527 data.guest_address = (page_to_pfn(guest_page[0]) << PAGE_SHIFT) + offset;
1528 data.guest_address |= sev_me_mask;
1529 data.guest_len = params.guest_len;
1530 data.handle = sev->handle;
1532 ret = sev_issue_cmd(kvm, SEV_CMD_RECEIVE_UPDATE_DATA, &data,
1548 struct sev_data_receive_finish data;
1553 data.handle = sev->handle;
1554 return sev_issue_cmd(kvm, SEV_CMD_RECEIVE_FINISH, &data, &argp->error);
1987 * flushed to ensure that guest data gets written into memory with
2335 * by leaving stale encrypted data in the cache.
2403 * The GHCB protocol so far allows for the following data
2408 * VM-Exit. It's the guest's responsibility to not consume random data.
2424 * The GHCB protocol so far allows for the following data
2716 * the vCPU next time (i.e. a read was requested so the data
2823 vcpu->run->system_event.data[0] = control->ghcb_gpa;