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

Rename old page*() functions to conform to new conventions.

Browse Source 
The general convention now is to prefix PostgreSQL functions with "pg".
This commit is contained in:
David Steele
2020-03-04 14:24:40 -05:00
parent a86253f112
commit 91f321fb86
8 changed files with 30 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lib/pgBackRest/LibCAuto.pm
View File

@ -78,7 +78,7 @@ sub libcAutoExportTag
{
checksum =>
[
'pageChecksum',
'pgPageChecksum',
],
config =>

2
libc/build/lib/pgBackRestLibC/Build.pm
View File

@ -74,7 +74,7 @@ my $rhExport =
'checksum' =>
{
&BLD_EXPORTTYPE_SUB => [qw(
pageChecksum
pgPageChecksum
)],
},

5
libc/xs/postgres/pageChecksum.xs
View File

@ -5,7 +5,7 @@
MODULE = pgBackRest::LibC PACKAGE = pgBackRest::LibC
U16
pageChecksum(page, blockNo, pageSize)
pgPageChecksum(page, blockNo, pageSize)
const char *page
U32 blockNo
U32 pageSize
@ -14,8 +14,7 @@ CODE:
ERROR_XS_BEGIN()
{
RETVAL = pageChecksum(
(const unsigned char *)page, blockNo, pageSize);
RETVAL = pgPageChecksum((const unsigned char *)page, blockNo, pageSize);
}
ERROR_XS_END();
OUTPUT:

4
src/command/backup/pageChecksum.c
View File

@ -99,7 +99,7 @@ pageChecksumProcess(THIS_VOID, const Buffer *input)
unsigned int pageNo = this->pageNoOffset + pageIdx;
size_t pageSize = this->align || pageIdx < pageTotal - 1 ? this->pageSize : pageRemainder;
if (!pageChecksumTest(
if (!pgPageChecksumTest(
pagePtr, pageNo, (unsigned int)pageSize, (unsigned int)(this->lsnLimit >> 32),
(unsigned int)(this->lsnLimit & 0xFFFFFFFF)))
{
@ -112,7 +112,7 @@ pageChecksumProcess(THIS_VOID, const Buffer *input)
// Add page number and lsn to the error list
VariantList *pair = varLstNew();
varLstAdd(pair, varNewUInt(pageNo));
varLstAdd(pair, varNewUInt64(pageLsn(pagePtr)));
varLstAdd(pair, varNewUInt64(pgPageLsn(pagePtr)));
varLstAdd(this->error, varNewVarLst(pair));
}
MEM_CONTEXT_END();

8
src/postgres/pageChecksum.c
View File

@ -142,7 +142,7 @@ The checksum includes the block number (to detect the case where a page is someh
(excluding the checksum itself), and the page data.
***********************************************************************************************************************************/
uint16_t
pageChecksum(const unsigned char *page, unsigned int blockNo, unsigned int pageSize)
pgPageChecksum(const unsigned char *page, unsigned int blockNo, unsigned int pageSize)
{
FUNCTION_TEST_BEGIN();
FUNCTION_TEST_PARAM_P(UCHARDATA, page);
@ -172,7 +172,7 @@ pageChecksum(const unsigned char *page, unsigned int blockNo, unsigned int pageS
Return the lsn for a page
***********************************************************************************************************************************/
uint64_t
pageLsn(const unsigned char *page)
pgPageLsn(const unsigned char *page)
{
FUNCTION_TEST_BEGIN();
FUNCTION_TEST_PARAM_P(UCHARDATA, page);
@ -185,7 +185,7 @@ pageLsn(const unsigned char *page)
pageChecksumTest - test if checksum is valid for a single page
***********************************************************************************************************************************/
bool
pageChecksumTest(
pgPageChecksumTest(
const unsigned char *page, unsigned int blockNo, unsigned int pageSize, uint32_t ignoreWalId, uint32_t ignoreWalOffset)
{
FUNCTION_TEST_BEGIN();
@ -204,5 +204,5 @@ pageChecksumTest(
// LSN is after the backup started so checksum is not tested because pages may be torn
(((PageHeader)page)->pd_lsn.xlogid >= ignoreWalId && ((PageHeader)page)->pd_lsn.xrecoff >= ignoreWalOffset) ||
// Checksum is valid if a full page
(pageSize == PG_PAGE_SIZE_DEFAULT && ((PageHeader)page)->pd_checksum == pageChecksum(page, blockNo, pageSize)));
(pageSize == PG_PAGE_SIZE_DEFAULT && ((PageHeader)page)->pd_checksum == pgPageChecksum(page, blockNo, pageSize)));
}

6
src/postgres/pageChecksum.h
View File

@ -9,9 +9,9 @@ Checksum Implementation for Data Pages
/***********************************************************************************************************************************
Functions
***********************************************************************************************************************************/
uint16_t pageChecksum(const unsigned char *page, unsigned int blockNo, unsigned int pageSize);
uint64_t pageLsn(const unsigned char *page);
bool pageChecksumTest(
uint16_t pgPageChecksum(const unsigned char *page, unsigned int blockNo, unsigned int pageSize);
uint64_t pgPageLsn(const unsigned char *page);
bool pgPageChecksumTest(
const unsigned char *page, unsigned int blockNo, unsigned int pageSize, uint32_t ignoreWalId, uint32_t ignoreWalOffset);
#endif

2
test/lib/pgBackRestTest/Module/Mock/MockAllTest.pm
View File

@ -49,7 +49,7 @@ sub pageBuild
my $iWalOffset = shift;
my $tPage = defined($iWalId) ? pack('I', $iWalId) . pack('I', $iWalOffset) . substr($tPageSource, 8) : $tPageSource;
my $iChecksum = pageChecksum($tPage, $iBlockNo, length($tPage));
my $iChecksum = pgPageChecksum($tPage, $iBlockNo, length($tPage));
return substr($tPage, 0, 8) . pack('S', $iChecksum) . substr($tPage, 10);
}

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

@ -26,23 +26,23 @@ testRun(void)
FUNCTION_HARNESS_VOID();
// *****************************************************************************************************************************
if (testBegin("pageChecksum()"))
if (testBegin("pgPageChecksum()"))
{
// Checksum for 0x00 fill, page 0x00
memset(testPage(0), 0, TEST_PAGE_SIZE);
TEST_RESULT_U16_HEX(pageChecksum(testPage(0), 0, TEST_PAGE_SIZE), 0xC6AA, "check for 0x00 filled page, block 0");
TEST_RESULT_U16_HEX(pgPageChecksum(testPage(0), 0, TEST_PAGE_SIZE), 0xC6AA, "check for 0x00 filled page, block 0");
// Checksum for 0xFF fill, page 0x00
memset(testPage(0), 0xFF, TEST_PAGE_SIZE);
TEST_RESULT_U16_HEX(pageChecksum(testPage(0), 0, TEST_PAGE_SIZE), 0x0E1C, "check for 0xFF filled page, block 0");
TEST_RESULT_U16_HEX(pgPageChecksum(testPage(0), 0, TEST_PAGE_SIZE), 0x0E1C, "check for 0xFF filled page, block 0");
// Checksum for 0xFF fill, page 0xFF
memset(testPage(0), 0xFF, TEST_PAGE_SIZE);
TEST_RESULT_U16_HEX(pageChecksum(testPage(0), 999, TEST_PAGE_SIZE), 0x0EC3, "check for 0xFF filled page, block 999");
TEST_RESULT_U16_HEX(pgPageChecksum(testPage(0), 999, TEST_PAGE_SIZE), 0x0EC3, "check for 0xFF filled page, block 999");
}
// *****************************************************************************************************************************
if (testBegin("pageChecksumTest() and pageLsn()"))
if (testBegin("pgPageChecksumTest() and pgPageLsn()"))
{
// Zero the pages
memset(testPage(0), 0, TEST_PAGE_TOTAL * TEST_PAGE_SIZE);
@ -51,33 +51,33 @@ testRun(void)
*(PageHeader)testPage(pageIdx) = (PageHeaderData){.pd_upper = 0x0};
// Pages with pd_upper = 0 should always return true no matter the block no
TEST_RESULT_BOOL(pageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 0, 0), true, "pd_upper is 0, block 0");
TEST_RESULT_BOOL(pageChecksumTest(testPage(1), 999, TEST_PAGE_SIZE, 0, 0), true, "pd_upper is 0, block 999");
TEST_RESULT_BOOL(pgPageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 0, 0), true, "pd_upper is 0, block 0");
TEST_RESULT_BOOL(pgPageChecksumTest(testPage(1), 999, TEST_PAGE_SIZE, 0, 0), true, "pd_upper is 0, block 999");
// Partial pages are always invalid
*(PageHeader)testPage(0) = (PageHeaderData){.pd_upper = 0x00FF};
((PageHeader)testPage(0))->pd_checksum = pageChecksum(testPage(0), 0, TEST_PAGE_SIZE);
TEST_RESULT_BOOL(pageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 1, 1), true, "valid page");
TEST_RESULT_BOOL(pageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE / 2, 1, 1), false, "invalid partial page");
((PageHeader)testPage(0))->pd_checksum = pgPageChecksum(testPage(0), 0, TEST_PAGE_SIZE);
TEST_RESULT_BOOL(pgPageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 1, 1), true, "valid page");
TEST_RESULT_BOOL(pgPageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE / 2, 1, 1), false, "invalid partial page");
// Update pd_upper and check for failure no matter the block no
*(PageHeader)testPage(0) = (PageHeaderData){.pd_upper = 0x00FF, .pd_checksum = 0};
TEST_RESULT_BOOL(pageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 0xFFFF, 0xFFFF), false, "badchecksum, page 0");
TEST_RESULT_BOOL(pgPageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 0xFFFF, 0xFFFF), false, "badchecksum, page 0");
TEST_RESULT_BOOL(
pageChecksumTest(testPage(0), 9999, TEST_PAGE_SIZE, 0xFFFF, 0xFFFF), false, "badchecksum, page 9999");
pgPageChecksumTest(testPage(0), 9999, TEST_PAGE_SIZE, 0xFFFF, 0xFFFF), false, "badchecksum, page 9999");
// Update LSNs and check that page checksums past the ignore limits are successful
((PageHeader)testPage(0))->pd_lsn.xlogid = 0x8888;
((PageHeader)testPage(0))->pd_lsn.xrecoff = 0x8888;
TEST_RESULT_UINT(pageLsn(testPage(0)), 0x0000888800008888, "check page lsn");
TEST_RESULT_UINT(pgPageLsn(testPage(0)), 0x0000888800008888, "check page lsn");
TEST_RESULT_BOOL(
pageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 0x8888, 0x8888), true, "bad checksum past ignore limit");
pgPageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 0x8888, 0x8888), true, "bad checksum past ignore limit");
TEST_RESULT_BOOL(
pageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 0x8888, 0x8889), false, "bad checksum before ignore limit");
pgPageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 0x8888, 0x8889), false, "bad checksum before ignore limit");
TEST_RESULT_BOOL(
pageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 0x8889, 0x8889), false, "bad checksum before ignore limit");
pgPageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 0x8889, 0x8889), false, "bad checksum before ignore limit");
}
FUNCTION_HARNESS_RESULT_VOID();