diff mbox series

[v4,07/17] sev: Update launch_update_data functions to use Error handling

Message ID d988d0ca2eadb0594cb694b65e972164a681af8e.1720004383.git.roy.hopkins@suse.com (mailing list archive)
State New, archived
Headers show
Series Introduce support for IGVM files | expand

Commit Message

Roy Hopkins July 3, 2024, 11:05 a.m. UTC 
The class function and implementations for updating launch data return
a code in case of error. In some cases an error message is generated and
in other cases, just the error return value is used.

This small refactor adds an 'Error **errp' parameter to all functions
which consistently set an error condition if a non-zero value is
returned.

Signed-off-by: Roy Hopkins <roy.hopkins@suse.com>
---
 target/i386/sev.c | 59 +++++++++++++++++++++++++----------------------
 1 file changed, 31 insertions(+), 28 deletions(-)

Comments

Daniel P. Berrangé July 24, 2024, 5:21 p.m. UTC | #1 
On Wed, Jul 03, 2024 at 12:05:45PM +0100, Roy Hopkins wrote:
> The class function and implementations for updating launch data return
> a code in case of error. In some cases an error message is generated and
> in other cases, just the error return value is used.
> 
> This small refactor adds an 'Error **errp' parameter to all functions
> which consistently set an error condition if a non-zero value is
> returned.

Ahh, OK, so you've already addressed my suggestion from the previous
patch then :-)


> Signed-off-by: Roy Hopkins <roy.hopkins@suse.com>
> ---
>  target/i386/sev.c | 59 +++++++++++++++++++++++++----------------------
>  1 file changed, 31 insertions(+), 28 deletions(-)
> 
> diff --git a/target/i386/sev.c b/target/i386/sev.c
> index 491ca5369e..5eabeadda6 100644
> --- a/target/i386/sev.c
> +++ b/target/i386/sev.c
> @@ -121,7 +121,8 @@ struct SevCommonStateClass {
>                                         Error **errp);
>      int (*launch_start)(SevCommonState *sev_common);
>      void (*launch_finish)(SevCommonState *sev_common);
> -    int (*launch_update_data)(SevCommonState *sev_common, hwaddr gpa, uint8_t *ptr, size_t len);
> +    int (*launch_update_data)(SevCommonState *sev_common, hwaddr gpa,
> +                              uint8_t *ptr, size_t len, Error **errp);
>      int (*kvm_init)(ConfidentialGuestSupport *cgs, Error **errp);
>  };
>  
> @@ -945,14 +946,16 @@ out:
>      return ret;
>  }
>  
> -static int
> -sev_launch_update_data(SevCommonState *sev_common, hwaddr gpa,
> -                       uint8_t *addr, size_t len)
> +static int sev_launch_update_data(SevCommonState *sev_common, hwaddr gpa,
> +                                  uint8_t *addr, size_t len, Error **errp)
>  {
>      int ret, fw_error;
>      struct kvm_sev_launch_update_data update;
>  
>      if (!addr || !len) {
> +        error_setg(errp,
> +                   "%s: Invalid parameters provided for updating launch data.",
> +                   __func__);
>          return 1;
>      }

This change I'm not too sure about. I feel like this was written to
be an intentional no-op, rather than an error. If it is supposed to
be an error then change to 'return -1' too.

>  
> @@ -962,8 +965,8 @@ sev_launch_update_data(SevCommonState *sev_common, hwaddr gpa,
>      ret = sev_ioctl(sev_common->sev_fd, KVM_SEV_LAUNCH_UPDATE_DATA,
>                      &update, &fw_error);
>      if (ret) {
> -        error_report("%s: LAUNCH_UPDATE ret=%d fw_error=%d '%s'",
> -                __func__, ret, fw_error, fw_error_to_str(fw_error));
> +        error_setg(errp, "%s: LAUNCH_UPDATE ret=%d fw_error=%d '%s'", __func__,
> +                   ret, fw_error, fw_error_to_str(fw_error));
>      }
>  
>      return ret;
> @@ -1091,8 +1094,8 @@ sev_launch_finish(SevCommonState *sev_common)
>      migrate_add_blocker(&sev_mig_blocker, &error_fatal);
>  }
>  
> -static int
> -snp_launch_update_data(uint64_t gpa, void *hva, size_t len, int type)
> +static int snp_launch_update_data(uint64_t gpa, void *hva, size_t len,
> +                                  int type, Error **errp)
>  {
>      SevLaunchUpdateData *data;
>  
> @@ -1107,13 +1110,11 @@ snp_launch_update_data(uint64_t gpa, void *hva, size_t len, int type)
>      return 0;
>  }
>  
> -static int
> -sev_snp_launch_update_data(SevCommonState *sev_common, hwaddr gpa,
> -                           uint8_t *ptr, size_t len)
> +static int sev_snp_launch_update_data(SevCommonState *sev_common, hwaddr gpa,
> +                                      uint8_t *ptr, size_t len, Error **errp)
>  {
> -       int ret = snp_launch_update_data(gpa, ptr, len,
> -                                         KVM_SEV_SNP_PAGE_TYPE_NORMAL);
> -       return ret;
> +    return snp_launch_update_data(gpa, ptr, len,
> +                                     KVM_SEV_SNP_PAGE_TYPE_NORMAL, errp);
>  }
>  
>  static int
> @@ -1165,8 +1166,8 @@ sev_snp_cpuid_info_fill(SnpCpuidInfo *snp_cpuid_info,
>      return 0;
>  }
>  
> -static int
> -snp_launch_update_cpuid(uint32_t cpuid_addr, void *hva, size_t cpuid_len)
> +static int snp_launch_update_cpuid(uint32_t cpuid_addr, void *hva,
> +                                   size_t cpuid_len, Error **errp)
>  {
>      KvmCpuidInfo kvm_cpuid_info = {0};
>      SnpCpuidInfo snp_cpuid_info;
> @@ -1183,26 +1184,26 @@ snp_launch_update_cpuid(uint32_t cpuid_addr, void *hva, size_t cpuid_len)
>      } while (ret == -E2BIG);
>  
>      if (ret) {
> -        error_report("SEV-SNP: unable to query CPUID values for CPU: '%s'",
> -                     strerror(-ret));
> +        error_setg(errp, "SEV-SNP: unable to query CPUID values for CPU: '%s'",
> +                   strerror(-ret));
>          return 1;
>      }
>  
>      ret = sev_snp_cpuid_info_fill(&snp_cpuid_info, &kvm_cpuid_info);
>      if (ret) {
> -        error_report("SEV-SNP: failed to generate CPUID table information");
> +        error_setg(errp, "SEV-SNP: failed to generate CPUID table information");
>          return 1;
>      }
>  
>      memcpy(hva, &snp_cpuid_info, sizeof(snp_cpuid_info));
>  
>      return snp_launch_update_data(cpuid_addr, hva, cpuid_len,
> -                                  KVM_SEV_SNP_PAGE_TYPE_CPUID);
> +                                  KVM_SEV_SNP_PAGE_TYPE_CPUID, errp);
>  }
>  
> -static int
> -snp_launch_update_kernel_hashes(SevSnpGuestState *sev_snp, uint32_t addr,
> -                                void *hva, uint32_t len)
> +static int snp_launch_update_kernel_hashes(SevSnpGuestState *sev_snp,
> +                                           uint32_t addr, void *hva,
> +                                           uint32_t len, Error **errp)
>  {
>      int type = KVM_SEV_SNP_PAGE_TYPE_ZERO;
>      if (sev_snp->parent_obj.kernel_hashes) {
> @@ -1214,7 +1215,7 @@ snp_launch_update_kernel_hashes(SevSnpGuestState *sev_snp, uint32_t addr,
>                 sizeof(*sev_snp->kernel_hashes_data));
>          type = KVM_SEV_SNP_PAGE_TYPE_NORMAL;
>      }
> -    return snp_launch_update_data(addr, hva, len, type);
> +    return snp_launch_update_data(addr, hva, len, type, errp);
>  }
>  
>  static int
> @@ -1252,12 +1253,14 @@ snp_populate_metadata_pages(SevSnpGuestState *sev_snp,
>          }
>  
>          if (type == KVM_SEV_SNP_PAGE_TYPE_CPUID) {
> -            ret = snp_launch_update_cpuid(desc->base, hva, desc->len);
> +            ret = snp_launch_update_cpuid(desc->base, hva, desc->len,
> +                                          &error_fatal);
>          } else if (desc->type == SEV_DESC_TYPE_SNP_KERNEL_HASHES) {
>              ret = snp_launch_update_kernel_hashes(sev_snp, desc->base, hva,
> -                                                  desc->len);
> +                                                  desc->len, &error_fatal);
>          } else {
> -            ret = snp_launch_update_data(desc->base, hva, desc->len, type);
> +            ret = snp_launch_update_data(desc->base, hva, desc->len, type,
> +                                         &error_fatal);
>          }
>  
>          if (ret) {
> @@ -1542,7 +1545,7 @@ sev_encrypt_flash(hwaddr gpa, uint8_t *ptr, uint64_t len, Error **errp)
>  
>      /* if SEV is in update state then encrypt the data else do nothing */
>      if (sev_check_state(sev_common, SEV_STATE_LAUNCH_UPDATE)) {
> -        if (klass->launch_update_data(sev_common, gpa, ptr, len)) {
> +        if (klass->launch_update_data(sev_common, gpa, ptr, len, errp)) {
>              error_setg(errp, "SEV: Failed to encrypt flash");
>              return -1;
>          }
> -- 
> 2.43.0
> 

With regards,
Daniel
diff mbox series

Patch

diff --git a/target/i386/sev.c b/target/i386/sev.c
index 491ca5369e..5eabeadda6 100644
--- a/target/i386/sev.c
+++ b/target/i386/sev.c
@@ -121,7 +121,8 @@  struct SevCommonStateClass {
                                        Error **errp);
     int (*launch_start)(SevCommonState *sev_common);
     void (*launch_finish)(SevCommonState *sev_common);
-    int (*launch_update_data)(SevCommonState *sev_common, hwaddr gpa, uint8_t *ptr, size_t len);
+    int (*launch_update_data)(SevCommonState *sev_common, hwaddr gpa,
+                              uint8_t *ptr, size_t len, Error **errp);
     int (*kvm_init)(ConfidentialGuestSupport *cgs, Error **errp);
 };
 
@@ -945,14 +946,16 @@  out:
     return ret;
 }
 
-static int
-sev_launch_update_data(SevCommonState *sev_common, hwaddr gpa,
-                       uint8_t *addr, size_t len)
+static int sev_launch_update_data(SevCommonState *sev_common, hwaddr gpa,
+                                  uint8_t *addr, size_t len, Error **errp)
 {
     int ret, fw_error;
     struct kvm_sev_launch_update_data update;
 
     if (!addr || !len) {
+        error_setg(errp,
+                   "%s: Invalid parameters provided for updating launch data.",
+                   __func__);
         return 1;
     }
 
@@ -962,8 +965,8 @@  sev_launch_update_data(SevCommonState *sev_common, hwaddr gpa,
     ret = sev_ioctl(sev_common->sev_fd, KVM_SEV_LAUNCH_UPDATE_DATA,
                     &update, &fw_error);
     if (ret) {
-        error_report("%s: LAUNCH_UPDATE ret=%d fw_error=%d '%s'",
-                __func__, ret, fw_error, fw_error_to_str(fw_error));
+        error_setg(errp, "%s: LAUNCH_UPDATE ret=%d fw_error=%d '%s'", __func__,
+                   ret, fw_error, fw_error_to_str(fw_error));
     }
 
     return ret;
@@ -1091,8 +1094,8 @@  sev_launch_finish(SevCommonState *sev_common)
     migrate_add_blocker(&sev_mig_blocker, &error_fatal);
 }
 
-static int
-snp_launch_update_data(uint64_t gpa, void *hva, size_t len, int type)
+static int snp_launch_update_data(uint64_t gpa, void *hva, size_t len,
+                                  int type, Error **errp)
 {
     SevLaunchUpdateData *data;
 
@@ -1107,13 +1110,11 @@  snp_launch_update_data(uint64_t gpa, void *hva, size_t len, int type)
     return 0;
 }
 
-static int
-sev_snp_launch_update_data(SevCommonState *sev_common, hwaddr gpa,
-                           uint8_t *ptr, size_t len)
+static int sev_snp_launch_update_data(SevCommonState *sev_common, hwaddr gpa,
+                                      uint8_t *ptr, size_t len, Error **errp)
 {
-       int ret = snp_launch_update_data(gpa, ptr, len,
-                                         KVM_SEV_SNP_PAGE_TYPE_NORMAL);
-       return ret;
+    return snp_launch_update_data(gpa, ptr, len,
+                                     KVM_SEV_SNP_PAGE_TYPE_NORMAL, errp);
 }
 
 static int
@@ -1165,8 +1166,8 @@  sev_snp_cpuid_info_fill(SnpCpuidInfo *snp_cpuid_info,
     return 0;
 }
 
-static int
-snp_launch_update_cpuid(uint32_t cpuid_addr, void *hva, size_t cpuid_len)
+static int snp_launch_update_cpuid(uint32_t cpuid_addr, void *hva,
+                                   size_t cpuid_len, Error **errp)
 {
     KvmCpuidInfo kvm_cpuid_info = {0};
     SnpCpuidInfo snp_cpuid_info;
@@ -1183,26 +1184,26 @@  snp_launch_update_cpuid(uint32_t cpuid_addr, void *hva, size_t cpuid_len)
     } while (ret == -E2BIG);
 
     if (ret) {
-        error_report("SEV-SNP: unable to query CPUID values for CPU: '%s'",
-                     strerror(-ret));
+        error_setg(errp, "SEV-SNP: unable to query CPUID values for CPU: '%s'",
+                   strerror(-ret));
         return 1;
     }
 
     ret = sev_snp_cpuid_info_fill(&snp_cpuid_info, &kvm_cpuid_info);
     if (ret) {
-        error_report("SEV-SNP: failed to generate CPUID table information");
+        error_setg(errp, "SEV-SNP: failed to generate CPUID table information");
         return 1;
     }
 
     memcpy(hva, &snp_cpuid_info, sizeof(snp_cpuid_info));
 
     return snp_launch_update_data(cpuid_addr, hva, cpuid_len,
-                                  KVM_SEV_SNP_PAGE_TYPE_CPUID);
+                                  KVM_SEV_SNP_PAGE_TYPE_CPUID, errp);
 }
 
-static int
-snp_launch_update_kernel_hashes(SevSnpGuestState *sev_snp, uint32_t addr,
-                                void *hva, uint32_t len)
+static int snp_launch_update_kernel_hashes(SevSnpGuestState *sev_snp,
+                                           uint32_t addr, void *hva,
+                                           uint32_t len, Error **errp)
 {
     int type = KVM_SEV_SNP_PAGE_TYPE_ZERO;
     if (sev_snp->parent_obj.kernel_hashes) {
@@ -1214,7 +1215,7 @@  snp_launch_update_kernel_hashes(SevSnpGuestState *sev_snp, uint32_t addr,
                sizeof(*sev_snp->kernel_hashes_data));
         type = KVM_SEV_SNP_PAGE_TYPE_NORMAL;
     }
-    return snp_launch_update_data(addr, hva, len, type);
+    return snp_launch_update_data(addr, hva, len, type, errp);
 }
 
 static int
@@ -1252,12 +1253,14 @@  snp_populate_metadata_pages(SevSnpGuestState *sev_snp,
         }
 
         if (type == KVM_SEV_SNP_PAGE_TYPE_CPUID) {
-            ret = snp_launch_update_cpuid(desc->base, hva, desc->len);
+            ret = snp_launch_update_cpuid(desc->base, hva, desc->len,
+                                          &error_fatal);
         } else if (desc->type == SEV_DESC_TYPE_SNP_KERNEL_HASHES) {
             ret = snp_launch_update_kernel_hashes(sev_snp, desc->base, hva,
-                                                  desc->len);
+                                                  desc->len, &error_fatal);
         } else {
-            ret = snp_launch_update_data(desc->base, hva, desc->len, type);
+            ret = snp_launch_update_data(desc->base, hva, desc->len, type,
+                                         &error_fatal);
         }
 
         if (ret) {
@@ -1542,7 +1545,7 @@  sev_encrypt_flash(hwaddr gpa, uint8_t *ptr, uint64_t len, Error **errp)
 
     /* if SEV is in update state then encrypt the data else do nothing */
     if (sev_check_state(sev_common, SEV_STATE_LAUNCH_UPDATE)) {
-        if (klass->launch_update_data(sev_common, gpa, ptr, len)) {
+        if (klass->launch_update_data(sev_common, gpa, ptr, len, errp)) {
             error_setg(errp, "SEV: Failed to encrypt flash");
             return -1;
         }