vboot: update secdata accessors to match those of FWMP

Instead of returning vb2_error_t, use VB2_DIE to exit on error.

BUG=b:124141368, chromium:972956, chromium:1006689,
TEST=make clean && make runtests
BRANCH=none

Change-Id: I9497eebb0b8815734fdf875ba4f9ef5eda5e82fd
Signed-off-by: Joel Kitching <kitching@google.com>
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/vboot_reference/+/1833365
Tested-by: Joel Kitching <kitching@chromium.org>
Commit-Queue: Joel Kitching <kitching@chromium.org>
Reviewed-by: Julius Werner <jwerner@chromium.org>

15 files changed, 212 insertions, 239 deletions

diff --git a/firmware/2lib/2misc.c b/firmware/2lib/2misc.c
index 389a80d7..a1635f7a 100644
--- a/firmware/2lib/2misc.c
+++ b/firmware/2lib/2misc.c
@@ -248,30 +248,19 @@ vb2_error_t vb2_check_dev_switch(struct vb2_context *ctx)
 	uint32_t flags = 0;
 	uint32_t old_flags;
 	int is_dev = 0;
-	int use_secdata = 1;
+	int valid_secdata = 1;
 	vb2_error_t rv;
 
+	/* Check whether secdata_firmware is initialized */
+	if (!(sd->status & VB2_SD_STATUS_SECDATA_FIRMWARE_INIT))
+		valid_secdata = 0;
+
 	/* Read secure flags */
-	rv = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_FLAGS, &flags);
-	if (rv) {
-		if (ctx->flags & VB2_CONTEXT_RECOVERY_MODE) {
-			/*
-			 * Recovery mode needs to check other ways developer
-			 * mode can be enabled, so don't give up yet.  But
-			 * since we can't read secdata, assume dev mode was
-			 * disabled.
-			 */
-			use_secdata = 0;
-			flags = 0;
-		} else {
-			/* Normal mode simply fails */
-			return rv;
-		}
-	}
+	flags = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_FLAGS);
 	old_flags = flags;
 
 	/* Handle dev disable request */
-	if (use_secdata && vb2_nv_get(ctx, VB2_NV_DISABLE_DEV_REQUEST)) {
+	if (valid_secdata && vb2_nv_get(ctx, VB2_NV_DISABLE_DEV_REQUEST)) {
 		flags &= ~VB2_SECDATA_FIRMWARE_FLAG_DEV_MODE;
 
 		/* Clear the request */
@@ -325,32 +314,28 @@ vb2_error_t vb2_check_dev_switch(struct vb2_context *ctx)
 		 * vb2_check_tpm_clear(), because we don't want to update
 		 * last_boot_developer and then fail to clear the TPM owner.
 		 *
-		 * Note that we do this even if we couldn't read secdata, since
-		 * the TPM owner and secdata may be independent, and we want
-		 * the owner to be cleared if *this boot* is different than the
-		 * last one (perhaps due to GBB or hardware override).
+		 * Note that we do this even if secdata_firmware is having
+		 * issues, since the TPM owner and secdata_firmware may be
+		 * independent, and we want the owner to be cleared if *this
+		 * boot* is different than the last one (perhaps due to GBB or
+		 * hardware override).
 		 */
 		rv = vb2ex_tpm_clear_owner(ctx);
-		if (use_secdata) {
-			/* Check for failure to clear owner */
-			if (rv) {
-				/*
-				 * Note that this truncates rv to 8 bit.  Which
-				 * is not as useful as the full error code, but
-				 * we don't have NVRAM space to store the full
-				 * 32-bit code.
-				 */
-				vb2api_fail(ctx, VB2_RECOVERY_TPM_CLEAR_OWNER,
-					    rv);
-				return rv;
-			}
-
-			/* Save new flags */
-			rv = vb2_secdata_firmware_set(
-				ctx, VB2_SECDATA_FIRMWARE_FLAGS, flags);
-			if (rv)
-				return rv;
+		/* Check for failure to clear owner */
+		if (valid_secdata && rv) {
+			/*
+			 * Note that this truncates rv to 8 bit.  Which
+			 * is not as useful as the full error code, but
+			 * we don't have NVRAM space to store the full
+			 * 32-bit code.
+			 */
+			vb2api_fail(ctx, VB2_RECOVERY_TPM_CLEAR_OWNER, rv);
+			return rv;
 		}
+
+		/* Save new flags */
+		vb2_secdata_firmware_set(ctx, VB2_SECDATA_FIRMWARE_FLAGS,
+					 flags);
 	}
 
 	return VB2_SUCCESS;
diff --git a/firmware/2lib/2secdata_firmware.c b/firmware/2lib/2secdata_firmware.c
index 1d3c855d..baca6c46 100644
--- a/firmware/2lib/2secdata_firmware.c
+++ b/firmware/2lib/2secdata_firmware.c
@@ -66,60 +66,68 @@ vb2_error_t vb2_secdata_firmware_init(struct vb2_context *ctx)
 	sd->status |= VB2_SD_STATUS_SECDATA_FIRMWARE_INIT;
 
 	/* Read this now to make sure crossystem has it even in rec mode */
-	rv = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
-				      &sd->fw_version_secdata);
-	if (rv)
-		return rv;
+	sd->fw_version_secdata =
+		vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 
 	return VB2_SUCCESS;
 }
 
-vb2_error_t vb2_secdata_firmware_get(struct vb2_context *ctx,
-				     enum vb2_secdata_firmware_param param,
-				     uint32_t *dest)
+uint32_t vb2_secdata_firmware_get(struct vb2_context *ctx,
+				  enum vb2_secdata_firmware_param param)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	struct vb2_secdata_firmware *sec =
 		(struct vb2_secdata_firmware *)ctx->secdata_firmware;
+	const char *msg;
 
-	if (!(sd->status & VB2_SD_STATUS_SECDATA_FIRMWARE_INIT))
-		return VB2_ERROR_SECDATA_FIRMWARE_GET_UNINITIALIZED;
+	if (!(sd->status & VB2_SD_STATUS_SECDATA_FIRMWARE_INIT)) {
+		msg = "get before init";
+		goto fail;
+	}
 
 	switch (param) {
 	case VB2_SECDATA_FIRMWARE_FLAGS:
-		*dest = sec->flags;
-		return VB2_SUCCESS;
+		return sec->flags;
 
 	case VB2_SECDATA_FIRMWARE_VERSIONS:
-		*dest = sec->fw_versions;
-		return VB2_SUCCESS;
+		return sec->fw_versions;
 
 	default:
-		return VB2_ERROR_SECDATA_FIRMWARE_GET_PARAM;
+		msg = "invalid param";
 	}
+
+ fail:
+	if (!(ctx->flags & VB2_CONTEXT_RECOVERY_MODE))
+		VB2_DIE("%s\n", msg);
+	VB2_DEBUG("ERROR [%s] ignored in recovery mode\n", msg);
+	return 0;
 }
 
-vb2_error_t vb2_secdata_firmware_set(struct vb2_context *ctx,
-				     enum vb2_secdata_firmware_param param,
-				     uint32_t value)
+void vb2_secdata_firmware_set(struct vb2_context *ctx,
+			      enum vb2_secdata_firmware_param param,
+			      uint32_t value)
 {
+	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	struct vb2_secdata_firmware *sec =
 		(struct vb2_secdata_firmware *)ctx->secdata_firmware;
-	uint32_t now;
+	const char *msg;
 
-	if (!(vb2_get_sd(ctx)->status & VB2_SD_STATUS_SECDATA_FIRMWARE_INIT))
-		return VB2_ERROR_SECDATA_FIRMWARE_SET_UNINITIALIZED;
+	if (!(sd->status & VB2_SD_STATUS_SECDATA_FIRMWARE_INIT)) {
+		msg = "set before init";
+		goto fail;
+	}
 
-	/* If not changing the value, don't regenerate the CRC */
-	if (vb2_secdata_firmware_get(ctx, param, &now) == VB2_SUCCESS &&
-	    now == value)
-		return VB2_SUCCESS;
+	/* If not changing the value, just return early */
+	if (value == vb2_secdata_firmware_get(ctx, param))
+		return;
 
 	switch (param) {
 	case VB2_SECDATA_FIRMWARE_FLAGS:
 		/* Make sure flags is in valid range */
-		if (value > 0xff)
-			return VB2_ERROR_SECDATA_FIRMWARE_SET_FLAGS;
+		if (value > 0xff) {
+			msg = "flags out of range";
+			goto fail;
+		}
 
 		VB2_DEBUG("secdata_firmware flags updated from 0x%x to 0x%x\n",
 			  sec->flags, value);
@@ -134,11 +142,17 @@ vb2_error_t vb2_secdata_firmware_set(struct vb2_context *ctx,
 		break;
 
 	default:
-		return VB2_ERROR_SECDATA_FIRMWARE_SET_PARAM;
+		msg = "invalid param";
+		goto fail;
 	}
 
 	/* Regenerate CRC */
 	sec->crc8 = vb2_crc8(sec, offsetof(struct vb2_secdata_firmware, crc8));
 	ctx->flags |= VB2_CONTEXT_SECDATA_FIRMWARE_CHANGED;
-	return VB2_SUCCESS;
+	return;
+
+ fail:
+	if (!(ctx->flags & VB2_CONTEXT_RECOVERY_MODE))
+		VB2_DIE("%s\n", msg);
+	VB2_DEBUG("ERROR [%s] ignored in recovery mode\n", msg);
 }
diff --git a/firmware/2lib/2secdata_kernel.c b/firmware/2lib/2secdata_kernel.c
index 5dbd4dde..2ed177f0 100644
--- a/firmware/2lib/2secdata_kernel.c
+++ b/firmware/2lib/2secdata_kernel.c
@@ -77,43 +77,51 @@ vb2_error_t vb2_secdata_kernel_init(struct vb2_context *ctx)
 	return VB2_SUCCESS;
 }
 
-vb2_error_t vb2_secdata_kernel_get(struct vb2_context *ctx,
-				   enum vb2_secdata_kernel_param param,
-				   uint32_t *dest)
+uint32_t vb2_secdata_kernel_get(struct vb2_context *ctx,
+				enum vb2_secdata_kernel_param param)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	struct vb2_secdata_kernel *sec =
 		(struct vb2_secdata_kernel *)ctx->secdata_kernel;
+	const char *msg;
 
-	if (!(sd->status & VB2_SD_STATUS_SECDATA_KERNEL_INIT))
-		return VB2_ERROR_SECDATA_KERNEL_GET_UNINITIALIZED;
+	if (!(sd->status & VB2_SD_STATUS_SECDATA_KERNEL_INIT)) {
+		msg = "get before init";
+		goto fail;
+	}
 
 	switch (param) {
 	case VB2_SECDATA_KERNEL_VERSIONS:
-		*dest = sec->kernel_versions;
-		return VB2_SUCCESS;
+		return sec->kernel_versions;
 
 	default:
-		return VB2_ERROR_SECDATA_KERNEL_GET_PARAM;
+		msg = "invalid param";
 	}
+
+ fail:
+	if (!(ctx->flags & VB2_CONTEXT_RECOVERY_MODE))
+		VB2_DIE("%s\n", msg);
+	VB2_DEBUG("ERROR [%s] ignored in recovery mode\n", msg);
+	return 0;
 }
 
-vb2_error_t vb2_secdata_kernel_set(struct vb2_context *ctx,
-				   enum vb2_secdata_kernel_param param,
-				   uint32_t value)
+void vb2_secdata_kernel_set(struct vb2_context *ctx,
+			    enum vb2_secdata_kernel_param param,
+			    uint32_t value)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	struct vb2_secdata_kernel *sec =
 		(struct vb2_secdata_kernel *)ctx->secdata_kernel;
-	uint32_t now;
+	const char *msg;
 
-	if (!(sd->status & VB2_SD_STATUS_SECDATA_KERNEL_INIT))
-		return VB2_ERROR_SECDATA_KERNEL_SET_UNINITIALIZED;
+	if (!(sd->status & VB2_SD_STATUS_SECDATA_KERNEL_INIT)) {
+		msg = "set before init";
+		goto fail;
+	}
 
-	/* If not changing the value, don't regenerate the CRC */
-	if (vb2_secdata_kernel_get(ctx, param, &now) == VB2_SUCCESS &&
-	    now == value)
-		return VB2_SUCCESS;
+	/* If not changing the value, just return early */
+	if (value == vb2_secdata_kernel_get(ctx, param))
+		return;
 
 	switch (param) {
 	case VB2_SECDATA_KERNEL_VERSIONS:
@@ -123,11 +131,17 @@ vb2_error_t vb2_secdata_kernel_set(struct vb2_context *ctx,
 		break;
 
 	default:
-		return VB2_ERROR_SECDATA_KERNEL_SET_PARAM;
+		msg = "invalid param";
+		goto fail;
 	}
 
 	/* Regenerate CRC */
 	sec->crc8 = vb2_crc8(sec, offsetof(struct vb2_secdata_kernel, crc8));
 	ctx->flags |= VB2_CONTEXT_SECDATA_KERNEL_CHANGED;
-	return VB2_SUCCESS;
+	return;
+
+ fail:
+	if (!(ctx->flags & VB2_CONTEXT_RECOVERY_MODE))
+		VB2_DIE("%s\n", msg);
+	VB2_DEBUG("ERROR [%s] ignored in recovery mode\n", msg);
 }
diff --git a/firmware/2lib/include/2api.h b/firmware/2lib/include/2api.h
index 982d4772..9aa031a9 100644
--- a/firmware/2lib/include/2api.h
+++ b/firmware/2lib/include/2api.h
@@ -126,7 +126,7 @@ enum vb2_context_flags {
 	VB2_CONTEXT_NOFAIL_BOOT = (1 << 12),
 
 	/*
-	 * Secdata is not ready this boot, but should be ready next boot.  It
+	 * secdata is not ready this boot, but should be ready next boot.  It
 	 * would like to reboot.  The decision whether to reboot or not must be
 	 * deferred until vboot, because rebooting all the time before then
 	 * could cause a device with malfunctioning secdata to get stuck in an
diff --git a/firmware/2lib/include/2return_codes.h b/firmware/2lib/include/2return_codes.h
index ed34109e..fa0ed3b7 100644
--- a/firmware/2lib/include/2return_codes.h
+++ b/firmware/2lib/include/2return_codes.h
@@ -160,20 +160,25 @@ enum vb2_return_code {
 	/* Bad struct version in vb2api_secdata_firmware_check() */
 	VB2_ERROR_SECDATA_FIRMWARE_VERSION,
 
-	/* Invalid param in vb2_secdata_firmware_get() */
-	VB2_ERROR_SECDATA_FIRMWARE_GET_PARAM,
+	/* Invalid param in vb2_secdata_firmware_get();
+	   Deprecated with chromium:972956. */
+	VB2_ERROR_DEPRECATED_SECDATA_FIRMWARE_GET_PARAM,
 
-	/* Invalid param in vb2_secdata_firmware_set() */
-	VB2_ERROR_SECDATA_FIRMWARE_SET_PARAM,
+	/* Invalid param in vb2_secdata_firmware_set();
+	   Deprecated with chromium:972956. */
+	VB2_ERROR_DEPRECATED_SECDATA_FIRMWARE_SET_PARAM,
 
-	/* Invalid flags passed to vb2_secdata_firmware_set() */
-	VB2_ERROR_SECDATA_FIRMWARE_SET_FLAGS,
+	/* Invalid flags passed to vb2_secdata_firmware_set();
+	   Deprecated with chromium:972956. */
+	VB2_ERROR_DEPRECATED_SECDATA_FIRMWARE_SET_FLAGS,
 
-	/* Called vb2_secdata_firmware_get() with uninitialized secdata */
-	VB2_ERROR_SECDATA_FIRMWARE_GET_UNINITIALIZED,
+	/* Called vb2_secdata_firmware_get() with uninitialized secdata;
+	   Deprecated with chromium:972956. */
+	VB2_ERROR_DEPRECATED_SECDATA_FIRMWARE_GET_UNINITIALIZED,
 
-	/* Called vb2_secdata_firmware_set() with uninitialized secdata */
-	VB2_ERROR_SECDATA_FIRMWARE_SET_UNINITIALIZED,
+	/* Called vb2_secdata_firmware_set() with uninitialized secdata;
+	   Deprecated with chromium:972956. */
+	VB2_ERROR_DEPRECATED_SECDATA_FIRMWARE_SET_UNINITIALIZED,
 
 	/* Bad CRC in vb2api_secdata_kernel_check() */
 	VB2_ERROR_SECDATA_KERNEL_CRC,
@@ -184,20 +189,25 @@ enum vb2_return_code {
 	/* Bad uid in vb2_secdata_kernel_init() */
 	VB2_ERROR_SECDATA_KERNEL_UID,
 
-	/* Invalid param in vb2_secdata_kernel_get() */
-	VB2_ERROR_SECDATA_KERNEL_GET_PARAM,
+	/* Invalid param in vb2_secdata_kernel_get();
+	   Deprecated with chromium:972956. */
+	VB2_ERROR_DEPRECATED_SECDATA_KERNEL_GET_PARAM,
 
-	/* Invalid param in vb2_secdata_kernel_set() */
-	VB2_ERROR_SECDATA_KERNEL_SET_PARAM,
+	/* Invalid param in vb2_secdata_kernel_set();
+	   Deprecated with chromium:972956. */
+	VB2_ERROR_DEPRECATED_SECDATA_KERNEL_SET_PARAM,
 
-	/* Invalid flags passed to vb2_secdata_kernel_set() */
-	VB2_ERROR_SECDATA_KERNEL_SET_FLAGS,
+	/* Invalid flags passed to vb2_secdata_kernel_set();
+	   Deprecated with chromium:972956. */
+	VB2_ERROR_DEPRECATED_SECDATA_KERNEL_SET_FLAGS,
 
-	/* Called vb2_secdata_kernel_get() with uninitialized secdata_kernel */
-	VB2_ERROR_SECDATA_KERNEL_GET_UNINITIALIZED,
+	/* Called vb2_secdata_kernel_get() with uninitialized secdata_kernel;
+	   Deprecated with chromium:972956. */
+	VB2_ERROR_DEPRECATED_SECDATA_KERNEL_GET_UNINITIALIZED,
 
-	/* Called vb2_secdata_kernel_set() with uninitialized secdata_kernel */
-	VB2_ERROR_SECDATA_KERNEL_SET_UNINITIALIZED,
+	/* Called vb2_secdata_kernel_set() with uninitialized secdata_kernel;
+	   Deprecated with chromium:972956. */
+	VB2_ERROR_DEPRECATED_SECDATA_KERNEL_SET_UNINITIALIZED,
 
 	/* Bad size in vb2api_secdata_fwmp_check() */
 	VB2_ERROR_SECDATA_FWMP_SIZE,
diff --git a/firmware/2lib/include/2secdata.h b/firmware/2lib/include/2secdata.h
index 99b557de..ec119e45 100644
--- a/firmware/2lib/include/2secdata.h
+++ b/firmware/2lib/include/2secdata.h
@@ -54,12 +54,10 @@ vb2_error_t vb2_secdata_firmware_init(struct vb2_context *ctx);
  *
  * @param ctx		Context pointer
  * @param param		Parameter to read
- * @param dest		Destination for value
- * @return VB2_SUCCESS, or non-zero error code if error.
+ * @return Requested parameter value
  */
-vb2_error_t vb2_secdata_firmware_get(struct vb2_context *ctx,
-				     enum vb2_secdata_firmware_param param,
-				     uint32_t *dest);
+uint32_t vb2_secdata_firmware_get(struct vb2_context *ctx,
+				  enum vb2_secdata_firmware_param param);
 
 /**
  * Write a firmware secure storage value.
@@ -67,11 +65,10 @@ vb2_error_t vb2_secdata_firmware_get(struct vb2_context *ctx,
  * @param ctx		Context pointer
  * @param param		Parameter to write
  * @param value		New value
- * @return VB2_SUCCESS, or non-zero error code if error.
  */
-vb2_error_t vb2_secdata_firmware_set(struct vb2_context *ctx,
-				     enum vb2_secdata_firmware_param param,
-				     uint32_t value);
+void vb2_secdata_firmware_set(struct vb2_context *ctx,
+			      enum vb2_secdata_firmware_param param,
+			      uint32_t value);
 
 /*****************************************************************************/
 /* Kernel secure storage space
@@ -101,12 +98,10 @@ vb2_error_t vb2_secdata_kernel_init(struct vb2_context *ctx);
  *
  * @param ctx		Context pointer
  * @param param		Parameter to read
- * @param dest		Destination for value
- * @return VB2_SUCCESS, or non-zero error code if error.
+ * @return Requested parameter value
  */
-vb2_error_t vb2_secdata_kernel_get(struct vb2_context *ctx,
-				   enum vb2_secdata_kernel_param param,
-				   uint32_t *dest);
+uint32_t vb2_secdata_kernel_get(struct vb2_context *ctx,
+				enum vb2_secdata_kernel_param param);
 
 /**
  * Write a kernel secure storage value.
@@ -114,11 +109,10 @@ vb2_error_t vb2_secdata_kernel_get(struct vb2_context *ctx,
  * @param ctx		Context pointer
  * @param param		Parameter to write
  * @param value		New value
- * @return VB2_SUCCESS, or non-zero error code if error.
  */
-vb2_error_t vb2_secdata_kernel_set(struct vb2_context *ctx,
-				   enum vb2_secdata_kernel_param param,
-				   uint32_t value);
+void vb2_secdata_kernel_set(struct vb2_context *ctx,
+			    enum vb2_secdata_kernel_param param,
+			    uint32_t value);
 
 /*****************************************************************************/
 /* Firmware management parameters (FWMP) space */
diff --git a/firmware/lib20/api_kernel.c b/firmware/lib20/api_kernel.c
index 3aad5967..99a4cf7f 100644
--- a/firmware/lib20/api_kernel.c
+++ b/firmware/lib20/api_kernel.c
@@ -27,20 +27,12 @@ vb2_error_t vb2api_kernel_phase1(struct vb2_context *ctx)
 
 	/* Initialize secure kernel data and read version */
 	rv = vb2_secdata_kernel_init(ctx);
-	if (!rv) {
-		rv = vb2_secdata_kernel_get(ctx, VB2_SECDATA_KERNEL_VERSIONS,
-					    &sd->kernel_version_secdata);
-	}
-
-	if (rv) {
-		if (ctx->flags & VB2_CONTEXT_RECOVERY_MODE) {
-			/* Ignore failure to get kernel version in recovery */
-			sd->kernel_version_secdata = 0;
-		} else {
-			vb2api_fail(ctx, VB2_RECOVERY_SECDATA_KERNEL_INIT, rv);
-			return rv;
-		}
+	if (rv && !(ctx->flags & VB2_CONTEXT_RECOVERY_MODE)) {
+		vb2api_fail(ctx, VB2_RECOVERY_SECDATA_KERNEL_INIT, rv);
+		return rv;
 	}
+	sd->kernel_version_secdata =
+		vb2_secdata_kernel_get(ctx, VB2_SECDATA_KERNEL_VERSIONS);
 
 	/* Find the key to use to verify the kernel keyblock */
 	if (ctx->flags & VB2_CONTEXT_RECOVERY_MODE) {
@@ -250,7 +242,6 @@ vb2_error_t vb2api_verify_kernel_data(struct vb2_context *ctx, const void *buf,
 vb2_error_t vb2api_kernel_phase3(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
-	vb2_error_t rv;
 
 	/*
 	 * If the kernel is a newer version than in secure storage, and the
@@ -261,10 +252,8 @@ vb2_error_t vb2api_kernel_phase3(struct vb2_context *ctx)
 	    (sd->flags & VB2_SD_FLAG_KERNEL_SIGNED) &&
 	    !(ctx->flags & VB2_CONTEXT_RECOVERY_MODE) &&
 	    (ctx->flags & VB2_CONTEXT_ALLOW_KERNEL_ROLL_FORWARD)) {
-		rv = vb2_secdata_kernel_set(ctx, VB2_SECDATA_KERNEL_VERSIONS,
+		vb2_secdata_kernel_set(ctx, VB2_SECDATA_KERNEL_VERSIONS,
 					    sd->kernel_version);
-		if (rv)
-			return rv;
 		sd->kernel_version_secdata = sd->kernel_version;
 	}
 
diff --git a/firmware/lib20/misc.c b/firmware/lib20/misc.c
index 330453b2..e6b4d56c 100644
--- a/firmware/lib20/misc.c
+++ b/firmware/lib20/misc.c
@@ -284,12 +284,9 @@ vb2_error_t vb2_load_fw_preamble(struct vb2_context *ctx)
 	if (sd->fw_version > sd->fw_version_secdata &&
 	    sd->last_fw_slot == sd->fw_slot &&
 	    sd->last_fw_result == VB2_FW_RESULT_SUCCESS) {
-
 		sd->fw_version_secdata = sd->fw_version;
-		rv = vb2_secdata_firmware_set(
-			ctx, VB2_SECDATA_FIRMWARE_VERSIONS, sd->fw_version);
-		if (rv)
-			return rv;
+		vb2_secdata_firmware_set(ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
+					 sd->fw_version);
 	}
 
 	/* Keep track of where we put the preamble */
diff --git a/firmware/lib21/misc.c b/firmware/lib21/misc.c
index 08f30d36..df50436d 100644
--- a/firmware/lib21/misc.c
+++ b/firmware/lib21/misc.c
@@ -230,12 +230,9 @@ vb2_error_t vb21_load_fw_preamble(struct vb2_context *ctx)
 	if (sd->fw_version > sd->fw_version_secdata &&
 	    sd->last_fw_slot == sd->fw_slot &&
 	    sd->last_fw_result == VB2_FW_RESULT_SUCCESS) {
-
 		sd->fw_version_secdata = sd->fw_version;
-		rv = vb2_secdata_firmware_set(
-			ctx, VB2_SECDATA_FIRMWARE_VERSIONS, sd->fw_version);
-		if (rv)
-			return rv;
+		vb2_secdata_firmware_set(ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
+					 sd->fw_version);
 	}
 
 	/* Keep track of where we put the preamble */
diff --git a/tests/vb20_api_kernel_tests.c b/tests/vb20_api_kernel_tests.c
index 0e59cc38..fdb890f2 100644
--- a/tests/vb20_api_kernel_tests.c
+++ b/tests/vb20_api_kernel_tests.c
@@ -105,6 +105,10 @@ static void reset_common_data(enum reset_type t)
 		vb2_set_workbuf_used(&ctx, sd->preamble_offset +
 				     sd->preamble_size);
 
+		/* Needed to check that secdata_kernel initialization is
+		   performed by phase1 function. */
+		sd->status &= ~VB2_SD_STATUS_SECDATA_KERNEL_INIT;
+
 	} else if (t == FOR_PHASE2) {
 		struct vb2_signature *sig;
 		struct vb2_digest_context dc;
@@ -275,8 +279,8 @@ static void phase1_tests(void)
 	ctx.secdata_kernel[0] ^= 0x33;
 	TEST_EQ(vb2api_kernel_phase1(&ctx), VB2_ERROR_SECDATA_KERNEL_CRC,
 		"phase1 bad secdata");
-	reset_common_data(FOR_PHASE1);
 
+	reset_common_data(FOR_PHASE1);
 	ctx.secdata_kernel[0] ^= 0x33;
 	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
 	TEST_SUCC(vb2api_kernel_phase1(&ctx), "phase1 bad secdata rec");
@@ -417,37 +421,36 @@ static void phase3_tests(void)
 
 	reset_common_data(FOR_PHASE3);
 	TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 good");
-	vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS, &v);
+	v = vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS);
 	TEST_EQ(v, 0x20004, "  version");
 
 	reset_common_data(FOR_PHASE3);
 	sd->kernel_version = 0x20001;
 	TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 no rollback");
-	vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS, &v);
+	v = vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS);
 	TEST_EQ(v, 0x20002, "  version");
 
 	reset_common_data(FOR_PHASE3);
 	sd->flags &= ~VB2_SD_FLAG_KERNEL_SIGNED;
 	TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 unsigned kernel");
-	vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS, &v);
+	v = vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS);
 	TEST_EQ(v, 0x20002, "  version");
 
 	reset_common_data(FOR_PHASE3);
 	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
 	TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 recovery");
-	vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS, &v);
+	v = vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS);
 	TEST_EQ(v, 0x20002, "  version");
 
 	reset_common_data(FOR_PHASE3);
 	ctx.flags &= ~VB2_CONTEXT_ALLOW_KERNEL_ROLL_FORWARD;
 	TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 no rollforward");
-	vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS, &v);
+	v = vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS);
 	TEST_EQ(v, 0x20002, "  version");
 
 	reset_common_data(FOR_PHASE3);
 	sd->status &= ~VB2_SD_STATUS_SECDATA_KERNEL_INIT;
-	TEST_EQ(vb2api_kernel_phase3(&ctx),
-		VB2_ERROR_SECDATA_KERNEL_SET_UNINITIALIZED, "phase3 set fail");
+	TEST_ABORT(vb2api_kernel_phase3(&ctx), "phase3 set fail");
 }
 
 int main(int argc, char* argv[])
diff --git a/tests/vb20_misc_tests.c b/tests/vb20_misc_tests.c
index 92f6eb18..7eed0867 100644
--- a/tests/vb20_misc_tests.c
+++ b/tests/vb20_misc_tests.c
@@ -367,7 +367,7 @@ static void verify_preamble_tests(void)
 	pre->firmware_version = 3;
 	TEST_SUCC(vb2_load_fw_preamble(&ctx),
 		  "preamble version roll forward");
-	vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS, &v);
+	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 	TEST_EQ(v, 0x20003, "roll forward");
 
 	/* Newer version without result success doesn't roll forward */
@@ -376,7 +376,7 @@ static void verify_preamble_tests(void)
 	sd->last_fw_result = VB2_FW_RESULT_UNKNOWN;
 	TEST_SUCC(vb2_load_fw_preamble(&ctx),
 		  "preamble version no roll forward 1");
-	vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS, &v);
+	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 	TEST_EQ(v, 0x20002, "no roll forward");
 
 	/* Newer version with success but for other slot doesn't roll forward */
@@ -385,7 +385,7 @@ static void verify_preamble_tests(void)
 	sd->last_fw_slot = 1;
 	TEST_SUCC(vb2_load_fw_preamble(&ctx),
 		  "preamble version no roll forward 2");
-	vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS, &v);
+	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 	TEST_EQ(v, 0x20002, "no roll forward");
 }
 
diff --git a/tests/vb21_misc_tests.c b/tests/vb21_misc_tests.c
index 0ad30c34..35ddf0e1 100644
--- a/tests/vb21_misc_tests.c
+++ b/tests/vb21_misc_tests.c
@@ -372,7 +372,7 @@ static void load_preamble_tests(void)
 	pre->fw_version = 3;
 	TEST_SUCC(vb21_load_fw_preamble(&ctx),
 		  "preamble version roll forward");
-	vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS, &v);
+	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 	TEST_EQ(v, 0x20003, "roll forward");
 
 	/* Newer version without result success doesn't roll forward */
@@ -381,7 +381,7 @@ static void load_preamble_tests(void)
 	sd->last_fw_result = VB2_FW_RESULT_UNKNOWN;
 	TEST_SUCC(vb21_load_fw_preamble(&ctx),
 		  "preamble version no roll forward 1");
-	vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS, &v);
+	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 	TEST_EQ(v, 0x20002, "no roll forward");
 
 	/* Newer version with success but for other slot doesn't roll forward */
@@ -390,7 +390,7 @@ static void load_preamble_tests(void)
 	sd->last_fw_slot = 1;
 	TEST_SUCC(vb21_load_fw_preamble(&ctx),
 		  "preamble version no roll forward 2");
-	vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS, &v);
+	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 	TEST_EQ(v, 0x20002, "no roll forward");
 }
 
diff --git a/tests/vb2_misc_tests.c b/tests/vb2_misc_tests.c
index 5e1383cd..2b18b4ee 100644
--- a/tests/vb2_misc_tests.c
+++ b/tests/vb2_misc_tests.c
@@ -399,7 +399,7 @@ static void dev_switch_tests(void)
 				 VB2_SECDATA_FIRMWARE_FLAG_DEV_MODE);
 	TEST_SUCC(vb2_check_dev_switch(&ctx), "to dev mode");
 	TEST_EQ(mock_tpm_clear_called, 1, "  tpm clear");
-	vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS, &v);
+	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS);
 	TEST_EQ(v, (VB2_SECDATA_FIRMWARE_FLAG_DEV_MODE |
 		    VB2_SECDATA_FIRMWARE_FLAG_LAST_BOOT_DEVELOPER),
 		"  last boot developer now");
@@ -410,7 +410,7 @@ static void dev_switch_tests(void)
 				 VB2_SECDATA_FIRMWARE_FLAG_LAST_BOOT_DEVELOPER);
 	TEST_SUCC(vb2_check_dev_switch(&ctx), "from dev mode");
 	TEST_EQ(mock_tpm_clear_called, 1, "  tpm clear");
-	vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS, &v);
+	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS);
 	TEST_EQ(v, 0, "  last boot not developer now");
 
 	/* Disable dev mode */
@@ -430,7 +430,7 @@ static void dev_switch_tests(void)
 	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON;
 	TEST_SUCC(vb2_check_dev_switch(&ctx), "dev on via gbb");
 	TEST_NEQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd in dev");
-	vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS, &v);
+	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS);
 	TEST_EQ(v, VB2_SECDATA_FIRMWARE_FLAG_LAST_BOOT_DEVELOPER,
 		"  doesn't set dev on in secdata_firmware "
 		"but does set last boot dev");
@@ -454,7 +454,7 @@ static void dev_switch_tests(void)
 	TEST_EQ(vb2_check_dev_switch(&ctx),
 		VB2_ERROR_EX_TPM_CLEAR_OWNER, "tpm clear fail");
 	TEST_EQ(mock_tpm_clear_called, 1, "  tpm clear");
-	vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS, &v);
+	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS);
 	TEST_EQ(v, VB2_SECDATA_FIRMWARE_FLAG_LAST_BOOT_DEVELOPER,
 		"  last boot still developer");
 	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
@@ -463,20 +463,18 @@ static void dev_switch_tests(void)
 		(uint8_t)VB2_ERROR_EX_TPM_CLEAR_OWNER, "  recovery subcode");
 
 	/*
-	 * Secdata failure in normal mode fails and shows dev=0 even if dev
-	 * mode was on in the (inaccessible) secdata_firmware.
+	 * secdata_firmware failure in normal mode fails and shows dev=0 even
+	 * if dev mode was on in the (inaccessible) secdata_firmware.
 	 */
 	reset_common_data();
 	vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_FLAGS,
 				 VB2_SECDATA_FIRMWARE_FLAG_DEV_MODE);
 	sd->status &= ~VB2_SD_STATUS_SECDATA_FIRMWARE_INIT;
-	TEST_EQ(vb2_check_dev_switch(&ctx),
-		VB2_ERROR_SECDATA_FIRMWARE_GET_UNINITIALIZED,
-		"secdata_firmware fail normal");
+	TEST_ABORT(vb2_check_dev_switch(&ctx), "secdata_firmware fail normal");
 	TEST_EQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd not in dev");
 	TEST_EQ(ctx.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx not in dev");
 
-	/* Secdata failure in recovery mode continues */
+	/* secdata_firmware failure in recovery mode continues */
 	reset_common_data();
 	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
 	sd->status &= ~VB2_SD_STATUS_SECDATA_FIRMWARE_INIT;
diff --git a/tests/vb2_secdata_firmware_tests.c b/tests/vb2_secdata_firmware_tests.c
index 45e38347..84cb2741 100644
--- a/tests/vb2_secdata_firmware_tests.c
+++ b/tests/vb2_secdata_firmware_tests.c
@@ -99,64 +99,46 @@ static void secdata_firmware_test(void)
 	vb2api_secdata_firmware_create(&ctx);
 	vb2_secdata_firmware_init(&ctx);
 	ctx.flags = 0;
-	TEST_SUCC(vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS,
-					   &v),
-		  "Get flags");
+	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS);
 	TEST_EQ(v, 0, "Flags created 0");
 	test_changed(&ctx, 0, "Get doesn't change data");
-	TEST_SUCC(vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_FLAGS,
-					   0x12),
-		  "Set flags");
+	vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_FLAGS, 0x12);
 	test_changed(&ctx, 1, "Set changes data");
-	TEST_SUCC(vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_FLAGS,
-					   0x12),
-		  "Set flags 2");
+	vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_FLAGS, 0x12);
 	test_changed(&ctx, 0, "Set again doesn't change data");
-	TEST_SUCC(vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS,
-					   &v),
-		  "Get flags 2");
+	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS);
 	TEST_EQ(v, 0x12, "Flags changed");
-	TEST_EQ(vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_FLAGS,
-					 0x100),
-		VB2_ERROR_SECDATA_FIRMWARE_SET_FLAGS, "Bad flags");
+	TEST_ABORT(vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_FLAGS,
+					    0x100),
+		   "Bad flags");
 
 	/* Read/write versions */
-	TEST_SUCC(vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
-					   &v),
-		  "Get versions");
+	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 	TEST_EQ(v, 0, "Versions created 0");
 	test_changed(&ctx, 0, "Get doesn't change data");
-	TEST_SUCC(vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
-					   0x123456ff),
-		  "Set versions");
+	vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
+				 0x123456ff);
 	test_changed(&ctx, 1, "Set changes data");
-	TEST_SUCC(vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
-					   0x123456ff),
-		  "Set versions 2");
+	vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
+				 0x123456ff);
 	test_changed(&ctx, 0, "Set again doesn't change data");
-	TEST_SUCC(vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
-					   &v),
-		  "Get versions 2");
+	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 	TEST_EQ(v, 0x123456ff, "Versions changed");
 
 	/* Invalid field fails */
-	TEST_EQ(vb2_secdata_firmware_get(&ctx, -1, &v),
-		VB2_ERROR_SECDATA_FIRMWARE_GET_PARAM, "Get invalid");
-	TEST_EQ(vb2_secdata_firmware_set(&ctx, -1, 456),
-		VB2_ERROR_SECDATA_FIRMWARE_SET_PARAM, "Set invalid");
+	TEST_ABORT(vb2_secdata_firmware_get(&ctx, -1), "Get invalid");
+	TEST_ABORT(vb2_secdata_firmware_set(&ctx, -1, 456), "Set invalid");
 	test_changed(&ctx, 0, "Set invalid field doesn't change data");
 
 	/* Read/write uninitialized data fails */
 	sd->status &= ~VB2_SD_STATUS_SECDATA_FIRMWARE_INIT;
-	TEST_EQ(vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
-					 &v),
-		VB2_ERROR_SECDATA_FIRMWARE_GET_UNINITIALIZED,
-		"Get uninitialized");
+	TEST_ABORT(vb2_secdata_firmware_get(&ctx,
+					    VB2_SECDATA_FIRMWARE_VERSIONS),
+		   "Get uninitialized");
 	test_changed(&ctx, 0, "Get uninitialized doesn't change data");
-	TEST_EQ(vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
-					 0x123456ff),
-		VB2_ERROR_SECDATA_FIRMWARE_SET_UNINITIALIZED,
-		"Set uninitialized");
+	TEST_ABORT(vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
+					    0x123456ff),
+		   "Set uninitialized");
 	test_changed(&ctx, 0, "Set uninitialized doesn't change data");
 }
 
diff --git a/tests/vb2_secdata_kernel_tests.c b/tests/vb2_secdata_kernel_tests.c
index d2abe10d..89184d99 100644
--- a/tests/vb2_secdata_kernel_tests.c
+++ b/tests/vb2_secdata_kernel_tests.c
@@ -104,39 +104,29 @@ static void secdata_kernel_test(void)
 	vb2api_secdata_kernel_create(&ctx);
 	vb2_secdata_kernel_init(&ctx);
 	ctx.flags = 0;
-	TEST_SUCC(vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS, &v),
-		  "Get versions");
+	v = vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS);
 	TEST_EQ(v, 0, "Versions created 0");
 	test_changed(&ctx, 0, "Get doesn't change data");
-	TEST_SUCC(vb2_secdata_kernel_set(&ctx, VB2_SECDATA_KERNEL_VERSIONS,
-					 0x123456ff),
-		  "Set versions");
+	vb2_secdata_kernel_set(&ctx, VB2_SECDATA_KERNEL_VERSIONS, 0x123456ff);
 	test_changed(&ctx, 1, "Set changes data");
-	TEST_SUCC(vb2_secdata_kernel_set(&ctx, VB2_SECDATA_KERNEL_VERSIONS,
-					 0x123456ff),
-		  "Set versions 2");
+	vb2_secdata_kernel_set(&ctx, VB2_SECDATA_KERNEL_VERSIONS, 0x123456ff);
 	test_changed(&ctx, 0, "Set again doesn't change data");
-	TEST_SUCC(vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS, &v),
-		  "Get versions 2");
+	v = vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS);
 	TEST_EQ(v, 0x123456ff, "Versions changed");
 
 	/* Invalid field fails */
-	TEST_EQ(vb2_secdata_kernel_get(&ctx, -1, &v),
-		VB2_ERROR_SECDATA_KERNEL_GET_PARAM, "Get invalid");
-	TEST_EQ(vb2_secdata_kernel_set(&ctx, -1, 456),
-		VB2_ERROR_SECDATA_KERNEL_SET_PARAM, "Set invalid");
+	TEST_ABORT(vb2_secdata_kernel_get(&ctx, -1), "Get invalid");
+	TEST_ABORT(vb2_secdata_kernel_set(&ctx, -1, 456), "Set invalid");
 	test_changed(&ctx, 0, "Set invalid field doesn't change data");
 
 	/* Read/write uninitialized data fails */
 	sd->status &= ~VB2_SD_STATUS_SECDATA_KERNEL_INIT;
-	TEST_EQ(vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS, &v),
-		VB2_ERROR_SECDATA_KERNEL_GET_UNINITIALIZED,
-		"Get uninitialized");
+	TEST_ABORT(vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS),
+		   "Get uninitialized");
 	test_changed(&ctx, 0, "Get uninitialized doesn't change data");
-	TEST_EQ(vb2_secdata_kernel_set(&ctx, VB2_SECDATA_KERNEL_VERSIONS,
-				       0x123456ff),
-		VB2_ERROR_SECDATA_KERNEL_SET_UNINITIALIZED,
-		"Set uninitialized");
+	TEST_ABORT(vb2_secdata_kernel_set(&ctx, VB2_SECDATA_KERNEL_VERSIONS,
+					  0x123456ff),
+		   "Set uninitialized");
 	test_changed(&ctx, 0, "Set uninitialized doesn't change data");
 }