#include "access/timeline.h"
#include "common/logging.h"
#include "datapagemap.h"
#include "libpq-fe.h"
#include "storage/block.h"
#include "storage/relfilenode.h"

Include dependency graph for pg_rewind.h:

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

Go to the source code of this file.

Macros
#define	pg_fatal(...) do { pg_log_fatal(__VA_ARGS__); exit(1); } while(0)

Functions
void	extractPageMap (const char datadir, XLogRecPtr startpoint, int tliIndex, XLogRecPtr endpoint, const char restoreCommand)

void	findLastCheckpoint (const char datadir, XLogRecPtr searchptr, int tliIndex, XLogRecPtr lastchkptrec, TimeLineID lastchkpttli, XLogRecPtr lastchkptredo, const char *restoreCommand)

XLogRecPtr	readOneRecord (const char datadir, XLogRecPtr ptr, int tliIndex, const char restoreCommand)

void	progress_report (bool finished)

TimeLineHistoryEntry *	rewind_parseTimeLineHistory (char buffer, TimeLineID targetTLI, int nentries)

Variables
char *	datadir_target

bool	showprogress

bool	dry_run

bool	do_sync

int	WalSegSz

TimeLineHistoryEntry *	targetHistory

int	targetNentries

uint64	fetch_size

uint64	fetch_done

Macro Definition Documentation

◆ pg_fatal

#define pg_fatal ( ... ) do { pg_log_fatal(__VA_ARGS__); exit(1); } while(0)

Definition at line 37 of file pg_rewind.h.

Referenced by adjust_data_dir(), check_cluster_compatibility(), check_cluster_versions(), check_control_data(), check_file_clone(), check_for_data_type_usage(), check_for_isn_and_int8_passing_mismatch(), check_for_jsonb_9_4_usage(), check_for_new_tablespace_dir(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_for_reg_data_type_usage(), check_for_tables_with_oids(), check_for_user_defined_postfix_ops(), check_hard_link(), check_is_install_user(), check_loadable_libraries(), check_locale_and_encoding(), check_new_cluster_is_empty(), check_pghost_envvar(), check_proper_datallowconn(), check_required_directory(), checkControlFile(), cloneFile(), close_target_file(), copyFile(), create_script_for_old_cluster_deletion(), create_target(), create_target_dir(), create_target_symlink(), createBackupLabel(), decide_file_action(), digestControlFile(), disable_old_cluster(), ensureCleanShutdown(), exec_prog(), extractPageInfo(), extractPageMap(), findCommonAncestorTimeline(), findLastCheckpoint(), gen_db_file_maps(), get_bin_version(), get_canonical_locale_name(), get_control_data(), get_loadable_libraries(), get_major_server_version(), get_sock_dir(), getRestoreCommand(), getTimelineHistory(), init_libpq_conn(), init_tablespaces(), libpq_fetch_file(), libpq_get_current_wal_insert_lsn(), libpq_traverse_files(), linkFile(), local_fetch_file_range(), main(), new_9_0_populate_pg_largeobject_metadata(), old_11_check_for_sql_identifier_data_type_usage(), old_9_3_check_for_line_data_type_usage(), old_9_6_check_for_unknown_data_type_usage(), old_9_6_invalidate_hash_indexes(), open_target_file(), parallel_exec_prog(), parallel_transfer_all_new_dbs(), parseCommandLine(), perform_rewind(), pid_lock_file_exists(), process_queued_fetch_requests(), process_source_file(), process_target_file(), process_target_wal_block_change(), readOneRecord(), reap_child(), recurse_dir(), remove_new_subdir(), remove_target(), remove_target_dir(), remove_target_file(), remove_target_symlink(), rewriteVisibilityMap(), run_simple_command(), run_simple_query(), sanityChecks(), setup(), slurpFile(), start_postmaster(), transfer_all_new_dbs(), transfer_relfile(), truncate_target_file(), validate_exec(), verify_directories(), and write_target_range().

Function Documentation

◆ extractPageMap()

void extractPageMap	(	const char *	datadir,
		XLogRecPtr	startpoint,
		int	tliIndex,
		XLogRecPtr	endpoint,
		const char *	restoreCommand
	)

Definition at line 63 of file parsexlog.c.

References Assert, close, XLogReaderState::EndRecPtr, extractPageInfo(), pg_fatal, XLogPageReadPrivate::restoreCommand, SimpleXLogPageRead(), XLogPageReadPrivate::tliIndex, WalSegSz, XL_ROUTINE, XLogBeginRead(), xlogreader, XLogReaderAllocate(), XLogReaderFree(), xlogreadfd, and XLogReadRecord().

Referenced by main().

 {
     XLogRecord *record;
     XLogReaderState *xlogreader;
     char       *errormsg;
     XLogPageReadPrivate private;
 
     private.tliIndex = tliIndex;
     private.restoreCommand = restoreCommand;
     xlogreader = XLogReaderAllocate(WalSegSz, datadir,
                                     XL_ROUTINE(.page_read = &SimpleXLogPageRead),
                                     &private);
     if (xlogreader == NULL)
         pg_fatal("out of memory");
 
     XLogBeginRead(xlogreader, startpoint);
     do
     {
         record = XLogReadRecord(xlogreader, &errormsg);
 
         if (record == NULL)
         {
             XLogRecPtr  errptr = xlogreader->EndRecPtr;
 
             if (errormsg)
                 pg_fatal("could not read WAL record at %X/%X: %s",
                          (uint32) (errptr >> 32), (uint32) (errptr),
                          errormsg);
             else
                 pg_fatal("could not read WAL record at %X/%X",
                          (uint32) (errptr >> 32), (uint32) (errptr));
         }
 
         extractPageInfo(xlogreader);
 
     } while (xlogreader->EndRecPtr < endpoint);
 
     /*
      * If 'endpoint' didn't point exactly at a record boundary, the caller
      * messed up.
      */
     Assert(xlogreader->EndRecPtr == endpoint);
 
     XLogReaderFree(xlogreader);
     if (xlogreadfd != -1)
     {
         close(xlogreadfd);
         xlogreadfd = -1;
     }
 }

◆ findLastCheckpoint()

void findLastCheckpoint	(	const char *	datadir,
		XLogRecPtr	searchptr,
		int	tliIndex,
		XLogRecPtr *	lastchkptrec,
		TimeLineID *	lastchkpttli,
		XLogRecPtr *	lastchkptredo,
		const char *	restoreCommand
	)

Definition at line 164 of file parsexlog.c.

References close, pg_fatal, CheckPoint::redo, XLogPageReadPrivate::restoreCommand, SimpleXLogPageRead(), SizeOfXLogLongPHD, SizeOfXLogShortPHD, CheckPoint::ThisTimeLineID, XLogPageReadPrivate::tliIndex, WalSegSz, XLogRecord::xl_prev, XL_ROUTINE, XLOG_CHECKPOINT_ONLINE, XLOG_CHECKPOINT_SHUTDOWN, XLogBeginRead(), xlogreader, XLogReaderAllocate(), XLogReaderFree(), xlogreadfd, XLogReadRecord(), XLogRecGetData, XLogRecGetInfo, XLogRecGetRmid, XLogSegmentOffset, and XLR_INFO_MASK.

Referenced by main().

 {
     /* Walk backwards, starting from the given record */
     XLogRecord *record;
     XLogRecPtr  searchptr;
     XLogReaderState *xlogreader;
     char       *errormsg;
     XLogPageReadPrivate private;
 
     /*
      * The given fork pointer points to the end of the last common record,
      * which is not necessarily the beginning of the next record, if the
      * previous record happens to end at a page boundary. Skip over the page
      * header in that case to find the next record.
      */
     if (forkptr % XLOG_BLCKSZ == 0)
     {
         if (XLogSegmentOffset(forkptr, WalSegSz) == 0)
             forkptr += SizeOfXLogLongPHD;
         else
             forkptr += SizeOfXLogShortPHD;
     }
 
     private.tliIndex = tliIndex;
     private.restoreCommand = restoreCommand;
     xlogreader = XLogReaderAllocate(WalSegSz, datadir,
                                     XL_ROUTINE(.page_read = &SimpleXLogPageRead),
                                     &private);
     if (xlogreader == NULL)
         pg_fatal("out of memory");
 
     searchptr = forkptr;
     for (;;)
     {
         uint8       info;
 
         XLogBeginRead(xlogreader, searchptr);
         record = XLogReadRecord(xlogreader, &errormsg);
 
         if (record == NULL)
         {
             if (errormsg)
                 pg_fatal("could not find previous WAL record at %X/%X: %s",
                          (uint32) (searchptr >> 32), (uint32) (searchptr),
                          errormsg);
             else
                 pg_fatal("could not find previous WAL record at %X/%X",
                          (uint32) (searchptr >> 32), (uint32) (searchptr));
         }
 
         /*
          * Check if it is a checkpoint record. This checkpoint record needs to
          * be the latest checkpoint before WAL forked and not the checkpoint
          * where the primary has been stopped to be rewound.
          */
         info = XLogRecGetInfo(xlogreader) & ~XLR_INFO_MASK;
         if (searchptr < forkptr &&
             XLogRecGetRmid(xlogreader) == RM_XLOG_ID &&
             (info == XLOG_CHECKPOINT_SHUTDOWN ||
              info == XLOG_CHECKPOINT_ONLINE))
         {
             CheckPoint  checkPoint;
 
             memcpy(&checkPoint, XLogRecGetData(xlogreader), sizeof(CheckPoint));
             *lastchkptrec = searchptr;
             *lastchkpttli = checkPoint.ThisTimeLineID;
             *lastchkptredo = checkPoint.redo;
             break;
         }
 
         /* Walk backwards to previous record. */
         searchptr = record->xl_prev;
     }
 
     XLogReaderFree(xlogreader);
     if (xlogreadfd != -1)
     {
         close(xlogreadfd);
         xlogreadfd = -1;
     }
 }

◆ progress_report()

void progress_report ( bool finished )

Definition at line 734 of file pg_rewind.c.

References _, fetch_done, fetch_size, fprintf, INT64_FORMAT, last_progress_report, now(), showprogress, and snprintf.

Referenced by perform_rewind().

 {
     static pg_time_t last_progress_report = 0;
     int         percent;
     char        fetch_done_str[32];
     char        fetch_size_str[32];
     pg_time_t   now;
 
     if (!showprogress)
         return;
 
     now = time(NULL);
     if (now == last_progress_report && !finished)
         return;                 /* Max once per second */
 
     last_progress_report = now;
     percent = fetch_size ? (int) ((fetch_done) * 100 / fetch_size) : 0;
 
     /*
      * Avoid overflowing past 100% or the full size. This may make the total
      * size number change as we approach the end of the backup (the estimate
      * will always be wrong if WAL is included), but that's better than having
      * the done column be bigger than the total.
      */
     if (percent > 100)
         percent = 100;
     if (fetch_done > fetch_size)
         fetch_size = fetch_done;
 
     /*
      * Separate step to keep platform-dependent format code out of
      * translatable strings.  And we only test for INT64_FORMAT availability
      * in snprintf, not fprintf.
      */
     snprintf(fetch_done_str, sizeof(fetch_done_str), INT64_FORMAT,
              fetch_done / 1024);
     snprintf(fetch_size_str, sizeof(fetch_size_str), INT64_FORMAT,
              fetch_size / 1024);
 
     fprintf(stderr, _("%*s/%s kB (%d%%) copied"),
             (int) strlen(fetch_size_str), fetch_done_str, fetch_size_str,
             percent);
 
     /*
      * Stay on the same line if reporting to a terminal and we're not done
      * yet.
      */
     fputc((!finished && isatty(fileno(stderr))) ? '\r' : '\n', stderr);
 }

◆ readOneRecord()

XLogRecPtr readOneRecord	(	const char *	datadir,
		XLogRecPtr	ptr,
		int	tliIndex,
		const char *	restoreCommand
	)

Definition at line 120 of file parsexlog.c.

References close, XLogReaderState::EndRecPtr, pg_fatal, XLogPageReadPrivate::restoreCommand, SimpleXLogPageRead(), XLogPageReadPrivate::tliIndex, WalSegSz, XL_ROUTINE, XLogBeginRead(), xlogreader, XLogReaderAllocate(), XLogReaderFree(), xlogreadfd, and XLogReadRecord().

Referenced by main().

 {
     XLogRecord *record;
     XLogReaderState *xlogreader;
     char       *errormsg;
     XLogPageReadPrivate private;
     XLogRecPtr  endptr;
 
     private.tliIndex = tliIndex;
     private.restoreCommand = restoreCommand;
     xlogreader = XLogReaderAllocate(WalSegSz, datadir,
                                     XL_ROUTINE(.page_read = &SimpleXLogPageRead),
                                     &private);
     if (xlogreader == NULL)
         pg_fatal("out of memory");
 
     XLogBeginRead(xlogreader, ptr);
     record = XLogReadRecord(xlogreader, &errormsg);
     if (record == NULL)
     {
         if (errormsg)
             pg_fatal("could not read WAL record at %X/%X: %s",
                      (uint32) (ptr >> 32), (uint32) (ptr), errormsg);
         else
             pg_fatal("could not read WAL record at %X/%X",
                      (uint32) (ptr >> 32), (uint32) (ptr));
     }
     endptr = xlogreader->EndRecPtr;
 
     XLogReaderFree(xlogreader);
     if (xlogreadfd != -1)
     {
         close(xlogreadfd);
         xlogreadfd = -1;
     }
 
     return endptr;
 }

◆ rewind_parseTimeLineHistory()

TimeLineHistoryEntry* rewind_parseTimeLineHistory	(	char *	buffer,
		TimeLineID	targetTLI,
		int *	nentries
	)

Definition at line 29 of file timeline.c.

References TimeLineHistoryEntry::begin, TimeLineHistoryEntry::end, InvalidXLogRecPtr, pg_log_error, pg_malloc(), pg_realloc(), and TimeLineHistoryEntry::tli.

Referenced by getTimelineHistory().

 {
     char       *fline;
     TimeLineHistoryEntry *entry;
     TimeLineHistoryEntry *entries = NULL;
     int         nlines = 0;
     TimeLineID  lasttli = 0;
     XLogRecPtr  prevend;
     char       *bufptr;
     bool        lastline = false;
 
     /*
      * Parse the file...
      */
     prevend = InvalidXLogRecPtr;
     bufptr = buffer;
     while (!lastline)
     {
         char       *ptr;
         TimeLineID  tli;
         uint32      switchpoint_hi;
         uint32      switchpoint_lo;
         int         nfields;
 
         fline = bufptr;
         while (*bufptr && *bufptr != '\n')
             bufptr++;
         if (!(*bufptr))
             lastline = true;
         else
             *bufptr++ = '\0';
 
         /* skip leading whitespace and check for # comment */
         for (ptr = fline; *ptr; ptr++)
         {
             if (!isspace((unsigned char) *ptr))
                 break;
         }
         if (*ptr == '\0' || *ptr == '#')
             continue;
 
         nfields = sscanf(fline, "%u\t%X/%X", &tli, &switchpoint_hi, &switchpoint_lo);
 
         if (nfields < 1)
         {
             /* expect a numeric timeline ID as first field of line */
             pg_log_error("syntax error in history file: %s", fline);
             pg_log_error("Expected a numeric timeline ID.");
             exit(1);
         }
         if (nfields != 3)
         {
             pg_log_error("syntax error in history file: %s", fline);
             pg_log_error("Expected a write-ahead log switchpoint location.");
             exit(1);
         }
         if (entries && tli <= lasttli)
         {
             pg_log_error("invalid data in history file: %s", fline);
             pg_log_error("Timeline IDs must be in increasing sequence.");
             exit(1);
         }
 
         lasttli = tli;
 
         nlines++;
         entries = pg_realloc(entries, nlines * sizeof(TimeLineHistoryEntry));
 
         entry = &entries[nlines - 1];
         entry->tli = tli;
         entry->begin = prevend;
         entry->end = ((uint64) (switchpoint_hi)) << 32 | (uint64) switchpoint_lo;
         prevend = entry->end;
 
         /* we ignore the remainder of each line */
     }
 
     if (entries && targetTLI <= lasttli)
     {
         pg_log_error("invalid data in history file");
         pg_log_error("Timeline IDs must be less than child timeline's ID.");
         exit(1);
     }
 
     /*
      * Create one more entry for the "tip" of the timeline, which has no entry
      * in the history file.
      */
     nlines++;
     if (entries)
         entries = pg_realloc(entries, nlines * sizeof(TimeLineHistoryEntry));
     else
         entries = pg_malloc(1 * sizeof(TimeLineHistoryEntry));
 
     entry = &entries[nlines - 1];
     entry->tli = targetTLI;
     entry->begin = prevend;
     entry->end = InvalidXLogRecPtr;
 
     *nentries = nlines;
     return entries;
 }