db/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-07-03 00:26:59 +02:00
Code Issues Releases Activity

Remove obsolete function pageChecksumBufferTest().

Browse Source 
This function made validation faster in Perl because fewer calls (and buffer transformations) were required when all checksums were valid.

In C calling pageChecksumTest() directly is just as efficient so there is no longer a need for pageChecksumBufferTest().
This commit is contained in:
David Steele
2020-03-04 14:12:02 -05:00
parent 9d48882268
commit a86253f112
4 changed files with 1 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
src/postgres/pageChecksum.c
View File

@ -206,42 +206,3 @@ pageChecksumTest(
// Checksum is valid if a full page
(pageSize == PG_PAGE_SIZE_DEFAULT && ((PageHeader)page)->pd_checksum == pageChecksum(page, blockNo, pageSize)));
}
/***********************************************************************************************************************************
pageChecksumBufferTest - test if checksums are valid for all pages in a buffer
***********************************************************************************************************************************/
bool
pageChecksumBufferTest(
const unsigned char *pageBuffer, unsigned int pageBufferSize, unsigned int blockNoBegin, unsigned int pageSize,
uint32_t ignoreWalId, uint32_t ignoreWalOffset)
{
FUNCTION_LOG_BEGIN(logLevelTrace);
FUNCTION_LOG_PARAM_P(UCHARDATA, pageBuffer);
FUNCTION_LOG_PARAM(UINT, pageBufferSize);
FUNCTION_LOG_PARAM(UINT, blockNoBegin);
FUNCTION_LOG_PARAM(UINT, pageSize);
FUNCTION_LOG_PARAM(UINT32, ignoreWalId);
FUNCTION_LOG_PARAM(UINT32, ignoreWalOffset);
FUNCTION_LOG_END();
ASSERT(pageBuffer != NULL);
ASSERT(pageBufferSize > 0);
ASSERT(pageBufferSize % pageSize == 0);
bool result = true;
// Loop through all pages in the buffer
for (unsigned int pageIdx = 0; pageIdx < pageBufferSize / pageSize; pageIdx++)
{
const unsigned char *page = pageBuffer + (pageIdx * pageSize);
// Return false if the checksums do not match
if (!pageChecksumTest(page, blockNoBegin + pageIdx, pageSize, ignoreWalId, ignoreWalOffset))
{
result = false;
break;
}
}
FUNCTION_LOG_RETURN(BOOL, result);
}

3
src/postgres/pageChecksum.h
View File

@ -13,8 +13,5 @@ uint16_t pageChecksum(const unsigned char *page, unsigned int blockNo, unsigned
uint64_t pageLsn(const unsigned char *page);
bool pageChecksumTest(
const unsigned char *page, unsigned int blockNo, unsigned int pageSize, uint32_t ignoreWalId, uint32_t ignoreWalOffset);
bool pageChecksumBufferTest(
const unsigned char *pageBuffer, unsigned int pageBufferSize, unsigned int blockNoBegin, unsigned int pageSize,
uint32_t ignoreWalId, uint32_t ignoreWalOffset);
#endif

2
test/define.yaml
View File

@ -323,7 +323,7 @@ unit:
# ----------------------------------------------------------------------------------------------------------------------------
- name: page-checksum
total: 3
total: 2
coverage:
postgres/pageChecksum: full

46
test/src/module/postgres/pageChecksumTest.c
View File

@ -80,51 +80,5 @@ testRun(void)
pageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 0x8889, 0x8889), false, "bad checksum before ignore limit");
}
// *****************************************************************************************************************************
if (testBegin("pageChecksumBufferTest()"))
{
// Check that assertion fails if page buffer and page size are not divisible
TEST_ERROR(
pageChecksumBufferTest(testPage(0), TEST_PAGE_TOTAL * TEST_PAGE_SIZE - 1, 0, TEST_PAGE_SIZE, 0, 0),
AssertError, "assertion 'pageBufferSize % pageSize == 0' failed");
// Create pages that will pass the test (starting with block 0)
for (unsigned int pageIdx = 0; pageIdx < TEST_PAGE_TOTAL; pageIdx++)
{
// Don't fill with zero because zeroes will succeed on the pd_upper check
memset(testPage(pageIdx), 0x77, TEST_PAGE_SIZE);
((PageHeader)testPage(pageIdx))->pd_checksum = pageChecksum(testPage(pageIdx), pageIdx, TEST_PAGE_SIZE);
}
TEST_RESULT_BOOL(
pageChecksumBufferTest(testPage(0), TEST_PAGE_TOTAL * TEST_PAGE_SIZE, 0, TEST_PAGE_SIZE, 0xFFFFFFFF, 0xFFFFFFFF),
true, "valid page buffer starting at block 0");
// Create pages that will pass the test (beginning with block <> 0)
unsigned int blockBegin = 999;
for (unsigned int pageIdx = 0; pageIdx < TEST_PAGE_TOTAL; pageIdx++)
{
((PageHeader)testPage(pageIdx))->pd_checksum = pageChecksum(
testPage(pageIdx), pageIdx + blockBegin, TEST_PAGE_SIZE);
}
TEST_RESULT_BOOL(
pageChecksumBufferTest(
testPage(0), TEST_PAGE_TOTAL * TEST_PAGE_SIZE, blockBegin, TEST_PAGE_SIZE, 0xFFFFFFFF, 0xFFFFFFFF),
true, "valid page buffer starting at block 999");
// Break the checksum for a page and make sure it is found
unsigned int pageInvalid = 7;
ASSERT(pageInvalid < TEST_PAGE_TOTAL);
((PageHeader)testPage(pageInvalid))->pd_checksum = 0xEEEE;
TEST_RESULT_BOOL(
pageChecksumBufferTest(
testPage(0), TEST_PAGE_TOTAL * TEST_PAGE_SIZE, blockBegin, TEST_PAGE_SIZE, 0xFFFFFFFF, 0xFFFFFFFF),
false, "invalid page buffer");
}
FUNCTION_HARNESS_RESULT_VOID();
}