vboot/secdata: remove retries from rollback functions

Assume that transport-layer communication to Cr50 is reliable.
No need for retries on reads/writes, or verification after write.

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

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

2 files changed, 109 insertions, 315 deletions

diff --git a/firmware/lib/rollback_index.c b/firmware/lib/rollback_index.c
index 663d50c1..3201c8e8 100644
--- a/firmware/lib/rollback_index.c
+++ b/firmware/lib/rollback_index.c
@@ -9,12 +9,9 @@
 #include "2sysincludes.h"
 #include "2common.h"
 #include "2crc8.h"
-
-#include "sysincludes.h"
 #include "rollback_index.h"
 #include "tlcl.h"
 #include "tss_constants.h"
-#include "utility.h"
 #include "vboot_api.h"
 
 #ifndef offsetof
@@ -75,72 +72,40 @@ uint32_t SafeWrite(uint32_t index, const void *data, uint32_t length)
 uint32_t ReadSpaceFirmware(RollbackSpaceFirmware *rsf)
 {
 	uint32_t r;
-	int attempts = 3;
-
-	while (attempts--) {
-		r = TlclRead(FIRMWARE_NV_INDEX, rsf,
-			     sizeof(RollbackSpaceFirmware));
-		if (r != TPM_SUCCESS)
-			return r;
 
-		/*
-		 * No CRC in this version, so we'll create one when we write
-		 * it. Note that we're marking this as version 2, not
-		 * ROLLBACK_SPACE_FIRMWARE_VERSION, because version 2 just
-		 * added the CRC. Later versions will need to set default
-		 * values for any extra fields explicitly (probably here).
-		 */
-		if (rsf->struct_version < 2) {
-			/* Danger Will Robinson! Danger! */
-			rsf->struct_version = 2;
-			return TPM_SUCCESS;
-		}
+	r = TlclRead(FIRMWARE_NV_INDEX, rsf, sizeof(RollbackSpaceFirmware));
+	if (TPM_SUCCESS != r)
+		return r;
 
-		/*
-		 * If the CRC is good, we're done. If it's bad, try a couple
-		 * more times to see if it gets better before we give up. It
-		 * could just be noise.
-		 */
-		if (rsf->crc8 == vb2_crc8(rsf,
-				      offsetof(RollbackSpaceFirmware, crc8)))
-			return TPM_SUCCESS;
+	/*
+	 * No CRC in this version, so we'll create one when we write
+	 * it. Note that we're marking this as version 2, not
+	 * ROLLBACK_SPACE_FIRMWARE_VERSION, because version 2 just
+	 * added the CRC. Later versions will need to set default
+	 * values for any extra fields explicitly (probably here).
+	 */
+	if (rsf->struct_version < 2) {
+		/* Danger Will Robinson! Danger! */
+		rsf->struct_version = 2;
+		return TPM_SUCCESS;
+	}
 
+	if (rsf->crc8 != vb2_crc8(rsf, offsetof(RollbackSpaceFirmware, crc8))) {
 		VB2_DEBUG("TPM: bad CRC\n");
+		return TPM_E_CORRUPTED_STATE;
 	}
 
-	VB2_DEBUG("TPM: too many bad CRCs, giving up\n");
-	return TPM_E_CORRUPTED_STATE;
+	return TPM_SUCCESS;
 }
 
 uint32_t WriteSpaceFirmware(RollbackSpaceFirmware *rsf)
 {
-	RollbackSpaceFirmware rsf2;
-	uint32_t r;
-	int attempts = 3;
-
 	/* All writes should use struct_version 2 or greater. */
 	if (rsf->struct_version < 2)
 		rsf->struct_version = 2;
 	rsf->crc8 = vb2_crc8(rsf, offsetof(RollbackSpaceFirmware, crc8));
 
-	while (attempts--) {
-		r = SafeWrite(FIRMWARE_NV_INDEX, rsf,
-			      sizeof(RollbackSpaceFirmware));
-		/* Can't write, not gonna try again */
-		if (r != TPM_SUCCESS)
-			return r;
-
-		/* Read it back to be sure it got the right values. */
-		r = ReadSpaceFirmware(&rsf2);    /* This checks the CRC */
-		if (r == TPM_SUCCESS)
-			return r;
-
-		VB2_DEBUG("TPM: bad CRC\n");
-		/* Try writing it again. Maybe it was garbled on the way out. */
-	}
-
-	VB2_DEBUG("TPM: too many bad CRCs, giving up\n");
-	return TPM_E_CORRUPTED_STATE;
+	return SafeWrite(FIRMWARE_NV_INDEX, rsf, sizeof(RollbackSpaceFirmware));
 }
 
 vb2_error_t SetVirtualDevMode(int val)
@@ -172,71 +137,40 @@ vb2_error_t SetVirtualDevMode(int val)
 uint32_t ReadSpaceKernel(RollbackSpaceKernel *rsk)
 {
 	uint32_t r;
-	int attempts = 3;
-
-	while (attempts--) {
-		r = TlclRead(KERNEL_NV_INDEX, rsk, sizeof(RollbackSpaceKernel));
-		if (r != TPM_SUCCESS)
-			return r;
 
-		/*
-		 * No CRC in this version, so we'll create one when we write
-		 * it. Note that we're marking this as version 2, not
-		 * ROLLBACK_SPACE_KERNEL_VERSION, because version 2 just added
-		 * the CRC. Later versions will need to set default values for
-		 * any extra fields explicitly (probably here).
-		 */
-		if (rsk->struct_version < 2) {
-			/* Danger Will Robinson! Danger! */
-			rsk->struct_version = 2;
-			return TPM_SUCCESS;
-		}
+	r = TlclRead(KERNEL_NV_INDEX, rsk, sizeof(RollbackSpaceKernel));
+	if (TPM_SUCCESS != r)
+		return r;
 
-		/*
-		 * If the CRC is good, we're done. If it's bad, try a couple
-		 * more times to see if it gets better before we give up. It
-		 * could just be noise.
-		 */
-		if (rsk->crc8 ==
-		    vb2_crc8(rsk, offsetof(RollbackSpaceKernel, crc8)))
-			return TPM_SUCCESS;
+	/*
+	 * No CRC in this version, so we'll create one when we write
+	 * it. Note that we're marking this as version 2, not
+	 * ROLLBACK_SPACE_KERNEL_VERSION, because version 2 just added
+	 * the CRC. Later versions will need to set default values for
+	 * any extra fields explicitly (probably here).
+	 */
+	if (rsk->struct_version < 2) {
+		/* Danger Will Robinson! Danger! */
+		rsk->struct_version = 2;
+		return TPM_SUCCESS;
+	}
 
+	if (rsk->crc8 != vb2_crc8(rsk, offsetof(RollbackSpaceKernel, crc8))) {
 		VB2_DEBUG("TPM: bad CRC\n");
+		return TPM_E_CORRUPTED_STATE;
 	}
 
-	VB2_DEBUG("TPM: too many bad CRCs, giving up\n");
-	return TPM_E_CORRUPTED_STATE;
+	return TPM_SUCCESS;
 }
 
 uint32_t WriteSpaceKernel(RollbackSpaceKernel *rsk)
 {
-	RollbackSpaceKernel rsk2;
-	uint32_t r;
-	int attempts = 3;
-
 	/* All writes should use struct_version 2 or greater. */
 	if (rsk->struct_version < 2)
 		rsk->struct_version = 2;
 	rsk->crc8 = vb2_crc8(rsk, offsetof(RollbackSpaceKernel, crc8));
 
-	while (attempts--) {
-		r = SafeWrite(KERNEL_NV_INDEX, rsk,
-			      sizeof(RollbackSpaceKernel));
-		/* Can't write, not gonna try again */
-		if (r != TPM_SUCCESS)
-			return r;
-
-		/* Read it back to be sure it got the right values. */
-		r = ReadSpaceKernel(&rsk2);    /* This checks the CRC */
-		if (r == TPM_SUCCESS)
-			return r;
-
-		VB2_DEBUG("TPM: bad CRC\n");
-		/* Try writing it again. Maybe it was garbled on the way out. */
-	}
-
-	VB2_DEBUG("TPM: too many bad CRCs, giving up\n");
-	return TPM_E_CORRUPTED_STATE;
+	return SafeWrite(KERNEL_NV_INDEX, rsk, sizeof(RollbackSpaceKernel));
 }
 
 #ifdef DISABLE_ROLLBACK_TPM
@@ -337,67 +271,61 @@ uint32_t RollbackFwmpRead(struct RollbackSpaceFwmp *fwmp)
 		struct RollbackSpaceFwmp bf;
 	} u;
 	uint32_t r;
-	int attempts = 3;
 
 	/* Clear destination in case error or FWMP not present */
 	memset(fwmp, 0, sizeof(*fwmp));
 
-	while (attempts--) {
-		/* Try to read entire 1.0 struct */
-		r = TlclRead(FWMP_NV_INDEX, u.buf, sizeof(u.bf));
-		if (r == TPM_E_BADINDEX) {
-			/* Missing space is not an error; use defaults */
-			VB2_DEBUG("TPM: no FWMP space\n");
-			return TPM_SUCCESS;
-		} else if (r != TPM_SUCCESS) {
-			VB2_DEBUG("TPM: read returned 0x%x\n", r);
-			return r;
-		}
+	/* Try to read entire 1.0 struct */
+	r = TlclRead(FWMP_NV_INDEX, u.buf, sizeof(u.bf));
+	if (TPM_E_BADINDEX == r) {
+		/* Missing space is not an error; use defaults */
+		VB2_DEBUG("TPM: no FWMP space\n");
+		return TPM_SUCCESS;
+	} else if (TPM_SUCCESS != r) {
+		VB2_DEBUG("TPM: read returned 0x%x\n", r);
+		return r;
+	}
 
-		/*
-		 * Struct must be at least big enough for 1.0, but not bigger
-		 * than our buffer size.
-		 */
-		if (u.bf.struct_size < sizeof(u.bf) ||
-		    u.bf.struct_size > sizeof(u.buf))
-			return TPM_E_STRUCT_SIZE;
+	/*
+	 * Struct must be at least big enough for 1.0, but not bigger
+	 * than our buffer size.
+	 */
+	if (u.bf.struct_size < sizeof(u.bf) ||
+	    u.bf.struct_size > sizeof(u.buf))
+		return TPM_E_STRUCT_SIZE;
 
-		/*
-		 * If space is bigger than we expect, re-read so we properly
-		 * compute the CRC.
-		 */
-		if (u.bf.struct_size > sizeof(u.bf)) {
-			r = TlclRead(FWMP_NV_INDEX, u.buf, u.bf.struct_size);
-			if (r != TPM_SUCCESS)
-				return r;
-		}
-
-		/* Verify CRC */
-		if (u.bf.crc != vb2_crc8(u.buf + 2, u.bf.struct_size - 2)) {
-			VB2_DEBUG("TPM: bad CRC\n");
-			continue;
-		}
-
-		/* Verify major version is compatible */
-		if ((u.bf.struct_version >> 4) !=
-		    (ROLLBACK_SPACE_FWMP_VERSION >> 4))
-			return TPM_E_STRUCT_VERSION;
+	/*
+	 * If space is bigger than we expect, re-read so we properly
+	 * compute the CRC.
+	 */
+	if (u.bf.struct_size > sizeof(u.bf)) {
+		r = TlclRead(FWMP_NV_INDEX, u.buf, u.bf.struct_size);
+		if (TPM_SUCCESS != r)
+			return r;
+	}
 
-		/*
-		 * Copy to destination.  Note that if the space is bigger than
-		 * we expect (due to a minor version change), we only copy the
-		 * part of the FWMP that we know what to do with.
-		 *
-		 * If this were a 1.1+ reader and the source was a 1.0 struct,
-		 * we would need to take care of initializing the extra fields
-		 * added in 1.1+.  But that's not an issue yet.
-		 */
-		memcpy(fwmp, &u.bf, sizeof(*fwmp));
-		return TPM_SUCCESS;
+	/* Verify CRC */
+	if (u.bf.crc != vb2_crc8(u.buf + 2, u.bf.struct_size - 2)) {
+		VB2_DEBUG("TPM: bad CRC\n");
+		return TPM_E_CORRUPTED_STATE;
 	}
 
-	VB2_DEBUG("TPM: too many bad CRCs, giving up\n");
-	return TPM_E_CORRUPTED_STATE;
+	/* Verify major version is compatible */
+	if ((u.bf.struct_version >> 4) !=
+	    (ROLLBACK_SPACE_FWMP_VERSION >> 4))
+		return TPM_E_STRUCT_VERSION;
+
+	/*
+	 * Copy to destination.  Note that if the space is bigger than
+	 * we expect (due to a minor version change), we only copy the
+	 * part of the FWMP that we know what to do with.
+	 *
+	 * If this were a 1.1+ reader and the source was a 1.0 struct,
+	 * we would need to take care of initializing the extra fields
+	 * added in 1.1+.  But that's not an issue yet.
+	 */
+	memcpy(fwmp, &u.bf, sizeof(*fwmp));
+	return TPM_SUCCESS;
 }
 
 #endif /* DISABLE_ROLLBACK_TPM */
diff --git a/tests/rollback_index2_tests.c b/tests/rollback_index2_tests.c
index 290f69eb..daf55e6c 100644
--- a/tests/rollback_index2_tests.c
+++ b/tests/rollback_index2_tests.c
@@ -14,8 +14,6 @@
 #include "rollback_index.h"
 #include "test_common.h"
 #include "tlcl.h"
-#include "utility.h"
-#include "vboot_common.h"
 
 /*
  * Buffer to hold accumulated list of calls to mocked Tlcl functions.
@@ -42,11 +40,6 @@ static int mock_count = 0;
 static int fail_at_count = 0;
 static uint32_t fail_with_error = TPM_SUCCESS;
 
-/* Similar, to determine when to inject noise during reads & writes */
-#define MAX_NOISE_COUNT 64              /* no noise after this many */
-static int noise_count = 0;             /* read/write attempt (zero-based) */
-static int noise_on[MAX_NOISE_COUNT];   /* calls to inject noise on */
-
 /* Params / backing store for mocked Tlcl functions. */
 static TPM_PERMANENT_FLAGS mock_pflags;
 static RollbackSpaceFirmware mock_rsf;
@@ -74,8 +67,6 @@ static void ResetMocks(int fail_on_call, uint32_t fail_with_err)
 	mock_count = 0;
 	fail_at_count = fail_on_call;
 	fail_with_error = fail_with_err;
-	noise_count = 0;
-	memset(&noise_on, 0, sizeof(noise_on));
 
 	memset(&mock_pflags, 0, sizeof(mock_pflags));
 	memset(&mock_rsf, 0, sizeof(mock_rsf));
@@ -93,17 +84,6 @@ static void ResetMocks(int fail_on_call, uint32_t fail_with_err)
 }
 
 /****************************************************************************/
-/* Function to garble data on its way to or from the TPM */
-static void MaybeInjectNoise(void *data, uint32_t length)
-{
-	if (noise_count < MAX_NOISE_COUNT && noise_on[noise_count]) {
-		uint8_t *val = data;
-		val[length - 1]++;
-	}
-	noise_count++;
-}
-
-/****************************************************************************/
 /* Mocks for tlcl functions which log the calls made to mock_calls[]. */
 
 uint32_t TlclLibInit(void)
@@ -150,17 +130,14 @@ uint32_t TlclRead(uint32_t index, void* data, uint32_t length)
 	if (FIRMWARE_NV_INDEX == index) {
 		TEST_EQ(length, sizeof(mock_rsf), "TlclRead rsf size");
 		memcpy(data, &mock_rsf, length);
-		MaybeInjectNoise(data, length);
 	} else if (KERNEL_NV_INDEX == index) {
 		TEST_EQ(length, sizeof(mock_rsk), "TlclRead rsk size");
 		memcpy(data, &mock_rsk, length);
-		MaybeInjectNoise(data, length);
 	} else if (FWMP_NV_INDEX == index) {
 		memset(data, 0, length);
 		if (length > sizeof(mock_fwmp))
 			length = sizeof(mock_fwmp);
 		memcpy(data, &mock_fwmp, length);
-		MaybeInjectNoise(data, length);
 	} else {
 		memset(data, 0, length);
 	}
@@ -176,11 +153,9 @@ uint32_t TlclWrite(uint32_t index, const void *data, uint32_t length)
 	if (FIRMWARE_NV_INDEX == index) {
 		TEST_EQ(length, sizeof(mock_rsf), "TlclWrite rsf size");
 		memcpy(&mock_rsf, data, length);
-		MaybeInjectNoise(&mock_rsf, length);
 	} else if (KERNEL_NV_INDEX == index) {
 		TEST_EQ(length, sizeof(mock_rsk), "TlclWrite rsk size");
 		memcpy(&mock_rsk, data, length);
-		MaybeInjectNoise(&mock_rsk, length);
 	}
 
 	return (++mock_count == fail_at_count) ? fail_with_error : TPM_SUCCESS;
@@ -269,38 +244,38 @@ static void CrcTestFirmware(void)
 {
 	RollbackSpaceFirmware rsf;
 
-	/* Noise on reading, shouldn't matter here because version == 0 */
+	/* Empty structure, so CRC is valid */
 	ResetMocks(0, 0);
-	noise_on[0] = 1;
 	TEST_EQ(ReadSpaceFirmware(&rsf), 0, "ReadSpaceFirmware(), v0");
 	TEST_STR_EQ(mock_calls,
 		    "TlclRead(0x1007, 10)\n",
 		    "tlcl calls");
 
-	/*
-	 * But if the version >= 2, it will try three times and fail because
-	 * the CRC is no good.
-	 */
+	/* version == 1 without CRC value gets silently updated */
+	ResetMocks(0, 0);
+	mock_rsf.struct_version = 1;
+	TEST_EQ(ReadSpaceFirmware(&rsf), 0, "ReadSpaceFirmware(), v1");
+	TEST_STR_EQ(mock_calls,
+		    "TlclRead(0x1007, 10)\n",
+		    "tlcl calls");
+
+	/* If version == 2, CRC is no longer valid */
 	ResetMocks(0, 0);
 	mock_rsf.struct_version = 2;
 	TEST_EQ(ReadSpaceFirmware(&rsf), TPM_E_CORRUPTED_STATE,
 		"ReadSpaceFirmware(), v2, bad CRC");
 	TEST_STR_EQ(mock_calls,
-		    "TlclRead(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n"
 		    "TlclRead(0x1007, 10)\n",
 		    "tlcl calls");
 
-	/* If the CRC is good and some noise happens, it should recover. */
+	/* Version set with valid CRC */
 	ResetMocks(0, 0);
 	mock_rsf.struct_version = 2;
 	mock_rsf.crc8 = vb2_crc8(&mock_rsf,
 				 offsetof(RollbackSpaceFirmware, crc8));
-	noise_on[0] = 1;
 	TEST_EQ(ReadSpaceFirmware(&rsf), 0,
 		"ReadSpaceFirmware(), v2, good CRC");
 	TEST_STR_EQ(mock_calls,
-		    "TlclRead(0x1007, 10)\n"
 		    "TlclRead(0x1007, 10)\n",
 		    "tlcl calls");
 
@@ -310,59 +285,7 @@ static void CrcTestFirmware(void)
 	TEST_EQ(WriteSpaceFirmware(&rsf), 0, "WriteSpaceFirmware(), v0");
 	TEST_EQ(mock_rsf.struct_version, 2, "WriteSpaceFirmware(), check v2");
 	TEST_STR_EQ(mock_calls,
-		    "TlclWrite(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n",
-		    "tlcl calls");
-
-	/* Same as above, but with some noise during the readback */
-	ResetMocks(0, 0);
-	memset(&rsf, 0, sizeof(rsf));
-	noise_on[1] = 1;
-	noise_on[2] = 1;
-	TEST_EQ(WriteSpaceFirmware(&rsf), 0,
-		"WriteSpaceFirmware(), read noise");
-	TEST_STR_EQ(mock_calls,
-		    "TlclWrite(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n",
-		    "tlcl calls");
-
-	/* With noise during the write, we'll try the write again */
-	ResetMocks(0, 0);
-	memset(&rsf, 0, sizeof(rsf));
-	noise_on[0] = 1;
-	TEST_EQ(WriteSpaceFirmware(&rsf), 0,
-		"WriteSpaceFirmware(), write noise");
-	TEST_EQ(mock_rsf.struct_version, 2, "WriteSpaceFirmware(), check v2");
-	TEST_STR_EQ(mock_calls,
-		    "TlclWrite(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n"
-		    "TlclWrite(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n",
-		    "tlcl calls");
-
-	/* Only if it just keeps on failing forever do we eventually give up */
-	ResetMocks(0, 0);
-	memset(&rsf, 0, sizeof(rsf));
-	memset(noise_on, 1, sizeof(noise_on));
-	TEST_EQ(WriteSpaceFirmware(&rsf), TPM_E_CORRUPTED_STATE,
-		"WriteSpaceFirmware(), always noise");
-	TEST_STR_EQ(mock_calls,
-		    "TlclWrite(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n"
-		    "TlclWrite(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n"
-		    "TlclWrite(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n"
-		    "TlclRead(0x1007, 10)\n",
+		    "TlclWrite(0x1007, 10)\n",
 		    "tlcl calls");
 }
 
@@ -373,37 +296,37 @@ static void CrcTestKernel(void)
 {
 	RollbackSpaceKernel rsk;
 
-	/* Noise on reading shouldn't matter here because version == 0 */
+	/* Empty structure, so CRC is valid */
 	ResetMocks(0, 0);
-	noise_on[0] = 1;
 	TEST_EQ(ReadSpaceKernel(&rsk), 0, "ReadSpaceKernel(), v0");
 	TEST_STR_EQ(mock_calls,
 		    "TlclRead(0x1008, 13)\n",
 		    "tlcl calls");
 
-	/*
-	 * But if the version >= 2, it will try three times and fail because
-	 * the CRC is no good.
-	 */
+	/* version == 1 without CRC value gets silently updated */
+	ResetMocks(0, 0);
+	mock_rsk.struct_version = 1;
+	TEST_EQ(ReadSpaceKernel(&rsk), 0, "ReadSpaceKernel(), v1");
+	TEST_STR_EQ(mock_calls,
+		    "TlclRead(0x1008, 13)\n",
+		    "tlcl calls");
+
+	/* If version == 2, CRC is no longer valid */
 	ResetMocks(0, 0);
 	mock_rsk.struct_version = 2;
 	TEST_EQ(ReadSpaceKernel(&rsk), TPM_E_CORRUPTED_STATE,
 		"ReadSpaceKernel(), v2, bad CRC");
 	TEST_STR_EQ(mock_calls,
-		    "TlclRead(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n"
 		    "TlclRead(0x1008, 13)\n",
 		    "tlcl calls");
 
-	/* If the CRC is good and some noise happens, it should recover. */
+	/* Version set with valid CRC */
 	ResetMocks(0, 0);
 	mock_rsk.struct_version = 2;
 	mock_rsk.crc8 = vb2_crc8(&mock_rsk,
 				 offsetof(RollbackSpaceKernel, crc8));
-	noise_on[0] = 1;
 	TEST_EQ(ReadSpaceKernel(&rsk), 0, "ReadSpaceKernel(), v2, good CRC");
 	TEST_STR_EQ(mock_calls,
-		    "TlclRead(0x1008, 13)\n"
 		    "TlclRead(0x1008, 13)\n",
 		    "tlcl calls");
 
@@ -413,57 +336,7 @@ static void CrcTestKernel(void)
 	TEST_EQ(WriteSpaceKernel(&rsk), 0, "WriteSpaceKernel(), v0");
 	TEST_EQ(mock_rsk.struct_version, 2, "WriteSpaceKernel(), check v2");
 	TEST_STR_EQ(mock_calls,
-		    "TlclWrite(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n",
-		    "tlcl calls");
-
-	/* Same as above, but with some noise during the readback */
-	ResetMocks(0, 0);
-	memset(&rsk, 0, sizeof(rsk));
-	noise_on[1] = 1;
-	noise_on[2] = 1;
-	TEST_EQ(WriteSpaceKernel(&rsk), 0, "WriteSpaceKernel(), read noise");
-	TEST_STR_EQ(mock_calls,
-		    "TlclWrite(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n",
-		    "tlcl calls");
-
-	/* With noise during the write, we'll try the write again */
-	ResetMocks(0, 0);
-	memset(&rsk, 0, sizeof(rsk));
-	noise_on[0] = 1;
-	TEST_EQ(WriteSpaceKernel(&rsk), 0, "WriteSpaceKernel(), write noise");
-	TEST_EQ(mock_rsk.struct_version, 2, "WriteSpaceKernel(), check v2");
-	TEST_STR_EQ(mock_calls,
-		    "TlclWrite(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n"
-		    "TlclWrite(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n",
-		    "tlcl calls");
-
-	/* Only if it just keeps on failing forever do we eventually give up */
-	ResetMocks(0, 0);
-	memset(&rsk, 0, sizeof(rsk));
-	memset(noise_on, 1, sizeof(noise_on));
-	TEST_EQ(WriteSpaceKernel(&rsk), TPM_E_CORRUPTED_STATE,
-		"WriteSpaceKernel(), always noise");
-	TEST_STR_EQ(mock_calls,
-		    "TlclWrite(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n"
-		    "TlclWrite(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n"
-		    "TlclWrite(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n",
+		    "TlclWrite(0x1008, 13)\n",
 		    "tlcl calls");
 }
 
@@ -552,8 +425,7 @@ static void RollbackKernelTest(void)
 		"RollbackKernelWrite() version");
 	TEST_STR_EQ(mock_calls,
 		    "TlclRead(0x1008, 13)\n"
-		    "TlclWrite(0x1008, 13)\n"
-		    "TlclRead(0x1008, 13)\n",
+		    "TlclWrite(0x1008, 13)\n",
 		    "tlcl calls");
 
 	ResetMocks(1, TPM_E_IOERROR);
@@ -633,8 +505,6 @@ static void RollbackFwmpTest(void)
 	TEST_EQ(RollbackFwmpRead(&fwmp), TPM_E_CORRUPTED_STATE,
 		"RollbackFwmpRead() crc");
 	TEST_STR_EQ(mock_calls,
-		    "TlclRead(0x100a, 40)\n"
-		    "TlclRead(0x100a, 40)\n"
 		    "TlclRead(0x100a, 40)\n",
 		    "  tlcl calls");
 
@@ -647,10 +517,6 @@ static void RollbackFwmpTest(void)
 		"RollbackFwmpRead() bigger crc");
 	TEST_STR_EQ(mock_calls,
 		    "TlclRead(0x100a, 40)\n"
-		    "TlclRead(0x100a, 44)\n"
-		    "TlclRead(0x100a, 40)\n"
-		    "TlclRead(0x100a, 44)\n"
-		    "TlclRead(0x100a, 40)\n"
 		    "TlclRead(0x100a, 44)\n",
 		    "  tlcl calls");
 	TEST_EQ(0, memcmp(&fwmp, &fwmp_zero, sizeof(fwmp)), "  data");