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/checksum.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_checksum_state
struct	xl_overwrite_contrecord
struct	xl_end_of_recovery
struct	xl_checkpoint_redo
struct	XLogRecData
struct	RmgrData

Macros
#define	XLOG_PAGE_MAGIC   0xD11F /* 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_FIRST_IS_OVERWRITE_CONTRECORD   0x0004
#define	XLP_ALL_FLAGS   0x0007
#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_checksum_state	xl_checksum_state
typedef struct xl_overwrite_contrecord	xl_overwrite_contrecord
typedef struct xl_end_of_recovery	xl_end_of_recovery
typedef struct xl_checkpoint_redo	xl_checkpoint_redo
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 91 of file xlog_internal.h.

DEFAULT_MIN_WAL_SEGS

#define DEFAULT_MIN_WAL_SEGS   5

Definition at line 90 of file xlog_internal.h.

IsPowerOf2

#define IsPowerOf2

(

x

)

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

Definition at line 94 of file xlog_internal.h.

IsValidWalSegSize

#define IsValidWalSegSize

(

size

)

Value:

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

Definition at line 95 of file xlog_internal.h.

{
    snprintf(fname, MAXFNAMELEN, "%08X%08X%08X", tli,
             (uint32) (logSegNo / XLogSegmentsPerXLogId(wal_segsz_bytes)),
             (uint32) (logSegNo % XLogSegmentsPerXLogId(wal_segsz_bytes)));
}
 
static inline void
XLogFileNameById(char *fname, TimeLineID tli, uint32 log, uint32 seg)
{
    snprintf(fname, MAXFNAMELEN, "%08X%08X%08X", tli, log, seg);
}
 
static inline bool
IsXLogFileName(const char *fname)
{
    return (strlen(fname) == XLOG_FNAME_LEN && \
            strspn(fname, "0123456789ABCDEF") == XLOG_FNAME_LEN);
}
 
/*
 * XLOG segment with .partial suffix.  Used by pg_receivewal and at end of
 * archive recovery, when we want to archive a WAL segment but it might not
 * be complete yet.
 */
static inline bool
IsPartialXLogFileName(const char *fname)
{
    return (strlen(fname) == XLOG_FNAME_LEN + strlen(".partial") &&
            strspn(fname, "0123456789ABCDEF") == XLOG_FNAME_LEN &&
            strcmp(fname + XLOG_FNAME_LEN, ".partial") == 0);
}
 
static inline void
XLogFromFileName(const char *fname, TimeLineID *tli, XLogSegNo *logSegNo, int wal_segsz_bytes)
{
    uint32      log;
    uint32      seg;
 
    sscanf(fname, "%08X%08X%08X", tli, &log, &seg);
    *logSegNo = (uint64) log * XLogSegmentsPerXLogId(wal_segsz_bytes) + seg;
}
 
static inline void
XLogFilePath(char *path, TimeLineID tli, XLogSegNo logSegNo, int wal_segsz_bytes)
{
    snprintf(path, MAXPGPATH, XLOGDIR "/%08X%08X%08X", tli,
             (uint32) (logSegNo / XLogSegmentsPerXLogId(wal_segsz_bytes)),
             (uint32) (logSegNo % XLogSegmentsPerXLogId(wal_segsz_bytes)));
}
 
static inline void
TLHistoryFileName(char *fname, TimeLineID tli)
{
    snprintf(fname, MAXFNAMELEN, "%08X.history", tli);
}
 
static inline bool
IsTLHistoryFileName(const char *fname)
{
    return (strlen(fname) == 8 + strlen(".history") &&
            strspn(fname, "0123456789ABCDEF") == 8 &&
            strcmp(fname + 8, ".history") == 0);
}
 
static inline void
TLHistoryFilePath(char *path, TimeLineID tli)
{
    snprintf(path, MAXPGPATH, XLOGDIR "/%08X.history", tli);
}
 
static inline void
StatusFilePath(char *path, const char *xlog, const char *suffix)
{
    snprintf(path, MAXPGPATH, XLOGDIR "/archive_status/%s%s", xlog, suffix);
}
 
static inline void
BackupHistoryFileName(char *fname, TimeLineID tli, XLogSegNo logSegNo, XLogRecPtr startpoint, int wal_segsz_bytes)
{
    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)));
}
 
static inline bool
IsBackupHistoryFileName(const char *fname)
{
    return (strlen(fname) > XLOG_FNAME_LEN &&
            strspn(fname, "0123456789ABCDEF") == XLOG_FNAME_LEN &&
            strcmp(fname + strlen(fname) - strlen(".backup"), ".backup") == 0);
}
 
static inline void
BackupHistoryFilePath(char *path, TimeLineID tli, XLogSegNo logSegNo, XLogRecPtr startpoint, int wal_segsz_bytes)
{
    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)));
}
 
/*
 * Information logged when we detect a change in one of the parameters
 * important for Hot Standby.
 */
typedef struct xl_parameter_change
{
    int         MaxConnections;
    int         max_worker_processes;
    int         max_wal_senders;
    int         max_prepared_xacts;
    int         max_locks_per_xact;
    int         wal_level;
    bool        wal_log_hints;
    bool        track_commit_timestamp;
} xl_parameter_change;
 
/* logs restore point */
typedef struct xl_restore_point
{
    TimestampTz rp_time;
    char        rp_name[MAXFNAMELEN];
} xl_restore_point;
 
/* Information logged when data checksum level is changed */
typedef struct xl_checksum_state
{
    ChecksumStateType new_checksum_state;
} xl_checksum_state;
 
/* Overwrite of prior contrecord */
typedef struct xl_overwrite_contrecord
{
    XLogRecPtr  overwritten_lsn;
    TimestampTz overwrite_time;
} xl_overwrite_contrecord;
 
/* End of recovery mark, when we don't do an END_OF_RECOVERY checkpoint */
typedef struct xl_end_of_recovery
{
    TimestampTz end_time;
    TimeLineID  ThisTimeLineID; /* new TLI */
    TimeLineID  PrevTimeLineID; /* previous TLI we forked off from */
    int         wal_level;
} xl_end_of_recovery;
 
/* checkpoint redo */
typedef struct xl_checkpoint_redo
{
    int         wal_level;
    uint32      data_checksum_version;
} xl_checkpoint_redo;
 
/*
 * The functions in xloginsert.c construct a chain of XLogRecData structs
 * to represent the final WAL record.
 */
typedef struct XLogRecData
{
    struct XLogRecData *next;   /* next struct in chain, or NULL */
    const void *data;           /* start of rmgr data to include */
    uint32      len;            /* length of rmgr data to include */
} XLogRecData;
 
struct LogicalDecodingContext;
struct XLogRecordBuffer;
 
/*
 * Method table for resource managers.
 *
 * This struct must be kept in sync with the PG_RMGR definition in
 * rmgr.c.
 *
 * rm_identify must return a name for the record based on xl_info (without
 * reference to the rmid). For example, XLOG_BTREE_VACUUM would be named
 * "VACUUM". rm_desc can then be called to obtain additional detail for the
 * record, if available (e.g. the last block).
 *
 * rm_mask takes as input a page modified by the resource manager and masks
 * out bits that shouldn't be flagged by wal_consistency_checking.
 *
 * RmgrTable[] is indexed by RmgrId values (see rmgrlist.h). If rm_name is
 * NULL, the corresponding RmgrTable entry is considered invalid.
 */
typedef struct RmgrData
{
    const char *rm_name;
    void        (*rm_redo) (XLogReaderState *record);
    void        (*rm_desc) (StringInfo buf, XLogReaderState *record);
    const char *(*rm_identify) (uint8 info);
    void        (*rm_startup) (void);
    void        (*rm_cleanup) (void);
    void        (*rm_mask) (char *pagedata, BlockNumber blkno);
    void        (*rm_decode) (struct LogicalDecodingContext *ctx,
                              struct XLogRecordBuffer *buf);
} RmgrData;
 
extern PGDLLIMPORT RmgrData RmgrTable[];
extern void RmgrStartup(void);
extern void RmgrCleanup(void);
extern void RmgrNotFound(RmgrId rmid);
extern void RegisterCustomRmgr(RmgrId rmid, const RmgrData *rmgr);
 
#ifndef FRONTEND
static inline bool
RmgrIdExists(RmgrId rmid)
{
    return RmgrTable[rmid].rm_name != NULL;
}
 
static inline RmgrData
GetRmgr(RmgrId rmid)
{
    if (unlikely(!RmgrIdExists(rmid)))
        RmgrNotFound(rmid);
    return RmgrTable[rmid];
}
#endif
 
/*
 * Exported to support xlog switching from checkpointer
 */
extern pg_time_t GetLastSegSwitchData(XLogRecPtr *lastSwitchLSN);
extern XLogRecPtr RequestXLogSwitch(bool mark_unimportant);
 
extern void GetOldestRestartPoint(XLogRecPtr *oldrecptr, TimeLineID *oldtli);
 
extern void XLogRecGetBlockRefInfo(XLogReaderState *record, bool pretty,
                                   bool detailed_format, StringInfo buf,
                                   uint32 *fpi_len);
 
/*
 * Exported for the functions in timeline.c and xlogarchive.c.  Only valid
 * in the startup process.
 */
extern PGDLLIMPORT bool ArchiveRecoveryRequested;
extern PGDLLIMPORT bool InArchiveRecovery;
extern PGDLLIMPORT bool StandbyMode;
extern PGDLLIMPORT char *recoveryRestoreCommand;
 
#endif                          /* XLOG_INTERNAL_H */

MAXFNAMELEN

#define MAXFNAMELEN   64

Definition at line 155 of file xlog_internal.h.

SizeOfXLogLongPHD

#define SizeOfXLogLongPHD   MAXALIGN(sizeof(XLogLongPageHeaderData))

Definition at line 70 of file xlog_internal.h.

SizeOfXLogShortPHD

#define SizeOfXLogShortPHD   MAXALIGN(sizeof(XLogPageHeaderData))

Definition at line 53 of file xlog_internal.h.

WalSegMaxSize

#define WalSegMaxSize   1024 * 1024 * 1024

Definition at line 88 of file xlog_internal.h.

WalSegMinSize

#define WalSegMinSize   1024 * 1024

Definition at line 87 of file xlog_internal.h.

XLByteInPrevSeg

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

Definition at line 138 of file xlog_internal.h.

XLByteInSeg

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

Definition at line 135 of file xlog_internal.h.

XLByteToPrevSeg

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

Definition at line 119 of file xlog_internal.h.

XLByteToSeg

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

Definition at line 116 of file xlog_internal.h.

XLOG_CONTROL_FILE

#define XLOG_CONTROL_FILE   "global/pg_control"

Definition at line 149 of file xlog_internal.h.

XLOG_FNAME_LEN

#define XLOG_FNAME_LEN   24

Definition at line 158 of file xlog_internal.h.

XLOG_PAGE_MAGIC

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

Definition at line 35 of file xlog_internal.h.

XLOGDIR

#define XLOGDIR   "pg_wal"

Definition at line 148 of file xlog_internal.h.

XLogMBVarToSegs

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

Definition at line 126 of file xlog_internal.h.

XLogPageHeaderSize

#define XLogPageHeaderSize

(

hdr

)

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

Definition at line 83 of file xlog_internal.h.

                                                             : SizeOfXLogShortPHD)

XLogSegmentOffset

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

Definition at line 105 of file xlog_internal.h.

XLogSegmentsPerXLogId

#define XLogSegmentsPerXLogId

(

wal_segsz_bytes

)

(UINT64CONST(0x100000000) / (wal_segsz_bytes))

Definition at line 99 of file xlog_internal.h.

XLogSegNoOffsetToRecPtr

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

Definition at line 102 of file xlog_internal.h.

XLP_ALL_FLAGS

#define XLP_ALL_FLAGS   0x0007

Definition at line 81 of file xlog_internal.h.

XLP_FIRST_IS_CONTRECORD

#define XLP_FIRST_IS_CONTRECORD   0x0001

Definition at line 75 of file xlog_internal.h.

XLP_FIRST_IS_OVERWRITE_CONTRECORD

#define XLP_FIRST_IS_OVERWRITE_CONTRECORD   0x0004

Definition at line 79 of file xlog_internal.h.

XLP_LONG_HEADER

#define XLP_LONG_HEADER   0x0002

Definition at line 77 of file xlog_internal.h.

XRecOffIsValid

#define XRecOffIsValid

(

xlrp

)

((xlrp) % XLOG_BLCKSZ >= SizeOfXLogShortPHD)

Definition at line 142 of file xlog_internal.h.

Typedef Documentation

RmgrData

typedef struct RmgrData RmgrData

xl_checkpoint_redo

typedef struct xl_checkpoint_redo xl_checkpoint_redo

xl_checksum_state

typedef struct xl_checksum_state xl_checksum_state

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 72 of file xlog_internal.h.

XLogLongPageHeaderData

typedef struct XLogLongPageHeaderData XLogLongPageHeaderData

XLogPageHeader

typedef XLogPageHeaderData* XLogPageHeader

Definition at line 55 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 243 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 fb(), 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 260 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 fb(), MAXPGPATH, snprintf, XLOGDIR, XLogSegmentOffset, and XLogSegmentsPerXLogId.

Referenced by do_pg_backup_stop().

GetLastSegSwitchData()

pg_time_t GetLastSegSwitchData ( XLogRecPtr *  lastSwitchLSN )

extern

Definition at line 7081 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 fb(), XLogCtlData::lastSegSwitchLSN, XLogCtlData::lastSegSwitchTime, LW_SHARED, LWLockAcquire(), LWLockRelease(), result, and XLogCtl.

Referenced by CheckArchiveTimeout().

GetOldestRestartPoint()

void GetOldestRestartPoint ( XLogRecPtr *  oldrecptr, TimeLineID *  oldtli  )

extern

Definition at line 10152 of file xlog.c.

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

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

Referenced by ExecuteRecoveryCommand(), and RestoreArchivedFile().

GetRmgr()

static RmgrData GetRmgr ( RmgrId  rmid )

inlinestatic

Definition at line 378 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(), pg_get_wal_resource_managers(), verifyBackupPageConsistency(), and xlog_outdesc().

IsBackupHistoryFileName()

static bool IsBackupHistoryFileName ( const char *  fname )

inlinestatic

Definition at line 252 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 fb(), and XLOG_FNAME_LEN.

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

IsPartialXLogFileName()

static bool IsPartialXLogFileName ( const char *  fname )

inlinestatic

Definition at line 191 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 fb(), and XLOG_FNAME_LEN.

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

IsTLHistoryFileName()

static bool IsTLHistoryFileName ( const char *  fname )

inlinestatic

Definition at line 223 of file xlog_internal.h.

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

References fb().

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

IsXLogFileName()

static bool IsXLogFileName ( const char *  fname )

inlinestatic

Definition at line 179 of file xlog_internal.h.

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

References fb(), and XLOG_FNAME_LEN.

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

RegisterCustomRmgr()

void RegisterCustomRmgr ( RmgrId  rmid, const RmgrData *  rmgr  )

extern

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, fb(), 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 )

extern

Definition at line 8607 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 fb(), 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  )

extern

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 fb(), RmgrData::rm_cleanup, RM_MAX_ID, RmgrIdExists(), and RmgrTable.

Referenced by PerformWalRecovery().

RmgrIdExists()

static bool RmgrIdExists ( RmgrId  rmid )

inlinestatic

Definition at line 372 of file xlog_internal.h.

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

References fb(), RmgrData::rm_name, and RmgrTable.

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

RmgrNotFound()

void RmgrNotFound ( RmgrId  rmid )

extern

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  )

extern

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 fb(), 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 237 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 217 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 231 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 165 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 fb(), 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(), read_archive_wal_page(), ReadRecord(), RemoveNonParentXlogFiles(), RemoveOldXlogFiles(), RestoreArchivedFile(), SimpleXLogPageRead(), TarWALDumpReadPage(), 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 173 of file xlog_internal.h.

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

References fb(), MAXFNAMELEN, and snprintf.

Referenced by SetWALFileNameForCleanup().

XLogFilePath()

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

inlinestatic

Definition at line 209 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 fb(), 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 199 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 fb(), and XLogSegmentsPerXLogId.

Referenced by astreamer_waldump_content(), decide_wal_file_action(), FindEndOfXLOG(), FindStreamingStart(), init_archive_reader(), main(), 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  )

extern

Definition at line 303 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, fb(), 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 141 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 142 of file xlogrecovery.c.

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

recoveryRestoreCommand

PGDLLIMPORT char* recoveryRestoreCommand

extern

Definition at line 86 of file xlogrecovery.c.

RmgrTable

PGDLLIMPORT RmgrData RmgrTable[]

extern

Definition at line 50 of file rmgr.c.

                                       {
#include "access/rmgrlist.h"
};

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

StandbyMode

PGDLLIMPORT bool StandbyMode

extern

Definition at line 151 of file xlogrecovery.c.