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

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 => checksum =>
[ [
'pageChecksum', 'pgPageChecksum',
], ],
config => config =>

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

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

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

@ -5,7 +5,7 @@
MODULE = pgBackRest::LibC PACKAGE = pgBackRest::LibC MODULE = pgBackRest::LibC PACKAGE = pgBackRest::LibC
U16 U16
pageChecksum(page, blockNo, pageSize) pgPageChecksum(page, blockNo, pageSize)
const char *page const char *page
U32 blockNo U32 blockNo
U32 pageSize U32 pageSize
@ -14,8 +14,7 @@ CODE:
ERROR_XS_BEGIN() ERROR_XS_BEGIN()
{ {
RETVAL = pageChecksum( RETVAL = pgPageChecksum((const unsigned char *)page, blockNo, pageSize);
(const unsigned char *)page, blockNo, pageSize);
} }
ERROR_XS_END(); ERROR_XS_END();
OUTPUT: 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; unsigned int pageNo = this->pageNoOffset + pageIdx;
size_t pageSize = this->align || pageIdx < pageTotal - 1 ? this->pageSize : pageRemainder; 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), pagePtr, pageNo, (unsigned int)pageSize, (unsigned int)(this->lsnLimit >> 32),
(unsigned int)(this->lsnLimit & 0xFFFFFFFF))) (unsigned int)(this->lsnLimit & 0xFFFFFFFF)))
{ {
@ -112,7 +112,7 @@ pageChecksumProcess(THIS_VOID, const Buffer *input)
// Add page number and lsn to the error list // Add page number and lsn to the error list
VariantList *pair = varLstNew(); VariantList *pair = varLstNew();
varLstAdd(pair, varNewUInt(pageNo)); varLstAdd(pair, varNewUInt(pageNo));
varLstAdd(pair, varNewUInt64(pageLsn(pagePtr))); varLstAdd(pair, varNewUInt64(pgPageLsn(pagePtr)));
varLstAdd(this->error, varNewVarLst(pair)); varLstAdd(this->error, varNewVarLst(pair));
} }
MEM_CONTEXT_END(); 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. (excluding the checksum itself), and the page data.
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
uint16_t 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_BEGIN();
FUNCTION_TEST_PARAM_P(UCHARDATA, page); 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 Return the lsn for a page
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
uint64_t uint64_t
pageLsn(const unsigned char *page) pgPageLsn(const unsigned char *page)
{ {
FUNCTION_TEST_BEGIN(); FUNCTION_TEST_BEGIN();
FUNCTION_TEST_PARAM_P(UCHARDATA, page); 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 pageChecksumTest - test if checksum is valid for a single page
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
bool bool
pageChecksumTest( pgPageChecksumTest(
const unsigned char *page, unsigned int blockNo, unsigned int pageSize, uint32_t ignoreWalId, uint32_t ignoreWalOffset) const unsigned char *page, unsigned int blockNo, unsigned int pageSize, uint32_t ignoreWalId, uint32_t ignoreWalOffset)
{ {
FUNCTION_TEST_BEGIN(); FUNCTION_TEST_BEGIN();
@ -204,5 +204,5 @@ pageChecksumTest(
// LSN is after the backup started so checksum is not tested because pages may be torn // 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) || (((PageHeader)page)->pd_lsn.xlogid >= ignoreWalId && ((PageHeader)page)->pd_lsn.xrecoff >= ignoreWalOffset) ||
// Checksum is valid if a full page // 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 Functions
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
uint16_t pageChecksum(const unsigned char *page, unsigned int blockNo, unsigned int pageSize); uint16_t pgPageChecksum(const unsigned char *page, unsigned int blockNo, unsigned int pageSize);
uint64_t pageLsn(const unsigned char *page); uint64_t pgPageLsn(const unsigned char *page);
bool pageChecksumTest( bool pgPageChecksumTest(
const unsigned char *page, unsigned int blockNo, unsigned int pageSize, uint32_t ignoreWalId, uint32_t ignoreWalOffset); const unsigned char *page, unsigned int blockNo, unsigned int pageSize, uint32_t ignoreWalId, uint32_t ignoreWalOffset);
#endif #endif

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

@ -49,7 +49,7 @@ sub pageBuild
my $iWalOffset = shift; my $iWalOffset = shift;
my $tPage = defined($iWalId) ? pack('I', $iWalId) . pack('I', $iWalOffset) . substr($tPageSource, 8) : $tPageSource; 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); 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(); FUNCTION_HARNESS_VOID();
// ***************************************************************************************************************************** // *****************************************************************************************************************************
if (testBegin("pageChecksum()")) if (testBegin("pgPageChecksum()"))
{ {
// Checksum for 0x00 fill, page 0x00 // Checksum for 0x00 fill, page 0x00
memset(testPage(0), 0, TEST_PAGE_SIZE); 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 // Checksum for 0xFF fill, page 0x00
memset(testPage(0), 0xFF, TEST_PAGE_SIZE); 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 // Checksum for 0xFF fill, page 0xFF
memset(testPage(0), 0xFF, TEST_PAGE_SIZE); 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 // Zero the pages
memset(testPage(0), 0, TEST_PAGE_TOTAL * TEST_PAGE_SIZE); memset(testPage(0), 0, TEST_PAGE_TOTAL * TEST_PAGE_SIZE);
@ -51,33 +51,33 @@ testRun(void)
*(PageHeader)testPage(pageIdx) = (PageHeaderData){.pd_upper = 0x0}; *(PageHeader)testPage(pageIdx) = (PageHeaderData){.pd_upper = 0x0};
// Pages with pd_upper = 0 should always return true no matter the block no // 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(pgPageChecksumTest(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(1), 999, TEST_PAGE_SIZE, 0, 0), true, "pd_upper is 0, block 999");
// Partial pages are always invalid // Partial pages are always invalid
*(PageHeader)testPage(0) = (PageHeaderData){.pd_upper = 0x00FF}; *(PageHeader)testPage(0) = (PageHeaderData){.pd_upper = 0x00FF};
((PageHeader)testPage(0))->pd_checksum = pageChecksum(testPage(0), 0, TEST_PAGE_SIZE); ((PageHeader)testPage(0))->pd_checksum = pgPageChecksum(testPage(0), 0, TEST_PAGE_SIZE);
TEST_RESULT_BOOL(pageChecksumTest(testPage(0), 0, TEST_PAGE_SIZE, 1, 1), true, "valid page"); TEST_RESULT_BOOL(pgPageChecksumTest(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"); 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 // Update pd_upper and check for failure no matter the block no
*(PageHeader)testPage(0) = (PageHeaderData){.pd_upper = 0x00FF, .pd_checksum = 0}; *(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( 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 // 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.xlogid = 0x8888;
((PageHeader)testPage(0))->pd_lsn.xrecoff = 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( 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( 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( 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(); FUNCTION_HARNESS_RESULT_VOID();