#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)

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

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

void	progress_report (bool force)

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

Variables
char *	datadir_target

char *	datadir_source

char *	connstr_source

bool	showprogress

bool	dry_run

int	WalSegSz

TimeLineHistoryEntry *	targetHistory

int	targetNentries

PGconn *	conn

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 41 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_pg_role_prefix(), check_for_prepared_transactions(), check_for_reg_data_type_usage(), check_for_tables_with_oids(), 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_cluster_analyze(), create_script_for_old_cluster_deletion(), create_target(), create_target_dir(), create_target_symlink(), createBackupLabel(), digestControlFile(), disable_old_cluster(), ensureCleanShutdown(), exec_prog(), extractPageInfo(), extractPageMap(), fetch_file_range(), 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(), getTimelineHistory(), init_tablespaces(), libpq_executeFileMap(), libpqConnect(), libpqGetCurrentXlogInsertLocation(), libpqGetFile(), libpqProcessFileList(), linkFile(), 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(), pid_lock_file_exists(), process_block_change(), process_source_file(), process_target_file(), readOneRecord(), reap_child(), receiveFileChunks(), recurse_dir(), remove_new_subdir(), remove_target_dir(), remove_target_file(), remove_target_symlink(), rewind_copy_file_range(), 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
	)

Definition at line 57 of file parsexlog.c.

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

Referenced by main().

 {
     XLogRecord *record;
     XLogReaderState *xlogreader;
     char       *errormsg;
     XLogPageReadPrivate private;
 
     private.tliIndex = tliIndex;
     xlogreader = XLogReaderAllocate(WalSegSz, datadir, &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->ReadRecPtr != 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
	)

Definition at line 147 of file parsexlog.c.

References close, pg_fatal, CheckPoint::redo, SimpleXLogPageRead(), SizeOfXLogLongPHD, SizeOfXLogShortPHD, CheckPoint::ThisTimeLineID, XLogPageReadPrivate::tliIndex, WalSegSz, XLogRecord::xl_prev, XLOG_CHECKPOINT_ONLINE, XLOG_CHECKPOINT_SHUTDOWN, XLogBeginRead(), 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;
     xlogreader = XLogReaderAllocate(WalSegSz, datadir, &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 master has been stopped to be rewinded.
          */
         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 force )

Definition at line 513 of file pg_rewind.c.

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

Referenced by main().

 {
     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 && !force)
         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);
     if (isatty(fileno(stderr)))
         fprintf(stderr, "\r");
     else
         fprintf(stderr, "\n");
 }

◆ readOneRecord()

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

Definition at line 106 of file parsexlog.c.

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

Referenced by main().

 {
     XLogRecord *record;
     XLogReaderState *xlogreader;
     char       *errormsg;
     XLogPageReadPrivate private;
     XLogRecPtr  endptr;
 
     private.tliIndex = tliIndex;
     xlogreader = XLogReaderAllocate(WalSegSz, datadir, &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;
 }