From 7ad9f51996d9d950dfbf6c11c82144f7026a68aa Mon Sep 17 00:00:00 2001 From: Joel Kitching Date: Thu, 1 Aug 2019 16:46:41 +0800 Subject: 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 Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/vboot_reference/+/1729713 Tested-by: Joel Kitching Reviewed-by: Julius Werner Commit-Queue: Joel Kitching --- firmware/lib/rollback_index.c | 240 +++++++++++++++--------------------------- tests/rollback_index2_tests.c | 184 +++++--------------------------- 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)); @@ -92,17 +83,6 @@ static void ResetMocks(int fail_on_call, uint32_t fail_with_err) RecalcFwmpCrc(); } -/****************************************************************************/ -/* 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[]. */ @@ -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"); @@ -646,10 +516,6 @@ static void RollbackFwmpTest(void) TEST_EQ(RollbackFwmpRead(&fwmp), TPM_E_CORRUPTED_STATE, "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"); -- cgit v1.2.1