You've already forked pgbackrest
mirror of
https://github.com/pgbackrest/pgbackrest.git
synced 2025-06-18 23:57:33 +02:00
Support configurable WAL segment size.
PostgreSQL 11 introduces configurable WAL segment sizes, from 1MB to 1GB. There are two areas that needed to be updated to support this: building the archive-get queue and checking that WAL has been archived after a backup. Both operations require the WAL segment size to properly build a list. Checking the archive after a backup is still implemented in Perl and has an active database connection, so just get the WAL segment size from the database. The archive-get command does not have a connection to the database, so get the WAL segment size from pg_control instead. This requires a deeper inspection of pg_control than has been done in the past, so it seemed best to copy the relevant data structures from each version of PostgreSQL and build a generic interface layer to address them. While this approach is a bit verbose, it has the advantage of being relatively simple, and can easily be updated for new versions of PostgreSQL. Since the integration tests generate pg_control files for testing, teach Perl how to generate files with the correct offsets for both 32-bit and 64-bit architectures.
This commit is contained in:
David Steele
@ -1,155 +0,0 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL Info
|
||||
***********************************************************************************************************************************/
|
||||
#include "common/debug.h"
|
||||
#include "common/log.h"
|
||||
#include "common/memContext.h"
|
||||
#include "common/type/convert.h"
|
||||
#include "common/regExp.h"
|
||||
#include "postgres/info.h"
|
||||
#include "postgres/type.h"
|
||||
#include "postgres/version.h"
|
||||
#include "storage/helper.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Set control data size. The control file is actually 8192 bytes but only the first 512 bytes are used to prevent torn pages even on
|
||||
really old storage with 512-byte sectors.
|
||||
***********************************************************************************************************************************/
|
||||
#define PG_CONTROL_DATA_SIZE 512
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Map control/catalog version to PostgreSQL version
|
||||
***********************************************************************************************************************************/
|
||||
static unsigned int
|
||||
pgVersionMap(uint32_t controlVersion, uint32_t catalogVersion)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(UINT32, controlVersion);
|
||||
FUNCTION_TEST_PARAM(UINT32, catalogVersion);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
unsigned int result = 0;
|
||||
|
||||
if (controlVersion == 1100 && catalogVersion == 201809051)
|
||||
result = PG_VERSION_11;
|
||||
else if (controlVersion == 1002 && catalogVersion == 201707211)
|
||||
result = PG_VERSION_10;
|
||||
else if (controlVersion == 960 && catalogVersion == 201608131)
|
||||
result = PG_VERSION_96;
|
||||
else if (controlVersion == 942 && catalogVersion == 201510051)
|
||||
result = PG_VERSION_95;
|
||||
else if (controlVersion == 942 && catalogVersion == 201409291)
|
||||
result = PG_VERSION_94;
|
||||
else if (controlVersion == 937 && catalogVersion == 201306121)
|
||||
result = PG_VERSION_93;
|
||||
else if (controlVersion == 922 && catalogVersion == 201204301)
|
||||
result = PG_VERSION_92;
|
||||
else if (controlVersion == 903 && catalogVersion == 201105231)
|
||||
result = PG_VERSION_91;
|
||||
else if (controlVersion == 903 && catalogVersion == 201008051)
|
||||
result = PG_VERSION_90;
|
||||
else if (controlVersion == 843 && catalogVersion == 200904091)
|
||||
result = PG_VERSION_84;
|
||||
else if (controlVersion == 833 && catalogVersion == 200711281)
|
||||
result = PG_VERSION_83;
|
||||
else
|
||||
{
|
||||
THROW_FMT(
|
||||
VersionNotSupportedError,
|
||||
"unexpected control version = %u and catalog version = %u\n"
|
||||
"HINT: is this version of PostgreSQL supported?",
|
||||
controlVersion, catalogVersion);
|
||||
}
|
||||
|
||||
FUNCTION_TEST_RESULT(UINT, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Convert version string to version number
|
||||
***********************************************************************************************************************************/
|
||||
unsigned int
|
||||
pgVersionFromStr(const String *version)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelTrace);
|
||||
FUNCTION_DEBUG_PARAM(STRING, version);
|
||||
|
||||
FUNCTION_DEBUG_ASSERT(version != NULL);
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
unsigned int result = 0;
|
||||
|
||||
MEM_CONTEXT_TEMP_BEGIN()
|
||||
{
|
||||
// If format is not number.number (9.4) or number only (10) then error
|
||||
if (!regExpMatchOne(strNew("^[0-9]+[.]*[0-9]+$"), version))
|
||||
THROW_FMT(AssertError, "version %s format is invalid", strPtr(version));
|
||||
|
||||
// If there is a dot set the major and minor versions, else just the major
|
||||
int idxStart = strChr(version, '.');
|
||||
unsigned int major;
|
||||
unsigned int minor = 0;
|
||||
|
||||
if (idxStart != -1)
|
||||
{
|
||||
major = cvtZToUInt(strPtr(strSubN(version, 0, (size_t)idxStart)));
|
||||
minor = cvtZToUInt(strPtr(strSub(version, (size_t)idxStart + 1)));
|
||||
}
|
||||
else
|
||||
major = cvtZToUInt(strPtr(version));
|
||||
|
||||
// No check to see if valid/supported PG version is on purpose
|
||||
result = major * 10000 + minor * 100;
|
||||
}
|
||||
MEM_CONTEXT_TEMP_END();
|
||||
|
||||
FUNCTION_DEBUG_RESULT(UINT, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Convert version number to string
|
||||
***********************************************************************************************************************************/
|
||||
String *
|
||||
pgVersionToStr(unsigned int version)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelTrace);
|
||||
FUNCTION_DEBUG_PARAM(UINT, version);
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
String *result = version >= PG_VERSION_10 ?
|
||||
strNewFmt("%u", version / 10000) : strNewFmt("%u.%u", version / 10000, version % 10000 / 100);
|
||||
|
||||
FUNCTION_DEBUG_RESULT(STRING, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Get info from pg_control
|
||||
***********************************************************************************************************************************/
|
||||
PgControlInfo
|
||||
pgControlInfo(const String *pgPath)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelDebug);
|
||||
FUNCTION_DEBUG_PARAM(STRING, pgPath);
|
||||
|
||||
FUNCTION_TEST_ASSERT(pgPath != NULL);
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
PgControlInfo result = {0};
|
||||
|
||||
MEM_CONTEXT_TEMP_BEGIN()
|
||||
{
|
||||
// Read control file
|
||||
PgControlFile *control = (PgControlFile *)bufPtr(
|
||||
storageGetP(
|
||||
storageNewReadNP(storageLocal(), strNewFmt("%s/" PG_PATH_GLOBAL "/" PG_FILE_PGCONTROL, strPtr(pgPath))),
|
||||
.exactSize = PG_CONTROL_DATA_SIZE));
|
||||
|
||||
// Get PostgreSQL version
|
||||
result.systemId = control->systemId;
|
||||
result.controlVersion = control->controlVersion;
|
||||
result.catalogVersion = control->catalogVersion;
|
||||
result.version = pgVersionMap(result.controlVersion, result.catalogVersion);
|
||||
}
|
||||
MEM_CONTEXT_TEMP_END();
|
||||
|
||||
FUNCTION_DEBUG_RESULT(PG_CONTROL_INFO, result);
|
||||
}
|
||||
365
src/postgres/interface.c
Normal file
365
src/postgres/interface.c
Normal file
@ -0,0 +1,365 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL Interface
|
||||
***********************************************************************************************************************************/
|
||||
#include <string.h>
|
||||
|
||||
#include "common/debug.h"
|
||||
#include "common/log.h"
|
||||
#include "common/memContext.h"
|
||||
#include "common/regExp.h"
|
||||
#include "postgres/interface.h"
|
||||
#include "postgres/interface/v083.h"
|
||||
#include "postgres/interface/v084.h"
|
||||
#include "postgres/interface/v090.h"
|
||||
#include "postgres/interface/v091.h"
|
||||
#include "postgres/interface/v092.h"
|
||||
#include "postgres/interface/v093.h"
|
||||
#include "postgres/interface/v094.h"
|
||||
#include "postgres/interface/v095.h"
|
||||
#include "postgres/interface/v096.h"
|
||||
#include "postgres/interface/v100.h"
|
||||
#include "postgres/interface/v110.h"
|
||||
#include "postgres/version.h"
|
||||
#include "storage/helper.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Define default page size
|
||||
|
||||
Page size can only be changed at compile time and is not known to be well-tested, so only the default page size is supported.
|
||||
***********************************************************************************************************************************/
|
||||
#define PG_PAGE_SIZE_DEFAULT ((unsigned int)(8 * 1024))
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Define default wal segment size
|
||||
|
||||
Page size can only be changed at compile time and and is not known to be well-tested, so only the default page size is supported.
|
||||
***********************************************************************************************************************************/
|
||||
#define PG_WAL_SEGMENT_SIZE_DEFAULT ((unsigned int)(16 * 1024 * 1024))
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Control file size. The control file is actually 8192 bytes but only the first 512 bytes are used to prevent torn pages even on
|
||||
really old storage with 512-byte sectors. This is true across all versions of PostgreSQL.
|
||||
***********************************************************************************************************************************/
|
||||
#define PG_CONTROL_SIZE ((unsigned int)(8 * 1024))
|
||||
#define PG_CONTROL_DATA_SIZE ((unsigned int)(512))
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL interface definitions
|
||||
***********************************************************************************************************************************/
|
||||
typedef struct PgInterface
|
||||
{
|
||||
unsigned int version;
|
||||
PgControl (*control)(const Buffer *);
|
||||
bool (*is)(const Buffer *);
|
||||
void (*controlTest)(PgControl, Buffer *);
|
||||
} PgInterface;
|
||||
|
||||
static const PgInterface pgInterface[] =
|
||||
{
|
||||
{
|
||||
.version = PG_VERSION_11,
|
||||
.control = pgInterfaceControl110,
|
||||
.is = pgInterfaceIs110,
|
||||
|
||||
#ifdef DEBUG
|
||||
.controlTest = pgInterfaceControlTest110,
|
||||
#endif
|
||||
},
|
||||
{
|
||||
.version = PG_VERSION_10,
|
||||
.control = pgInterfaceControl100,
|
||||
.is = pgInterfaceIs100,
|
||||
|
||||
#ifdef DEBUG
|
||||
.controlTest = pgInterfaceControlTest100,
|
||||
#endif
|
||||
},
|
||||
{
|
||||
.version = PG_VERSION_96,
|
||||
.control = pgInterfaceControl096,
|
||||
.is = pgInterfaceIs096,
|
||||
|
||||
#ifdef DEBUG
|
||||
.controlTest = pgInterfaceControlTest096,
|
||||
#endif
|
||||
},
|
||||
{
|
||||
.version = PG_VERSION_95,
|
||||
.control = pgInterfaceControl095,
|
||||
.is = pgInterfaceIs095,
|
||||
|
||||
#ifdef DEBUG
|
||||
.controlTest = pgInterfaceControlTest095,
|
||||
#endif
|
||||
},
|
||||
{
|
||||
.version = PG_VERSION_94,
|
||||
.control = pgInterfaceControl094,
|
||||
.is = pgInterfaceIs094,
|
||||
|
||||
#ifdef DEBUG
|
||||
.controlTest = pgInterfaceControlTest094,
|
||||
#endif
|
||||
},
|
||||
{
|
||||
.version = PG_VERSION_93,
|
||||
.control = pgInterfaceControl093,
|
||||
.is = pgInterfaceIs093,
|
||||
|
||||
#ifdef DEBUG
|
||||
.controlTest = pgInterfaceControlTest093,
|
||||
#endif
|
||||
},
|
||||
{
|
||||
.version = PG_VERSION_92,
|
||||
.control = pgInterfaceControl092,
|
||||
.is = pgInterfaceIs092,
|
||||
|
||||
#ifdef DEBUG
|
||||
.controlTest = pgInterfaceControlTest092,
|
||||
#endif
|
||||
},
|
||||
{
|
||||
.version = PG_VERSION_91,
|
||||
.control = pgInterfaceControl091,
|
||||
.is = pgInterfaceIs091,
|
||||
|
||||
#ifdef DEBUG
|
||||
.controlTest = pgInterfaceControlTest091,
|
||||
#endif
|
||||
},
|
||||
{
|
||||
.version = PG_VERSION_90,
|
||||
.control = pgInterfaceControl090,
|
||||
.is = pgInterfaceIs090,
|
||||
|
||||
#ifdef DEBUG
|
||||
.controlTest = pgInterfaceControlTest090,
|
||||
#endif
|
||||
},
|
||||
{
|
||||
.version = PG_VERSION_84,
|
||||
.control = pgInterfaceControl084,
|
||||
.is = pgInterfaceIs084,
|
||||
|
||||
#ifdef DEBUG
|
||||
.controlTest = pgInterfaceControlTest084,
|
||||
#endif
|
||||
},
|
||||
{
|
||||
.version = PG_VERSION_83,
|
||||
.control = pgInterfaceControl083,
|
||||
.is = pgInterfaceIs083,
|
||||
|
||||
#ifdef DEBUG
|
||||
.controlTest = pgInterfaceControlTest083,
|
||||
#endif
|
||||
},
|
||||
};
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
These pg_control fields are common to all versions of PostgreSQL, so we can use them to generate error messages when the pg_control
|
||||
version cannot be found.
|
||||
***********************************************************************************************************************************/
|
||||
typedef struct PgControlCommon
|
||||
{
|
||||
uint64_t systemId;
|
||||
uint32_t controlVersion;
|
||||
uint32_t catalogVersion;
|
||||
} PgControlCommon;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Get info from pg_control
|
||||
***********************************************************************************************************************************/
|
||||
PgControl
|
||||
pgControlFromBuffer(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelTrace);
|
||||
FUNCTION_DEBUG_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
// Search for the version of PostgreSQL that uses this control file
|
||||
const PgInterface *interface = NULL;
|
||||
|
||||
for (unsigned int interfaceIdx = 0; interfaceIdx < sizeof(pgInterface) / sizeof(PgInterface); interfaceIdx++)
|
||||
{
|
||||
if (pgInterface[interfaceIdx].is(controlFile))
|
||||
{
|
||||
interface = &pgInterface[interfaceIdx];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// If the version was not found then error with the control and catalog version that were found
|
||||
if (interface == NULL)
|
||||
{
|
||||
PgControlCommon *controlCommon = (PgControlCommon *)bufPtr(controlFile);
|
||||
|
||||
THROW_FMT(
|
||||
VersionNotSupportedError,
|
||||
"unexpected control version = %u and catalog version = %u\n"
|
||||
"HINT: is this version of PostgreSQL supported?",
|
||||
controlCommon->controlVersion, controlCommon->catalogVersion);
|
||||
}
|
||||
|
||||
// Get info from the control file
|
||||
PgControl result = interface->control(controlFile);
|
||||
result.version = interface->version;
|
||||
|
||||
// Check the segment size
|
||||
if (result.version < PG_VERSION_11 && result.walSegmentSize != PG_WAL_SEGMENT_SIZE_DEFAULT)
|
||||
{
|
||||
THROW_FMT(
|
||||
FormatError, "wal segment size is %u but must be %u for " PG_NAME " <= " PG_VERSION_10_STR, result.walSegmentSize,
|
||||
PG_WAL_SEGMENT_SIZE_DEFAULT);
|
||||
}
|
||||
|
||||
// Check the page size
|
||||
if (result.pageSize != PG_PAGE_SIZE_DEFAULT)
|
||||
THROW_FMT(FormatError, "page size is %u but must be %u", result.pageSize, PG_PAGE_SIZE_DEFAULT);
|
||||
|
||||
FUNCTION_DEBUG_RESULT(PG_CONTROL, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Get info from pg_control
|
||||
***********************************************************************************************************************************/
|
||||
PgControl
|
||||
pgControlFromFile(const String *pgPath)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelDebug);
|
||||
FUNCTION_DEBUG_PARAM(STRING, pgPath);
|
||||
|
||||
FUNCTION_TEST_ASSERT(pgPath != NULL);
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
PgControl result = {0};
|
||||
|
||||
MEM_CONTEXT_TEMP_BEGIN()
|
||||
{
|
||||
// Read control file
|
||||
Buffer *controlFile = storageGetP(
|
||||
storageNewReadNP(storageLocal(), strNewFmt("%s/" PG_PATH_GLOBAL "/" PG_FILE_PGCONTROL, strPtr(pgPath))),
|
||||
.exactSize = PG_CONTROL_DATA_SIZE);
|
||||
|
||||
result = pgControlFromBuffer(controlFile);
|
||||
}
|
||||
MEM_CONTEXT_TEMP_END();
|
||||
|
||||
FUNCTION_DEBUG_RESULT(PG_CONTROL, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Create pg_control for testing
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
|
||||
Buffer *
|
||||
pgControlTestToBuffer(PgControl pgControl)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(PG_CONTROL, pgControl);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
// Set defaults if values are not passed
|
||||
pgControl.pageSize = pgControl.pageSize == 0 ? PG_PAGE_SIZE_DEFAULT : pgControl.pageSize;
|
||||
pgControl.walSegmentSize = pgControl.walSegmentSize == 0 ? PG_WAL_SEGMENT_SIZE_DEFAULT : pgControl.walSegmentSize;
|
||||
|
||||
// Create the buffer and clear it
|
||||
Buffer *result = bufNew(PG_CONTROL_SIZE);
|
||||
memset(bufPtr(result), 0, bufSize(result));
|
||||
bufUsedSet(result, bufSize(result));
|
||||
|
||||
// Find the interface for the version of PostgreSQL
|
||||
const PgInterface *interface = NULL;
|
||||
|
||||
for (unsigned int interfaceIdx = 0; interfaceIdx < sizeof(pgInterface) / sizeof(PgInterface); interfaceIdx++)
|
||||
{
|
||||
if (pgInterface[interfaceIdx].version == pgControl.version)
|
||||
{
|
||||
interface = &pgInterface[interfaceIdx];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// If the version was not found then error
|
||||
if (interface == NULL)
|
||||
THROW_FMT(AssertError, "invalid version %u", pgControl.version);
|
||||
|
||||
// Generate pg_control
|
||||
interface->controlTest(pgControl, result);
|
||||
|
||||
FUNCTION_TEST_RESULT(BUFFER, result);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Convert version string to version number
|
||||
***********************************************************************************************************************************/
|
||||
unsigned int
|
||||
pgVersionFromStr(const String *version)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelTrace);
|
||||
FUNCTION_DEBUG_PARAM(STRING, version);
|
||||
|
||||
FUNCTION_DEBUG_ASSERT(version != NULL);
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
unsigned int result = 0;
|
||||
|
||||
MEM_CONTEXT_TEMP_BEGIN()
|
||||
{
|
||||
// If format is not number.number (9.4) or number only (10) then error
|
||||
if (!regExpMatchOne(strNew("^[0-9]+[.]*[0-9]+$"), version))
|
||||
THROW_FMT(AssertError, "version %s format is invalid", strPtr(version));
|
||||
|
||||
// If there is a dot set the major and minor versions, else just the major
|
||||
int idxStart = strChr(version, '.');
|
||||
unsigned int major;
|
||||
unsigned int minor = 0;
|
||||
|
||||
if (idxStart != -1)
|
||||
{
|
||||
major = cvtZToUInt(strPtr(strSubN(version, 0, (size_t)idxStart)));
|
||||
minor = cvtZToUInt(strPtr(strSub(version, (size_t)idxStart + 1)));
|
||||
}
|
||||
else
|
||||
major = cvtZToUInt(strPtr(version));
|
||||
|
||||
// No check to see if valid/supported PG version is on purpose
|
||||
result = major * 10000 + minor * 100;
|
||||
}
|
||||
MEM_CONTEXT_TEMP_END();
|
||||
|
||||
FUNCTION_DEBUG_RESULT(UINT, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Convert version number to string
|
||||
***********************************************************************************************************************************/
|
||||
String *
|
||||
pgVersionToStr(unsigned int version)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelTrace);
|
||||
FUNCTION_DEBUG_PARAM(UINT, version);
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
String *result = version >= PG_VERSION_10 ?
|
||||
strNewFmt("%u", version / 10000) : strNewFmt("%u.%u", version / 10000, version % 10000 / 100);
|
||||
|
||||
FUNCTION_DEBUG_RESULT(STRING, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Render as string for logging
|
||||
***********************************************************************************************************************************/
|
||||
String *
|
||||
pgControlToLog(const PgControl *pgControl)
|
||||
{
|
||||
return strNewFmt(
|
||||
"{version: %u, systemId: %" PRIu64 ", walSegmentSize: %u, pageChecksum: %s}", pgControl->version, pgControl->systemId,
|
||||
pgControl->walSegmentSize, cvtBoolToConstZ(pgControl->pageChecksum));
|
||||
}
|
||||
@ -1,38 +1,61 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL Info
|
||||
PostgreSQL Interface
|
||||
***********************************************************************************************************************************/
|
||||
#ifndef POSTGRES_INFO_H
|
||||
#define POSTGRES_INFO_H
|
||||
#ifndef POSTGRES_INTERFACE_H
|
||||
#define POSTGRES_INTERFACE_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include "common/type/string.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Defines for various Postgres paths and files
|
||||
***********************************************************************************************************************************/
|
||||
#define PG_FILE_PGCONTROL "pg_control"
|
||||
|
||||
#define PG_PATH_GLOBAL "global"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL Control File Info
|
||||
***********************************************************************************************************************************/
|
||||
typedef struct PgControlInfo
|
||||
typedef struct PgControl
|
||||
{
|
||||
unsigned int version;
|
||||
uint64_t systemId;
|
||||
|
||||
uint32_t controlVersion;
|
||||
uint32_t catalogVersion;
|
||||
unsigned int version;
|
||||
} PgControlInfo;
|
||||
|
||||
#include "common/type/string.h"
|
||||
unsigned int pageSize;
|
||||
unsigned int walSegmentSize;
|
||||
|
||||
bool pageChecksum;
|
||||
} PgControl;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Functions
|
||||
***********************************************************************************************************************************/
|
||||
PgControlInfo pgControlInfo(const String *pgPath);
|
||||
PgControl pgControlFromFile(const String *pgPath);
|
||||
PgControl pgControlFromBuffer(const Buffer *controlFile);
|
||||
unsigned int pgVersionFromStr(const String *version);
|
||||
String *pgVersionToStr(unsigned int version);
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Test Functions
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
Buffer *pgControlTestToBuffer(PgControl pgControl);
|
||||
#endif
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Macros for function logging
|
||||
***********************************************************************************************************************************/
|
||||
#define FUNCTION_DEBUG_PG_CONTROL_INFO_TYPE \
|
||||
PgControlInfo
|
||||
#define FUNCTION_DEBUG_PG_CONTROL_INFO_FORMAT(value, buffer, bufferSize) \
|
||||
objToLog(&value, "PgControlInfo", buffer, bufferSize)
|
||||
String *pgControlToLog(const PgControl *pgControl);
|
||||
|
||||
#define FUNCTION_DEBUG_PG_CONTROL_TYPE \
|
||||
PgControl
|
||||
#define FUNCTION_DEBUG_PG_CONTROL_FORMAT(value, buffer, bufferSize) \
|
||||
FUNCTION_DEBUG_STRING_OBJECT_FORMAT(&value, pgControlToLog, buffer, bufferSize)
|
||||
|
||||
#endif
|
||||
203
src/postgres/interface/v083.auto.c
Normal file
203
src/postgres/interface/v083.auto.c
Normal file
@ -0,0 +1,203 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 8.3 Types
|
||||
***********************************************************************************************************************************/
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/c.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef int64_t int64;
|
||||
typedef uint32_t uint32;
|
||||
typedef uint64_t uint64;
|
||||
|
||||
typedef uint32 TransactionId;
|
||||
|
||||
/* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
|
||||
typedef TransactionId MultiXactId;
|
||||
|
||||
typedef uint32 MultiXactOffset;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/postgres_ext.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Object ID is a fundamental type in Postgres.
|
||||
*/
|
||||
typedef unsigned int Oid;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/utils/pg_crc32.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef uint32 pg_crc32;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/access/xlogdefs.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Pointer to a location in the XLOG. These pointers are 64 bits wide,
|
||||
* because we don't want them ever to overflow.
|
||||
*
|
||||
* NOTE: xrecoff == 0 is used to indicate an invalid pointer. This is OK
|
||||
* because we use page headers in the XLOG, so no XLOG record can start
|
||||
* right at the beginning of a file.
|
||||
*
|
||||
* NOTE: the "log file number" is somewhat misnamed, since the actual files
|
||||
* making up the XLOG are much smaller than 4Gb. Each actual file is an
|
||||
* XLogSegSize-byte "segment" of a logical log file having the indicated
|
||||
* xlogid. The log file number and segment number together identify a
|
||||
* physical XLOG file. Segment number and offset within the physical file
|
||||
* are computed from xrecoff div and mod XLogSegSize.
|
||||
*/
|
||||
typedef struct XLogRecPtr
|
||||
{
|
||||
uint32 xlogid; /* log file #, 0 based */
|
||||
uint32 xrecoff; /* byte offset of location in log file */
|
||||
} XLogRecPtr;
|
||||
|
||||
/*
|
||||
* TimeLineID (TLI) - identifies different database histories to prevent
|
||||
* confusion after restoring a prior state of a database installation.
|
||||
* TLI does not change in a normal stop/restart of the database (including
|
||||
* crash-and-recover cases); but we must assign a new TLI after doing
|
||||
* a recovery to a prior state, a/k/a point-in-time recovery. This makes
|
||||
* the new WAL logfile sequence we generate distinguishable from the
|
||||
* sequence that was generated in the previous incarnation.
|
||||
*/
|
||||
typedef uint32 TimeLineID;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/catversion.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* We could use anything we wanted for version numbers, but I recommend
|
||||
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
||||
* YYYYMMDD are the date of the change, and N is the number of the change
|
||||
* on that day. (Hopefully we'll never commit ten independent sets of
|
||||
* catalog changes on the same day...)
|
||||
*/
|
||||
|
||||
/* yyyymmddN */
|
||||
#define CATALOG_VERSION_NO 200711281
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/pg_control.h
|
||||
***********************************************************************************************************************************/
|
||||
/* Version identifier for this pg_control format */
|
||||
#define PG_CONTROL_VERSION 833
|
||||
|
||||
/*
|
||||
* Body of CheckPoint XLOG records. This is declared here because we keep
|
||||
* a copy of the latest one in pg_control for possible disaster recovery.
|
||||
*/
|
||||
typedef struct CheckPoint
|
||||
{
|
||||
XLogRecPtr redo; /* next RecPtr available when we began to
|
||||
* create CheckPoint (i.e. REDO start point) */
|
||||
TimeLineID ThisTimeLineID; /* current TLI */
|
||||
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
||||
TransactionId nextXid; /* next free XID */
|
||||
Oid nextOid; /* next free OID */
|
||||
MultiXactId nextMulti; /* next free MultiXactId */
|
||||
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
||||
time_t time; /* time stamp of checkpoint */
|
||||
} CheckPoint;
|
||||
|
||||
/* System status indicator */
|
||||
typedef enum DBState
|
||||
{
|
||||
DB_STARTUP = 0,
|
||||
DB_SHUTDOWNED,
|
||||
DB_SHUTDOWNING,
|
||||
DB_IN_CRASH_RECOVERY,
|
||||
DB_IN_ARCHIVE_RECOVERY,
|
||||
DB_IN_PRODUCTION
|
||||
} DBState;
|
||||
|
||||
#define LOCALE_NAME_BUFLEN 128
|
||||
|
||||
/*
|
||||
* Contents of pg_control.
|
||||
*
|
||||
* NOTE: try to keep this under 512 bytes so that it will fit on one physical
|
||||
* sector of typical disk drives. This reduces the odds of corruption due to
|
||||
* power failure midway through a write. Currently it fits comfortably,
|
||||
* but we could probably reduce LOCALE_NAME_BUFLEN if things get tight.
|
||||
*/
|
||||
|
||||
typedef struct ControlFileData
|
||||
{
|
||||
/*
|
||||
* Unique system identifier --- to ensure we match up xlog files with the
|
||||
* installation that produced them.
|
||||
*/
|
||||
uint64 system_identifier;
|
||||
|
||||
/*
|
||||
* Version identifier information. Keep these fields at the same offset,
|
||||
* especially pg_control_version; they won't be real useful if they move
|
||||
* around. (For historical reasons they must be 8 bytes into the file
|
||||
* rather than immediately at the front.)
|
||||
*
|
||||
* pg_control_version identifies the format of pg_control itself.
|
||||
* catalog_version_no identifies the format of the system catalogs.
|
||||
*
|
||||
* There are additional version identifiers in individual files; for
|
||||
* example, WAL logs contain per-page magic numbers that can serve as
|
||||
* version cues for the WAL log.
|
||||
*/
|
||||
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
||||
uint32 catalog_version_no; /* see catversion.h */
|
||||
|
||||
/*
|
||||
* System status data
|
||||
*/
|
||||
DBState state; /* see enum above */
|
||||
time_t time; /* time stamp of last pg_control update */
|
||||
XLogRecPtr checkPoint; /* last check point record ptr */
|
||||
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
||||
|
||||
CheckPoint checkPointCopy; /* copy of last check point record */
|
||||
|
||||
XLogRecPtr minRecoveryPoint; /* must replay xlog to here */
|
||||
|
||||
/*
|
||||
* This data is used to check for hardware-architecture compatibility of
|
||||
* the database and the backend executable. We need not check endianness
|
||||
* explicitly, since the pg_control version will surely look wrong to a
|
||||
* machine of different endianness, but we do need to worry about MAXALIGN
|
||||
* and floating-point format. (Note: storage layout nominally also
|
||||
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
||||
* on all architectures of interest.)
|
||||
*
|
||||
* Testing just one double value is not a very bulletproof test for
|
||||
* floating-point compatibility, but it will catch most cases.
|
||||
*/
|
||||
uint32 maxAlign; /* alignment requirement for tuples */
|
||||
double floatFormat; /* constant 1234567.0 */
|
||||
#define FLOATFORMAT_VALUE 1234567.0
|
||||
|
||||
/*
|
||||
* This data is used to make sure that configuration of this database is
|
||||
* compatible with the backend executable.
|
||||
*/
|
||||
uint32 blcksz; /* data block size for this DB */
|
||||
uint32 relseg_size; /* blocks per segment of large relation */
|
||||
|
||||
uint32 xlog_blcksz; /* block size within WAL files */
|
||||
uint32 xlog_seg_size; /* size of each WAL segment */
|
||||
|
||||
uint32 nameDataLen; /* catalog name field width */
|
||||
uint32 indexMaxKeys; /* max number of columns in an index */
|
||||
|
||||
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
||||
|
||||
/* flag indicating internal format of timestamp, interval, time */
|
||||
uint32 enableIntTimes; /* int64 storage enabled? */
|
||||
|
||||
/* active locales */
|
||||
uint32 localeBuflen;
|
||||
char lc_collate[LOCALE_NAME_BUFLEN];
|
||||
char lc_ctype[LOCALE_NAME_BUFLEN];
|
||||
|
||||
/* CRC of all above ... MUST BE LAST! */
|
||||
pg_crc32 crc;
|
||||
} ControlFileData;
|
||||
81
src/postgres/interface/v083.c
Normal file
81
src/postgres/interface/v083.c
Normal file
@ -0,0 +1,81 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 8.3 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#include "common/debug.h"
|
||||
#include "common/log.h"
|
||||
#include "postgres/interface/v083.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Include PostgreSQL Types
|
||||
***********************************************************************************************************************************/
|
||||
#include "postgres/interface/v083.auto.c"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Is the control file for this version of PostgreSQL?
|
||||
***********************************************************************************************************************************/
|
||||
bool
|
||||
pgInterfaceIs083(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
FUNCTION_TEST_RESULT(
|
||||
BOOL, controlData->pg_control_version == PG_CONTROL_VERSION && controlData->catalog_version_no == CATALOG_VERSION_NO);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Get information from pg_control in a common format
|
||||
***********************************************************************************************************************************/
|
||||
PgControl
|
||||
pgInterfaceControl083(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelTrace);
|
||||
FUNCTION_DEBUG_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_ASSERT(pgInterfaceIs083(controlFile));
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
PgControl result = {0};
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
result.systemId = controlData->system_identifier;
|
||||
result.controlVersion = controlData->pg_control_version;
|
||||
result.catalogVersion = controlData->catalog_version_no;
|
||||
|
||||
result.pageSize = controlData->blcksz;
|
||||
result.walSegmentSize = controlData->xlog_seg_size;
|
||||
|
||||
FUNCTION_DEBUG_RESULT(PG_CONTROL, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Create pg_control for testing
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
|
||||
void
|
||||
pgInterfaceControlTest083(PgControl pgControl, Buffer *buffer)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(PG_CONTROL, pgControl);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(buffer);
|
||||
|
||||
controlData->system_identifier = pgControl.systemId;
|
||||
controlData->pg_control_version = pgControl.controlVersion == 0 ? PG_CONTROL_VERSION : pgControl.controlVersion;
|
||||
controlData->catalog_version_no = pgControl.catalogVersion == 0 ? CATALOG_VERSION_NO : pgControl.catalogVersion;
|
||||
|
||||
controlData->blcksz = pgControl.pageSize;
|
||||
controlData->xlog_seg_size = pgControl.walSegmentSize;
|
||||
|
||||
FUNCTION_TEST_RESULT_VOID();
|
||||
}
|
||||
|
||||
#endif
|
||||
22
src/postgres/interface/v083.h
Normal file
22
src/postgres/interface/v083.h
Normal file
@ -0,0 +1,22 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 8.3 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#ifndef POSTGRES_INTERFACE_INTERFACE083_H
|
||||
#define POSTGRES_INTERFACE_INTERFACE083_H
|
||||
|
||||
#include "postgres/interface.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Functions
|
||||
***********************************************************************************************************************************/
|
||||
bool pgInterfaceIs083(const Buffer *controlFile);
|
||||
PgControl pgInterfaceControl083(const Buffer *controlFile);
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Test Functions
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
void pgInterfaceControlTest083(PgControl pgControl, Buffer *buffer);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
208
src/postgres/interface/v084.auto.c
Normal file
208
src/postgres/interface/v084.auto.c
Normal file
@ -0,0 +1,208 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 8.4 Types
|
||||
***********************************************************************************************************************************/
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/c.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef int64_t int64;
|
||||
typedef uint32_t uint32;
|
||||
typedef uint64_t uint64;
|
||||
|
||||
typedef uint32 TransactionId;
|
||||
|
||||
/* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
|
||||
typedef TransactionId MultiXactId;
|
||||
|
||||
typedef uint32 MultiXactOffset;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/pgtime.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* The API of this library is generally similar to the corresponding
|
||||
* C library functions, except that we use pg_time_t which (we hope) is
|
||||
* 64 bits wide, and which is most definitely signed not unsigned.
|
||||
*/
|
||||
typedef int64 pg_time_t;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/postgres_ext.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Object ID is a fundamental type in Postgres.
|
||||
*/
|
||||
typedef unsigned int Oid;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/utils/pg_crc32.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef uint32 pg_crc32;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/access/xlogdefs.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Pointer to a location in the XLOG. These pointers are 64 bits wide,
|
||||
* because we don't want them ever to overflow.
|
||||
*
|
||||
* NOTE: xrecoff == 0 is used to indicate an invalid pointer. This is OK
|
||||
* because we use page headers in the XLOG, so no XLOG record can start
|
||||
* right at the beginning of a file.
|
||||
*
|
||||
* NOTE: the "log file number" is somewhat misnamed, since the actual files
|
||||
* making up the XLOG are much smaller than 4Gb. Each actual file is an
|
||||
* XLogSegSize-byte "segment" of a logical log file having the indicated
|
||||
* xlogid. The log file number and segment number together identify a
|
||||
* physical XLOG file. Segment number and offset within the physical file
|
||||
* are computed from xrecoff div and mod XLogSegSize.
|
||||
*/
|
||||
typedef struct XLogRecPtr
|
||||
{
|
||||
uint32 xlogid; /* log file #, 0 based */
|
||||
uint32 xrecoff; /* byte offset of location in log file */
|
||||
} XLogRecPtr;
|
||||
|
||||
/*
|
||||
* TimeLineID (TLI) - identifies different database histories to prevent
|
||||
* confusion after restoring a prior state of a database installation.
|
||||
* TLI does not change in a normal stop/restart of the database (including
|
||||
* crash-and-recover cases); but we must assign a new TLI after doing
|
||||
* a recovery to a prior state, a/k/a point-in-time recovery. This makes
|
||||
* the new WAL logfile sequence we generate distinguishable from the
|
||||
* sequence that was generated in the previous incarnation.
|
||||
*/
|
||||
typedef uint32 TimeLineID;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/catversion.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* We could use anything we wanted for version numbers, but I recommend
|
||||
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
||||
* YYYYMMDD are the date of the change, and N is the number of the change
|
||||
* on that day. (Hopefully we'll never commit ten independent sets of
|
||||
* catalog changes on the same day...)
|
||||
*/
|
||||
|
||||
/* yyyymmddN */
|
||||
#define CATALOG_VERSION_NO 200904091
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/pg_control.h
|
||||
***********************************************************************************************************************************/
|
||||
/* Version identifier for this pg_control format */
|
||||
#define PG_CONTROL_VERSION 843
|
||||
|
||||
/*
|
||||
* Body of CheckPoint XLOG records. This is declared here because we keep
|
||||
* a copy of the latest one in pg_control for possible disaster recovery.
|
||||
*/
|
||||
typedef struct CheckPoint
|
||||
{
|
||||
XLogRecPtr redo; /* next RecPtr available when we began to
|
||||
* create CheckPoint (i.e. REDO start point) */
|
||||
TimeLineID ThisTimeLineID; /* current TLI */
|
||||
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
||||
TransactionId nextXid; /* next free XID */
|
||||
Oid nextOid; /* next free OID */
|
||||
MultiXactId nextMulti; /* next free MultiXactId */
|
||||
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
||||
pg_time_t time; /* time stamp of checkpoint */
|
||||
} CheckPoint;
|
||||
|
||||
/* System status indicator */
|
||||
typedef enum DBState
|
||||
{
|
||||
DB_STARTUP = 0,
|
||||
DB_SHUTDOWNED,
|
||||
DB_SHUTDOWNING,
|
||||
DB_IN_CRASH_RECOVERY,
|
||||
DB_IN_ARCHIVE_RECOVERY,
|
||||
DB_IN_PRODUCTION
|
||||
} DBState;
|
||||
|
||||
/*
|
||||
* Contents of pg_control.
|
||||
*
|
||||
* NOTE: try to keep this under 512 bytes so that it will fit on one physical
|
||||
* sector of typical disk drives. This reduces the odds of corruption due to
|
||||
* power failure midway through a write.
|
||||
*/
|
||||
typedef struct ControlFileData
|
||||
{
|
||||
/*
|
||||
* Unique system identifier --- to ensure we match up xlog files with the
|
||||
* installation that produced them.
|
||||
*/
|
||||
uint64 system_identifier;
|
||||
|
||||
/*
|
||||
* Version identifier information. Keep these fields at the same offset,
|
||||
* especially pg_control_version; they won't be real useful if they move
|
||||
* around. (For historical reasons they must be 8 bytes into the file
|
||||
* rather than immediately at the front.)
|
||||
*
|
||||
* pg_control_version identifies the format of pg_control itself.
|
||||
* catalog_version_no identifies the format of the system catalogs.
|
||||
*
|
||||
* There are additional version identifiers in individual files; for
|
||||
* example, WAL logs contain per-page magic numbers that can serve as
|
||||
* version cues for the WAL log.
|
||||
*/
|
||||
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
||||
uint32 catalog_version_no; /* see catversion.h */
|
||||
|
||||
/*
|
||||
* System status data
|
||||
*/
|
||||
DBState state; /* see enum above */
|
||||
pg_time_t time; /* time stamp of last pg_control update */
|
||||
XLogRecPtr checkPoint; /* last check point record ptr */
|
||||
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
||||
|
||||
CheckPoint checkPointCopy; /* copy of last check point record */
|
||||
|
||||
XLogRecPtr minRecoveryPoint; /* must replay xlog to here */
|
||||
|
||||
/*
|
||||
* This data is used to check for hardware-architecture compatibility of
|
||||
* the database and the backend executable. We need not check endianness
|
||||
* explicitly, since the pg_control version will surely look wrong to a
|
||||
* machine of different endianness, but we do need to worry about MAXALIGN
|
||||
* and floating-point format. (Note: storage layout nominally also
|
||||
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
||||
* on all architectures of interest.)
|
||||
*
|
||||
* Testing just one double value is not a very bulletproof test for
|
||||
* floating-point compatibility, but it will catch most cases.
|
||||
*/
|
||||
uint32 maxAlign; /* alignment requirement for tuples */
|
||||
double floatFormat; /* constant 1234567.0 */
|
||||
#define FLOATFORMAT_VALUE 1234567.0
|
||||
|
||||
/*
|
||||
* This data is used to make sure that configuration of this database is
|
||||
* compatible with the backend executable.
|
||||
*/
|
||||
uint32 blcksz; /* data block size for this DB */
|
||||
uint32 relseg_size; /* blocks per segment of large relation */
|
||||
|
||||
uint32 xlog_blcksz; /* block size within WAL files */
|
||||
uint32 xlog_seg_size; /* size of each WAL segment */
|
||||
|
||||
uint32 nameDataLen; /* catalog name field width */
|
||||
uint32 indexMaxKeys; /* max number of columns in an index */
|
||||
|
||||
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
||||
|
||||
/* flag indicating internal format of timestamp, interval, time */
|
||||
bool enableIntTimes; /* int64 storage enabled? */
|
||||
|
||||
/* flags indicating pass-by-value status of various types */
|
||||
bool float4ByVal; /* float4 pass-by-value? */
|
||||
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
||||
|
||||
/* CRC of all above ... MUST BE LAST! */
|
||||
pg_crc32 crc;
|
||||
} ControlFileData;
|
||||
81
src/postgres/interface/v084.c
Normal file
81
src/postgres/interface/v084.c
Normal file
@ -0,0 +1,81 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 8.4 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#include "common/debug.h"
|
||||
#include "common/log.h"
|
||||
#include "postgres/interface/v084.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Include PostgreSQL Types
|
||||
***********************************************************************************************************************************/
|
||||
#include "postgres/interface/v084.auto.c"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Is the control file for this version of PostgreSQL?
|
||||
***********************************************************************************************************************************/
|
||||
bool
|
||||
pgInterfaceIs084(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
FUNCTION_TEST_RESULT(
|
||||
BOOL, controlData->pg_control_version == PG_CONTROL_VERSION && controlData->catalog_version_no == CATALOG_VERSION_NO);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Get information from pg_control in a common format
|
||||
***********************************************************************************************************************************/
|
||||
PgControl
|
||||
pgInterfaceControl084(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelTrace);
|
||||
FUNCTION_DEBUG_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_ASSERT(pgInterfaceIs084(controlFile));
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
PgControl result = {0};
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
result.systemId = controlData->system_identifier;
|
||||
result.controlVersion = controlData->pg_control_version;
|
||||
result.catalogVersion = controlData->catalog_version_no;
|
||||
|
||||
result.pageSize = controlData->blcksz;
|
||||
result.walSegmentSize = controlData->xlog_seg_size;
|
||||
|
||||
FUNCTION_DEBUG_RESULT(PG_CONTROL, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Create pg_control for testing
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
|
||||
void
|
||||
pgInterfaceControlTest084(PgControl pgControl, Buffer *buffer)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(PG_CONTROL, pgControl);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(buffer);
|
||||
|
||||
controlData->system_identifier = pgControl.systemId;
|
||||
controlData->pg_control_version = pgControl.controlVersion == 0 ? PG_CONTROL_VERSION : pgControl.controlVersion;
|
||||
controlData->catalog_version_no = pgControl.catalogVersion == 0 ? CATALOG_VERSION_NO : pgControl.catalogVersion;
|
||||
|
||||
controlData->blcksz = pgControl.pageSize;
|
||||
controlData->xlog_seg_size = pgControl.walSegmentSize;
|
||||
|
||||
FUNCTION_TEST_RESULT_VOID();
|
||||
}
|
||||
|
||||
#endif
|
||||
22
src/postgres/interface/v084.h
Normal file
22
src/postgres/interface/v084.h
Normal file
@ -0,0 +1,22 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 8.4 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#ifndef POSTGRES_INTERFACE_INTERFACE084_H
|
||||
#define POSTGRES_INTERFACE_INTERFACE084_H
|
||||
|
||||
#include "postgres/interface.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Functions
|
||||
***********************************************************************************************************************************/
|
||||
bool pgInterfaceIs084(const Buffer *controlFile);
|
||||
PgControl pgInterfaceControl084(const Buffer *controlFile);
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Test Functions
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
void pgInterfaceControlTest084(PgControl pgControl, Buffer *buffer);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
252
src/postgres/interface/v090.auto.c
Normal file
252
src/postgres/interface/v090.auto.c
Normal file
@ -0,0 +1,252 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.0 Types
|
||||
***********************************************************************************************************************************/
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/c.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef int64_t int64;
|
||||
typedef uint32_t uint32;
|
||||
typedef uint64_t uint64;
|
||||
|
||||
typedef uint32 TransactionId;
|
||||
|
||||
/* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
|
||||
typedef TransactionId MultiXactId;
|
||||
|
||||
typedef uint32 MultiXactOffset;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/pgtime.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* The API of this library is generally similar to the corresponding
|
||||
* C library functions, except that we use pg_time_t which (we hope) is
|
||||
* 64 bits wide, and which is most definitely signed not unsigned.
|
||||
*/
|
||||
typedef int64 pg_time_t;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/postgres_ext.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Object ID is a fundamental type in Postgres.
|
||||
*/
|
||||
typedef unsigned int Oid;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/utils/pg_crc32.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef uint32 pg_crc32;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/access/xlogdefs.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Pointer to a location in the XLOG. These pointers are 64 bits wide,
|
||||
* because we don't want them ever to overflow.
|
||||
*
|
||||
* NOTE: xrecoff == 0 is used to indicate an invalid pointer. This is OK
|
||||
* because we use page headers in the XLOG, so no XLOG record can start
|
||||
* right at the beginning of a file.
|
||||
*
|
||||
* NOTE: the "log file number" is somewhat misnamed, since the actual files
|
||||
* making up the XLOG are much smaller than 4Gb. Each actual file is an
|
||||
* XLogSegSize-byte "segment" of a logical log file having the indicated
|
||||
* xlogid. The log file number and segment number together identify a
|
||||
* physical XLOG file. Segment number and offset within the physical file
|
||||
* are computed from xrecoff div and mod XLogSegSize.
|
||||
*/
|
||||
typedef struct XLogRecPtr
|
||||
{
|
||||
uint32 xlogid; /* log file #, 0 based */
|
||||
uint32 xrecoff; /* byte offset of location in log file */
|
||||
} XLogRecPtr;
|
||||
|
||||
/*
|
||||
* TimeLineID (TLI) - identifies different database histories to prevent
|
||||
* confusion after restoring a prior state of a database installation.
|
||||
* TLI does not change in a normal stop/restart of the database (including
|
||||
* crash-and-recover cases); but we must assign a new TLI after doing
|
||||
* a recovery to a prior state, a/k/a point-in-time recovery. This makes
|
||||
* the new WAL logfile sequence we generate distinguishable from the
|
||||
* sequence that was generated in the previous incarnation.
|
||||
*/
|
||||
typedef uint32 TimeLineID;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/catversion.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* We could use anything we wanted for version numbers, but I recommend
|
||||
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
||||
* YYYYMMDD are the date of the change, and N is the number of the change
|
||||
* on that day. (Hopefully we'll never commit ten independent sets of
|
||||
* catalog changes on the same day...)
|
||||
*/
|
||||
|
||||
/* yyyymmddN */
|
||||
#define CATALOG_VERSION_NO 201008051
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/pg_control.h
|
||||
***********************************************************************************************************************************/
|
||||
/* Version identifier for this pg_control format */
|
||||
#define PG_CONTROL_VERSION 903
|
||||
|
||||
/*
|
||||
* Body of CheckPoint XLOG records. This is declared here because we keep
|
||||
* a copy of the latest one in pg_control for possible disaster recovery.
|
||||
* Changing this struct requires a PG_CONTROL_VERSION bump.
|
||||
*/
|
||||
typedef struct CheckPoint
|
||||
{
|
||||
XLogRecPtr redo; /* next RecPtr available when we began to
|
||||
* create CheckPoint (i.e. REDO start point) */
|
||||
TimeLineID ThisTimeLineID; /* current TLI */
|
||||
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
||||
TransactionId nextXid; /* next free XID */
|
||||
Oid nextOid; /* next free OID */
|
||||
MultiXactId nextMulti; /* next free MultiXactId */
|
||||
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
||||
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
|
||||
Oid oldestXidDB; /* database with minimum datfrozenxid */
|
||||
pg_time_t time; /* time stamp of checkpoint */
|
||||
|
||||
/*
|
||||
* Oldest XID still running. This is only needed to initialize hot standby
|
||||
* mode from an online checkpoint, so we only bother calculating this for
|
||||
* online checkpoints and only when wal_level is hot_standby. Otherwise it's
|
||||
* set to InvalidTransactionId.
|
||||
*/
|
||||
TransactionId oldestActiveXid;
|
||||
} CheckPoint;
|
||||
|
||||
/*
|
||||
* System status indicator. Note this is stored in pg_control; if you change
|
||||
* it, you must bump PG_CONTROL_VERSION
|
||||
*/
|
||||
typedef enum DBState
|
||||
{
|
||||
DB_STARTUP = 0,
|
||||
DB_SHUTDOWNED,
|
||||
DB_SHUTDOWNED_IN_RECOVERY,
|
||||
DB_SHUTDOWNING,
|
||||
DB_IN_CRASH_RECOVERY,
|
||||
DB_IN_ARCHIVE_RECOVERY,
|
||||
DB_IN_PRODUCTION
|
||||
} DBState;
|
||||
|
||||
/*
|
||||
* Contents of pg_control.
|
||||
*
|
||||
* NOTE: try to keep this under 512 bytes so that it will fit on one physical
|
||||
* sector of typical disk drives. This reduces the odds of corruption due to
|
||||
* power failure midway through a write.
|
||||
*/
|
||||
typedef struct ControlFileData
|
||||
{
|
||||
/*
|
||||
* Unique system identifier --- to ensure we match up xlog files with the
|
||||
* installation that produced them.
|
||||
*/
|
||||
uint64 system_identifier;
|
||||
|
||||
/*
|
||||
* Version identifier information. Keep these fields at the same offset,
|
||||
* especially pg_control_version; they won't be real useful if they move
|
||||
* around. (For historical reasons they must be 8 bytes into the file
|
||||
* rather than immediately at the front.)
|
||||
*
|
||||
* pg_control_version identifies the format of pg_control itself.
|
||||
* catalog_version_no identifies the format of the system catalogs.
|
||||
*
|
||||
* There are additional version identifiers in individual files; for
|
||||
* example, WAL logs contain per-page magic numbers that can serve as
|
||||
* version cues for the WAL log.
|
||||
*/
|
||||
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
||||
uint32 catalog_version_no; /* see catversion.h */
|
||||
|
||||
/*
|
||||
* System status data
|
||||
*/
|
||||
DBState state; /* see enum above */
|
||||
pg_time_t time; /* time stamp of last pg_control update */
|
||||
XLogRecPtr checkPoint; /* last check point record ptr */
|
||||
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
||||
|
||||
CheckPoint checkPointCopy; /* copy of last check point record */
|
||||
|
||||
/*
|
||||
* These two values determine the minimum point we must recover up to
|
||||
* before starting up:
|
||||
*
|
||||
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
||||
* flush a data change during archive recovery. That guards against
|
||||
* starting archive recovery, aborting it, and restarting with an earlier
|
||||
* stop location. If we've already flushed data changes from WAL record X
|
||||
* to disk, we mustn't start up until we reach X again. Zero when not
|
||||
* doing archive recovery.
|
||||
*
|
||||
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
||||
* we are recovering from an online backup and haven't reached the end of
|
||||
* backup yet. It is reset to zero when the end of backup is reached, and
|
||||
* we mustn't start up before that. A boolean would suffice otherwise, but
|
||||
* we use the redo pointer as a cross-check when we see an end-of-backup
|
||||
* record, to make sure the end-of-backup record corresponds the base
|
||||
* backup we're recovering from.
|
||||
*/
|
||||
XLogRecPtr minRecoveryPoint;
|
||||
XLogRecPtr backupStartPoint;
|
||||
|
||||
/*
|
||||
* Parameter settings that determine if the WAL can be used for archival
|
||||
* or hot standby.
|
||||
*/
|
||||
int wal_level;
|
||||
int MaxConnections;
|
||||
int max_prepared_xacts;
|
||||
int max_locks_per_xact;
|
||||
|
||||
/*
|
||||
* This data is used to check for hardware-architecture compatibility of
|
||||
* the database and the backend executable. We need not check endianness
|
||||
* explicitly, since the pg_control version will surely look wrong to a
|
||||
* machine of different endianness, but we do need to worry about MAXALIGN
|
||||
* and floating-point format. (Note: storage layout nominally also
|
||||
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
||||
* on all architectures of interest.)
|
||||
*
|
||||
* Testing just one double value is not a very bulletproof test for
|
||||
* floating-point compatibility, but it will catch most cases.
|
||||
*/
|
||||
uint32 maxAlign; /* alignment requirement for tuples */
|
||||
double floatFormat; /* constant 1234567.0 */
|
||||
#define FLOATFORMAT_VALUE 1234567.0
|
||||
|
||||
/*
|
||||
* This data is used to make sure that configuration of this database is
|
||||
* compatible with the backend executable.
|
||||
*/
|
||||
uint32 blcksz; /* data block size for this DB */
|
||||
uint32 relseg_size; /* blocks per segment of large relation */
|
||||
|
||||
uint32 xlog_blcksz; /* block size within WAL files */
|
||||
uint32 xlog_seg_size; /* size of each WAL segment */
|
||||
|
||||
uint32 nameDataLen; /* catalog name field width */
|
||||
uint32 indexMaxKeys; /* max number of columns in an index */
|
||||
|
||||
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
||||
|
||||
/* flag indicating internal format of timestamp, interval, time */
|
||||
bool enableIntTimes; /* int64 storage enabled? */
|
||||
|
||||
/* flags indicating pass-by-value status of various types */
|
||||
bool float4ByVal; /* float4 pass-by-value? */
|
||||
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
||||
|
||||
/* CRC of all above ... MUST BE LAST! */
|
||||
pg_crc32 crc;
|
||||
} ControlFileData;
|
||||
81
src/postgres/interface/v090.c
Normal file
81
src/postgres/interface/v090.c
Normal file
@ -0,0 +1,81 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.0 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#include "common/debug.h"
|
||||
#include "common/log.h"
|
||||
#include "postgres/interface/v090.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Include PostgreSQL Types
|
||||
***********************************************************************************************************************************/
|
||||
#include "postgres/interface/v090.auto.c"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Is the control file for this version of PostgreSQL?
|
||||
***********************************************************************************************************************************/
|
||||
bool
|
||||
pgInterfaceIs090(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
FUNCTION_TEST_RESULT(
|
||||
BOOL, controlData->pg_control_version == PG_CONTROL_VERSION && controlData->catalog_version_no == CATALOG_VERSION_NO);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Get information from pg_control in a common format
|
||||
***********************************************************************************************************************************/
|
||||
PgControl
|
||||
pgInterfaceControl090(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelTrace);
|
||||
FUNCTION_DEBUG_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_ASSERT(pgInterfaceIs090(controlFile));
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
PgControl result = {0};
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
result.systemId = controlData->system_identifier;
|
||||
result.controlVersion = controlData->pg_control_version;
|
||||
result.catalogVersion = controlData->catalog_version_no;
|
||||
|
||||
result.pageSize = controlData->blcksz;
|
||||
result.walSegmentSize = controlData->xlog_seg_size;
|
||||
|
||||
FUNCTION_DEBUG_RESULT(PG_CONTROL, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Create pg_control for testing
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
|
||||
void
|
||||
pgInterfaceControlTest090(PgControl pgControl, Buffer *buffer)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(PG_CONTROL, pgControl);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(buffer);
|
||||
|
||||
controlData->system_identifier = pgControl.systemId;
|
||||
controlData->pg_control_version = pgControl.controlVersion == 0 ? PG_CONTROL_VERSION : pgControl.controlVersion;
|
||||
controlData->catalog_version_no = pgControl.catalogVersion == 0 ? CATALOG_VERSION_NO : pgControl.catalogVersion;
|
||||
|
||||
controlData->blcksz = pgControl.pageSize;
|
||||
controlData->xlog_seg_size = pgControl.walSegmentSize;
|
||||
|
||||
FUNCTION_TEST_RESULT_VOID();
|
||||
}
|
||||
|
||||
#endif
|
||||
22
src/postgres/interface/v090.h
Normal file
22
src/postgres/interface/v090.h
Normal file
@ -0,0 +1,22 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.0 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#ifndef POSTGRES_INTERFACE_INTERFACE090_H
|
||||
#define POSTGRES_INTERFACE_INTERFACE090_H
|
||||
|
||||
#include "postgres/interface.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Functions
|
||||
***********************************************************************************************************************************/
|
||||
bool pgInterfaceIs090(const Buffer *controlFile);
|
||||
PgControl pgInterfaceControl090(const Buffer *controlFile);
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Test Functions
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
void pgInterfaceControlTest090(PgControl pgControl, Buffer *buffer);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
252
src/postgres/interface/v091.auto.c
Normal file
252
src/postgres/interface/v091.auto.c
Normal file
@ -0,0 +1,252 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.1 Types
|
||||
***********************************************************************************************************************************/
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/c.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef int64_t int64;
|
||||
typedef uint32_t uint32;
|
||||
typedef uint64_t uint64;
|
||||
|
||||
typedef uint32 TransactionId;
|
||||
|
||||
/* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
|
||||
typedef TransactionId MultiXactId;
|
||||
|
||||
typedef uint32 MultiXactOffset;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/pgtime.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* The API of this library is generally similar to the corresponding
|
||||
* C library functions, except that we use pg_time_t which (we hope) is
|
||||
* 64 bits wide, and which is most definitely signed not unsigned.
|
||||
*/
|
||||
typedef int64 pg_time_t;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/postgres_ext.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Object ID is a fundamental type in Postgres.
|
||||
*/
|
||||
typedef unsigned int Oid;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/utils/pg_crc32.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef uint32 pg_crc32;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/access/xlogdefs.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Pointer to a location in the XLOG. These pointers are 64 bits wide,
|
||||
* because we don't want them ever to overflow.
|
||||
*
|
||||
* NOTE: xrecoff == 0 is used to indicate an invalid pointer. This is OK
|
||||
* because we use page headers in the XLOG, so no XLOG record can start
|
||||
* right at the beginning of a file.
|
||||
*
|
||||
* NOTE: the "log file number" is somewhat misnamed, since the actual files
|
||||
* making up the XLOG are much smaller than 4Gb. Each actual file is an
|
||||
* XLogSegSize-byte "segment" of a logical log file having the indicated
|
||||
* xlogid. The log file number and segment number together identify a
|
||||
* physical XLOG file. Segment number and offset within the physical file
|
||||
* are computed from xrecoff div and mod XLogSegSize.
|
||||
*/
|
||||
typedef struct XLogRecPtr
|
||||
{
|
||||
uint32 xlogid; /* log file #, 0 based */
|
||||
uint32 xrecoff; /* byte offset of location in log file */
|
||||
} XLogRecPtr;
|
||||
|
||||
/*
|
||||
* TimeLineID (TLI) - identifies different database histories to prevent
|
||||
* confusion after restoring a prior state of a database installation.
|
||||
* TLI does not change in a normal stop/restart of the database (including
|
||||
* crash-and-recover cases); but we must assign a new TLI after doing
|
||||
* a recovery to a prior state, a/k/a point-in-time recovery. This makes
|
||||
* the new WAL logfile sequence we generate distinguishable from the
|
||||
* sequence that was generated in the previous incarnation.
|
||||
*/
|
||||
typedef uint32 TimeLineID;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/catversion.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* We could use anything we wanted for version numbers, but I recommend
|
||||
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
||||
* YYYYMMDD are the date of the change, and N is the number of the change
|
||||
* on that day. (Hopefully we'll never commit ten independent sets of
|
||||
* catalog changes on the same day...)
|
||||
*/
|
||||
|
||||
/* yyyymmddN */
|
||||
#define CATALOG_VERSION_NO 201105231
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/pg_control.h
|
||||
***********************************************************************************************************************************/
|
||||
/* Version identifier for this pg_control format */
|
||||
#define PG_CONTROL_VERSION 903
|
||||
|
||||
/*
|
||||
* Body of CheckPoint XLOG records. This is declared here because we keep
|
||||
* a copy of the latest one in pg_control for possible disaster recovery.
|
||||
* Changing this struct requires a PG_CONTROL_VERSION bump.
|
||||
*/
|
||||
typedef struct CheckPoint
|
||||
{
|
||||
XLogRecPtr redo; /* next RecPtr available when we began to
|
||||
* create CheckPoint (i.e. REDO start point) */
|
||||
TimeLineID ThisTimeLineID; /* current TLI */
|
||||
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
||||
TransactionId nextXid; /* next free XID */
|
||||
Oid nextOid; /* next free OID */
|
||||
MultiXactId nextMulti; /* next free MultiXactId */
|
||||
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
||||
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
|
||||
Oid oldestXidDB; /* database with minimum datfrozenxid */
|
||||
pg_time_t time; /* time stamp of checkpoint */
|
||||
|
||||
/*
|
||||
* Oldest XID still running. This is only needed to initialize hot standby
|
||||
* mode from an online checkpoint, so we only bother calculating this for
|
||||
* online checkpoints and only when wal_level is hot_standby. Otherwise
|
||||
* it's set to InvalidTransactionId.
|
||||
*/
|
||||
TransactionId oldestActiveXid;
|
||||
} CheckPoint;
|
||||
|
||||
/*
|
||||
* System status indicator. Note this is stored in pg_control; if you change
|
||||
* it, you must bump PG_CONTROL_VERSION
|
||||
*/
|
||||
typedef enum DBState
|
||||
{
|
||||
DB_STARTUP = 0,
|
||||
DB_SHUTDOWNED,
|
||||
DB_SHUTDOWNED_IN_RECOVERY,
|
||||
DB_SHUTDOWNING,
|
||||
DB_IN_CRASH_RECOVERY,
|
||||
DB_IN_ARCHIVE_RECOVERY,
|
||||
DB_IN_PRODUCTION
|
||||
} DBState;
|
||||
|
||||
/*
|
||||
* Contents of pg_control.
|
||||
*
|
||||
* NOTE: try to keep this under 512 bytes so that it will fit on one physical
|
||||
* sector of typical disk drives. This reduces the odds of corruption due to
|
||||
* power failure midway through a write.
|
||||
*/
|
||||
typedef struct ControlFileData
|
||||
{
|
||||
/*
|
||||
* Unique system identifier --- to ensure we match up xlog files with the
|
||||
* installation that produced them.
|
||||
*/
|
||||
uint64 system_identifier;
|
||||
|
||||
/*
|
||||
* Version identifier information. Keep these fields at the same offset,
|
||||
* especially pg_control_version; they won't be real useful if they move
|
||||
* around. (For historical reasons they must be 8 bytes into the file
|
||||
* rather than immediately at the front.)
|
||||
*
|
||||
* pg_control_version identifies the format of pg_control itself.
|
||||
* catalog_version_no identifies the format of the system catalogs.
|
||||
*
|
||||
* There are additional version identifiers in individual files; for
|
||||
* example, WAL logs contain per-page magic numbers that can serve as
|
||||
* version cues for the WAL log.
|
||||
*/
|
||||
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
||||
uint32 catalog_version_no; /* see catversion.h */
|
||||
|
||||
/*
|
||||
* System status data
|
||||
*/
|
||||
DBState state; /* see enum above */
|
||||
pg_time_t time; /* time stamp of last pg_control update */
|
||||
XLogRecPtr checkPoint; /* last check point record ptr */
|
||||
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
||||
|
||||
CheckPoint checkPointCopy; /* copy of last check point record */
|
||||
|
||||
/*
|
||||
* These two values determine the minimum point we must recover up to
|
||||
* before starting up:
|
||||
*
|
||||
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
||||
* flush a data change during archive recovery. That guards against
|
||||
* starting archive recovery, aborting it, and restarting with an earlier
|
||||
* stop location. If we've already flushed data changes from WAL record X
|
||||
* to disk, we mustn't start up until we reach X again. Zero when not
|
||||
* doing archive recovery.
|
||||
*
|
||||
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
||||
* we are recovering from an online backup and haven't reached the end of
|
||||
* backup yet. It is reset to zero when the end of backup is reached, and
|
||||
* we mustn't start up before that. A boolean would suffice otherwise, but
|
||||
* we use the redo pointer as a cross-check when we see an end-of-backup
|
||||
* record, to make sure the end-of-backup record corresponds the base
|
||||
* backup we're recovering from.
|
||||
*/
|
||||
XLogRecPtr minRecoveryPoint;
|
||||
XLogRecPtr backupStartPoint;
|
||||
|
||||
/*
|
||||
* Parameter settings that determine if the WAL can be used for archival
|
||||
* or hot standby.
|
||||
*/
|
||||
int wal_level;
|
||||
int MaxConnections;
|
||||
int max_prepared_xacts;
|
||||
int max_locks_per_xact;
|
||||
|
||||
/*
|
||||
* This data is used to check for hardware-architecture compatibility of
|
||||
* the database and the backend executable. We need not check endianness
|
||||
* explicitly, since the pg_control version will surely look wrong to a
|
||||
* machine of different endianness, but we do need to worry about MAXALIGN
|
||||
* and floating-point format. (Note: storage layout nominally also
|
||||
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
||||
* on all architectures of interest.)
|
||||
*
|
||||
* Testing just one double value is not a very bulletproof test for
|
||||
* floating-point compatibility, but it will catch most cases.
|
||||
*/
|
||||
uint32 maxAlign; /* alignment requirement for tuples */
|
||||
double floatFormat; /* constant 1234567.0 */
|
||||
#define FLOATFORMAT_VALUE 1234567.0
|
||||
|
||||
/*
|
||||
* This data is used to make sure that configuration of this database is
|
||||
* compatible with the backend executable.
|
||||
*/
|
||||
uint32 blcksz; /* data block size for this DB */
|
||||
uint32 relseg_size; /* blocks per segment of large relation */
|
||||
|
||||
uint32 xlog_blcksz; /* block size within WAL files */
|
||||
uint32 xlog_seg_size; /* size of each WAL segment */
|
||||
|
||||
uint32 nameDataLen; /* catalog name field width */
|
||||
uint32 indexMaxKeys; /* max number of columns in an index */
|
||||
|
||||
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
||||
|
||||
/* flag indicating internal format of timestamp, interval, time */
|
||||
bool enableIntTimes; /* int64 storage enabled? */
|
||||
|
||||
/* flags indicating pass-by-value status of various types */
|
||||
bool float4ByVal; /* float4 pass-by-value? */
|
||||
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
||||
|
||||
/* CRC of all above ... MUST BE LAST! */
|
||||
pg_crc32 crc;
|
||||
} ControlFileData;
|
||||
81
src/postgres/interface/v091.c
Normal file
81
src/postgres/interface/v091.c
Normal file
@ -0,0 +1,81 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.1 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#include "common/debug.h"
|
||||
#include "common/log.h"
|
||||
#include "postgres/interface/v091.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Include PostgreSQL Types
|
||||
***********************************************************************************************************************************/
|
||||
#include "postgres/interface/v091.auto.c"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Is the control file for this version of PostgreSQL?
|
||||
***********************************************************************************************************************************/
|
||||
bool
|
||||
pgInterfaceIs091(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
FUNCTION_TEST_RESULT(
|
||||
BOOL, controlData->pg_control_version == PG_CONTROL_VERSION && controlData->catalog_version_no == CATALOG_VERSION_NO);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Get information from pg_control in a common format
|
||||
***********************************************************************************************************************************/
|
||||
PgControl
|
||||
pgInterfaceControl091(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelTrace);
|
||||
FUNCTION_DEBUG_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_ASSERT(pgInterfaceIs091(controlFile));
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
PgControl result = {0};
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
result.systemId = controlData->system_identifier;
|
||||
result.controlVersion = controlData->pg_control_version;
|
||||
result.catalogVersion = controlData->catalog_version_no;
|
||||
|
||||
result.pageSize = controlData->blcksz;
|
||||
result.walSegmentSize = controlData->xlog_seg_size;
|
||||
|
||||
FUNCTION_DEBUG_RESULT(PG_CONTROL, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Create pg_control for testing
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
|
||||
void
|
||||
pgInterfaceControlTest091(PgControl pgControl, Buffer *buffer)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(PG_CONTROL, pgControl);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(buffer);
|
||||
|
||||
controlData->system_identifier = pgControl.systemId;
|
||||
controlData->pg_control_version = pgControl.controlVersion == 0 ? PG_CONTROL_VERSION : pgControl.controlVersion;
|
||||
controlData->catalog_version_no = pgControl.catalogVersion == 0 ? CATALOG_VERSION_NO : pgControl.catalogVersion;
|
||||
|
||||
controlData->blcksz = pgControl.pageSize;
|
||||
controlData->xlog_seg_size = pgControl.walSegmentSize;
|
||||
|
||||
FUNCTION_TEST_RESULT_VOID();
|
||||
}
|
||||
|
||||
#endif
|
||||
22
src/postgres/interface/v091.h
Normal file
22
src/postgres/interface/v091.h
Normal file
@ -0,0 +1,22 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.1 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#ifndef POSTGRES_INTERFACE_INTERFACE091_H
|
||||
#define POSTGRES_INTERFACE_INTERFACE091_H
|
||||
|
||||
#include "postgres/interface.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Functions
|
||||
***********************************************************************************************************************************/
|
||||
bool pgInterfaceIs091(const Buffer *controlFile);
|
||||
PgControl pgInterfaceControl091(const Buffer *controlFile);
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Test Functions
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
void pgInterfaceControlTest091(PgControl pgControl, Buffer *buffer);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
267
src/postgres/interface/v092.auto.c
Normal file
267
src/postgres/interface/v092.auto.c
Normal file
@ -0,0 +1,267 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.2 Types
|
||||
***********************************************************************************************************************************/
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/c.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef int64_t int64;
|
||||
typedef uint32_t uint32;
|
||||
typedef uint64_t uint64;
|
||||
|
||||
typedef uint32 TransactionId;
|
||||
|
||||
/* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
|
||||
typedef TransactionId MultiXactId;
|
||||
|
||||
typedef uint32 MultiXactOffset;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/pgtime.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* The API of this library is generally similar to the corresponding
|
||||
* C library functions, except that we use pg_time_t which (we hope) is
|
||||
* 64 bits wide, and which is most definitely signed not unsigned.
|
||||
*/
|
||||
typedef int64 pg_time_t;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/postgres_ext.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Object ID is a fundamental type in Postgres.
|
||||
*/
|
||||
typedef unsigned int Oid;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/utils/pg_crc32.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef uint32 pg_crc32;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/access/xlogdefs.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Pointer to a location in the XLOG. These pointers are 64 bits wide,
|
||||
* because we don't want them ever to overflow.
|
||||
*
|
||||
* NOTE: xrecoff == 0 is used to indicate an invalid pointer. This is OK
|
||||
* because we use page headers in the XLOG, so no XLOG record can start
|
||||
* right at the beginning of a file.
|
||||
*
|
||||
* NOTE: the "log file number" is somewhat misnamed, since the actual files
|
||||
* making up the XLOG are much smaller than 4Gb. Each actual file is an
|
||||
* XLogSegSize-byte "segment" of a logical log file having the indicated
|
||||
* xlogid. The log file number and segment number together identify a
|
||||
* physical XLOG file. Segment number and offset within the physical file
|
||||
* are computed from xrecoff div and mod XLogSegSize.
|
||||
*/
|
||||
typedef struct XLogRecPtr
|
||||
{
|
||||
uint32 xlogid; /* log file #, 0 based */
|
||||
uint32 xrecoff; /* byte offset of location in log file */
|
||||
} XLogRecPtr;
|
||||
|
||||
/*
|
||||
* TimeLineID (TLI) - identifies different database histories to prevent
|
||||
* confusion after restoring a prior state of a database installation.
|
||||
* TLI does not change in a normal stop/restart of the database (including
|
||||
* crash-and-recover cases); but we must assign a new TLI after doing
|
||||
* a recovery to a prior state, a/k/a point-in-time recovery. This makes
|
||||
* the new WAL logfile sequence we generate distinguishable from the
|
||||
* sequence that was generated in the previous incarnation.
|
||||
*/
|
||||
typedef uint32 TimeLineID;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/catversion.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* We could use anything we wanted for version numbers, but I recommend
|
||||
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
||||
* YYYYMMDD are the date of the change, and N is the number of the change
|
||||
* on that day. (Hopefully we'll never commit ten independent sets of
|
||||
* catalog changes on the same day...)
|
||||
*/
|
||||
|
||||
/* yyyymmddN */
|
||||
#define CATALOG_VERSION_NO 201204301
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/pg_control.h
|
||||
***********************************************************************************************************************************/
|
||||
/* Version identifier for this pg_control format */
|
||||
#define PG_CONTROL_VERSION 922
|
||||
|
||||
/*
|
||||
* Body of CheckPoint XLOG records. This is declared here because we keep
|
||||
* a copy of the latest one in pg_control for possible disaster recovery.
|
||||
* Changing this struct requires a PG_CONTROL_VERSION bump.
|
||||
*/
|
||||
typedef struct CheckPoint
|
||||
{
|
||||
XLogRecPtr redo; /* next RecPtr available when we began to
|
||||
* create CheckPoint (i.e. REDO start point) */
|
||||
TimeLineID ThisTimeLineID; /* current TLI */
|
||||
bool fullPageWrites; /* current full_page_writes */
|
||||
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
||||
TransactionId nextXid; /* next free XID */
|
||||
Oid nextOid; /* next free OID */
|
||||
MultiXactId nextMulti; /* next free MultiXactId */
|
||||
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
||||
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
|
||||
Oid oldestXidDB; /* database with minimum datfrozenxid */
|
||||
pg_time_t time; /* time stamp of checkpoint */
|
||||
|
||||
/*
|
||||
* Oldest XID still running. This is only needed to initialize hot standby
|
||||
* mode from an online checkpoint, so we only bother calculating this for
|
||||
* online checkpoints and only when wal_level is hot_standby. Otherwise
|
||||
* it's set to InvalidTransactionId.
|
||||
*/
|
||||
TransactionId oldestActiveXid;
|
||||
} CheckPoint;
|
||||
|
||||
/*
|
||||
* System status indicator. Note this is stored in pg_control; if you change
|
||||
* it, you must bump PG_CONTROL_VERSION
|
||||
*/
|
||||
typedef enum DBState
|
||||
{
|
||||
DB_STARTUP = 0,
|
||||
DB_SHUTDOWNED,
|
||||
DB_SHUTDOWNED_IN_RECOVERY,
|
||||
DB_SHUTDOWNING,
|
||||
DB_IN_CRASH_RECOVERY,
|
||||
DB_IN_ARCHIVE_RECOVERY,
|
||||
DB_IN_PRODUCTION
|
||||
} DBState;
|
||||
|
||||
/*
|
||||
* Contents of pg_control.
|
||||
*
|
||||
* NOTE: try to keep this under 512 bytes so that it will fit on one physical
|
||||
* sector of typical disk drives. This reduces the odds of corruption due to
|
||||
* power failure midway through a write.
|
||||
*/
|
||||
typedef struct ControlFileData
|
||||
{
|
||||
/*
|
||||
* Unique system identifier --- to ensure we match up xlog files with the
|
||||
* installation that produced them.
|
||||
*/
|
||||
uint64 system_identifier;
|
||||
|
||||
/*
|
||||
* Version identifier information. Keep these fields at the same offset,
|
||||
* especially pg_control_version; they won't be real useful if they move
|
||||
* around. (For historical reasons they must be 8 bytes into the file
|
||||
* rather than immediately at the front.)
|
||||
*
|
||||
* pg_control_version identifies the format of pg_control itself.
|
||||
* catalog_version_no identifies the format of the system catalogs.
|
||||
*
|
||||
* There are additional version identifiers in individual files; for
|
||||
* example, WAL logs contain per-page magic numbers that can serve as
|
||||
* version cues for the WAL log.
|
||||
*/
|
||||
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
||||
uint32 catalog_version_no; /* see catversion.h */
|
||||
|
||||
/*
|
||||
* System status data
|
||||
*/
|
||||
DBState state; /* see enum above */
|
||||
pg_time_t time; /* time stamp of last pg_control update */
|
||||
XLogRecPtr checkPoint; /* last check point record ptr */
|
||||
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
||||
|
||||
CheckPoint checkPointCopy; /* copy of last check point record */
|
||||
|
||||
/*
|
||||
* These two values determine the minimum point we must recover up to
|
||||
* before starting up:
|
||||
*
|
||||
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
||||
* flush a data change during archive recovery. That guards against
|
||||
* starting archive recovery, aborting it, and restarting with an earlier
|
||||
* stop location. If we've already flushed data changes from WAL record X
|
||||
* to disk, we mustn't start up until we reach X again. Zero when not
|
||||
* doing archive recovery.
|
||||
*
|
||||
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
||||
* we are recovering from an online backup and haven't reached the end of
|
||||
* backup yet. It is reset to zero when the end of backup is reached, and
|
||||
* we mustn't start up before that. A boolean would suffice otherwise, but
|
||||
* we use the redo pointer as a cross-check when we see an end-of-backup
|
||||
* record, to make sure the end-of-backup record corresponds the base
|
||||
* backup we're recovering from.
|
||||
*
|
||||
* backupEndPoint is the backup end location, if we are recovering from an
|
||||
* online backup which was taken from the standby and haven't reached the
|
||||
* end of backup yet. It is initialized to the minimum recovery point in
|
||||
* pg_control which was backed up last. It is reset to zero when the end
|
||||
* of backup is reached, and we mustn't start up before that.
|
||||
*
|
||||
* If backupEndRequired is true, we know for sure that we're restoring
|
||||
* from a backup, and must see a backup-end record before we can safely
|
||||
* start up. If it's false, but backupStartPoint is set, a backup_label
|
||||
* file was found at startup but it may have been a leftover from a stray
|
||||
* pg_start_backup() call, not accompanied by pg_stop_backup().
|
||||
*/
|
||||
XLogRecPtr minRecoveryPoint;
|
||||
XLogRecPtr backupStartPoint;
|
||||
XLogRecPtr backupEndPoint;
|
||||
bool backupEndRequired;
|
||||
|
||||
/*
|
||||
* Parameter settings that determine if the WAL can be used for archival
|
||||
* or hot standby.
|
||||
*/
|
||||
int wal_level;
|
||||
int MaxConnections;
|
||||
int max_prepared_xacts;
|
||||
int max_locks_per_xact;
|
||||
|
||||
/*
|
||||
* This data is used to check for hardware-architecture compatibility of
|
||||
* the database and the backend executable. We need not check endianness
|
||||
* explicitly, since the pg_control version will surely look wrong to a
|
||||
* machine of different endianness, but we do need to worry about MAXALIGN
|
||||
* and floating-point format. (Note: storage layout nominally also
|
||||
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
||||
* on all architectures of interest.)
|
||||
*
|
||||
* Testing just one double value is not a very bulletproof test for
|
||||
* floating-point compatibility, but it will catch most cases.
|
||||
*/
|
||||
uint32 maxAlign; /* alignment requirement for tuples */
|
||||
double floatFormat; /* constant 1234567.0 */
|
||||
#define FLOATFORMAT_VALUE 1234567.0
|
||||
|
||||
/*
|
||||
* This data is used to make sure that configuration of this database is
|
||||
* compatible with the backend executable.
|
||||
*/
|
||||
uint32 blcksz; /* data block size for this DB */
|
||||
uint32 relseg_size; /* blocks per segment of large relation */
|
||||
|
||||
uint32 xlog_blcksz; /* block size within WAL files */
|
||||
uint32 xlog_seg_size; /* size of each WAL segment */
|
||||
|
||||
uint32 nameDataLen; /* catalog name field width */
|
||||
uint32 indexMaxKeys; /* max number of columns in an index */
|
||||
|
||||
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
||||
|
||||
/* flag indicating internal format of timestamp, interval, time */
|
||||
bool enableIntTimes; /* int64 storage enabled? */
|
||||
|
||||
/* flags indicating pass-by-value status of various types */
|
||||
bool float4ByVal; /* float4 pass-by-value? */
|
||||
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
||||
|
||||
/* CRC of all above ... MUST BE LAST! */
|
||||
pg_crc32 crc;
|
||||
} ControlFileData;
|
||||
81
src/postgres/interface/v092.c
Normal file
81
src/postgres/interface/v092.c
Normal file
@ -0,0 +1,81 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.2 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#include "common/debug.h"
|
||||
#include "common/log.h"
|
||||
#include "postgres/interface/v092.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Include PostgreSQL Types
|
||||
***********************************************************************************************************************************/
|
||||
#include "postgres/interface/v092.auto.c"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Is the control file for this version of PostgreSQL?
|
||||
***********************************************************************************************************************************/
|
||||
bool
|
||||
pgInterfaceIs092(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
FUNCTION_TEST_RESULT(
|
||||
BOOL, controlData->pg_control_version == PG_CONTROL_VERSION && controlData->catalog_version_no == CATALOG_VERSION_NO);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Get information from pg_control in a common format
|
||||
***********************************************************************************************************************************/
|
||||
PgControl
|
||||
pgInterfaceControl092(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelTrace);
|
||||
FUNCTION_DEBUG_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_ASSERT(pgInterfaceIs092(controlFile));
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
PgControl result = {0};
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
result.systemId = controlData->system_identifier;
|
||||
result.controlVersion = controlData->pg_control_version;
|
||||
result.catalogVersion = controlData->catalog_version_no;
|
||||
|
||||
result.pageSize = controlData->blcksz;
|
||||
result.walSegmentSize = controlData->xlog_seg_size;
|
||||
|
||||
FUNCTION_DEBUG_RESULT(PG_CONTROL, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Create pg_control for testing
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
|
||||
void
|
||||
pgInterfaceControlTest092(PgControl pgControl, Buffer *buffer)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(PG_CONTROL, pgControl);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(buffer);
|
||||
|
||||
controlData->system_identifier = pgControl.systemId;
|
||||
controlData->pg_control_version = pgControl.controlVersion == 0 ? PG_CONTROL_VERSION : pgControl.controlVersion;
|
||||
controlData->catalog_version_no = pgControl.catalogVersion == 0 ? CATALOG_VERSION_NO : pgControl.catalogVersion;
|
||||
|
||||
controlData->blcksz = pgControl.pageSize;
|
||||
controlData->xlog_seg_size = pgControl.walSegmentSize;
|
||||
|
||||
FUNCTION_TEST_RESULT_VOID();
|
||||
}
|
||||
|
||||
#endif
|
||||
22
src/postgres/interface/v092.h
Normal file
22
src/postgres/interface/v092.h
Normal file
@ -0,0 +1,22 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.2 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#ifndef POSTGRES_INTERFACE_INTERFACE092_H
|
||||
#define POSTGRES_INTERFACE_INTERFACE092_H
|
||||
|
||||
#include "postgres/interface.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Functions
|
||||
***********************************************************************************************************************************/
|
||||
bool pgInterfaceIs092(const Buffer *controlFile);
|
||||
PgControl pgInterfaceControl092(const Buffer *controlFile);
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Test Functions
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
void pgInterfaceControlTest092(PgControl pgControl, Buffer *buffer);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
262
src/postgres/interface/v093.auto.c
Normal file
262
src/postgres/interface/v093.auto.c
Normal file
@ -0,0 +1,262 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.3 Types
|
||||
***********************************************************************************************************************************/
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/c.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef int64_t int64;
|
||||
typedef uint32_t uint32;
|
||||
typedef uint64_t uint64;
|
||||
|
||||
typedef uint32 TransactionId;
|
||||
|
||||
/* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
|
||||
typedef TransactionId MultiXactId;
|
||||
|
||||
typedef uint32 MultiXactOffset;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/pgtime.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* The API of this library is generally similar to the corresponding
|
||||
* C library functions, except that we use pg_time_t which (we hope) is
|
||||
* 64 bits wide, and which is most definitely signed not unsigned.
|
||||
*/
|
||||
typedef int64 pg_time_t;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/postgres_ext.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Object ID is a fundamental type in Postgres.
|
||||
*/
|
||||
typedef unsigned int Oid;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/utils/pg_crc32.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef uint32 pg_crc32;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/access/xlogdefs.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Pointer to a location in the XLOG. These pointers are 64 bits wide,
|
||||
* because we don't want them ever to overflow.
|
||||
*/
|
||||
typedef uint64 XLogRecPtr;
|
||||
|
||||
/*
|
||||
* TimeLineID (TLI) - identifies different database histories to prevent
|
||||
* confusion after restoring a prior state of a database installation.
|
||||
* TLI does not change in a normal stop/restart of the database (including
|
||||
* crash-and-recover cases); but we must assign a new TLI after doing
|
||||
* a recovery to a prior state, a/k/a point-in-time recovery. This makes
|
||||
* the new WAL logfile sequence we generate distinguishable from the
|
||||
* sequence that was generated in the previous incarnation.
|
||||
*/
|
||||
typedef uint32 TimeLineID;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/catversion.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* We could use anything we wanted for version numbers, but I recommend
|
||||
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
||||
* YYYYMMDD are the date of the change, and N is the number of the change
|
||||
* on that day. (Hopefully we'll never commit ten independent sets of
|
||||
* catalog changes on the same day...)
|
||||
*/
|
||||
|
||||
/* yyyymmddN */
|
||||
#define CATALOG_VERSION_NO 201306121
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/pg_control.h
|
||||
***********************************************************************************************************************************/
|
||||
/* Version identifier for this pg_control format */
|
||||
#define PG_CONTROL_VERSION 937
|
||||
|
||||
/*
|
||||
* Body of CheckPoint XLOG records. This is declared here because we keep
|
||||
* a copy of the latest one in pg_control for possible disaster recovery.
|
||||
* Changing this struct requires a PG_CONTROL_VERSION bump.
|
||||
*/
|
||||
typedef struct CheckPoint
|
||||
{
|
||||
XLogRecPtr redo; /* next RecPtr available when we began to
|
||||
* create CheckPoint (i.e. REDO start point) */
|
||||
TimeLineID ThisTimeLineID; /* current TLI */
|
||||
TimeLineID PrevTimeLineID; /* previous TLI, if this record begins a new
|
||||
* timeline (equals ThisTimeLineID otherwise) */
|
||||
bool fullPageWrites; /* current full_page_writes */
|
||||
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
||||
TransactionId nextXid; /* next free XID */
|
||||
Oid nextOid; /* next free OID */
|
||||
MultiXactId nextMulti; /* next free MultiXactId */
|
||||
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
||||
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
|
||||
Oid oldestXidDB; /* database with minimum datfrozenxid */
|
||||
MultiXactId oldestMulti; /* cluster-wide minimum datminmxid */
|
||||
Oid oldestMultiDB; /* database with minimum datminmxid */
|
||||
pg_time_t time; /* time stamp of checkpoint */
|
||||
|
||||
/*
|
||||
* Oldest XID still running. This is only needed to initialize hot standby
|
||||
* mode from an online checkpoint, so we only bother calculating this for
|
||||
* online checkpoints and only when wal_level is hot_standby. Otherwise
|
||||
* it's set to InvalidTransactionId.
|
||||
*/
|
||||
TransactionId oldestActiveXid;
|
||||
} CheckPoint;
|
||||
|
||||
/*
|
||||
* System status indicator. Note this is stored in pg_control; if you change
|
||||
* it, you must bump PG_CONTROL_VERSION
|
||||
*/
|
||||
typedef enum DBState
|
||||
{
|
||||
DB_STARTUP = 0,
|
||||
DB_SHUTDOWNED,
|
||||
DB_SHUTDOWNED_IN_RECOVERY,
|
||||
DB_SHUTDOWNING,
|
||||
DB_IN_CRASH_RECOVERY,
|
||||
DB_IN_ARCHIVE_RECOVERY,
|
||||
DB_IN_PRODUCTION
|
||||
} DBState;
|
||||
|
||||
/*
|
||||
* Contents of pg_control.
|
||||
*
|
||||
* NOTE: try to keep this under 512 bytes so that it will fit on one physical
|
||||
* sector of typical disk drives. This reduces the odds of corruption due to
|
||||
* power failure midway through a write.
|
||||
*/
|
||||
typedef struct ControlFileData
|
||||
{
|
||||
/*
|
||||
* Unique system identifier --- to ensure we match up xlog files with the
|
||||
* installation that produced them.
|
||||
*/
|
||||
uint64 system_identifier;
|
||||
|
||||
/*
|
||||
* Version identifier information. Keep these fields at the same offset,
|
||||
* especially pg_control_version; they won't be real useful if they move
|
||||
* around. (For historical reasons they must be 8 bytes into the file
|
||||
* rather than immediately at the front.)
|
||||
*
|
||||
* pg_control_version identifies the format of pg_control itself.
|
||||
* catalog_version_no identifies the format of the system catalogs.
|
||||
*
|
||||
* There are additional version identifiers in individual files; for
|
||||
* example, WAL logs contain per-page magic numbers that can serve as
|
||||
* version cues for the WAL log.
|
||||
*/
|
||||
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
||||
uint32 catalog_version_no; /* see catversion.h */
|
||||
|
||||
/*
|
||||
* System status data
|
||||
*/
|
||||
DBState state; /* see enum above */
|
||||
pg_time_t time; /* time stamp of last pg_control update */
|
||||
XLogRecPtr checkPoint; /* last check point record ptr */
|
||||
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
||||
|
||||
CheckPoint checkPointCopy; /* copy of last check point record */
|
||||
|
||||
XLogRecPtr unloggedLSN; /* current fake LSN value, for unlogged rels */
|
||||
|
||||
/*
|
||||
* These two values determine the minimum point we must recover up to
|
||||
* before starting up:
|
||||
*
|
||||
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
||||
* flush a data change during archive recovery. That guards against
|
||||
* starting archive recovery, aborting it, and restarting with an earlier
|
||||
* stop location. If we've already flushed data changes from WAL record X
|
||||
* to disk, we mustn't start up until we reach X again. Zero when not
|
||||
* doing archive recovery.
|
||||
*
|
||||
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
||||
* we are recovering from an online backup and haven't reached the end of
|
||||
* backup yet. It is reset to zero when the end of backup is reached, and
|
||||
* we mustn't start up before that. A boolean would suffice otherwise, but
|
||||
* we use the redo pointer as a cross-check when we see an end-of-backup
|
||||
* record, to make sure the end-of-backup record corresponds the base
|
||||
* backup we're recovering from.
|
||||
*
|
||||
* backupEndPoint is the backup end location, if we are recovering from an
|
||||
* online backup which was taken from the standby and haven't reached the
|
||||
* end of backup yet. It is initialized to the minimum recovery point in
|
||||
* pg_control which was backed up last. It is reset to zero when the end
|
||||
* of backup is reached, and we mustn't start up before that.
|
||||
*
|
||||
* If backupEndRequired is true, we know for sure that we're restoring
|
||||
* from a backup, and must see a backup-end record before we can safely
|
||||
* start up. If it's false, but backupStartPoint is set, a backup_label
|
||||
* file was found at startup but it may have been a leftover from a stray
|
||||
* pg_start_backup() call, not accompanied by pg_stop_backup().
|
||||
*/
|
||||
XLogRecPtr minRecoveryPoint;
|
||||
TimeLineID minRecoveryPointTLI;
|
||||
XLogRecPtr backupStartPoint;
|
||||
XLogRecPtr backupEndPoint;
|
||||
bool backupEndRequired;
|
||||
|
||||
/*
|
||||
* Parameter settings that determine if the WAL can be used for archival
|
||||
* or hot standby.
|
||||
*/
|
||||
int wal_level;
|
||||
int MaxConnections;
|
||||
int max_prepared_xacts;
|
||||
int max_locks_per_xact;
|
||||
|
||||
/*
|
||||
* This data is used to check for hardware-architecture compatibility of
|
||||
* the database and the backend executable. We need not check endianness
|
||||
* explicitly, since the pg_control version will surely look wrong to a
|
||||
* machine of different endianness, but we do need to worry about MAXALIGN
|
||||
* and floating-point format. (Note: storage layout nominally also
|
||||
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
||||
* on all architectures of interest.)
|
||||
*
|
||||
* Testing just one double value is not a very bulletproof test for
|
||||
* floating-point compatibility, but it will catch most cases.
|
||||
*/
|
||||
uint32 maxAlign; /* alignment requirement for tuples */
|
||||
double floatFormat; /* constant 1234567.0 */
|
||||
#define FLOATFORMAT_VALUE 1234567.0
|
||||
|
||||
/*
|
||||
* This data is used to make sure that configuration of this database is
|
||||
* compatible with the backend executable.
|
||||
*/
|
||||
uint32 blcksz; /* data block size for this DB */
|
||||
uint32 relseg_size; /* blocks per segment of large relation */
|
||||
|
||||
uint32 xlog_blcksz; /* block size within WAL files */
|
||||
uint32 xlog_seg_size; /* size of each WAL segment */
|
||||
|
||||
uint32 nameDataLen; /* catalog name field width */
|
||||
uint32 indexMaxKeys; /* max number of columns in an index */
|
||||
|
||||
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
||||
|
||||
/* flag indicating internal format of timestamp, interval, time */
|
||||
bool enableIntTimes; /* int64 storage enabled? */
|
||||
|
||||
/* flags indicating pass-by-value status of various types */
|
||||
bool float4ByVal; /* float4 pass-by-value? */
|
||||
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
||||
|
||||
/* Are data pages protected by checksums? Zero if no checksum version */
|
||||
uint32 data_checksum_version;
|
||||
|
||||
/* CRC of all above ... MUST BE LAST! */
|
||||
pg_crc32 crc;
|
||||
} ControlFileData;
|
||||
85
src/postgres/interface/v093.c
Normal file
85
src/postgres/interface/v093.c
Normal file
@ -0,0 +1,85 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.3 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#include "common/debug.h"
|
||||
#include "common/log.h"
|
||||
#include "postgres/interface/v093.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Include PostgreSQL Types
|
||||
***********************************************************************************************************************************/
|
||||
#include "postgres/interface/v093.auto.c"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Is the control file for this version of PostgreSQL?
|
||||
***********************************************************************************************************************************/
|
||||
bool
|
||||
pgInterfaceIs093(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
FUNCTION_TEST_RESULT(
|
||||
BOOL, controlData->pg_control_version == PG_CONTROL_VERSION && controlData->catalog_version_no == CATALOG_VERSION_NO);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Get information from pg_control in a common format
|
||||
***********************************************************************************************************************************/
|
||||
PgControl
|
||||
pgInterfaceControl093(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelTrace);
|
||||
FUNCTION_DEBUG_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_ASSERT(pgInterfaceIs093(controlFile));
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
PgControl result = {0};
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
result.systemId = controlData->system_identifier;
|
||||
result.controlVersion = controlData->pg_control_version;
|
||||
result.catalogVersion = controlData->catalog_version_no;
|
||||
|
||||
result.pageSize = controlData->blcksz;
|
||||
result.walSegmentSize = controlData->xlog_seg_size;
|
||||
|
||||
result.pageChecksum = controlData->data_checksum_version != 0;
|
||||
|
||||
FUNCTION_DEBUG_RESULT(PG_CONTROL, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Create pg_control for testing
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
|
||||
void
|
||||
pgInterfaceControlTest093(PgControl pgControl, Buffer *buffer)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(PG_CONTROL, pgControl);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(buffer);
|
||||
|
||||
controlData->system_identifier = pgControl.systemId;
|
||||
controlData->pg_control_version = pgControl.controlVersion == 0 ? PG_CONTROL_VERSION : pgControl.controlVersion;
|
||||
controlData->catalog_version_no = pgControl.catalogVersion == 0 ? CATALOG_VERSION_NO : pgControl.catalogVersion;
|
||||
|
||||
controlData->blcksz = pgControl.pageSize;
|
||||
controlData->xlog_seg_size = pgControl.walSegmentSize;
|
||||
|
||||
controlData->data_checksum_version = pgControl.pageChecksum;
|
||||
|
||||
FUNCTION_TEST_RESULT_VOID();
|
||||
}
|
||||
|
||||
#endif
|
||||
22
src/postgres/interface/v093.h
Normal file
22
src/postgres/interface/v093.h
Normal file
@ -0,0 +1,22 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.3 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#ifndef POSTGRES_INTERFACE_INTERFACE093_H
|
||||
#define POSTGRES_INTERFACE_INTERFACE093_H
|
||||
|
||||
#include "postgres/interface.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Functions
|
||||
***********************************************************************************************************************************/
|
||||
bool pgInterfaceIs093(const Buffer *controlFile);
|
||||
PgControl pgInterfaceControl093(const Buffer *controlFile);
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Test Functions
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
void pgInterfaceControlTest093(PgControl pgControl, Buffer *buffer);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
265
src/postgres/interface/v094.auto.c
Normal file
265
src/postgres/interface/v094.auto.c
Normal file
@ -0,0 +1,265 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.4 Types
|
||||
***********************************************************************************************************************************/
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/c.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef int64_t int64;
|
||||
typedef uint32_t uint32;
|
||||
typedef uint64_t uint64;
|
||||
|
||||
typedef uint32 TransactionId;
|
||||
|
||||
/* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
|
||||
typedef TransactionId MultiXactId;
|
||||
|
||||
typedef uint32 MultiXactOffset;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/pgtime.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* The API of this library is generally similar to the corresponding
|
||||
* C library functions, except that we use pg_time_t which (we hope) is
|
||||
* 64 bits wide, and which is most definitely signed not unsigned.
|
||||
*/
|
||||
typedef int64 pg_time_t;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/postgres_ext.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Object ID is a fundamental type in Postgres.
|
||||
*/
|
||||
typedef unsigned int Oid;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/utils/pg_crc32.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef uint32 pg_crc32;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/access/xlogdefs.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Pointer to a location in the XLOG. These pointers are 64 bits wide,
|
||||
* because we don't want them ever to overflow.
|
||||
*/
|
||||
typedef uint64 XLogRecPtr;
|
||||
|
||||
/*
|
||||
* TimeLineID (TLI) - identifies different database histories to prevent
|
||||
* confusion after restoring a prior state of a database installation.
|
||||
* TLI does not change in a normal stop/restart of the database (including
|
||||
* crash-and-recover cases); but we must assign a new TLI after doing
|
||||
* a recovery to a prior state, a/k/a point-in-time recovery. This makes
|
||||
* the new WAL logfile sequence we generate distinguishable from the
|
||||
* sequence that was generated in the previous incarnation.
|
||||
*/
|
||||
typedef uint32 TimeLineID;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/catversion.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* We could use anything we wanted for version numbers, but I recommend
|
||||
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
||||
* YYYYMMDD are the date of the change, and N is the number of the change
|
||||
* on that day. (Hopefully we'll never commit ten independent sets of
|
||||
* catalog changes on the same day...)
|
||||
*/
|
||||
|
||||
/* yyyymmddN */
|
||||
#define CATALOG_VERSION_NO 201409291
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/pg_control.h
|
||||
***********************************************************************************************************************************/
|
||||
/* Version identifier for this pg_control format */
|
||||
#define PG_CONTROL_VERSION 942
|
||||
|
||||
/*
|
||||
* Body of CheckPoint XLOG records. This is declared here because we keep
|
||||
* a copy of the latest one in pg_control for possible disaster recovery.
|
||||
* Changing this struct requires a PG_CONTROL_VERSION bump.
|
||||
*/
|
||||
typedef struct CheckPoint
|
||||
{
|
||||
XLogRecPtr redo; /* next RecPtr available when we began to
|
||||
* create CheckPoint (i.e. REDO start point) */
|
||||
TimeLineID ThisTimeLineID; /* current TLI */
|
||||
TimeLineID PrevTimeLineID; /* previous TLI, if this record begins a new
|
||||
* timeline (equals ThisTimeLineID otherwise) */
|
||||
bool fullPageWrites; /* current full_page_writes */
|
||||
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
||||
TransactionId nextXid; /* next free XID */
|
||||
Oid nextOid; /* next free OID */
|
||||
MultiXactId nextMulti; /* next free MultiXactId */
|
||||
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
||||
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
|
||||
Oid oldestXidDB; /* database with minimum datfrozenxid */
|
||||
MultiXactId oldestMulti; /* cluster-wide minimum datminmxid */
|
||||
Oid oldestMultiDB; /* database with minimum datminmxid */
|
||||
pg_time_t time; /* time stamp of checkpoint */
|
||||
|
||||
/*
|
||||
* Oldest XID still running. This is only needed to initialize hot standby
|
||||
* mode from an online checkpoint, so we only bother calculating this for
|
||||
* online checkpoints and only when wal_level is hot_standby. Otherwise
|
||||
* it's set to InvalidTransactionId.
|
||||
*/
|
||||
TransactionId oldestActiveXid;
|
||||
} CheckPoint;
|
||||
|
||||
/*
|
||||
* System status indicator. Note this is stored in pg_control; if you change
|
||||
* it, you must bump PG_CONTROL_VERSION
|
||||
*/
|
||||
typedef enum DBState
|
||||
{
|
||||
DB_STARTUP = 0,
|
||||
DB_SHUTDOWNED,
|
||||
DB_SHUTDOWNED_IN_RECOVERY,
|
||||
DB_SHUTDOWNING,
|
||||
DB_IN_CRASH_RECOVERY,
|
||||
DB_IN_ARCHIVE_RECOVERY,
|
||||
DB_IN_PRODUCTION
|
||||
} DBState;
|
||||
|
||||
/*
|
||||
* Contents of pg_control.
|
||||
*
|
||||
* NOTE: try to keep this under 512 bytes so that it will fit on one physical
|
||||
* sector of typical disk drives. This reduces the odds of corruption due to
|
||||
* power failure midway through a write.
|
||||
*/
|
||||
typedef struct ControlFileData
|
||||
{
|
||||
/*
|
||||
* Unique system identifier --- to ensure we match up xlog files with the
|
||||
* installation that produced them.
|
||||
*/
|
||||
uint64 system_identifier;
|
||||
|
||||
/*
|
||||
* Version identifier information. Keep these fields at the same offset,
|
||||
* especially pg_control_version; they won't be real useful if they move
|
||||
* around. (For historical reasons they must be 8 bytes into the file
|
||||
* rather than immediately at the front.)
|
||||
*
|
||||
* pg_control_version identifies the format of pg_control itself.
|
||||
* catalog_version_no identifies the format of the system catalogs.
|
||||
*
|
||||
* There are additional version identifiers in individual files; for
|
||||
* example, WAL logs contain per-page magic numbers that can serve as
|
||||
* version cues for the WAL log.
|
||||
*/
|
||||
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
||||
uint32 catalog_version_no; /* see catversion.h */
|
||||
|
||||
/*
|
||||
* System status data
|
||||
*/
|
||||
DBState state; /* see enum above */
|
||||
pg_time_t time; /* time stamp of last pg_control update */
|
||||
XLogRecPtr checkPoint; /* last check point record ptr */
|
||||
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
||||
|
||||
CheckPoint checkPointCopy; /* copy of last check point record */
|
||||
|
||||
XLogRecPtr unloggedLSN; /* current fake LSN value, for unlogged rels */
|
||||
|
||||
/*
|
||||
* These two values determine the minimum point we must recover up to
|
||||
* before starting up:
|
||||
*
|
||||
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
||||
* flush a data change during archive recovery. That guards against
|
||||
* starting archive recovery, aborting it, and restarting with an earlier
|
||||
* stop location. If we've already flushed data changes from WAL record X
|
||||
* to disk, we mustn't start up until we reach X again. Zero when not
|
||||
* doing archive recovery.
|
||||
*
|
||||
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
||||
* we are recovering from an online backup and haven't reached the end of
|
||||
* backup yet. It is reset to zero when the end of backup is reached, and
|
||||
* we mustn't start up before that. A boolean would suffice otherwise, but
|
||||
* we use the redo pointer as a cross-check when we see an end-of-backup
|
||||
* record, to make sure the end-of-backup record corresponds the base
|
||||
* backup we're recovering from.
|
||||
*
|
||||
* backupEndPoint is the backup end location, if we are recovering from an
|
||||
* online backup which was taken from the standby and haven't reached the
|
||||
* end of backup yet. It is initialized to the minimum recovery point in
|
||||
* pg_control which was backed up last. It is reset to zero when the end
|
||||
* of backup is reached, and we mustn't start up before that.
|
||||
*
|
||||
* If backupEndRequired is true, we know for sure that we're restoring
|
||||
* from a backup, and must see a backup-end record before we can safely
|
||||
* start up. If it's false, but backupStartPoint is set, a backup_label
|
||||
* file was found at startup but it may have been a leftover from a stray
|
||||
* pg_start_backup() call, not accompanied by pg_stop_backup().
|
||||
*/
|
||||
XLogRecPtr minRecoveryPoint;
|
||||
TimeLineID minRecoveryPointTLI;
|
||||
XLogRecPtr backupStartPoint;
|
||||
XLogRecPtr backupEndPoint;
|
||||
bool backupEndRequired;
|
||||
|
||||
/*
|
||||
* Parameter settings that determine if the WAL can be used for archival
|
||||
* or hot standby.
|
||||
*/
|
||||
int wal_level;
|
||||
bool wal_log_hints;
|
||||
int MaxConnections;
|
||||
int max_worker_processes;
|
||||
int max_prepared_xacts;
|
||||
int max_locks_per_xact;
|
||||
|
||||
/*
|
||||
* This data is used to check for hardware-architecture compatibility of
|
||||
* the database and the backend executable. We need not check endianness
|
||||
* explicitly, since the pg_control version will surely look wrong to a
|
||||
* machine of different endianness, but we do need to worry about MAXALIGN
|
||||
* and floating-point format. (Note: storage layout nominally also
|
||||
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
||||
* on all architectures of interest.)
|
||||
*
|
||||
* Testing just one double value is not a very bulletproof test for
|
||||
* floating-point compatibility, but it will catch most cases.
|
||||
*/
|
||||
uint32 maxAlign; /* alignment requirement for tuples */
|
||||
double floatFormat; /* constant 1234567.0 */
|
||||
#define FLOATFORMAT_VALUE 1234567.0
|
||||
|
||||
/*
|
||||
* This data is used to make sure that configuration of this database is
|
||||
* compatible with the backend executable.
|
||||
*/
|
||||
uint32 blcksz; /* data block size for this DB */
|
||||
uint32 relseg_size; /* blocks per segment of large relation */
|
||||
|
||||
uint32 xlog_blcksz; /* block size within WAL files */
|
||||
uint32 xlog_seg_size; /* size of each WAL segment */
|
||||
|
||||
uint32 nameDataLen; /* catalog name field width */
|
||||
uint32 indexMaxKeys; /* max number of columns in an index */
|
||||
|
||||
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
||||
uint32 loblksize; /* chunk size in pg_largeobject */
|
||||
|
||||
/* flag indicating internal format of timestamp, interval, time */
|
||||
bool enableIntTimes; /* int64 storage enabled? */
|
||||
|
||||
/* flags indicating pass-by-value status of various types */
|
||||
bool float4ByVal; /* float4 pass-by-value? */
|
||||
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
||||
|
||||
/* Are data pages protected by checksums? Zero if no checksum version */
|
||||
uint32 data_checksum_version;
|
||||
|
||||
/* CRC of all above ... MUST BE LAST! */
|
||||
pg_crc32 crc;
|
||||
} ControlFileData;
|
||||
85
src/postgres/interface/v094.c
Normal file
85
src/postgres/interface/v094.c
Normal file
@ -0,0 +1,85 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.4 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#include "common/debug.h"
|
||||
#include "common/log.h"
|
||||
#include "postgres/interface/v094.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Include PostgreSQL Types
|
||||
***********************************************************************************************************************************/
|
||||
#include "postgres/interface/v094.auto.c"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Is the control file for this version of PostgreSQL?
|
||||
***********************************************************************************************************************************/
|
||||
bool
|
||||
pgInterfaceIs094(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
FUNCTION_TEST_RESULT(
|
||||
BOOL, controlData->pg_control_version == PG_CONTROL_VERSION && controlData->catalog_version_no == CATALOG_VERSION_NO);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Get information from pg_control in a common format
|
||||
***********************************************************************************************************************************/
|
||||
PgControl
|
||||
pgInterfaceControl094(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelTrace);
|
||||
FUNCTION_DEBUG_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_ASSERT(pgInterfaceIs094(controlFile));
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
PgControl result = {0};
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
result.systemId = controlData->system_identifier;
|
||||
result.controlVersion = controlData->pg_control_version;
|
||||
result.catalogVersion = controlData->catalog_version_no;
|
||||
|
||||
result.pageSize = controlData->blcksz;
|
||||
result.walSegmentSize = controlData->xlog_seg_size;
|
||||
|
||||
result.pageChecksum = controlData->data_checksum_version != 0;
|
||||
|
||||
FUNCTION_DEBUG_RESULT(PG_CONTROL, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Create pg_control for testing
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
|
||||
void
|
||||
pgInterfaceControlTest094(PgControl pgControl, Buffer *buffer)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(PG_CONTROL, pgControl);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(buffer);
|
||||
|
||||
controlData->system_identifier = pgControl.systemId;
|
||||
controlData->pg_control_version = pgControl.controlVersion == 0 ? PG_CONTROL_VERSION : pgControl.controlVersion;
|
||||
controlData->catalog_version_no = pgControl.catalogVersion == 0 ? CATALOG_VERSION_NO : pgControl.catalogVersion;
|
||||
|
||||
controlData->blcksz = pgControl.pageSize;
|
||||
controlData->xlog_seg_size = pgControl.walSegmentSize;
|
||||
|
||||
controlData->data_checksum_version = pgControl.pageChecksum;
|
||||
|
||||
FUNCTION_TEST_RESULT_VOID();
|
||||
}
|
||||
|
||||
#endif
|
||||
22
src/postgres/interface/v094.h
Normal file
22
src/postgres/interface/v094.h
Normal file
@ -0,0 +1,22 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.4 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#ifndef POSTGRES_INTERFACE_INTERFACE094_H
|
||||
#define POSTGRES_INTERFACE_INTERFACE094_H
|
||||
|
||||
#include "postgres/interface.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Functions
|
||||
***********************************************************************************************************************************/
|
||||
bool pgInterfaceIs094(const Buffer *controlFile);
|
||||
PgControl pgInterfaceControl094(const Buffer *controlFile);
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Test Functions
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
void pgInterfaceControlTest094(PgControl pgControl, Buffer *buffer);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
270
src/postgres/interface/v095.auto.c
Normal file
270
src/postgres/interface/v095.auto.c
Normal file
@ -0,0 +1,270 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.5 Types
|
||||
***********************************************************************************************************************************/
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/c.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef int64_t int64;
|
||||
typedef uint32_t uint32;
|
||||
typedef uint64_t uint64;
|
||||
|
||||
typedef uint32 TransactionId;
|
||||
|
||||
/* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
|
||||
typedef TransactionId MultiXactId;
|
||||
|
||||
typedef uint32 MultiXactOffset;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/pgtime.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* The API of this library is generally similar to the corresponding
|
||||
* C library functions, except that we use pg_time_t which (we hope) is
|
||||
* 64 bits wide, and which is most definitely signed not unsigned.
|
||||
*/
|
||||
typedef int64 pg_time_t;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/postgres_ext.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Object ID is a fundamental type in Postgres.
|
||||
*/
|
||||
typedef unsigned int Oid;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/port/pg_crc32c.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef uint32 pg_crc32c;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/access/xlogdefs.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Pointer to a location in the XLOG. These pointers are 64 bits wide,
|
||||
* because we don't want them ever to overflow.
|
||||
*/
|
||||
typedef uint64 XLogRecPtr;
|
||||
|
||||
/*
|
||||
* TimeLineID (TLI) - identifies different database histories to prevent
|
||||
* confusion after restoring a prior state of a database installation.
|
||||
* TLI does not change in a normal stop/restart of the database (including
|
||||
* crash-and-recover cases); but we must assign a new TLI after doing
|
||||
* a recovery to a prior state, a/k/a point-in-time recovery. This makes
|
||||
* the new WAL logfile sequence we generate distinguishable from the
|
||||
* sequence that was generated in the previous incarnation.
|
||||
*/
|
||||
typedef uint32 TimeLineID;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/catversion.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* We could use anything we wanted for version numbers, but I recommend
|
||||
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
||||
* YYYYMMDD are the date of the change, and N is the number of the change
|
||||
* on that day. (Hopefully we'll never commit ten independent sets of
|
||||
* catalog changes on the same day...)
|
||||
*/
|
||||
|
||||
/* yyyymmddN */
|
||||
#define CATALOG_VERSION_NO 201510051
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/pg_control.h
|
||||
***********************************************************************************************************************************/
|
||||
/* Version identifier for this pg_control format */
|
||||
#define PG_CONTROL_VERSION 942
|
||||
|
||||
/*
|
||||
* Body of CheckPoint XLOG records. This is declared here because we keep
|
||||
* a copy of the latest one in pg_control for possible disaster recovery.
|
||||
* Changing this struct requires a PG_CONTROL_VERSION bump.
|
||||
*/
|
||||
typedef struct CheckPoint
|
||||
{
|
||||
XLogRecPtr redo; /* next RecPtr available when we began to
|
||||
* create CheckPoint (i.e. REDO start point) */
|
||||
TimeLineID ThisTimeLineID; /* current TLI */
|
||||
TimeLineID PrevTimeLineID; /* previous TLI, if this record begins a new
|
||||
* timeline (equals ThisTimeLineID otherwise) */
|
||||
bool fullPageWrites; /* current full_page_writes */
|
||||
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
||||
TransactionId nextXid; /* next free XID */
|
||||
Oid nextOid; /* next free OID */
|
||||
MultiXactId nextMulti; /* next free MultiXactId */
|
||||
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
||||
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
|
||||
Oid oldestXidDB; /* database with minimum datfrozenxid */
|
||||
MultiXactId oldestMulti; /* cluster-wide minimum datminmxid */
|
||||
Oid oldestMultiDB; /* database with minimum datminmxid */
|
||||
pg_time_t time; /* time stamp of checkpoint */
|
||||
TransactionId oldestCommitTsXid; /* oldest Xid with valid commit
|
||||
* timestamp */
|
||||
TransactionId newestCommitTsXid; /* newest Xid with valid commit
|
||||
* timestamp */
|
||||
|
||||
/*
|
||||
* Oldest XID still running. This is only needed to initialize hot standby
|
||||
* mode from an online checkpoint, so we only bother calculating this for
|
||||
* online checkpoints and only when wal_level is hot_standby. Otherwise
|
||||
* it's set to InvalidTransactionId.
|
||||
*/
|
||||
TransactionId oldestActiveXid;
|
||||
} CheckPoint;
|
||||
|
||||
/*
|
||||
* System status indicator. Note this is stored in pg_control; if you change
|
||||
* it, you must bump PG_CONTROL_VERSION
|
||||
*/
|
||||
typedef enum DBState
|
||||
{
|
||||
DB_STARTUP = 0,
|
||||
DB_SHUTDOWNED,
|
||||
DB_SHUTDOWNED_IN_RECOVERY,
|
||||
DB_SHUTDOWNING,
|
||||
DB_IN_CRASH_RECOVERY,
|
||||
DB_IN_ARCHIVE_RECOVERY,
|
||||
DB_IN_PRODUCTION
|
||||
} DBState;
|
||||
|
||||
/*
|
||||
* Contents of pg_control.
|
||||
*
|
||||
* NOTE: try to keep this under 512 bytes so that it will fit on one physical
|
||||
* sector of typical disk drives. This reduces the odds of corruption due to
|
||||
* power failure midway through a write.
|
||||
*/
|
||||
typedef struct ControlFileData
|
||||
{
|
||||
/*
|
||||
* Unique system identifier --- to ensure we match up xlog files with the
|
||||
* installation that produced them.
|
||||
*/
|
||||
uint64 system_identifier;
|
||||
|
||||
/*
|
||||
* Version identifier information. Keep these fields at the same offset,
|
||||
* especially pg_control_version; they won't be real useful if they move
|
||||
* around. (For historical reasons they must be 8 bytes into the file
|
||||
* rather than immediately at the front.)
|
||||
*
|
||||
* pg_control_version identifies the format of pg_control itself.
|
||||
* catalog_version_no identifies the format of the system catalogs.
|
||||
*
|
||||
* There are additional version identifiers in individual files; for
|
||||
* example, WAL logs contain per-page magic numbers that can serve as
|
||||
* version cues for the WAL log.
|
||||
*/
|
||||
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
||||
uint32 catalog_version_no; /* see catversion.h */
|
||||
|
||||
/*
|
||||
* System status data
|
||||
*/
|
||||
DBState state; /* see enum above */
|
||||
pg_time_t time; /* time stamp of last pg_control update */
|
||||
XLogRecPtr checkPoint; /* last check point record ptr */
|
||||
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
||||
|
||||
CheckPoint checkPointCopy; /* copy of last check point record */
|
||||
|
||||
XLogRecPtr unloggedLSN; /* current fake LSN value, for unlogged rels */
|
||||
|
||||
/*
|
||||
* These two values determine the minimum point we must recover up to
|
||||
* before starting up:
|
||||
*
|
||||
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
||||
* flush a data change during archive recovery. That guards against
|
||||
* starting archive recovery, aborting it, and restarting with an earlier
|
||||
* stop location. If we've already flushed data changes from WAL record X
|
||||
* to disk, we mustn't start up until we reach X again. Zero when not
|
||||
* doing archive recovery.
|
||||
*
|
||||
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
||||
* we are recovering from an online backup and haven't reached the end of
|
||||
* backup yet. It is reset to zero when the end of backup is reached, and
|
||||
* we mustn't start up before that. A boolean would suffice otherwise, but
|
||||
* we use the redo pointer as a cross-check when we see an end-of-backup
|
||||
* record, to make sure the end-of-backup record corresponds the base
|
||||
* backup we're recovering from.
|
||||
*
|
||||
* backupEndPoint is the backup end location, if we are recovering from an
|
||||
* online backup which was taken from the standby and haven't reached the
|
||||
* end of backup yet. It is initialized to the minimum recovery point in
|
||||
* pg_control which was backed up last. It is reset to zero when the end
|
||||
* of backup is reached, and we mustn't start up before that.
|
||||
*
|
||||
* If backupEndRequired is true, we know for sure that we're restoring
|
||||
* from a backup, and must see a backup-end record before we can safely
|
||||
* start up. If it's false, but backupStartPoint is set, a backup_label
|
||||
* file was found at startup but it may have been a leftover from a stray
|
||||
* pg_start_backup() call, not accompanied by pg_stop_backup().
|
||||
*/
|
||||
XLogRecPtr minRecoveryPoint;
|
||||
TimeLineID minRecoveryPointTLI;
|
||||
XLogRecPtr backupStartPoint;
|
||||
XLogRecPtr backupEndPoint;
|
||||
bool backupEndRequired;
|
||||
|
||||
/*
|
||||
* Parameter settings that determine if the WAL can be used for archival
|
||||
* or hot standby.
|
||||
*/
|
||||
int wal_level;
|
||||
bool wal_log_hints;
|
||||
int MaxConnections;
|
||||
int max_worker_processes;
|
||||
int max_prepared_xacts;
|
||||
int max_locks_per_xact;
|
||||
bool track_commit_timestamp;
|
||||
|
||||
/*
|
||||
* This data is used to check for hardware-architecture compatibility of
|
||||
* the database and the backend executable. We need not check endianness
|
||||
* explicitly, since the pg_control version will surely look wrong to a
|
||||
* machine of different endianness, but we do need to worry about MAXALIGN
|
||||
* and floating-point format. (Note: storage layout nominally also
|
||||
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
||||
* on all architectures of interest.)
|
||||
*
|
||||
* Testing just one double value is not a very bulletproof test for
|
||||
* floating-point compatibility, but it will catch most cases.
|
||||
*/
|
||||
uint32 maxAlign; /* alignment requirement for tuples */
|
||||
double floatFormat; /* constant 1234567.0 */
|
||||
#define FLOATFORMAT_VALUE 1234567.0
|
||||
|
||||
/*
|
||||
* This data is used to make sure that configuration of this database is
|
||||
* compatible with the backend executable.
|
||||
*/
|
||||
uint32 blcksz; /* data block size for this DB */
|
||||
uint32 relseg_size; /* blocks per segment of large relation */
|
||||
|
||||
uint32 xlog_blcksz; /* block size within WAL files */
|
||||
uint32 xlog_seg_size; /* size of each WAL segment */
|
||||
|
||||
uint32 nameDataLen; /* catalog name field width */
|
||||
uint32 indexMaxKeys; /* max number of columns in an index */
|
||||
|
||||
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
||||
uint32 loblksize; /* chunk size in pg_largeobject */
|
||||
|
||||
/* flag indicating internal format of timestamp, interval, time */
|
||||
bool enableIntTimes; /* int64 storage enabled? */
|
||||
|
||||
/* flags indicating pass-by-value status of various types */
|
||||
bool float4ByVal; /* float4 pass-by-value? */
|
||||
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
||||
|
||||
/* Are data pages protected by checksums? Zero if no checksum version */
|
||||
uint32 data_checksum_version;
|
||||
|
||||
/* CRC of all above ... MUST BE LAST! */
|
||||
pg_crc32c crc;
|
||||
} ControlFileData;
|
||||
85
src/postgres/interface/v095.c
Normal file
85
src/postgres/interface/v095.c
Normal file
@ -0,0 +1,85 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.5 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#include "common/debug.h"
|
||||
#include "common/log.h"
|
||||
#include "postgres/interface/v095.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Include PostgreSQL Types
|
||||
***********************************************************************************************************************************/
|
||||
#include "postgres/interface/v095.auto.c"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Is the control file for this version of PostgreSQL?
|
||||
***********************************************************************************************************************************/
|
||||
bool
|
||||
pgInterfaceIs095(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
FUNCTION_TEST_RESULT(
|
||||
BOOL, controlData->pg_control_version == PG_CONTROL_VERSION && controlData->catalog_version_no == CATALOG_VERSION_NO);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Get information from pg_control in a common format
|
||||
***********************************************************************************************************************************/
|
||||
PgControl
|
||||
pgInterfaceControl095(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelTrace);
|
||||
FUNCTION_DEBUG_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_ASSERT(pgInterfaceIs095(controlFile));
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
PgControl result = {0};
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
result.systemId = controlData->system_identifier;
|
||||
result.controlVersion = controlData->pg_control_version;
|
||||
result.catalogVersion = controlData->catalog_version_no;
|
||||
|
||||
result.pageSize = controlData->blcksz;
|
||||
result.walSegmentSize = controlData->xlog_seg_size;
|
||||
|
||||
result.pageChecksum = controlData->data_checksum_version != 0;
|
||||
|
||||
FUNCTION_DEBUG_RESULT(PG_CONTROL, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Create pg_control for testing
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
|
||||
void
|
||||
pgInterfaceControlTest095(PgControl pgControl, Buffer *buffer)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(PG_CONTROL, pgControl);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(buffer);
|
||||
|
||||
controlData->system_identifier = pgControl.systemId;
|
||||
controlData->pg_control_version = pgControl.controlVersion == 0 ? PG_CONTROL_VERSION : pgControl.controlVersion;
|
||||
controlData->catalog_version_no = pgControl.catalogVersion == 0 ? CATALOG_VERSION_NO : pgControl.catalogVersion;
|
||||
|
||||
controlData->blcksz = pgControl.pageSize;
|
||||
controlData->xlog_seg_size = pgControl.walSegmentSize;
|
||||
|
||||
controlData->data_checksum_version = pgControl.pageChecksum;
|
||||
|
||||
FUNCTION_TEST_RESULT_VOID();
|
||||
}
|
||||
|
||||
#endif
|
||||
22
src/postgres/interface/v095.h
Normal file
22
src/postgres/interface/v095.h
Normal file
@ -0,0 +1,22 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.5 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#ifndef POSTGRES_INTERFACE_INTERFACE095_H
|
||||
#define POSTGRES_INTERFACE_INTERFACE095_H
|
||||
|
||||
#include "postgres/interface.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Functions
|
||||
***********************************************************************************************************************************/
|
||||
bool pgInterfaceIs095(const Buffer *controlFile);
|
||||
PgControl pgInterfaceControl095(const Buffer *controlFile);
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Test Functions
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
void pgInterfaceControlTest095(PgControl pgControl, Buffer *buffer);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
270
src/postgres/interface/v096.auto.c
Normal file
270
src/postgres/interface/v096.auto.c
Normal file
@ -0,0 +1,270 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.6 Types
|
||||
***********************************************************************************************************************************/
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/c.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef int64_t int64;
|
||||
typedef uint32_t uint32;
|
||||
typedef uint64_t uint64;
|
||||
|
||||
typedef uint32 TransactionId;
|
||||
|
||||
/* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
|
||||
typedef TransactionId MultiXactId;
|
||||
|
||||
typedef uint32 MultiXactOffset;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/pgtime.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* The API of this library is generally similar to the corresponding
|
||||
* C library functions, except that we use pg_time_t which (we hope) is
|
||||
* 64 bits wide, and which is most definitely signed not unsigned.
|
||||
*/
|
||||
typedef int64 pg_time_t;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/postgres_ext.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Object ID is a fundamental type in Postgres.
|
||||
*/
|
||||
typedef unsigned int Oid;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/port/pg_crc32c.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef uint32 pg_crc32c;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/access/xlogdefs.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Pointer to a location in the XLOG. These pointers are 64 bits wide,
|
||||
* because we don't want them ever to overflow.
|
||||
*/
|
||||
typedef uint64 XLogRecPtr;
|
||||
|
||||
/*
|
||||
* TimeLineID (TLI) - identifies different database histories to prevent
|
||||
* confusion after restoring a prior state of a database installation.
|
||||
* TLI does not change in a normal stop/restart of the database (including
|
||||
* crash-and-recover cases); but we must assign a new TLI after doing
|
||||
* a recovery to a prior state, a/k/a point-in-time recovery. This makes
|
||||
* the new WAL logfile sequence we generate distinguishable from the
|
||||
* sequence that was generated in the previous incarnation.
|
||||
*/
|
||||
typedef uint32 TimeLineID;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/catversion.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* We could use anything we wanted for version numbers, but I recommend
|
||||
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
||||
* YYYYMMDD are the date of the change, and N is the number of the change
|
||||
* on that day. (Hopefully we'll never commit ten independent sets of
|
||||
* catalog changes on the same day...)
|
||||
*/
|
||||
|
||||
/* yyyymmddN */
|
||||
#define CATALOG_VERSION_NO 201608131
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/pg_control.h
|
||||
***********************************************************************************************************************************/
|
||||
/* Version identifier for this pg_control format */
|
||||
#define PG_CONTROL_VERSION 960
|
||||
|
||||
/*
|
||||
* Body of CheckPoint XLOG records. This is declared here because we keep
|
||||
* a copy of the latest one in pg_control for possible disaster recovery.
|
||||
* Changing this struct requires a PG_CONTROL_VERSION bump.
|
||||
*/
|
||||
typedef struct CheckPoint
|
||||
{
|
||||
XLogRecPtr redo; /* next RecPtr available when we began to
|
||||
* create CheckPoint (i.e. REDO start point) */
|
||||
TimeLineID ThisTimeLineID; /* current TLI */
|
||||
TimeLineID PrevTimeLineID; /* previous TLI, if this record begins a new
|
||||
* timeline (equals ThisTimeLineID otherwise) */
|
||||
bool fullPageWrites; /* current full_page_writes */
|
||||
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
||||
TransactionId nextXid; /* next free XID */
|
||||
Oid nextOid; /* next free OID */
|
||||
MultiXactId nextMulti; /* next free MultiXactId */
|
||||
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
||||
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
|
||||
Oid oldestXidDB; /* database with minimum datfrozenxid */
|
||||
MultiXactId oldestMulti; /* cluster-wide minimum datminmxid */
|
||||
Oid oldestMultiDB; /* database with minimum datminmxid */
|
||||
pg_time_t time; /* time stamp of checkpoint */
|
||||
TransactionId oldestCommitTsXid; /* oldest Xid with valid commit
|
||||
* timestamp */
|
||||
TransactionId newestCommitTsXid; /* newest Xid with valid commit
|
||||
* timestamp */
|
||||
|
||||
/*
|
||||
* Oldest XID still running. This is only needed to initialize hot standby
|
||||
* mode from an online checkpoint, so we only bother calculating this for
|
||||
* online checkpoints and only when wal_level is replica. Otherwise it's
|
||||
* set to InvalidTransactionId.
|
||||
*/
|
||||
TransactionId oldestActiveXid;
|
||||
} CheckPoint;
|
||||
|
||||
/*
|
||||
* System status indicator. Note this is stored in pg_control; if you change
|
||||
* it, you must bump PG_CONTROL_VERSION
|
||||
*/
|
||||
typedef enum DBState
|
||||
{
|
||||
DB_STARTUP = 0,
|
||||
DB_SHUTDOWNED,
|
||||
DB_SHUTDOWNED_IN_RECOVERY,
|
||||
DB_SHUTDOWNING,
|
||||
DB_IN_CRASH_RECOVERY,
|
||||
DB_IN_ARCHIVE_RECOVERY,
|
||||
DB_IN_PRODUCTION
|
||||
} DBState;
|
||||
|
||||
/*
|
||||
* Contents of pg_control.
|
||||
*
|
||||
* NOTE: try to keep this under 512 bytes so that it will fit on one physical
|
||||
* sector of typical disk drives. This reduces the odds of corruption due to
|
||||
* power failure midway through a write.
|
||||
*/
|
||||
typedef struct ControlFileData
|
||||
{
|
||||
/*
|
||||
* Unique system identifier --- to ensure we match up xlog files with the
|
||||
* installation that produced them.
|
||||
*/
|
||||
uint64 system_identifier;
|
||||
|
||||
/*
|
||||
* Version identifier information. Keep these fields at the same offset,
|
||||
* especially pg_control_version; they won't be real useful if they move
|
||||
* around. (For historical reasons they must be 8 bytes into the file
|
||||
* rather than immediately at the front.)
|
||||
*
|
||||
* pg_control_version identifies the format of pg_control itself.
|
||||
* catalog_version_no identifies the format of the system catalogs.
|
||||
*
|
||||
* There are additional version identifiers in individual files; for
|
||||
* example, WAL logs contain per-page magic numbers that can serve as
|
||||
* version cues for the WAL log.
|
||||
*/
|
||||
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
||||
uint32 catalog_version_no; /* see catversion.h */
|
||||
|
||||
/*
|
||||
* System status data
|
||||
*/
|
||||
DBState state; /* see enum above */
|
||||
pg_time_t time; /* time stamp of last pg_control update */
|
||||
XLogRecPtr checkPoint; /* last check point record ptr */
|
||||
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
||||
|
||||
CheckPoint checkPointCopy; /* copy of last check point record */
|
||||
|
||||
XLogRecPtr unloggedLSN; /* current fake LSN value, for unlogged rels */
|
||||
|
||||
/*
|
||||
* These two values determine the minimum point we must recover up to
|
||||
* before starting up:
|
||||
*
|
||||
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
||||
* flush a data change during archive recovery. That guards against
|
||||
* starting archive recovery, aborting it, and restarting with an earlier
|
||||
* stop location. If we've already flushed data changes from WAL record X
|
||||
* to disk, we mustn't start up until we reach X again. Zero when not
|
||||
* doing archive recovery.
|
||||
*
|
||||
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
||||
* we are recovering from an online backup and haven't reached the end of
|
||||
* backup yet. It is reset to zero when the end of backup is reached, and
|
||||
* we mustn't start up before that. A boolean would suffice otherwise, but
|
||||
* we use the redo pointer as a cross-check when we see an end-of-backup
|
||||
* record, to make sure the end-of-backup record corresponds the base
|
||||
* backup we're recovering from.
|
||||
*
|
||||
* backupEndPoint is the backup end location, if we are recovering from an
|
||||
* online backup which was taken from the standby and haven't reached the
|
||||
* end of backup yet. It is initialized to the minimum recovery point in
|
||||
* pg_control which was backed up last. It is reset to zero when the end
|
||||
* of backup is reached, and we mustn't start up before that.
|
||||
*
|
||||
* If backupEndRequired is true, we know for sure that we're restoring
|
||||
* from a backup, and must see a backup-end record before we can safely
|
||||
* start up. If it's false, but backupStartPoint is set, a backup_label
|
||||
* file was found at startup but it may have been a leftover from a stray
|
||||
* pg_start_backup() call, not accompanied by pg_stop_backup().
|
||||
*/
|
||||
XLogRecPtr minRecoveryPoint;
|
||||
TimeLineID minRecoveryPointTLI;
|
||||
XLogRecPtr backupStartPoint;
|
||||
XLogRecPtr backupEndPoint;
|
||||
bool backupEndRequired;
|
||||
|
||||
/*
|
||||
* Parameter settings that determine if the WAL can be used for archival
|
||||
* or hot standby.
|
||||
*/
|
||||
int wal_level;
|
||||
bool wal_log_hints;
|
||||
int MaxConnections;
|
||||
int max_worker_processes;
|
||||
int max_prepared_xacts;
|
||||
int max_locks_per_xact;
|
||||
bool track_commit_timestamp;
|
||||
|
||||
/*
|
||||
* This data is used to check for hardware-architecture compatibility of
|
||||
* the database and the backend executable. We need not check endianness
|
||||
* explicitly, since the pg_control version will surely look wrong to a
|
||||
* machine of different endianness, but we do need to worry about MAXALIGN
|
||||
* and floating-point format. (Note: storage layout nominally also
|
||||
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
||||
* on all architectures of interest.)
|
||||
*
|
||||
* Testing just one double value is not a very bulletproof test for
|
||||
* floating-point compatibility, but it will catch most cases.
|
||||
*/
|
||||
uint32 maxAlign; /* alignment requirement for tuples */
|
||||
double floatFormat; /* constant 1234567.0 */
|
||||
#define FLOATFORMAT_VALUE 1234567.0
|
||||
|
||||
/*
|
||||
* This data is used to make sure that configuration of this database is
|
||||
* compatible with the backend executable.
|
||||
*/
|
||||
uint32 blcksz; /* data block size for this DB */
|
||||
uint32 relseg_size; /* blocks per segment of large relation */
|
||||
|
||||
uint32 xlog_blcksz; /* block size within WAL files */
|
||||
uint32 xlog_seg_size; /* size of each WAL segment */
|
||||
|
||||
uint32 nameDataLen; /* catalog name field width */
|
||||
uint32 indexMaxKeys; /* max number of columns in an index */
|
||||
|
||||
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
||||
uint32 loblksize; /* chunk size in pg_largeobject */
|
||||
|
||||
/* flag indicating internal format of timestamp, interval, time */
|
||||
bool enableIntTimes; /* int64 storage enabled? */
|
||||
|
||||
/* flags indicating pass-by-value status of various types */
|
||||
bool float4ByVal; /* float4 pass-by-value? */
|
||||
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
||||
|
||||
/* Are data pages protected by checksums? Zero if no checksum version */
|
||||
uint32 data_checksum_version;
|
||||
|
||||
/* CRC of all above ... MUST BE LAST! */
|
||||
pg_crc32c crc;
|
||||
} ControlFileData;
|
||||
85
src/postgres/interface/v096.c
Normal file
85
src/postgres/interface/v096.c
Normal file
@ -0,0 +1,85 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.6 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#include "common/debug.h"
|
||||
#include "common/log.h"
|
||||
#include "postgres/interface/v096.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Include PostgreSQL Types
|
||||
***********************************************************************************************************************************/
|
||||
#include "postgres/interface/v096.auto.c"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Is the control file for this version of PostgreSQL?
|
||||
***********************************************************************************************************************************/
|
||||
bool
|
||||
pgInterfaceIs096(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
FUNCTION_TEST_RESULT(
|
||||
BOOL, controlData->pg_control_version == PG_CONTROL_VERSION && controlData->catalog_version_no == CATALOG_VERSION_NO);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Get information from pg_control in a common format
|
||||
***********************************************************************************************************************************/
|
||||
PgControl
|
||||
pgInterfaceControl096(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelTrace);
|
||||
FUNCTION_DEBUG_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_ASSERT(pgInterfaceIs096(controlFile));
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
PgControl result = {0};
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
result.systemId = controlData->system_identifier;
|
||||
result.controlVersion = controlData->pg_control_version;
|
||||
result.catalogVersion = controlData->catalog_version_no;
|
||||
|
||||
result.pageSize = controlData->blcksz;
|
||||
result.walSegmentSize = controlData->xlog_seg_size;
|
||||
|
||||
result.pageChecksum = controlData->data_checksum_version != 0;
|
||||
|
||||
FUNCTION_DEBUG_RESULT(PG_CONTROL, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Create pg_control for testing
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
|
||||
void
|
||||
pgInterfaceControlTest096(PgControl pgControl, Buffer *buffer)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(PG_CONTROL, pgControl);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(buffer);
|
||||
|
||||
controlData->system_identifier = pgControl.systemId;
|
||||
controlData->pg_control_version = pgControl.controlVersion == 0 ? PG_CONTROL_VERSION : pgControl.controlVersion;
|
||||
controlData->catalog_version_no = pgControl.catalogVersion == 0 ? CATALOG_VERSION_NO : pgControl.catalogVersion;
|
||||
|
||||
controlData->blcksz = pgControl.pageSize;
|
||||
controlData->xlog_seg_size = pgControl.walSegmentSize;
|
||||
|
||||
controlData->data_checksum_version = pgControl.pageChecksum;
|
||||
|
||||
FUNCTION_TEST_RESULT_VOID();
|
||||
}
|
||||
|
||||
#endif
|
||||
22
src/postgres/interface/v096.h
Normal file
22
src/postgres/interface/v096.h
Normal file
@ -0,0 +1,22 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 9.6 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#ifndef POSTGRES_INTERFACE_INTERFACE096_H
|
||||
#define POSTGRES_INTERFACE_INTERFACE096_H
|
||||
|
||||
#include "postgres/interface.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Functions
|
||||
***********************************************************************************************************************************/
|
||||
bool pgInterfaceIs096(const Buffer *controlFile);
|
||||
PgControl pgInterfaceControl096(const Buffer *controlFile);
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Test Functions
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
void pgInterfaceControlTest096(PgControl pgControl, Buffer *buffer);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
273
src/postgres/interface/v100.auto.c
Normal file
273
src/postgres/interface/v100.auto.c
Normal file
@ -0,0 +1,273 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 10 Types
|
||||
***********************************************************************************************************************************/
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/c.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef int64_t int64;
|
||||
typedef uint32_t uint32;
|
||||
typedef uint64_t uint64;
|
||||
|
||||
typedef uint32 TransactionId;
|
||||
|
||||
/* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
|
||||
typedef TransactionId MultiXactId;
|
||||
|
||||
typedef uint32 MultiXactOffset;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/pgtime.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* The API of this library is generally similar to the corresponding
|
||||
* C library functions, except that we use pg_time_t which (we hope) is
|
||||
* 64 bits wide, and which is most definitely signed not unsigned.
|
||||
*/
|
||||
typedef int64 pg_time_t;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/postgres_ext.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Object ID is a fundamental type in Postgres.
|
||||
*/
|
||||
typedef unsigned int Oid;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/port/pg_crc32c.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef uint32 pg_crc32c;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/access/xlogdefs.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Pointer to a location in the XLOG. These pointers are 64 bits wide,
|
||||
* because we don't want them ever to overflow.
|
||||
*/
|
||||
typedef uint64 XLogRecPtr;
|
||||
|
||||
/*
|
||||
* TimeLineID (TLI) - identifies different database histories to prevent
|
||||
* confusion after restoring a prior state of a database installation.
|
||||
* TLI does not change in a normal stop/restart of the database (including
|
||||
* crash-and-recover cases); but we must assign a new TLI after doing
|
||||
* a recovery to a prior state, a/k/a point-in-time recovery. This makes
|
||||
* the new WAL logfile sequence we generate distinguishable from the
|
||||
* sequence that was generated in the previous incarnation.
|
||||
*/
|
||||
typedef uint32 TimeLineID;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/catversion.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* We could use anything we wanted for version numbers, but I recommend
|
||||
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
||||
* YYYYMMDD are the date of the change, and N is the number of the change
|
||||
* on that day. (Hopefully we'll never commit ten independent sets of
|
||||
* catalog changes on the same day...)
|
||||
*/
|
||||
|
||||
/* yyyymmddN */
|
||||
#define CATALOG_VERSION_NO 201707211
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/pg_control.h
|
||||
***********************************************************************************************************************************/
|
||||
/* Version identifier for this pg_control format */
|
||||
#define PG_CONTROL_VERSION 1002
|
||||
|
||||
/* Nonce key length, see below */
|
||||
#define MOCK_AUTH_NONCE_LEN 32
|
||||
|
||||
/*
|
||||
* Body of CheckPoint XLOG records. This is declared here because we keep
|
||||
* a copy of the latest one in pg_control for possible disaster recovery.
|
||||
* Changing this struct requires a PG_CONTROL_VERSION bump.
|
||||
*/
|
||||
typedef struct CheckPoint
|
||||
{
|
||||
XLogRecPtr redo; /* next RecPtr available when we began to
|
||||
* create CheckPoint (i.e. REDO start point) */
|
||||
TimeLineID ThisTimeLineID; /* current TLI */
|
||||
TimeLineID PrevTimeLineID; /* previous TLI, if this record begins a new
|
||||
* timeline (equals ThisTimeLineID otherwise) */
|
||||
bool fullPageWrites; /* current full_page_writes */
|
||||
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
||||
TransactionId nextXid; /* next free XID */
|
||||
Oid nextOid; /* next free OID */
|
||||
MultiXactId nextMulti; /* next free MultiXactId */
|
||||
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
||||
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
|
||||
Oid oldestXidDB; /* database with minimum datfrozenxid */
|
||||
MultiXactId oldestMulti; /* cluster-wide minimum datminmxid */
|
||||
Oid oldestMultiDB; /* database with minimum datminmxid */
|
||||
pg_time_t time; /* time stamp of checkpoint */
|
||||
TransactionId oldestCommitTsXid; /* oldest Xid with valid commit
|
||||
* timestamp */
|
||||
TransactionId newestCommitTsXid; /* newest Xid with valid commit
|
||||
* timestamp */
|
||||
|
||||
/*
|
||||
* Oldest XID still running. This is only needed to initialize hot standby
|
||||
* mode from an online checkpoint, so we only bother calculating this for
|
||||
* online checkpoints and only when wal_level is replica. Otherwise it's
|
||||
* set to InvalidTransactionId.
|
||||
*/
|
||||
TransactionId oldestActiveXid;
|
||||
} CheckPoint;
|
||||
|
||||
/*
|
||||
* System status indicator. Note this is stored in pg_control; if you change
|
||||
* it, you must bump PG_CONTROL_VERSION
|
||||
*/
|
||||
typedef enum DBState
|
||||
{
|
||||
DB_STARTUP = 0,
|
||||
DB_SHUTDOWNED,
|
||||
DB_SHUTDOWNED_IN_RECOVERY,
|
||||
DB_SHUTDOWNING,
|
||||
DB_IN_CRASH_RECOVERY,
|
||||
DB_IN_ARCHIVE_RECOVERY,
|
||||
DB_IN_PRODUCTION
|
||||
} DBState;
|
||||
|
||||
/*
|
||||
* Contents of pg_control.
|
||||
*/
|
||||
typedef struct ControlFileData
|
||||
{
|
||||
/*
|
||||
* Unique system identifier --- to ensure we match up xlog files with the
|
||||
* installation that produced them.
|
||||
*/
|
||||
uint64 system_identifier;
|
||||
|
||||
/*
|
||||
* Version identifier information. Keep these fields at the same offset,
|
||||
* especially pg_control_version; they won't be real useful if they move
|
||||
* around. (For historical reasons they must be 8 bytes into the file
|
||||
* rather than immediately at the front.)
|
||||
*
|
||||
* pg_control_version identifies the format of pg_control itself.
|
||||
* catalog_version_no identifies the format of the system catalogs.
|
||||
*
|
||||
* There are additional version identifiers in individual files; for
|
||||
* example, WAL logs contain per-page magic numbers that can serve as
|
||||
* version cues for the WAL log.
|
||||
*/
|
||||
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
||||
uint32 catalog_version_no; /* see catversion.h */
|
||||
|
||||
/*
|
||||
* System status data
|
||||
*/
|
||||
DBState state; /* see enum above */
|
||||
pg_time_t time; /* time stamp of last pg_control update */
|
||||
XLogRecPtr checkPoint; /* last check point record ptr */
|
||||
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
||||
|
||||
CheckPoint checkPointCopy; /* copy of last check point record */
|
||||
|
||||
XLogRecPtr unloggedLSN; /* current fake LSN value, for unlogged rels */
|
||||
|
||||
/*
|
||||
* These two values determine the minimum point we must recover up to
|
||||
* before starting up:
|
||||
*
|
||||
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
||||
* flush a data change during archive recovery. That guards against
|
||||
* starting archive recovery, aborting it, and restarting with an earlier
|
||||
* stop location. If we've already flushed data changes from WAL record X
|
||||
* to disk, we mustn't start up until we reach X again. Zero when not
|
||||
* doing archive recovery.
|
||||
*
|
||||
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
||||
* we are recovering from an online backup and haven't reached the end of
|
||||
* backup yet. It is reset to zero when the end of backup is reached, and
|
||||
* we mustn't start up before that. A boolean would suffice otherwise, but
|
||||
* we use the redo pointer as a cross-check when we see an end-of-backup
|
||||
* record, to make sure the end-of-backup record corresponds the base
|
||||
* backup we're recovering from.
|
||||
*
|
||||
* backupEndPoint is the backup end location, if we are recovering from an
|
||||
* online backup which was taken from the standby and haven't reached the
|
||||
* end of backup yet. It is initialized to the minimum recovery point in
|
||||
* pg_control which was backed up last. It is reset to zero when the end
|
||||
* of backup is reached, and we mustn't start up before that.
|
||||
*
|
||||
* If backupEndRequired is true, we know for sure that we're restoring
|
||||
* from a backup, and must see a backup-end record before we can safely
|
||||
* start up. If it's false, but backupStartPoint is set, a backup_label
|
||||
* file was found at startup but it may have been a leftover from a stray
|
||||
* pg_start_backup() call, not accompanied by pg_stop_backup().
|
||||
*/
|
||||
XLogRecPtr minRecoveryPoint;
|
||||
TimeLineID minRecoveryPointTLI;
|
||||
XLogRecPtr backupStartPoint;
|
||||
XLogRecPtr backupEndPoint;
|
||||
bool backupEndRequired;
|
||||
|
||||
/*
|
||||
* Parameter settings that determine if the WAL can be used for archival
|
||||
* or hot standby.
|
||||
*/
|
||||
int wal_level;
|
||||
bool wal_log_hints;
|
||||
int MaxConnections;
|
||||
int max_worker_processes;
|
||||
int max_prepared_xacts;
|
||||
int max_locks_per_xact;
|
||||
bool track_commit_timestamp;
|
||||
|
||||
/*
|
||||
* This data is used to check for hardware-architecture compatibility of
|
||||
* the database and the backend executable. We need not check endianness
|
||||
* explicitly, since the pg_control version will surely look wrong to a
|
||||
* machine of different endianness, but we do need to worry about MAXALIGN
|
||||
* and floating-point format. (Note: storage layout nominally also
|
||||
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
||||
* on all architectures of interest.)
|
||||
*
|
||||
* Testing just one double value is not a very bulletproof test for
|
||||
* floating-point compatibility, but it will catch most cases.
|
||||
*/
|
||||
uint32 maxAlign; /* alignment requirement for tuples */
|
||||
double floatFormat; /* constant 1234567.0 */
|
||||
#define FLOATFORMAT_VALUE 1234567.0
|
||||
|
||||
/*
|
||||
* This data is used to make sure that configuration of this database is
|
||||
* compatible with the backend executable.
|
||||
*/
|
||||
uint32 blcksz; /* data block size for this DB */
|
||||
uint32 relseg_size; /* blocks per segment of large relation */
|
||||
|
||||
uint32 xlog_blcksz; /* block size within WAL files */
|
||||
uint32 xlog_seg_size; /* size of each WAL segment */
|
||||
|
||||
uint32 nameDataLen; /* catalog name field width */
|
||||
uint32 indexMaxKeys; /* max number of columns in an index */
|
||||
|
||||
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
||||
uint32 loblksize; /* chunk size in pg_largeobject */
|
||||
|
||||
/* flags indicating pass-by-value status of various types */
|
||||
bool float4ByVal; /* float4 pass-by-value? */
|
||||
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
||||
|
||||
/* Are data pages protected by checksums? Zero if no checksum version */
|
||||
uint32 data_checksum_version;
|
||||
|
||||
/*
|
||||
* Random nonce, used in authentication requests that need to proceed
|
||||
* based on values that are cluster-unique, like a SASL exchange that
|
||||
* failed at an early stage.
|
||||
*/
|
||||
char mock_authentication_nonce[MOCK_AUTH_NONCE_LEN];
|
||||
|
||||
/* CRC of all above ... MUST BE LAST! */
|
||||
pg_crc32c crc;
|
||||
} ControlFileData;
|
||||
85
src/postgres/interface/v100.c
Normal file
85
src/postgres/interface/v100.c
Normal file
@ -0,0 +1,85 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 10 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#include "common/debug.h"
|
||||
#include "common/log.h"
|
||||
#include "postgres/interface/v100.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Include PostgreSQL Types
|
||||
***********************************************************************************************************************************/
|
||||
#include "postgres/interface/v100.auto.c"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Is the control file for this version of PostgreSQL?
|
||||
***********************************************************************************************************************************/
|
||||
bool
|
||||
pgInterfaceIs100(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
FUNCTION_TEST_RESULT(
|
||||
BOOL, controlData->pg_control_version == PG_CONTROL_VERSION && controlData->catalog_version_no == CATALOG_VERSION_NO);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Get information from pg_control in a common format
|
||||
***********************************************************************************************************************************/
|
||||
PgControl
|
||||
pgInterfaceControl100(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelTrace);
|
||||
FUNCTION_DEBUG_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_ASSERT(pgInterfaceIs100(controlFile));
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
PgControl result = {0};
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
result.systemId = controlData->system_identifier;
|
||||
result.controlVersion = controlData->pg_control_version;
|
||||
result.catalogVersion = controlData->catalog_version_no;
|
||||
|
||||
result.pageSize = controlData->blcksz;
|
||||
result.walSegmentSize = controlData->xlog_seg_size;
|
||||
|
||||
result.pageChecksum = controlData->data_checksum_version != 0;
|
||||
|
||||
FUNCTION_DEBUG_RESULT(PG_CONTROL, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Create pg_control for testing
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
|
||||
void
|
||||
pgInterfaceControlTest100(PgControl pgControl, Buffer *buffer)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(PG_CONTROL, pgControl);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(buffer);
|
||||
|
||||
controlData->system_identifier = pgControl.systemId;
|
||||
controlData->pg_control_version = pgControl.controlVersion == 0 ? PG_CONTROL_VERSION : pgControl.controlVersion;
|
||||
controlData->catalog_version_no = pgControl.catalogVersion == 0 ? CATALOG_VERSION_NO : pgControl.catalogVersion;
|
||||
|
||||
controlData->blcksz = pgControl.pageSize;
|
||||
controlData->xlog_seg_size = pgControl.walSegmentSize;
|
||||
|
||||
controlData->data_checksum_version = pgControl.pageChecksum;
|
||||
|
||||
FUNCTION_TEST_RESULT_VOID();
|
||||
}
|
||||
|
||||
#endif
|
||||
22
src/postgres/interface/v100.h
Normal file
22
src/postgres/interface/v100.h
Normal file
@ -0,0 +1,22 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 10 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#ifndef POSTGRES_INTERFACE_INTERFACE100_H
|
||||
#define POSTGRES_INTERFACE_INTERFACE100_H
|
||||
|
||||
#include "postgres/interface.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Functions
|
||||
***********************************************************************************************************************************/
|
||||
bool pgInterfaceIs100(const Buffer *controlFile);
|
||||
PgControl pgInterfaceControl100(const Buffer *controlFile);
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Test Functions
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
void pgInterfaceControlTest100(PgControl pgControl, Buffer *buffer);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
272
src/postgres/interface/v110.auto.c
Normal file
272
src/postgres/interface/v110.auto.c
Normal file
@ -0,0 +1,272 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 11 Types
|
||||
***********************************************************************************************************************************/
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/c.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef int64_t int64;
|
||||
typedef uint32_t uint32;
|
||||
typedef uint64_t uint64;
|
||||
|
||||
typedef uint32 TransactionId;
|
||||
|
||||
/* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
|
||||
typedef TransactionId MultiXactId;
|
||||
|
||||
typedef uint32 MultiXactOffset;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/pgtime.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* The API of this library is generally similar to the corresponding
|
||||
* C library functions, except that we use pg_time_t which (we hope) is
|
||||
* 64 bits wide, and which is most definitely signed not unsigned.
|
||||
*/
|
||||
typedef int64 pg_time_t;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/postgres_ext.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Object ID is a fundamental type in Postgres.
|
||||
*/
|
||||
typedef unsigned int Oid;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/port/pg_crc32c.h
|
||||
***********************************************************************************************************************************/
|
||||
typedef uint32 pg_crc32c;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/access/xlogdefs.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* Pointer to a location in the XLOG. These pointers are 64 bits wide,
|
||||
* because we don't want them ever to overflow.
|
||||
*/
|
||||
typedef uint64 XLogRecPtr;
|
||||
|
||||
/*
|
||||
* TimeLineID (TLI) - identifies different database histories to prevent
|
||||
* confusion after restoring a prior state of a database installation.
|
||||
* TLI does not change in a normal stop/restart of the database (including
|
||||
* crash-and-recover cases); but we must assign a new TLI after doing
|
||||
* a recovery to a prior state, a/k/a point-in-time recovery. This makes
|
||||
* the new WAL logfile sequence we generate distinguishable from the
|
||||
* sequence that was generated in the previous incarnation.
|
||||
*/
|
||||
typedef uint32 TimeLineID;
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/catversion.h
|
||||
***********************************************************************************************************************************/
|
||||
/*
|
||||
* We could use anything we wanted for version numbers, but I recommend
|
||||
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
||||
* YYYYMMDD are the date of the change, and N is the number of the change
|
||||
* on that day. (Hopefully we'll never commit ten independent sets of
|
||||
* catalog changes on the same day...)
|
||||
*/
|
||||
|
||||
/* yyyymmddN */
|
||||
#define CATALOG_VERSION_NO 201809051
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Types from src/include/catalog/pg_control.h
|
||||
***********************************************************************************************************************************/
|
||||
/* Version identifier for this pg_control format */
|
||||
#define PG_CONTROL_VERSION 1100
|
||||
|
||||
/* Nonce key length, see below */
|
||||
#define MOCK_AUTH_NONCE_LEN 32
|
||||
|
||||
/*
|
||||
* Body of CheckPoint XLOG records. This is declared here because we keep
|
||||
* a copy of the latest one in pg_control for possible disaster recovery.
|
||||
* Changing this struct requires a PG_CONTROL_VERSION bump.
|
||||
*/
|
||||
typedef struct CheckPoint
|
||||
{
|
||||
XLogRecPtr redo; /* next RecPtr available when we began to
|
||||
* create CheckPoint (i.e. REDO start point) */
|
||||
TimeLineID ThisTimeLineID; /* current TLI */
|
||||
TimeLineID PrevTimeLineID; /* previous TLI, if this record begins a new
|
||||
* timeline (equals ThisTimeLineID otherwise) */
|
||||
bool fullPageWrites; /* current full_page_writes */
|
||||
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
||||
TransactionId nextXid; /* next free XID */
|
||||
Oid nextOid; /* next free OID */
|
||||
MultiXactId nextMulti; /* next free MultiXactId */
|
||||
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
||||
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
|
||||
Oid oldestXidDB; /* database with minimum datfrozenxid */
|
||||
MultiXactId oldestMulti; /* cluster-wide minimum datminmxid */
|
||||
Oid oldestMultiDB; /* database with minimum datminmxid */
|
||||
pg_time_t time; /* time stamp of checkpoint */
|
||||
TransactionId oldestCommitTsXid; /* oldest Xid with valid commit
|
||||
* timestamp */
|
||||
TransactionId newestCommitTsXid; /* newest Xid with valid commit
|
||||
* timestamp */
|
||||
|
||||
/*
|
||||
* Oldest XID still running. This is only needed to initialize hot standby
|
||||
* mode from an online checkpoint, so we only bother calculating this for
|
||||
* online checkpoints and only when wal_level is replica. Otherwise it's
|
||||
* set to InvalidTransactionId.
|
||||
*/
|
||||
TransactionId oldestActiveXid;
|
||||
} CheckPoint;
|
||||
|
||||
/*
|
||||
* System status indicator. Note this is stored in pg_control; if you change
|
||||
* it, you must bump PG_CONTROL_VERSION
|
||||
*/
|
||||
typedef enum DBState
|
||||
{
|
||||
DB_STARTUP = 0,
|
||||
DB_SHUTDOWNED,
|
||||
DB_SHUTDOWNED_IN_RECOVERY,
|
||||
DB_SHUTDOWNING,
|
||||
DB_IN_CRASH_RECOVERY,
|
||||
DB_IN_ARCHIVE_RECOVERY,
|
||||
DB_IN_PRODUCTION
|
||||
} DBState;
|
||||
|
||||
/*
|
||||
* Contents of pg_control.
|
||||
*/
|
||||
typedef struct ControlFileData
|
||||
{
|
||||
/*
|
||||
* Unique system identifier --- to ensure we match up xlog files with the
|
||||
* installation that produced them.
|
||||
*/
|
||||
uint64 system_identifier;
|
||||
|
||||
/*
|
||||
* Version identifier information. Keep these fields at the same offset,
|
||||
* especially pg_control_version; they won't be real useful if they move
|
||||
* around. (For historical reasons they must be 8 bytes into the file
|
||||
* rather than immediately at the front.)
|
||||
*
|
||||
* pg_control_version identifies the format of pg_control itself.
|
||||
* catalog_version_no identifies the format of the system catalogs.
|
||||
*
|
||||
* There are additional version identifiers in individual files; for
|
||||
* example, WAL logs contain per-page magic numbers that can serve as
|
||||
* version cues for the WAL log.
|
||||
*/
|
||||
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
||||
uint32 catalog_version_no; /* see catversion.h */
|
||||
|
||||
/*
|
||||
* System status data
|
||||
*/
|
||||
DBState state; /* see enum above */
|
||||
pg_time_t time; /* time stamp of last pg_control update */
|
||||
XLogRecPtr checkPoint; /* last check point record ptr */
|
||||
|
||||
CheckPoint checkPointCopy; /* copy of last check point record */
|
||||
|
||||
XLogRecPtr unloggedLSN; /* current fake LSN value, for unlogged rels */
|
||||
|
||||
/*
|
||||
* These two values determine the minimum point we must recover up to
|
||||
* before starting up:
|
||||
*
|
||||
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
||||
* flush a data change during archive recovery. That guards against
|
||||
* starting archive recovery, aborting it, and restarting with an earlier
|
||||
* stop location. If we've already flushed data changes from WAL record X
|
||||
* to disk, we mustn't start up until we reach X again. Zero when not
|
||||
* doing archive recovery.
|
||||
*
|
||||
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
||||
* we are recovering from an online backup and haven't reached the end of
|
||||
* backup yet. It is reset to zero when the end of backup is reached, and
|
||||
* we mustn't start up before that. A boolean would suffice otherwise, but
|
||||
* we use the redo pointer as a cross-check when we see an end-of-backup
|
||||
* record, to make sure the end-of-backup record corresponds the base
|
||||
* backup we're recovering from.
|
||||
*
|
||||
* backupEndPoint is the backup end location, if we are recovering from an
|
||||
* online backup which was taken from the standby and haven't reached the
|
||||
* end of backup yet. It is initialized to the minimum recovery point in
|
||||
* pg_control which was backed up last. It is reset to zero when the end
|
||||
* of backup is reached, and we mustn't start up before that.
|
||||
*
|
||||
* If backupEndRequired is true, we know for sure that we're restoring
|
||||
* from a backup, and must see a backup-end record before we can safely
|
||||
* start up. If it's false, but backupStartPoint is set, a backup_label
|
||||
* file was found at startup but it may have been a leftover from a stray
|
||||
* pg_start_backup() call, not accompanied by pg_stop_backup().
|
||||
*/
|
||||
XLogRecPtr minRecoveryPoint;
|
||||
TimeLineID minRecoveryPointTLI;
|
||||
XLogRecPtr backupStartPoint;
|
||||
XLogRecPtr backupEndPoint;
|
||||
bool backupEndRequired;
|
||||
|
||||
/*
|
||||
* Parameter settings that determine if the WAL can be used for archival
|
||||
* or hot standby.
|
||||
*/
|
||||
int wal_level;
|
||||
bool wal_log_hints;
|
||||
int MaxConnections;
|
||||
int max_worker_processes;
|
||||
int max_prepared_xacts;
|
||||
int max_locks_per_xact;
|
||||
bool track_commit_timestamp;
|
||||
|
||||
/*
|
||||
* This data is used to check for hardware-architecture compatibility of
|
||||
* the database and the backend executable. We need not check endianness
|
||||
* explicitly, since the pg_control version will surely look wrong to a
|
||||
* machine of different endianness, but we do need to worry about MAXALIGN
|
||||
* and floating-point format. (Note: storage layout nominally also
|
||||
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
||||
* on all architectures of interest.)
|
||||
*
|
||||
* Testing just one double value is not a very bulletproof test for
|
||||
* floating-point compatibility, but it will catch most cases.
|
||||
*/
|
||||
uint32 maxAlign; /* alignment requirement for tuples */
|
||||
double floatFormat; /* constant 1234567.0 */
|
||||
#define FLOATFORMAT_VALUE 1234567.0
|
||||
|
||||
/*
|
||||
* This data is used to make sure that configuration of this database is
|
||||
* compatible with the backend executable.
|
||||
*/
|
||||
uint32 blcksz; /* data block size for this DB */
|
||||
uint32 relseg_size; /* blocks per segment of large relation */
|
||||
|
||||
uint32 xlog_blcksz; /* block size within WAL files */
|
||||
uint32 xlog_seg_size; /* size of each WAL segment */
|
||||
|
||||
uint32 nameDataLen; /* catalog name field width */
|
||||
uint32 indexMaxKeys; /* max number of columns in an index */
|
||||
|
||||
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
||||
uint32 loblksize; /* chunk size in pg_largeobject */
|
||||
|
||||
/* flags indicating pass-by-value status of various types */
|
||||
bool float4ByVal; /* float4 pass-by-value? */
|
||||
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
||||
|
||||
/* Are data pages protected by checksums? Zero if no checksum version */
|
||||
uint32 data_checksum_version;
|
||||
|
||||
/*
|
||||
* Random nonce, used in authentication requests that need to proceed
|
||||
* based on values that are cluster-unique, like a SASL exchange that
|
||||
* failed at an early stage.
|
||||
*/
|
||||
char mock_authentication_nonce[MOCK_AUTH_NONCE_LEN];
|
||||
|
||||
/* CRC of all above ... MUST BE LAST! */
|
||||
pg_crc32c crc;
|
||||
} ControlFileData;
|
||||
85
src/postgres/interface/v110.c
Normal file
85
src/postgres/interface/v110.c
Normal file
@ -0,0 +1,85 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 11 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#include "common/debug.h"
|
||||
#include "common/log.h"
|
||||
#include "postgres/interface/v110.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Include PostgreSQL Types
|
||||
***********************************************************************************************************************************/
|
||||
#include "postgres/interface/v110.auto.c"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Is the control file for this version of PostgreSQL?
|
||||
***********************************************************************************************************************************/
|
||||
bool
|
||||
pgInterfaceIs110(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
FUNCTION_TEST_RESULT(
|
||||
BOOL, controlData->pg_control_version == PG_CONTROL_VERSION && controlData->catalog_version_no == CATALOG_VERSION_NO);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Get information from pg_control in a common format
|
||||
***********************************************************************************************************************************/
|
||||
PgControl
|
||||
pgInterfaceControl110(const Buffer *controlFile)
|
||||
{
|
||||
FUNCTION_DEBUG_BEGIN(logLevelTrace);
|
||||
FUNCTION_DEBUG_PARAM(BUFFER, controlFile);
|
||||
|
||||
FUNCTION_TEST_ASSERT(controlFile != NULL);
|
||||
FUNCTION_TEST_ASSERT(pgInterfaceIs110(controlFile));
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
PgControl result = {0};
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(controlFile);
|
||||
|
||||
result.systemId = controlData->system_identifier;
|
||||
result.controlVersion = controlData->pg_control_version;
|
||||
result.catalogVersion = controlData->catalog_version_no;
|
||||
|
||||
result.pageSize = controlData->blcksz;
|
||||
result.walSegmentSize = controlData->xlog_seg_size;
|
||||
|
||||
result.pageChecksum = controlData->data_checksum_version != 0;
|
||||
|
||||
FUNCTION_DEBUG_RESULT(PG_CONTROL, result);
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Create pg_control for testing
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
|
||||
void
|
||||
pgInterfaceControlTest110(PgControl pgControl, Buffer *buffer)
|
||||
{
|
||||
FUNCTION_TEST_BEGIN();
|
||||
FUNCTION_TEST_PARAM(PG_CONTROL, pgControl);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
ControlFileData *controlData = (ControlFileData *)bufPtr(buffer);
|
||||
|
||||
controlData->system_identifier = pgControl.systemId;
|
||||
controlData->pg_control_version = pgControl.controlVersion == 0 ? PG_CONTROL_VERSION : pgControl.controlVersion;
|
||||
controlData->catalog_version_no = pgControl.catalogVersion == 0 ? CATALOG_VERSION_NO : pgControl.catalogVersion;
|
||||
|
||||
controlData->blcksz = pgControl.pageSize;
|
||||
controlData->xlog_seg_size = pgControl.walSegmentSize;
|
||||
|
||||
controlData->data_checksum_version = pgControl.pageChecksum;
|
||||
|
||||
FUNCTION_TEST_RESULT_VOID();
|
||||
}
|
||||
|
||||
#endif
|
||||
22
src/postgres/interface/v110.h
Normal file
22
src/postgres/interface/v110.h
Normal file
@ -0,0 +1,22 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL 11 Interface
|
||||
***********************************************************************************************************************************/
|
||||
#ifndef POSTGRES_INTERFACE_INTERFACE110_H
|
||||
#define POSTGRES_INTERFACE_INTERFACE110_H
|
||||
|
||||
#include "postgres/interface.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Functions
|
||||
***********************************************************************************************************************************/
|
||||
bool pgInterfaceIs110(const Buffer *controlFile);
|
||||
PgControl pgInterfaceControl110(const Buffer *controlFile);
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Test Functions
|
||||
***********************************************************************************************************************************/
|
||||
#ifdef DEBUG
|
||||
void pgInterfaceControlTest110(PgControl pgControl, Buffer *buffer);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -69,7 +69,6 @@ minimize register spilling. For less sophisticated compilers it might be benefic
|
||||
#include "common/error.h"
|
||||
#include "common/log.h"
|
||||
#include "postgres/pageChecksum.h"
|
||||
#include "postgres/type.h"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
For historical reasons, the 64-bit LSN value is stored as two 32-bit values.
|
||||
@ -143,7 +142,6 @@ pageChecksumBlock(const unsigned char *page, unsigned int pageSize)
|
||||
FUNCTION_TEST_PARAM(UINT, pageSize);
|
||||
|
||||
FUNCTION_TEST_ASSERT(page != NULL);
|
||||
FUNCTION_TEST_ASSERT(pageSize == PG_PAGE_SIZE);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
uint32_t sums[N_SUMS];
|
||||
@ -186,7 +184,6 @@ pageChecksum(const unsigned char *page, unsigned int blockNo, unsigned int pageS
|
||||
FUNCTION_TEST_PARAM(UINT, pageSize);
|
||||
|
||||
FUNCTION_TEST_ASSERT(page != NULL);
|
||||
FUNCTION_TEST_ASSERT(pageSize == PG_PAGE_SIZE);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
// Save pd_checksum and temporarily set it to zero, so that the checksum calculation isn't affected by the old checksum stored
|
||||
@ -220,7 +217,6 @@ pageChecksumTest(
|
||||
FUNCTION_TEST_PARAM(UINT32, ignoreWalOffset);
|
||||
|
||||
FUNCTION_TEST_ASSERT(page != NULL);
|
||||
FUNCTION_TEST_ASSERT(pageSize == PG_PAGE_SIZE);
|
||||
FUNCTION_TEST_END();
|
||||
|
||||
FUNCTION_TEST_RESULT(
|
||||
@ -251,7 +247,6 @@ pageChecksumBufferTest(
|
||||
|
||||
FUNCTION_TEST_ASSERT(pageBuffer != NULL);
|
||||
FUNCTION_DEBUG_ASSERT(pageBufferSize > 0);
|
||||
FUNCTION_DEBUG_ASSERT(pageSize == PG_PAGE_SIZE);
|
||||
FUNCTION_DEBUG_ASSERT(pageBufferSize % pageSize == 0);
|
||||
FUNCTION_DEBUG_END();
|
||||
|
||||
|
||||
@ -1,31 +0,0 @@
|
||||
/***********************************************************************************************************************************
|
||||
PostreSQL Types
|
||||
***********************************************************************************************************************************/
|
||||
#ifndef POSTGRES_TYPE_H
|
||||
#define POSTGRES_TYPE_H
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Define page size
|
||||
|
||||
Page size can only be changed at compile time and and is not known to be well-tested, so only the default page size is supported.
|
||||
***********************************************************************************************************************************/
|
||||
#define PG_PAGE_SIZE 8192
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
Defines for various Postgres paths and files
|
||||
***********************************************************************************************************************************/
|
||||
#define PG_FILE_PGCONTROL "pg_control"
|
||||
|
||||
#define PG_PATH_GLOBAL "global"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
pg_control file data
|
||||
***********************************************************************************************************************************/
|
||||
typedef struct PgControlFile
|
||||
{
|
||||
uint64_t systemId;
|
||||
uint32_t controlVersion;
|
||||
uint32_t catalogVersion;
|
||||
} PgControlFile;
|
||||
|
||||
#endif
|
||||
@ -4,6 +4,11 @@ PostreSQL Version Constants
|
||||
#ifndef POSTGRES_VERSION_H
|
||||
#define POSTGRES_VERSION_H
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL name
|
||||
***********************************************************************************************************************************/
|
||||
#define PG_NAME "PostgreSQL"
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL version constants
|
||||
***********************************************************************************************************************************/
|
||||
@ -19,4 +24,19 @@ PostgreSQL version constants
|
||||
#define PG_VERSION_10 100000
|
||||
#define PG_VERSION_11 110000
|
||||
|
||||
/***********************************************************************************************************************************
|
||||
PostgreSQL version string constants for use in error messages
|
||||
***********************************************************************************************************************************/
|
||||
#define PG_VERSION_83_STR "8.3"
|
||||
#define PG_VERSION_84_STR "8.4"
|
||||
#define PG_VERSION_90_STR "9.0"
|
||||
#define PG_VERSION_91_STR "9.1"
|
||||
#define PG_VERSION_92_STR "9.2"
|
||||
#define PG_VERSION_93_STR "9.3"
|
||||
#define PG_VERSION_94_STR "9.4"
|
||||
#define PG_VERSION_95_STR "9.5"
|
||||
#define PG_VERSION_96_STR "9.6"
|
||||
#define PG_VERSION_10_STR "10"
|
||||
#define PG_VERSION_11_STR "11"
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user