xlog_internal.h File Reference

#include "access/xlogdefs.h"
#include "access/xlogreader.h"
#include "datatype/timestamp.h"
#include "lib/stringinfo.h"
#include "pgtime.h"
#include "storage/block.h"
#include "storage/relfilelocator.h"

Include dependency graph for xlog_internal.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	XLogPageHeaderData
struct	XLogLongPageHeaderData
struct	xl_parameter_change
struct	xl_restore_point
struct	xl_overwrite_contrecord
struct	xl_end_of_recovery
struct	XLogRecData
struct	RmgrData

Macros
#define	XLOG_PAGE_MAGIC   0xD119 /* can be used as WAL version indicator */
#define	SizeOfXLogShortPHD   MAXALIGN(sizeof(XLogPageHeaderData))
#define	SizeOfXLogLongPHD   MAXALIGN(sizeof(XLogLongPageHeaderData))
#define	XLP_FIRST_IS_CONTRECORD   0x0001
#define	XLP_LONG_HEADER   0x0002
#define	XLP_BKP_REMOVABLE   0x0004
#define	XLP_FIRST_IS_OVERWRITE_CONTRECORD   0x0008
#define	XLP_ALL_FLAGS   0x000F
#define	XLogPageHeaderSize(hdr)    (((hdr)->xlp_info & XLP_LONG_HEADER) ? SizeOfXLogLongPHD : SizeOfXLogShortPHD)
#define	WalSegMinSize   1024 * 1024
#define	WalSegMaxSize   1024 * 1024 * 1024
#define	DEFAULT_MIN_WAL_SEGS   5
#define	DEFAULT_MAX_WAL_SEGS   64
#define	IsPowerOf2(x)   (x > 0 && ((x) & ((x)-1)) == 0)
#define	IsValidWalSegSize(size)
#define	XLogSegmentsPerXLogId(wal_segsz_bytes)    (UINT64CONST(0x100000000) / (wal_segsz_bytes))
#define	XLogSegNoOffsetToRecPtr(segno, offset, wal_segsz_bytes, dest)    (dest) = (segno) * (wal_segsz_bytes) + (offset)
#define	XLogSegmentOffset(xlogptr, wal_segsz_bytes)    ((xlogptr) & ((wal_segsz_bytes) - 1))
#define	XLByteToSeg(xlrp, logSegNo, wal_segsz_bytes)    logSegNo = (xlrp) / (wal_segsz_bytes)
#define	XLByteToPrevSeg(xlrp, logSegNo, wal_segsz_bytes)    logSegNo = ((xlrp) - 1) / (wal_segsz_bytes)
#define	XLogMBVarToSegs(mbvar, wal_segsz_bytes)    ((mbvar) / ((wal_segsz_bytes) / (1024 * 1024)))
#define	XLByteInSeg(xlrp, logSegNo, wal_segsz_bytes)    (((xlrp) / (wal_segsz_bytes)) == (logSegNo))
#define	XLByteInPrevSeg(xlrp, logSegNo, wal_segsz_bytes)    ((((xlrp) - 1) / (wal_segsz_bytes)) == (logSegNo))
#define	XRecOffIsValid(xlrp)    ((xlrp) % XLOG_BLCKSZ >= SizeOfXLogShortPHD)
#define	XLOGDIR   "pg_wal"
#define	XLOG_CONTROL_FILE   "global/pg_control"
#define	MAXFNAMELEN   64
#define	XLOG_FNAME_LEN   24

Typedefs
typedef struct XLogPageHeaderData	XLogPageHeaderData
typedef XLogPageHeaderData *	XLogPageHeader
typedef struct XLogLongPageHeaderData	XLogLongPageHeaderData
typedef XLogLongPageHeaderData *	XLogLongPageHeader
typedef struct xl_parameter_change	xl_parameter_change
typedef struct xl_restore_point	xl_restore_point
typedef struct xl_overwrite_contrecord	xl_overwrite_contrecord
typedef struct xl_end_of_recovery	xl_end_of_recovery
typedef struct XLogRecData	XLogRecData
typedef struct RmgrData	RmgrData

Functions
static void	XLogFileName (char *fname, TimeLineID tli, XLogSegNo logSegNo, int wal_segsz_bytes)
static void	XLogFileNameById (char *fname, TimeLineID tli, uint32 log, uint32 seg)
static bool	IsXLogFileName (const char *fname)
static bool	IsPartialXLogFileName (const char *fname)
static void	XLogFromFileName (const char *fname, TimeLineID *tli, XLogSegNo *logSegNo, int wal_segsz_bytes)
static void	XLogFilePath (char *path, TimeLineID tli, XLogSegNo logSegNo, int wal_segsz_bytes)
static void	TLHistoryFileName (char *fname, TimeLineID tli)
static bool	IsTLHistoryFileName (const char *fname)
static void	TLHistoryFilePath (char *path, TimeLineID tli)
static void	StatusFilePath (char *path, const char *xlog, const char *suffix)
static void	BackupHistoryFileName (char *fname, TimeLineID tli, XLogSegNo logSegNo, XLogRecPtr startpoint, int wal_segsz_bytes)
static bool	IsBackupHistoryFileName (const char *fname)
static void	BackupHistoryFilePath (char *path, TimeLineID tli, XLogSegNo logSegNo, XLogRecPtr startpoint, int wal_segsz_bytes)
void	RmgrStartup (void)
void	RmgrCleanup (void)
void	RmgrNotFound (RmgrId rmid)
void	RegisterCustomRmgr (RmgrId rmid, const RmgrData *rmgr)
static bool	RmgrIdExists (RmgrId rmid)
static RmgrData	GetRmgr (RmgrId rmid)
pg_time_t	GetLastSegSwitchData (XLogRecPtr *lastSwitchLSN)
XLogRecPtr	RequestXLogSwitch (bool mark_unimportant)
void	GetOldestRestartPoint (XLogRecPtr *oldrecptr, TimeLineID *oldtli)
void	XLogRecGetBlockRefInfo (XLogReaderState *record, bool pretty, bool detailed_format, StringInfo buf, uint32 *fpi_len)

Variables
PGDLLIMPORT RmgrData	RmgrTable []
PGDLLIMPORT bool	ArchiveRecoveryRequested
PGDLLIMPORT bool	InArchiveRecovery
PGDLLIMPORT bool	StandbyMode
PGDLLIMPORT char *	recoveryRestoreCommand

Macro Definition Documentation

DEFAULT_MAX_WAL_SEGS

#define DEFAULT_MAX_WAL_SEGS   64

Definition at line 92 of file xlog_internal.h.

DEFAULT_MIN_WAL_SEGS

#define DEFAULT_MIN_WAL_SEGS   5

Definition at line 91 of file xlog_internal.h.

IsPowerOf2

#define IsPowerOf2

(

x

)

(x > 0 && ((x) & ((x)-1)) == 0)

Definition at line 95 of file xlog_internal.h.

IsValidWalSegSize

#define IsValidWalSegSize

(

size

)

Value:

     (IsPowerOf2(size) && \
     ((size) >= WalSegMinSize && (size) <= WalSegMaxSize))

Definition at line 96 of file xlog_internal.h.

MAXFNAMELEN

#define MAXFNAMELEN   64

Definition at line 156 of file xlog_internal.h.

SizeOfXLogLongPHD

#define SizeOfXLogLongPHD   MAXALIGN(sizeof(XLogLongPageHeaderData))

Definition at line 69 of file xlog_internal.h.

SizeOfXLogShortPHD

#define SizeOfXLogShortPHD   MAXALIGN(sizeof(XLogPageHeaderData))

Definition at line 52 of file xlog_internal.h.

WalSegMaxSize

#define WalSegMaxSize   1024 * 1024 * 1024

Definition at line 89 of file xlog_internal.h.

WalSegMinSize

#define WalSegMinSize   1024 * 1024

Definition at line 88 of file xlog_internal.h.

XLByteInPrevSeg

#define XLByteInPrevSeg	(		xlrp,
			logSegNo,
			wal_segsz_bytes
	)		((((xlrp) - 1) / (wal_segsz_bytes)) == (logSegNo))

Definition at line 139 of file xlog_internal.h.

XLByteInSeg

#define XLByteInSeg	(		xlrp,
			logSegNo,
			wal_segsz_bytes
	)		(((xlrp) / (wal_segsz_bytes)) == (logSegNo))

Definition at line 136 of file xlog_internal.h.

XLByteToPrevSeg

#define XLByteToPrevSeg	(		xlrp,
			logSegNo,
			wal_segsz_bytes
	)		logSegNo = ((xlrp) - 1) / (wal_segsz_bytes)

Definition at line 120 of file xlog_internal.h.

XLByteToSeg

#define XLByteToSeg	(		xlrp,
			logSegNo,
			wal_segsz_bytes
	)		logSegNo = (xlrp) / (wal_segsz_bytes)

Definition at line 117 of file xlog_internal.h.

XLOG_CONTROL_FILE

#define XLOG_CONTROL_FILE   "global/pg_control"

Definition at line 150 of file xlog_internal.h.

XLOG_FNAME_LEN

#define XLOG_FNAME_LEN   24

Definition at line 159 of file xlog_internal.h.

XLOG_PAGE_MAGIC

#define XLOG_PAGE_MAGIC   0xD119 /* can be used as WAL version indicator */

Definition at line 34 of file xlog_internal.h.

XLOGDIR

#define XLOGDIR   "pg_wal"

Definition at line 149 of file xlog_internal.h.

XLogMBVarToSegs

#define XLogMBVarToSegs	(		mbvar,
			wal_segsz_bytes
	)		((mbvar) / ((wal_segsz_bytes) / (1024 * 1024)))

Definition at line 127 of file xlog_internal.h.

XLogPageHeaderSize

#define XLogPageHeaderSize

(

hdr

)

(((hdr)->xlp_info & XLP_LONG_HEADER) ? SizeOfXLogLongPHD : SizeOfXLogShortPHD)

Definition at line 84 of file xlog_internal.h.

XLogSegmentOffset

#define XLogSegmentOffset	(		xlogptr,
			wal_segsz_bytes
	)		((xlogptr) & ((wal_segsz_bytes) - 1))

Definition at line 106 of file xlog_internal.h.

XLogSegmentsPerXLogId

#define XLogSegmentsPerXLogId

(

wal_segsz_bytes

)

(UINT64CONST(0x100000000) / (wal_segsz_bytes))

Definition at line 100 of file xlog_internal.h.

XLogSegNoOffsetToRecPtr

#define XLogSegNoOffsetToRecPtr	(		segno,
			offset,
			wal_segsz_bytes,
			dest
	)		(dest) = (segno) * (wal_segsz_bytes) + (offset)

Definition at line 103 of file xlog_internal.h.

XLP_ALL_FLAGS

#define XLP_ALL_FLAGS   0x000F

Definition at line 82 of file xlog_internal.h.

XLP_BKP_REMOVABLE

#define XLP_BKP_REMOVABLE   0x0004

Definition at line 78 of file xlog_internal.h.

XLP_FIRST_IS_CONTRECORD

#define XLP_FIRST_IS_CONTRECORD   0x0001

Definition at line 74 of file xlog_internal.h.

XLP_FIRST_IS_OVERWRITE_CONTRECORD

#define XLP_FIRST_IS_OVERWRITE_CONTRECORD   0x0008

Definition at line 80 of file xlog_internal.h.

XLP_LONG_HEADER

#define XLP_LONG_HEADER   0x0002

Definition at line 76 of file xlog_internal.h.

XRecOffIsValid

#define XRecOffIsValid

(

xlrp

)

((xlrp) % XLOG_BLCKSZ >= SizeOfXLogShortPHD)

Definition at line 143 of file xlog_internal.h.

Typedef Documentation

RmgrData

typedef struct RmgrData RmgrData

xl_end_of_recovery

typedef struct xl_end_of_recovery xl_end_of_recovery

xl_overwrite_contrecord

typedef struct xl_overwrite_contrecord xl_overwrite_contrecord

xl_parameter_change

typedef struct xl_parameter_change xl_parameter_change

xl_restore_point

typedef struct xl_restore_point xl_restore_point

XLogLongPageHeader

typedef XLogLongPageHeaderData* XLogLongPageHeader

Definition at line 71 of file xlog_internal.h.

XLogLongPageHeaderData

typedef struct XLogLongPageHeaderData XLogLongPageHeaderData

XLogPageHeader

typedef XLogPageHeaderData* XLogPageHeader

Definition at line 54 of file xlog_internal.h.

XLogPageHeaderData

typedef struct XLogPageHeaderData XLogPageHeaderData

XLogRecData

typedef struct XLogRecData XLogRecData

Function Documentation

BackupHistoryFileName()

static void BackupHistoryFileName ( char *  fname, TimeLineID  tli, XLogSegNo  logSegNo, XLogRecPtr  startpoint, int  wal_segsz_bytes  )

inlinestatic

Definition at line 244 of file xlog_internal.h.

{
    snprintf(fname, MAXFNAMELEN, "%08X%08X%08X.%08X.backup", tli,
             (uint32) (logSegNo / XLogSegmentsPerXLogId(wal_segsz_bytes)),
             (uint32) (logSegNo % XLogSegmentsPerXLogId(wal_segsz_bytes)),
             (uint32) (XLogSegmentOffset(startpoint, wal_segsz_bytes)));
}

References MAXFNAMELEN, snprintf, XLogSegmentOffset, and XLogSegmentsPerXLogId.

Referenced by do_pg_backup_stop().

BackupHistoryFilePath()

static void BackupHistoryFilePath ( char *  path, TimeLineID  tli, XLogSegNo  logSegNo, XLogRecPtr  startpoint, int  wal_segsz_bytes  )

inlinestatic

Definition at line 261 of file xlog_internal.h.

{
    snprintf(path, MAXPGPATH, XLOGDIR "/%08X%08X%08X.%08X.backup", tli,
             (uint32) (logSegNo / XLogSegmentsPerXLogId(wal_segsz_bytes)),
             (uint32) (logSegNo % XLogSegmentsPerXLogId(wal_segsz_bytes)),
             (uint32) (XLogSegmentOffset((startpoint), wal_segsz_bytes)));
}

References MAXPGPATH, snprintf, XLOGDIR, XLogSegmentOffset, and XLogSegmentsPerXLogId.

Referenced by do_pg_backup_stop().

GetLastSegSwitchData()

pg_time_t GetLastSegSwitchData

(

XLogRecPtr *

lastSwitchLSN

)

Definition at line 6657 of file xlog.c.

{
    pg_time_t   result;
 
    /* Need WALWriteLock, but shared lock is sufficient */
    LWLockAcquire(WALWriteLock, LW_SHARED);
    result = XLogCtl->lastSegSwitchTime;
    *lastSwitchLSN = XLogCtl->lastSegSwitchLSN;
    LWLockRelease(WALWriteLock);
 
    return result;
}

References XLogCtlData::lastSegSwitchLSN, XLogCtlData::lastSegSwitchTime, LW_SHARED, LWLockAcquire(), LWLockRelease(), and XLogCtl.

Referenced by CheckArchiveTimeout().

GetOldestRestartPoint()

void GetOldestRestartPoint	(	XLogRecPtr *	oldrecptr,
		TimeLineID *	oldtli
	)

Definition at line 9527 of file xlog.c.

{
    LWLockAcquire(ControlFileLock, LW_SHARED);
    *oldrecptr = ControlFile->checkPointCopy.redo;
    *oldtli = ControlFile->checkPointCopy.ThisTimeLineID;
    LWLockRelease(ControlFileLock);
}

References ControlFileData::checkPointCopy, ControlFile, LW_SHARED, LWLockAcquire(), LWLockRelease(), CheckPoint::redo, and CheckPoint::ThisTimeLineID.

Referenced by ExecuteRecoveryCommand(), and RestoreArchivedFile().

GetRmgr()

static RmgrData GetRmgr ( RmgrId  rmid )

inlinestatic

Definition at line 366 of file xlog_internal.h.

{
    if (unlikely(!RmgrIdExists(rmid)))
        RmgrNotFound(rmid);
    return RmgrTable[rmid];
}

References RmgrIdExists(), RmgrNotFound(), RmgrTable, and unlikely.

Referenced by ApplyWalRecord(), check_wal_consistency_checking(), GetWALBlockInfo(), GetWALRecordInfo(), GetXLogSummaryStats(), LogicalDecodingProcessRecord(), verifyBackupPageConsistency(), and xlog_outdesc().

IsBackupHistoryFileName()

static bool IsBackupHistoryFileName ( const char *  fname )

inlinestatic

Definition at line 253 of file xlog_internal.h.

{
    return (strlen(fname) > XLOG_FNAME_LEN &&
            strspn(fname, "0123456789ABCDEF") == XLOG_FNAME_LEN &&
            strcmp(fname + strlen(fname) - strlen(".backup"), ".backup") == 0);
}

References XLOG_FNAME_LEN.

Referenced by CleanupBackupHistory(), CleanupPriorWALFiles(), and SetWALFileNameForCleanup().

IsPartialXLogFileName()

static bool IsPartialXLogFileName ( const char *  fname )

inlinestatic

Definition at line 192 of file xlog_internal.h.

{
    return (strlen(fname) == XLOG_FNAME_LEN + strlen(".partial") &&
            strspn(fname, "0123456789ABCDEF") == XLOG_FNAME_LEN &&
            strcmp(fname + XLOG_FNAME_LEN, ".partial") == 0);
}

References XLOG_FNAME_LEN.

Referenced by CleanupPriorWALFiles(), FindEndOfXLOG(), KillExistingXLOG(), RemoveOldXlogFiles(), and SetWALFileNameForCleanup().

IsTLHistoryFileName()

static bool IsTLHistoryFileName ( const char *  fname )

inlinestatic

Definition at line 224 of file xlog_internal.h.

{
    return (strlen(fname) == 8 + strlen(".history") &&
            strspn(fname, "0123456789ABCDEF") == 8 &&
            strcmp(fname + 8, ".history") == 0);
}

Referenced by perform_base_backup(), ready_file_comparator(), and XLogArchiveNotify().

IsXLogFileName()

static bool IsXLogFileName ( const char *  fname )

inlinestatic

Definition at line 180 of file xlog_internal.h.

{
    return (strlen(fname) == XLOG_FNAME_LEN && \
            strspn(fname, "0123456789ABCDEF") == XLOG_FNAME_LEN);
}

References XLOG_FNAME_LEN.

Referenced by CleanupPriorWALFiles(), FindEndOfXLOG(), getFileContentType(), KillExistingXLOG(), perform_base_backup(), pg_split_walfile_name(), RemoveNonParentXlogFiles(), RemoveOldXlogFiles(), search_directory(), SetWALFileNameForCleanup(), and XLogGetOldestSegno().

RegisterCustomRmgr()

void RegisterCustomRmgr	(	RmgrId	rmid,
		const RmgrData *	rmgr
	)

Definition at line 107 of file rmgr.c.

{
    if (rmgr->rm_name == NULL || strlen(rmgr->rm_name) == 0)
        ereport(ERROR, (errmsg("custom resource manager name is invalid"),
                        errhint("Provide a non-empty name for the custom resource manager.")));
 
    if (!RmgrIdIsCustom(rmid))
        ereport(ERROR, (errmsg("custom resource manager ID %d is out of range", rmid),
                        errhint("Provide a custom resource manager ID between %d and %d.",
                                RM_MIN_CUSTOM_ID, RM_MAX_CUSTOM_ID)));
 
    if (!process_shared_preload_libraries_in_progress)
        ereport(ERROR,
                (errmsg("failed to register custom resource manager \"%s\" with ID %d", rmgr->rm_name, rmid),
                 errdetail("Custom resource manager must be registered while initializing modules in \"shared_preload_libraries\".")));
 
    if (RmgrTable[rmid].rm_name != NULL)
        ereport(ERROR,
                (errmsg("failed to register custom resource manager \"%s\" with ID %d", rmgr->rm_name, rmid),
                 errdetail("Custom resource manager \"%s\" already registered with the same ID.",
                           RmgrTable[rmid].rm_name)));
 
    /* check for existing rmgr with the same name */
    for (int existing_rmid = 0; existing_rmid <= RM_MAX_ID; existing_rmid++)
    {
        if (!RmgrIdExists(existing_rmid))
            continue;
 
        if (!pg_strcasecmp(RmgrTable[existing_rmid].rm_name, rmgr->rm_name))
            ereport(ERROR,
                    (errmsg("failed to register custom resource manager \"%s\" with ID %d", rmgr->rm_name, rmid),
                     errdetail("Existing resource manager with ID %d has the same name.", existing_rmid)));
    }
 
    /* register it */
    RmgrTable[rmid] = *rmgr;
    ereport(LOG,
            (errmsg("registered custom resource manager \"%s\" with ID %d",
                    rmgr->rm_name, rmid)));
}

References ereport, errdetail(), errhint(), errmsg(), ERROR, LOG, pg_strcasecmp(), process_shared_preload_libraries_in_progress, RM_MAX_CUSTOM_ID, RM_MAX_ID, RM_MIN_CUSTOM_ID, RmgrData::rm_name, RmgrIdExists(), RmgrIdIsCustom(), and RmgrTable.

Referenced by _PG_init().

RequestXLogSwitch()

XLogRecPtr RequestXLogSwitch

(

bool

mark_unimportant

)

Definition at line 8130 of file xlog.c.

{
    XLogRecPtr  RecPtr;
 
    /* XLOG SWITCH has no data */
    XLogBeginInsert();
 
    if (mark_unimportant)
        XLogSetRecordFlags(XLOG_MARK_UNIMPORTANT);
    RecPtr = XLogInsert(RM_XLOG_ID, XLOG_SWITCH);
 
    return RecPtr;
}

References XLOG_MARK_UNIMPORTANT, XLOG_SWITCH, XLogBeginInsert(), XLogInsert(), and XLogSetRecordFlags().

Referenced by CheckArchiveTimeout(), do_pg_backup_start(), do_pg_backup_stop(), pg_switch_wal(), and ShutdownXLOG().

RmgrCleanup()

void RmgrCleanup

(

void

)

Definition at line 74 of file rmgr.c.

{
    for (int rmid = 0; rmid <= RM_MAX_ID; rmid++)
    {
        if (!RmgrIdExists(rmid))
            continue;
 
        if (RmgrTable[rmid].rm_cleanup != NULL)
            RmgrTable[rmid].rm_cleanup();
    }
}

References RmgrData::rm_cleanup, RM_MAX_ID, RmgrIdExists(), and RmgrTable.

Referenced by PerformWalRecovery().

RmgrIdExists()

static bool RmgrIdExists ( RmgrId  rmid )

inlinestatic

Definition at line 360 of file xlog_internal.h.

{
    return RmgrTable[rmid].rm_name != NULL;
}

References RmgrData::rm_name, and RmgrTable.

Referenced by check_wal_consistency_checking(), GetRmgr(), GetXLogSummaryStats(), RegisterCustomRmgr(), RmgrCleanup(), and RmgrStartup().

RmgrNotFound()

void RmgrNotFound

(

RmgrId

rmid

)

Definition at line 91 of file rmgr.c.

{
    ereport(ERROR, (errmsg("resource manager with ID %d not registered", rmid),
                    errhint("Include the extension module that implements this resource manager in \"shared_preload_libraries\".")));
}

References ereport, errhint(), errmsg(), and ERROR.

Referenced by GetRmgr().

RmgrStartup()

void RmgrStartup

(

void

)

Definition at line 58 of file rmgr.c.

{
    for (int rmid = 0; rmid <= RM_MAX_ID; rmid++)
    {
        if (!RmgrIdExists(rmid))
            continue;
 
        if (RmgrTable[rmid].rm_startup != NULL)
            RmgrTable[rmid].rm_startup();
    }
}

References RM_MAX_ID, RmgrData::rm_startup, RmgrIdExists(), and RmgrTable.

Referenced by PerformWalRecovery().

StatusFilePath()

static void StatusFilePath ( char *  path, const char *  xlog, const char *  suffix  )

inlinestatic

Definition at line 238 of file xlog_internal.h.

{
    snprintf(path, MAXPGPATH, XLOGDIR "/archive_status/%s%s", xlog, suffix);
}

References MAXPGPATH, snprintf, and XLOGDIR.

Referenced by perform_base_backup(), pgarch_archiveDone(), pgarch_ArchiverCopyLoop(), pgarch_readyXlog(), XLogArchiveCheckDone(), XLogArchiveCleanup(), XLogArchiveForceDone(), XLogArchiveIsBusy(), XLogArchiveIsReady(), XLogArchiveIsReadyOrDone(), and XLogArchiveNotify().

TLHistoryFileName()

static void TLHistoryFileName ( char *  fname, TimeLineID  tli  )

inlinestatic

Definition at line 218 of file xlog_internal.h.

{
    snprintf(fname, MAXFNAMELEN, "%08X.history", tli);
}

References MAXFNAMELEN, and snprintf.

Referenced by existsTimeLineHistory(), existsTimeLineHistoryFile(), readTimeLineHistory(), restoreTimeLineHistoryFiles(), SendTimeLineHistory(), WalRcvFetchTimeLineHistoryFiles(), writeTimeLineHistory(), and writeTimeLineHistoryFile().

TLHistoryFilePath()

static void TLHistoryFilePath ( char *  path, TimeLineID  tli  )

inlinestatic

Definition at line 232 of file xlog_internal.h.

{
    snprintf(path, MAXPGPATH, XLOGDIR "/%08X.history", tli);
}

References MAXPGPATH, snprintf, and XLOGDIR.

Referenced by existsTimeLineHistory(), getTimelineHistory(), readTimeLineHistory(), SendTimeLineHistory(), writeTimeLineHistory(), and writeTimeLineHistoryFile().

XLogFileName()

static void XLogFileName ( char *  fname, TimeLineID  tli, XLogSegNo  logSegNo, int  wal_segsz_bytes  )

inlinestatic

Definition at line 166 of file xlog_internal.h.

{
    snprintf(fname, MAXFNAMELEN, "%08X%08X%08X", tli,
             (uint32) (logSegNo / XLogSegmentsPerXLogId(wal_segsz_bytes)),
             (uint32) (logSegNo % XLogSegmentsPerXLogId(wal_segsz_bytes)));
}

References MAXFNAMELEN, snprintf, and XLogSegmentsPerXLogId.

Referenced by assign_wal_sync_method(), build_backup_content(), CheckXLogRemoved(), CleanupAfterArchiveRecovery(), createBackupLabel(), do_pg_backup_stop(), ExecuteRecoveryCommand(), findLastCheckpoint(), issue_xlog_fsync(), main(), open_walfile(), perform_base_backup(), pg_control_checkpoint(), pg_walfile_name(), pg_walfile_name_offset(), PrintNewControlValues(), ReadRecord(), RemoveNonParentXlogFiles(), RemoveOldXlogFiles(), RestoreArchivedFile(), SimpleXLogPageRead(), WALDumpOpenSegment(), WALDumpReadPage(), WALReadRaiseError(), WalReceiverMain(), WalSndSegmentOpen(), XLogArchiveNotifySeg(), XLogFileClose(), XLogFileRead(), XLogInitNewTimeline(), XLogPageRead(), XLogReaderValidatePageHeader(), XLogWalRcvClose(), XLogWalRcvWrite(), and XLogWrite().

XLogFileNameById()

static void XLogFileNameById ( char *  fname, TimeLineID  tli, uint32  log, uint32  seg  )

inlinestatic

Definition at line 174 of file xlog_internal.h.

{
    snprintf(fname, MAXFNAMELEN, "%08X%08X%08X", tli, log, seg);
}

References MAXFNAMELEN, and snprintf.

Referenced by SetWALFileNameForCleanup().

XLogFilePath()

static void XLogFilePath ( char *  path, TimeLineID  tli, XLogSegNo  logSegNo, int  wal_segsz_bytes  )

inlinestatic

Definition at line 210 of file xlog_internal.h.

{
    snprintf(path, MAXPGPATH, XLOGDIR "/%08X%08X%08X", tli,
             (uint32) (logSegNo / XLogSegmentsPerXLogId(wal_segsz_bytes)),
             (uint32) (logSegNo % XLogSegmentsPerXLogId(wal_segsz_bytes)));
}

References MAXPGPATH, snprintf, XLOGDIR, and XLogSegmentsPerXLogId.

Referenced by CleanupAfterArchiveRecovery(), InstallXLogFileSegment(), wal_segment_open(), WalSndSegmentOpen(), WriteEmptyXLOG(), XLogFileCopy(), XLogFileInitInternal(), XLogFileOpen(), XLogFileRead(), and XLogFileReadAnyTLI().

XLogFromFileName()

static void XLogFromFileName ( const char *  fname, TimeLineID *  tli, XLogSegNo *  logSegNo, int  wal_segsz_bytes  )

inlinestatic

Definition at line 200 of file xlog_internal.h.

{
    uint32      log;
    uint32      seg;
 
    sscanf(fname, "%08X%08X%08X", tli, &log, &seg);
    *logSegNo = (uint64) log * XLogSegmentsPerXLogId(wal_segsz_bytes) + seg;
}

References XLogSegmentsPerXLogId.

Referenced by decide_wal_file_action(), FindEndOfXLOG(), FindStreamingStart(), main(), perform_base_backup(), pg_split_walfile_name(), UpdateLastRemovedPtr(), and XLogGetOldestSegno().

XLogRecGetBlockRefInfo()

void XLogRecGetBlockRefInfo	(	XLogReaderState *	record,
		bool	pretty,
		bool	detailed_format,
		StringInfo	buf,
		uint32 *	fpi_len
	)

Definition at line 231 of file xlogdesc.c.

{
    int         block_id;
 
    Assert(record != NULL);
 
    if (detailed_format && pretty)
        appendStringInfoChar(buf, '\n');
 
    for (block_id = 0; block_id <= XLogRecMaxBlockId(record); block_id++)
    {
        RelFileLocator rlocator;
        ForkNumber  forknum;
        BlockNumber blk;
 
        if (!XLogRecGetBlockTagExtended(record, block_id,
                                        &rlocator, &forknum, &blk, NULL))
            continue;
 
        if (detailed_format)
        {
            /* Get block references in detailed format. */
 
            if (pretty)
                appendStringInfoChar(buf, '\t');
            else if (block_id > 0)
                appendStringInfoChar(buf, ' ');
 
            appendStringInfo(buf,
                             "blkref #%d: rel %u/%u/%u fork %s blk %u",
                             block_id,
                             rlocator.spcOid, rlocator.dbOid, rlocator.relNumber,
                             forkNames[forknum],
                             blk);
 
            if (XLogRecHasBlockImage(record, block_id))
            {
                uint8       bimg_info = XLogRecGetBlock(record, block_id)->bimg_info;
 
                /* Calculate the amount of FPI data in the record. */
                if (fpi_len)
                    *fpi_len += XLogRecGetBlock(record, block_id)->bimg_len;
 
                if (BKPIMAGE_COMPRESSED(bimg_info))
                {
                    const char *method;
 
                    if ((bimg_info & BKPIMAGE_COMPRESS_PGLZ) != 0)
                        method = "pglz";
                    else if ((bimg_info & BKPIMAGE_COMPRESS_LZ4) != 0)
                        method = "lz4";
                    else if ((bimg_info & BKPIMAGE_COMPRESS_ZSTD) != 0)
                        method = "zstd";
                    else
                        method = "unknown";
 
                    appendStringInfo(buf,
                                     " (FPW%s); hole: offset: %u, length: %u, "
                                     "compression saved: %u, method: %s",
                                     XLogRecBlockImageApply(record, block_id) ?
                                     "" : " for WAL verification",
                                     XLogRecGetBlock(record, block_id)->hole_offset,
                                     XLogRecGetBlock(record, block_id)->hole_length,
                                     BLCKSZ -
                                     XLogRecGetBlock(record, block_id)->hole_length -
                                     XLogRecGetBlock(record, block_id)->bimg_len,
                                     method);
                }
                else
                {
                    appendStringInfo(buf,
                                     " (FPW%s); hole: offset: %u, length: %u",
                                     XLogRecBlockImageApply(record, block_id) ?
                                     "" : " for WAL verification",
                                     XLogRecGetBlock(record, block_id)->hole_offset,
                                     XLogRecGetBlock(record, block_id)->hole_length);
                }
            }
 
            if (pretty)
                appendStringInfoChar(buf, '\n');
        }
        else
        {
            /* Get block references in short format. */
 
            if (forknum != MAIN_FORKNUM)
            {
                appendStringInfo(buf,
                                 ", blkref #%d: rel %u/%u/%u fork %s blk %u",
                                 block_id,
                                 rlocator.spcOid, rlocator.dbOid, rlocator.relNumber,
                                 forkNames[forknum],
                                 blk);
            }
            else
            {
                appendStringInfo(buf,
                                 ", blkref #%d: rel %u/%u/%u blk %u",
                                 block_id,
                                 rlocator.spcOid, rlocator.dbOid, rlocator.relNumber,
                                 blk);
            }
 
            if (XLogRecHasBlockImage(record, block_id))
            {
                /* Calculate the amount of FPI data in the record. */
                if (fpi_len)
                    *fpi_len += XLogRecGetBlock(record, block_id)->bimg_len;
 
                if (XLogRecBlockImageApply(record, block_id))
                    appendStringInfoString(buf, " FPW");
                else
                    appendStringInfoString(buf, " FPW for WAL verification");
            }
        }
    }
 
    if (!detailed_format && pretty)
        appendStringInfoChar(buf, '\n');
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert(), BKPIMAGE_COMPRESS_LZ4, BKPIMAGE_COMPRESS_PGLZ, BKPIMAGE_COMPRESS_ZSTD, BKPIMAGE_COMPRESSED, buf, RelFileLocator::dbOid, forkNames, MAIN_FORKNUM, RelFileLocator::relNumber, RelFileLocator::spcOid, XLogRecBlockImageApply, XLogRecGetBlock, XLogRecGetBlockTagExtended(), XLogRecHasBlockImage, and XLogRecMaxBlockId.

Referenced by GetWALRecordInfo(), and XLogDumpDisplayRecord().

Variable Documentation

ArchiveRecoveryRequested

PGDLLIMPORT bool ArchiveRecoveryRequested

extern

Definition at line 140 of file xlogrecovery.c.

Referenced by CheckRequiredParameterValues(), existsTimeLineHistory(), FinishWalRecovery(), InitWalRecovery(), PerformRecoveryXLogAction(), PerformWalRecovery(), ReadRecord(), readRecoverySignalFile(), readTimeLineHistory(), recoveryApplyDelay(), recoveryStopsAfter(), recoveryStopsBefore(), RestoreArchivedFile(), ShutdownWalRecovery(), StartupXLOG(), validateRecoveryParameters(), writeTimeLineHistory(), xlog_redo(), and XLogPageRead().

InArchiveRecovery

PGDLLIMPORT bool InArchiveRecovery

extern

Definition at line 141 of file xlogrecovery.c.

Referenced by CheckRecoveryConsistency(), FinishWalRecovery(), InitWalRecovery(), ReadRecord(), StartupXLOG(), WaitForWALToBecomeAvailable(), and xlog_redo().

recoveryRestoreCommand

PGDLLIMPORT char* recoveryRestoreCommand

extern

Definition at line 85 of file xlogrecovery.c.

RmgrTable

PGDLLIMPORT RmgrData RmgrTable[]

extern

Definition at line 50 of file rmgr.c.

Referenced by GetRmgr(), RegisterCustomRmgr(), RmgrCleanup(), RmgrIdExists(), and RmgrStartup().

StandbyMode

PGDLLIMPORT bool StandbyMode

extern

Definition at line 150 of file xlogrecovery.c.