61 #include "utils/fmgrprotos.h"
68 #define RECOVERY_COMMAND_FILE "recovery.conf"
69 #define RECOVERY_COMMAND_DONE "recovery.done"
416 int emode,
bool fetching_ckpt,
420 int reqLen,
XLogRecPtr targetRecPtr,
char *readBuf);
513 bool *haveBackupLabel_ptr,
bool *haveTblspcMap_ptr)
520 bool haveTblspcMap =
false;
521 bool haveBackupLabel =
false;
523 bool backupFromStandby =
false;
558 .segment_open = NULL,
563 (
errcode(ERRCODE_OUT_OF_MEMORY),
565 errdetail(
"Failed while allocating a WAL reading processor.")));
617 (
errmsg(
"starting backup recovery with redo LSN %X/%X, checkpoint LSN %X/%X, on timeline ID %u",
649 (
errmsg(
"could not find redo location %X/%X referenced by checkpoint record at %X/%X",
651 errhint(
"If you are restoring from a backup, touch \"%s/recovery.signal\" or \"%s/standby.signal\" and add required recovery options.\n"
652 "If you are not restoring from a backup, try removing the file \"%s/backup_label\".\n"
653 "Be careful: removing \"%s/backup_label\" will result in a corrupt cluster if restoring from a backup.",
660 (
errmsg(
"could not locate required checkpoint record at %X/%X",
662 errhint(
"If you are restoring from a backup, touch \"%s/recovery.signal\" or \"%s/standby.signal\" and add required recovery options.\n"
663 "If you are not restoring from a backup, try removing the file \"%s/backup_label\".\n"
664 "Be careful: removing \"%s/backup_label\" will result in a corrupt cluster if restoring from a backup.",
674 foreach(lc, tablespaces)
690 errmsg(
"could not create symbolic link \"%s\": %m",
698 haveTblspcMap =
true;
702 haveBackupLabel =
true;
723 (
errmsg(
"ignoring file \"%s\" because no file \"%s\" exists",
725 errdetail(
"File \"%s\" was renamed to \"%s\".",
729 (
errmsg(
"ignoring file \"%s\" because no file \"%s\" exists",
731 errdetail(
"Could not rename file \"%s\" to \"%s\": %m.",
770 (
errmsg(
"restarting backup recovery with redo LSN %X/%X",
795 (
errmsg(
"could not locate a valid checkpoint record at %X/%X",
806 (
errmsg(
"entering standby mode")));
809 (
errmsg(
"starting point-in-time recovery to XID %u",
813 (
errmsg(
"starting point-in-time recovery to %s",
817 (
errmsg(
"starting point-in-time recovery to \"%s\"",
821 (
errmsg(
"starting point-in-time recovery to WAL location (LSN) \"%X/%X\"",
825 (
errmsg(
"starting point-in-time recovery to earliest consistent point")));
828 (
errmsg(
"starting archive recovery")));
849 (
errmsg(
"requested timeline %u is not a child of this server's history",
851 errdetail(
"Latest checkpoint is at %X/%X on timeline %u, but in the history of the requested timeline, the server forked off from that timeline at %X/%X.",
865 (
errmsg(
"requested timeline %u does not contain minimum recovery point %X/%X on timeline %u",
873 wasShutdown ?
"true" :
"false")));
893 (
errmsg(
"invalid next transaction ID")));
898 (
errmsg(
"invalid redo in checkpoint record")));
909 (
errmsg(
"invalid redo record in shutdown checkpoint")));
938 (
errmsg(
"database system was not properly shut down; "
939 "automatic recovery in progress")));
942 (
errmsg(
"crash recovery starts in timeline %u "
943 "and has target timeline %u",
980 if (backupFromStandby)
985 (
errmsg(
"backup_label contains data inconsistent with control file"),
986 errhint(
"This means that the backup is corrupted and you will "
987 "have to use another backup for recovery.")));
1014 *wasShutdown_ptr = wasShutdown;
1015 *haveBackupLabel_ptr = haveBackupLabel;
1016 *haveTblspcMap_ptr = haveTblspcMap;
1029 struct stat stat_buf;
1040 errmsg(
"using recovery command file \"%s\" is not supported",
1104 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1105 errmsg(
"standby mode is not supported by single-user servers")));
1122 (
errmsg(
"specified neither primary_conninfo nor restore_command"),
1123 errhint(
"The database server will regularly poll the pg_wal subdirectory to check for files placed there.")));
1130 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1131 errmsg(
"must specify restore_command when standby mode is not enabled")));
1168 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1169 errmsg(
"recovery target timeline %u does not exist",
1216 char backuptype[20];
1217 char backupfrom[20];
1219 char backuptime[128];
1225 *backupLabelTLI = 0;
1227 *backupFromStandby =
false;
1235 if (errno != ENOENT)
1238 errmsg(
"could not read file \"%s\": %m",
1248 if (fscanf(lfp,
"START WAL LOCATION: %X/%X (file %08X%16s)%c",
1249 &hi, &lo, &tli_from_walseg, startxlogfilename, &ch) != 5 || ch !=
'\n')
1251 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1255 if (fscanf(lfp,
"CHECKPOINT LOCATION: %X/%X%c",
1256 &hi, &lo, &ch) != 3 || ch !=
'\n')
1258 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1260 *checkPointLoc = ((uint64) hi) << 32 | lo;
1261 *backupLabelTLI = tli_from_walseg;
1273 if (fscanf(lfp,
"BACKUP METHOD: %19s\n", backuptype) == 1)
1275 if (strcmp(backuptype,
"streamed") == 0)
1284 if (fscanf(lfp,
"BACKUP FROM: %19s\n", backupfrom) == 1)
1286 if (strcmp(backupfrom,
"standby") == 0)
1287 *backupFromStandby =
true;
1299 if (fscanf(lfp,
"START TIME: %127[^\n]\n", backuptime) == 1)
1304 if (fscanf(lfp,
"LABEL: %1023[^\n]\n", backuplabel) == 1)
1313 if (fscanf(lfp,
"START TIMELINE: %u\n", &tli_from_file) == 1)
1315 if (tli_from_walseg != tli_from_file)
1317 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1319 errdetail(
"Timeline ID parsed is %u, but expected %u.",
1320 tli_from_file, tli_from_walseg)));
1327 if (fscanf(lfp,
"INCREMENTAL FROM LSN: %X/%X\n", &hi, &lo) > 0)
1329 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1330 errmsg(
"this is an incremental backup, not a data directory"),
1331 errhint(
"Use pg_combinebackup to reconstruct a valid data directory.")));
1336 errmsg(
"could not read file \"%s\": %m",
1370 if (errno != ENOENT)
1373 errmsg(
"could not read file \"%s\": %m",
1384 was_backslash =
false;
1385 while ((ch = fgetc(lfp)) != EOF)
1387 if (!was_backslash && (ch ==
'\n' || ch ==
'\r'))
1401 while (
str[n] &&
str[n] !=
' ')
1403 if (n < 1 || n >=
i - 1)
1405 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1411 ti->
oid = strtoul(
str, &endp, 10);
1412 if (*endp !=
'\0' || errno == EINVAL || errno == ERANGE)
1414 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1417 *tablespaces =
lappend(*tablespaces, ti);
1422 else if (!was_backslash && ch ==
'\\')
1423 was_backslash =
true;
1426 if (
i <
sizeof(
str) - 1)
1428 was_backslash =
false;
1432 if (
i != 0 || was_backslash)
1434 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1440 errmsg(
"could not read file \"%s\": %m",
1561 if (endOfLog % XLOG_BLCKSZ != 0)
1567 pageBeginPtr = endOfLog - (endOfLog % XLOG_BLCKSZ);
1571 len = endOfLog % XLOG_BLCKSZ;
1631 unlink(recoveryPath);
1635 unlink(recoveryPath);
1655 bool reachedRecoveryTarget =
false;
1714 if (record->
xl_rmid != RM_XLOG_ID ||
1717 (
errmsg(
"unexpected record type found at redo point %X/%X",
1740 (
errmsg(
"redo starts at %X/%X",
1798 reachedRecoveryTarget =
true;
1827 reachedRecoveryTarget =
true;
1833 }
while (record != NULL);
1839 if (reachedRecoveryTarget)
1843 (
errmsg(
"requested recovery stop point is before consistent recovery point")));
1875 (
errmsg(
"redo done at %X/%X system usage: %s",
1881 (
errmsg(
"last completed transaction was at log time %s",
1890 (
errmsg(
"redo is not required")));
1899 !reachedRecoveryTarget)
1901 (
errmsg(
"recovery ended before configured recovery target was reached")));
1911 bool switchedTLI =
false;
1932 if (record->
xl_rmid == RM_XLOG_ID)
1955 if (newReplayTLI != *replayTLI)
1959 newReplayTLI, prevReplayTLI, *replayTLI);
1962 *replayTLI = newReplayTLI;
1987 if (record->
xl_rmid == RM_XLOG_ID)
2086 elog(
FATAL,
"mismatching overwritten LSN %X/%X -> %X/%X",
2095 (
errmsg(
"successfully skipped missing contrecord at %X/%X, overwritten at %s",
2118 elog(
DEBUG1,
"end of backup record reached");
2123 elog(
DEBUG1,
"saw end-of-backup record for backup starting at %X/%X, waiting for %X/%X",
2149 while ((de =
ReadDir(dir,
"pg_tblspc")) != NULL)
2154 if (strspn(de->
d_name,
"0123456789") != strlen(de->
d_name))
2162 errmsg(
"unexpected directory entry \"%s\" found in %s",
2163 de->
d_name,
"pg_tblspc/"),
2164 errdetail(
"All directory entries in pg_tblspc/ should be symbolic links."),
2165 errhint(
"Remove those directories, or set allow_in_place_tablespaces to ON transiently to let recovery complete.")));
2217 (
errmsg(
"completed backup recovery with redo LSN %X/%X and end LSN %X/%X",
2247 (
errmsg(
"consistent recovery state reached at %X/%X",
2348 &rlocator, &forknum, &blk, NULL))
2381 if (prevTLI != replayTLI)
2383 (
errmsg(
"unexpected previous timeline ID %u (current timeline ID %u) in checkpoint record",
2384 prevTLI, replayTLI)));
2392 (
errmsg(
"unexpected timeline ID %u (after %u) in checkpoint record",
2393 newTLI, replayTLI)));
2408 (
errmsg(
"unexpected timeline ID %u in checkpoint record, before reaching minimum recovery point %X/%X on timeline %u",
2481 &rlocator, &forknum, &blkno, NULL))
2540 (
errcode(ERRCODE_INTERNAL_ERROR),
2557 "inconsistent page found, rel %u/%u/%u, forknum %u, blkno %u",
2575 bool stopsHere =
false;
2592 (
errmsg(
"recovery stopping after reaching consistency")));
2613 (
errmsg(
"recovery stopping before WAL location (LSN) \"%X/%X\"",
2703 (
errmsg(
"recovery stopping before commit of transaction %u, time %s",
2710 (
errmsg(
"recovery stopping before abort of transaction %u, time %s",
2763 (
errmsg(
"recovery stopping at restore point \"%s\", time %s",
2781 (
errmsg(
"recovery stopping after WAL location (LSN) \"%X/%X\"",
2786 if (rmid != RM_XACT_ID)
2848 (
errmsg(
"recovery stopping after commit of transaction %u, time %s",
2856 (
errmsg(
"recovery stopping after abort of transaction %u, time %s",
2868 (
errmsg(
"recovery stopping after reaching consistency")));
2892 "%s transaction %u",
2907 "at restore point \"%s\"",
2910 snprintf(reason,
sizeof(reason),
"reached consistency");
2912 snprintf(reason,
sizeof(reason),
"no recovery target specified");
2937 (
errmsg(
"pausing at the end of recovery"),
2938 errhint(
"Execute pg_wal_replay_resume() to promote.")));
2941 (
errmsg(
"recovery has paused"),
2942 errhint(
"Execute pg_wal_replay_resume() to continue.")));
2963 WAIT_EVENT_RECOVERY_PAUSE);
3056 elog(
DEBUG2,
"recovery apply delay %ld milliseconds", msecs);
3061 WAIT_EVENT_RECOVERY_APPLY_DELAY);
3139 private->fetching_ckpt = fetching_ckpt;
3140 private->emode = emode;
3142 private->replayTLI = replayTLI;
3205 (
errmsg(
"unexpected timeline ID %u in WAL segment %s, LSN %X/%X, offset %u",
3239 (
errmsg_internal(
"reached end of WAL in pg_wal, entering archive recovery")));
3303 int emode = private->emode;
3352 private->randAccess,
3353 private->fetching_ckpt,
3387 if (((targetPagePtr) / XLOG_BLCKSZ) != (
flushedUpto / XLOG_BLCKSZ))
3401 if (r != XLOG_BLCKSZ)
3404 int save_errno = errno;
3413 errmsg(
"could not read from WAL segment %s, LSN %X/%X, offset %u: %m",
3420 errmsg(
"could not read from WAL segment %s, LSN %X/%X, offset %u: read %d of %zu",
3423 goto next_record_is_invalid;
3478 goto next_record_is_invalid;
3483 next_record_is_invalid:
3548 bool streaming_reply_sent =
false;
3588 bool startWalReceiver =
false;
3635 startWalReceiver =
true;
3698 elog(
LOG,
"waiting for WAL to become available at %X/%X",
3708 WAIT_EVENT_RECOVERY_RETRIEVE_RETRY_INTERVAL);
3715 last_fail_time =
now;
3735 elog(
DEBUG2,
"switched WAL source from %s to %s after %s",
3809 startWalReceiver =
true;
3822 if (startWalReceiver &&
3844 elog(
ERROR,
"according to history file, WAL location %X/%X belongs to timeline %u, but previous recovered WAL file came from timeline %u",
3887 if (latestChunkStart <= RecPtr)
3964 if (!streaming_reply_sent)
3967 streaming_reply_sent =
true;
3983 WAIT_EVENT_RECOVERY_WAL_STREAM);
4036 if (RecPtr == lastComplaint)
4039 lastComplaint = RecPtr;
4060 (
errmsg(
"invalid checkpoint location")));
4070 (
errmsg(
"invalid checkpoint record")));
4073 if (record->
xl_rmid != RM_XLOG_ID)
4076 (
errmsg(
"invalid resource manager ID in checkpoint record")));
4084 (
errmsg(
"invalid xl_info in checkpoint record")));
4090 (
errmsg(
"invalid length of checkpoint record")));
4106 List *newExpectedTLEs;
4131 foreach(cell, newExpectedTLEs)
4144 (
errmsg(
"new timeline %u is not a child of database system timeline %u",
4155 if (currentTle->
end < replayLSN)
4158 (
errmsg(
"new timeline %u forked off current database system timeline %u before current recovery point %X/%X",
4177 (
errmsg(
"new target timeline is %u",
4205 snprintf(activitymsg,
sizeof(activitymsg),
"waiting for %s",
4247 snprintf(activitymsg,
sizeof(activitymsg),
"recovering %s",
4260 if (errno != ENOENT || !notfoundOk)
4263 errmsg(
"could not open file \"%s\": %m", path)));
4331 if (segno < beginseg)
4341 elog(
DEBUG1,
"got WAL segment from archive");
4366 errmsg(
"could not open file \"%s\": %m", path)));
4380 (
errmsg(
"WAL receiver process shutdown requested")));
4465 struct stat stat_buf;
4573 *replayEndTLI = tli;
4661 if (currValue < minValue)
4665 bool warned_for_promote =
false;
4668 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4669 errmsg(
"hot standby is not possible because of insufficient parameter settings"),
4670 errdetail(
"%s = %d is a lower setting than on the primary server, where its value was %d.",
4678 (
errmsg(
"recovery has paused"),
4679 errdetail(
"If recovery is unpaused, the server will shut down."),
4680 errhint(
"You can then restart the server after making the necessary configuration changes.")));
4688 if (!warned_for_promote)
4690 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4691 errmsg(
"promotion is not possible because of insufficient parameter settings"),
4697 errdetail(
"%s = %d is a lower setting than on the primary server, where its value was %d.",
4701 errhint(
"Restart the server after making the necessary configuration changes.")));
4702 warned_for_promote =
true;
4718 WAIT_EVENT_RECOVERY_PAUSE);
4724 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4725 errmsg(
"recovery aborted because of insufficient parameter settings"),
4727 errdetail(
"%s = %d is a lower setting than on the primary server, where its value was %d.",
4731 errhint(
"You can restart the server after making the necessary configuration changes.")));
4769 error_multiple_recovery_targets(
void)
4772 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4773 errmsg(
"multiple recovery targets specified"),
4774 errdetail(
"At most one of recovery_target, recovery_target_lsn, recovery_target_name, recovery_target_time, recovery_target_xid may be set.")));
4783 if (strcmp(*
newval,
"immediate") != 0 && strcmp(*
newval,
"") != 0)
4799 error_multiple_recovery_targets();
4813 if (strcmp(*
newval,
"") != 0)
4817 bool have_error =
false;
4825 *extra = (
void *) myextra;
4838 error_multiple_recovery_targets();
4873 error_multiple_recovery_targets();
4896 if (strcmp(*
newval,
"") != 0)
4899 if (strcmp(*
newval,
"now") == 0 ||
4900 strcmp(*
newval,
"today") == 0 ||
4901 strcmp(*
newval,
"tomorrow") == 0 ||
4902 strcmp(*
newval,
"yesterday") == 0)
4929 &dtype,
tm, &fsec, &tz, &dtextra);
4953 error_multiple_recovery_targets();
4970 if (strcmp(*
newval,
"current") == 0)
4972 else if (strcmp(*
newval,
"latest") == 0)
4979 strtoul(*
newval, NULL, 0);
4980 if (errno == EINVAL || errno == ERANGE)
4989 *extra = (
void *) myextra;
5013 if (strcmp(*
newval,
"") != 0)
5020 if (errno == EINVAL || errno == ERANGE)
5025 *extra = (
void *) myextra;
5038 error_multiple_recovery_targets();
TimeLineID findNewestTimeLine(TimeLineID startTLI)
TimeLineID tliOfPointInHistory(XLogRecPtr ptr, List *history)
XLogRecPtr tliSwitchPoint(TimeLineID tli, List *history, TimeLineID *nextTLI)
bool existsTimeLineHistory(TimeLineID probeTLI)
void restoreTimeLineHistoryFiles(TimeLineID begin, TimeLineID end)
List * readTimeLineHistory(TimeLineID targetTLI)
bool tliInHistory(TimeLineID tli, List *expectedTLEs)
void remove_tablespace_symlink(const char *linkloc)
bool allow_in_place_tablespaces
void HandleStartupProcInterrupts(void)
void disable_startup_progress_timeout(void)
bool IsPromoteSignaled(void)
void begin_startup_progress_phase(void)
void ResetPromoteSignaled(void)
int ParseDateTime(const char *timestr, char *workbuf, size_t buflen, char **field, int *ftype, int maxfields, int *numfields)
int DecodeDateTime(char **field, int *ftype, int nf, int *dtype, struct pg_tm *tm, fsec_t *fsec, int *tzp, DateTimeErrorExtra *extra)
long TimestampDifferenceMilliseconds(TimestampTz start_time, TimestampTz stop_time)
int tm2timestamp(struct pg_tm *tm, fsec_t fsec, int *tzp, Timestamp *result)
bool TimestampDifferenceExceeds(TimestampTz start_time, TimestampTz stop_time, int msec)
Datum timestamptz_in(PG_FUNCTION_ARGS)
TimestampTz GetCurrentTimestamp(void)
Datum now(PG_FUNCTION_ARGS)
const char * timestamptz_to_str(TimestampTz t)
void UnlockReleaseBuffer(Buffer buffer)
void LockBuffer(Buffer buffer, int mode)
static Page BufferGetPage(Buffer buffer)
#define BUFFER_LOCK_EXCLUSIVE
static bool BufferIsValid(Buffer bufnum)
static XLogRecPtr PageGetLSN(Page page)
#define PG_USED_FOR_ASSERTS_ONLY
#define strtou64(str, endptr, base)
void RequestCheckpoint(int flags)
bool ConditionVariableCancelSleep(void)
bool ConditionVariableTimedSleep(ConditionVariable *cv, long timeout, uint32 wait_event_info)
void ConditionVariableBroadcast(ConditionVariable *cv)
void ConditionVariableInit(ConditionVariable *cv)
int errmsg_internal(const char *fmt,...)
int errcode_for_file_access(void)
int errdetail(const char *fmt,...)
ErrorContextCallback * error_context_stack
int errhint(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
struct dirent * ReadDir(DIR *dir, const char *dirname)
FILE * AllocateFile(const char *name, const char *mode)
int BasicOpenFilePerm(const char *fileName, int fileFlags, mode_t fileMode)
int durable_rename(const char *oldfile, const char *newfile, int elevel)
int BasicOpenFile(const char *fileName, int fileFlags)
DIR * AllocateDir(const char *dirname)
PGFileType get_dirent_type(const char *path, const struct dirent *de, bool look_through_symlinks, int elevel)
#define DirectFunctionCall3(func, arg1, arg2, arg3)
bool IsPostmasterEnvironment
void * guc_malloc(int elevel, size_t size)
#define GUC_check_errdetail
void OwnLatch(Latch *latch)
void DisownLatch(Latch *latch)
void InitSharedLatch(Latch *latch)
void SetLatch(Latch *latch)
void ResetLatch(Latch *latch)
int WaitLatch(Latch *latch, int wakeEvents, long timeout, uint32 wait_event_info)
#define WL_EXIT_ON_PM_DEATH
Assert(fmt[strlen(fmt) - 1] !='\n')
List * lappend(List *list, void *datum)
void list_free_deep(List *list)
char * pstrdup(const char *in)
void pfree(void *pointer)
void * palloc0(Size size)
#define AmStartupProcess()
#define IsBootstrapProcessingMode()
#define ERRCODE_DATA_CORRUPTED
#define XLOG_RESTORE_POINT
#define XLOG_CHECKPOINT_REDO
#define XLOG_OVERWRITE_CONTRECORD
@ DB_SHUTDOWNED_IN_RECOVERY
#define XLOG_CHECKPOINT_SHUTDOWN
#define XLOG_CHECKPOINT_ONLINE
#define XLOG_END_OF_RECOVERY
XLogRecPtr pg_lsn_in_internal(const char *str, bool *have_error)
static rewind_source * source
const char * pg_rusage_show(const PGRUsage *ru0)
void pg_rusage_init(PGRUsage *ru0)
void SendPostmasterSignal(PMSignalReason reason)
@ PMSIGNAL_RECOVERY_STARTED
@ PMSIGNAL_BEGIN_HOT_STANDBY
size_t strlcpy(char *dst, const char *src, size_t siz)
static Datum ObjectIdGetDatum(Oid X)
static Datum CStringGetDatum(const char *X)
static Datum Int32GetDatum(int32 X)
static int fd(const char *x, int i)
void RecordKnownAssignedTransactionIds(TransactionId xid)
void KnownAssignedTransactionIdsIdleMaintenance(void)
static void set_ps_display(const char *activity)
char * psprintf(const char *fmt,...)
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
static pg_noinline void Size size
bool ReplicationSlotValidateName(const char *name, int elevel)
void ShutDownSlotSync(void)
#define SpinLockInit(lock)
#define SpinLockRelease(lock)
#define SpinLockAcquire(lock)
#define ereport_startup_progress(msg,...)
void appendStringInfo(StringInfo str, const char *fmt,...)
void appendStringInfoString(StringInfo str, const char *s)
void appendStringInfoChar(StringInfo str, char ch)
void initStringInfo(StringInfo str)
MultiXactOffset nextMultiOffset
TransactionId newestCommitTsXid
TimeLineID PrevTimeLineID
TimeLineID ThisTimeLineID
FullTransactionId nextXid
TransactionId oldestCommitTsXid
XLogRecPtr backupStartPoint
CheckPoint checkPointCopy
XLogRecPtr backupEndPoint
XLogRecPtr minRecoveryPoint
TimeLineID minRecoveryPointTLI
bool standby_signal_file_found
XLogRecPtr lastPageBeginPtr
char * recoveryStopReason
XLogRecPtr missingContrecPtr
bool recovery_signal_file_found
struct ErrorContextCallback * previous
void(* callback)(void *arg)
void(* rm_mask)(char *pagedata, BlockNumber blkno)
void(* rm_redo)(XLogReaderState *record)
const char *(* rm_identify)(uint8 info)
void(* rm_desc)(StringInfo buf, XLogReaderState *record)
XLogRecPtr missingContrecPtr
XLogRecPtr overwrittenRecPtr
ConditionVariable recoveryNotPausedCV
XLogRecPtr lastReplayedEndRecPtr
bool SharedHotStandbyActive
TimeLineID lastReplayedTLI
bool SharedPromoteIsTriggered
TimestampTz currentChunkStartTime
XLogRecPtr replayEndRecPtr
Latch recoveryWakeupLatch
TimestampTz recoveryLastXTime
RecoveryPauseState recoveryPauseState
XLogRecPtr lastReplayedReadRecPtr
TimeLineID PrevTimeLineID
TimeLineID ThisTimeLineID
TimestampTz overwrite_time
XLogRecPtr overwritten_lsn
char rp_name[MAXFNAMELEN]
TransactionId twophase_xid
TransactionId twophase_xid
#define InvalidTransactionId
#define U64FromFullTransactionId(x)
#define XidFromFullTransactionId(x)
#define TransactionIdIsValid(xid)
#define TransactionIdIsNormal(xid)
#define TimestampTzPlusMilliseconds(tz, ms)
static TimestampTz DatumGetTimestampTz(Datum X)
void AdvanceNextFullTransactionIdPastXid(TransactionId xid)
static void pgstat_report_wait_start(uint32 wait_event_info)
static void pgstat_report_wait_end(void)
void WalRcvForceReply(void)
#define AllowCascadeReplication()
XLogRecPtr GetWalRcvFlushRecPtr(XLogRecPtr *latestChunkStart, TimeLineID *receiveTLI)
bool WalRcvStreaming(void)
void RequestXLogStreaming(TimeLineID tli, XLogRecPtr recptr, const char *conninfo, const char *slotname, bool create_temp_slot)
void WalSndWakeup(bool physical, bool logical)
#define symlink(oldpath, newpath)
#define XLOG_XACT_COMMIT_PREPARED
#define XLOG_XACT_ABORT_PREPARED
void ParseCommitRecord(uint8 info, xl_xact_commit *xlrec, xl_xact_parsed_commit *parsed)
void ParseAbortRecord(uint8 info, xl_xact_abort *xlrec, xl_xact_parsed_abort *parsed)
int wal_decode_buffer_size
XLogRecPtr GetRedoRecPtr(void)
void SetInstallXLogFileSegmentActive(void)
bool IsInstallXLogFileSegmentActive(void)
void SwitchIntoArchiveRecovery(XLogRecPtr EndRecPtr, TimeLineID replayTLI)
void RemoveNonParentXlogFiles(XLogRecPtr switchpoint, TimeLineID newTLI)
void ReachedEndOfBackup(XLogRecPtr EndRecPtr, TimeLineID tli)
int wal_retrieve_retry_interval
static ControlFileData * ControlFile
void XLogShutdownWalRcv(void)
bool XLogCheckpointNeeded(XLogSegNo new_segno)
#define TABLESPACE_MAP_OLD
#define STANDBY_SIGNAL_FILE
#define CHECKPOINT_CAUSE_XLOG
#define PROMOTE_SIGNAL_FILE
#define BACKUP_LABEL_FILE
#define RECOVERY_SIGNAL_FILE
static RmgrData GetRmgr(RmgrId rmid)
@ RECOVERY_TARGET_ACTION_PAUSE
@ RECOVERY_TARGET_ACTION_PROMOTE
@ RECOVERY_TARGET_ACTION_SHUTDOWN
#define XLogSegmentOffset(xlogptr, wal_segsz_bytes)
#define XLByteToSeg(xlrp, logSegNo, wal_segsz_bytes)
static void XLogFilePath(char *path, TimeLineID tli, XLogSegNo logSegNo, int wal_segsz_bytes)
#define XRecOffIsValid(xlrp)
static void XLogFileName(char *fname, TimeLineID tli, XLogSegNo logSegNo, int wal_segsz_bytes)
#define XLByteInSeg(xlrp, logSegNo, wal_segsz_bytes)
bool RestoreArchivedFile(char *path, const char *xlogfname, const char *recovername, off_t expectedSize, bool cleanupEnabled)
void KeepFileRestoredFromArchive(const char *path, const char *xlogfname)
#define LSN_FORMAT_ARGS(lsn)
#define XLogRecPtrIsInvalid(r)
#define InvalidXLogRecPtr
void XLogPrefetcherComputeStats(XLogPrefetcher *prefetcher)
XLogRecord * XLogPrefetcherReadRecord(XLogPrefetcher *prefetcher, char **errmsg)
void XLogPrefetchReconfigure(void)
XLogPrefetcher * XLogPrefetcherAllocate(XLogReaderState *reader)
void XLogPrefetcherBeginRead(XLogPrefetcher *prefetcher, XLogRecPtr recPtr)
void XLogPrefetcherFree(XLogPrefetcher *prefetcher)
XLogReaderState * XLogPrefetcherGetReader(XLogPrefetcher *prefetcher)
bool XLogRecGetBlockTagExtended(XLogReaderState *record, uint8 block_id, RelFileLocator *rlocator, ForkNumber *forknum, BlockNumber *blknum, Buffer *prefetch_buffer)
void XLogReaderSetDecodeBuffer(XLogReaderState *state, void *buffer, size_t size)
void XLogReaderResetError(XLogReaderState *state)
bool XLogReaderValidatePageHeader(XLogReaderState *state, XLogRecPtr recptr, char *phdr)
void XLogReaderFree(XLogReaderState *state)
XLogReaderState * XLogReaderAllocate(int wal_segment_size, const char *waldir, XLogReaderRoutine *routine, void *private_data)
bool RestoreBlockImage(XLogReaderState *record, uint8 block_id, char *page)
#define XLogRecGetDataLen(decoder)
#define XLogRecGetInfo(decoder)
#define XLogRecBlockImageApply(decoder, block_id)
#define XLogRecGetRmid(decoder)
#define XLogRecGetData(decoder)
#define XLogRecGetXid(decoder)
#define XLogRecMaxBlockId(decoder)
#define XLogRecHasBlockImage(decoder, block_id)
#define XLogRecGetPrev(decoder)
#define XLogRecHasAnyBlockRefs(decoder)
#define SizeOfXLogRecordDataHeaderShort
#define XLR_CHECK_CONSISTENCY
bool check_primary_slot_name(char **newval, void **extra, GucSource source)
static bool getRecordTimestamp(XLogReaderState *record, TimestampTz *recordXtime)
static XLogRecPtr recoveryStopLSN
static bool recoveryStopsBefore(XLogReaderState *record)
static TimestampTz recoveryStopTime
void assign_recovery_target_xid(const char *newval, void *extra)
static bool CheckForStandbyTrigger(void)
int recovery_min_apply_delay
bool check_recovery_target(char **newval, void **extra, GucSource source)
static bool backupEndRequired
bool HotStandbyActive(void)
static char * getRecoveryStopReason(void)
void ShutdownWalRecovery(void)
RecoveryTargetTimeLineGoal recoveryTargetTimeLineGoal
static void rm_redo_error_callback(void *arg)
static bool recoveryApplyDelay(XLogReaderState *record)
bool ArchiveRecoveryRequested
const char * recoveryTargetName
static void xlogrecovery_redo(XLogReaderState *record, TimeLineID replayTLI)
static void pg_attribute_noreturn() error_multiple_recovery_targets(void)
bool check_recovery_target_timeline(char **newval, void **extra, GucSource source)
static XLogRecPtr minRecoveryPoint
static int XLogPageRead(XLogReaderState *xlogreader, XLogRecPtr targetPagePtr, int reqLen, XLogRecPtr targetRecPtr, char *readBuf)
static XLogRecPtr backupEndPoint
const struct config_enum_entry recovery_target_action_options[]
static void validateRecoveryParameters(void)
static void checkTimeLineSwitch(XLogRecPtr lsn, TimeLineID newTLI, TimeLineID prevTLI, TimeLineID replayTLI)
static XLogRecord * ReadCheckpointRecord(XLogPrefetcher *xlogprefetcher, XLogRecPtr RecPtr, TimeLineID replayTLI)
void StartupRequestWalReceiverRestart(void)
static bool recoveryStopsAfter(XLogReaderState *record)
void RecoveryRequiresIntParameter(const char *param_name, int currValue, int minValue)
static TimeLineID curFileTLI
static char recoveryStopName[MAXFNAMELEN]
static void CheckRecoveryConsistency(void)
static bool pendingWalRcvRestart
void PerformWalRecovery(void)
static XLogSource XLogReceiptSource
bool CheckPromoteSignal(void)
struct XLogPageReadPrivate XLogPageReadPrivate
static bool recoveryStopAfter
static const char *const xlogSourceNames[]
static TimeLineID RedoStartTLI
char * recoveryRestoreCommand
static void verifyBackupPageConsistency(XLogReaderState *record)
void assign_recovery_target(const char *newval, void *extra)
void SetRecoveryPause(bool recoveryPause)
EndOfWalRecoveryInfo * FinishWalRecovery(void)
static bool lastSourceFailed
char * archiveCleanupCommand
XLogRecPtr GetCurrentReplayRecPtr(TimeLineID *replayEndTLI)
static TimeLineID receiveTLI
void WakeupRecovery(void)
void xlog_outdesc(StringInfo buf, XLogReaderState *record)
static bool LocalPromoteIsTriggered
bool PromoteIsTriggered(void)
TimestampTz GetCurrentChunkReplayStartTime(void)
static void ConfirmRecoveryPaused(void)
static void readRecoverySignalFile(void)
static XLogRecPtr missingContrecPtr
static XLogRecoveryCtlData * XLogRecoveryCtl
static bool standby_signal_file_found
char * recovery_target_time_string
static XLogPageReadResult WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess, bool fetching_ckpt, XLogRecPtr tliRecPtr, TimeLineID replayTLI, XLogRecPtr replayLSN, bool nonblocking)
XLogRecPtr recoveryTargetLSN
RecoveryTargetType recoveryTarget
static bool read_tablespace_map(List **tablespaces)
static bool doRequestWalReceiverReply
static bool read_backup_label(XLogRecPtr *checkPointLoc, TimeLineID *backupLabelTLI, bool *backupEndRequired, bool *backupFromStandby)
static XLogSource currentSource
XLogRecPtr GetXLogReplayRecPtr(TimeLineID *replayTLI)
void GetXLogReceiptTime(TimestampTz *rtime, bool *fromStream)
static List * expectedTLEs
static int XLogFileReadAnyTLI(XLogSegNo segno, int emode, XLogSource source)
static XLogSegNo readSegNo
void assign_recovery_target_name(const char *newval, void *extra)
static int XLogFileRead(XLogSegNo segno, int emode, TimeLineID tli, XLogSource source, bool notfoundOk)
static XLogRecPtr abortedRecPtr
static char * primary_image_masked
static TimeLineID minRecoveryPointTLI
static XLogRecord * ReadRecord(XLogPrefetcher *xlogprefetcher, int emode, bool fetching_ckpt, TimeLineID replayTLI)
void assign_recovery_target_time(const char *newval, void *extra)
static void SetCurrentChunkStartTime(TimestampTz xtime)
static XLogRecPtr CheckPointLoc
bool check_recovery_target_xid(char **newval, void **extra, GucSource source)
static bool LocalHotStandbyActive
struct XLogRecoveryCtlData XLogRecoveryCtlData
static bool HotStandbyActiveInReplay(void)
static TransactionId recoveryStopXid
bool check_recovery_target_time(char **newval, void **extra, GucSource source)
static XLogSource readSource
static void SetPromoteIsTriggered(void)
#define RECOVERY_COMMAND_FILE
TransactionId recoveryTargetXid
TimeLineID recoveryTargetTLIRequested
void InitWalRecovery(ControlFileData *ControlFile, bool *wasShutdown_ptr, bool *haveBackupLabel_ptr, bool *haveTblspcMap_ptr)
static void xlog_block_info(StringInfo buf, XLogReaderState *record)
static TimestampTz XLogReceiptTime
static void ApplyWalRecord(XLogReaderState *xlogreader, XLogRecord *record, TimeLineID *replayTLI)
Size XLogRecoveryShmemSize(void)
static char * replay_image_masked
bool wal_receiver_create_temp_slot
static void CheckTablespaceDirectory(void)
char * recoveryEndCommand
RecoveryPauseState GetRecoveryPauseState(void)
TimeLineID recoveryTargetTLI
static int emode_for_corrupt_record(int emode, XLogRecPtr RecPtr)
void assign_recovery_target_lsn(const char *newval, void *extra)
bool check_recovery_target_lsn(char **newval, void **extra, GucSource source)
static XLogRecPtr RedoStartLSN
static XLogRecPtr flushedUpto
void XLogRecoveryShmemInit(void)
static void recoveryPausesHere(bool endOfRecovery)
static void EnableStandbyMode(void)
#define RECOVERY_COMMAND_DONE
static bool recovery_signal_file_found
TimestampTz recoveryTargetTime
TimestampTz GetLatestXTime(void)
void XLogRequestWalReceiverReply(void)
static bool rescanLatestTimeLine(TimeLineID replayTLI, XLogRecPtr replayLSN)
static XLogPrefetcher * xlogprefetcher
static bool StandbyModeRequested
bool check_recovery_target_name(char **newval, void **extra, GucSource source)
bool recoveryTargetInclusive
static XLogReaderState * xlogreader
void RemovePromoteSignalFiles(void)
void assign_recovery_target_timeline(const char *newval, void *extra)
static XLogRecPtr backupStartPoint
static void SetLatestXTime(TimestampTz xtime)
static TimeLineID CheckPointTLI
@ RECOVERY_TARGET_IMMEDIATE
RecoveryTargetTimeLineGoal
@ RECOVERY_TARGET_TIMELINE_NUMERIC
@ RECOVERY_TARGET_TIMELINE_CONTROLFILE
@ RECOVERY_TARGET_TIMELINE_LATEST
@ RECOVERY_PAUSE_REQUESTED
void wal_segment_close(XLogReaderState *state)
Buffer XLogReadBufferExtended(RelFileLocator rlocator, ForkNumber forknum, BlockNumber blkno, ReadBufferMode mode, Buffer recent_buffer)
HotStandbyState standbyState
void XLogCheckInvalidPages(void)