#include "access/timeline.h"
#include "common/logging.h"
#include "common/file_utils.h"

Include dependency graph for pg_rewind.h:

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

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

void	findLastCheckpoint (const char datadir, XLogRecPtr forkptr, 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

DataDirSyncMethod	sync_method

TimeLineHistoryEntry *	targetHistory

int	targetNentries

uint64	fetch_size

uint64	fetch_done

Function Documentation

◆ extractPageMap()

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

Definition at line 66 of file parsexlog.c.

 {
     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 while allocating a WAL reading processor");
  
     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",
                          LSN_FORMAT_ARGS(errptr),
                          errormsg);
             else
                 pg_fatal("could not read WAL record at %X/%X",
                          LSN_FORMAT_ARGS(errptr));
         }
  
         extractPageInfo(xlogreader);
     } while (xlogreader->EndRecPtr < endpoint);
  
     /*
      * If 'endpoint' didn't point exactly at a record boundary, the caller
      * messed up.
      */
     if (xlogreader->EndRecPtr != endpoint)
         pg_fatal("end pointer %X/%X is not a valid end point; expected %X/%X",
                  LSN_FORMAT_ARGS(endpoint), LSN_FORMAT_ARGS(xlogreader->EndRecPtr));
  
     XLogReaderFree(xlogreader);
     if (xlogreadfd != -1)
     {
         close(xlogreadfd);
         xlogreadfd = -1;
     }
 }

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

Referenced by main().

◆ findLastCheckpoint()

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

Definition at line 168 of file parsexlog.c.

 {
     /* Walk backwards, starting from the given record */
     XLogRecord *record;
     XLogRecPtr  searchptr;
     XLogReaderState *xlogreader;
     char       *errormsg;
     XLogPageReadPrivate private;
     XLogSegNo   current_segno = 0;
     TimeLineID  current_tli = 0;
  
     /*
      * 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 while allocating a WAL reading processor");
  
     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",
                          LSN_FORMAT_ARGS(searchptr),
                          errormsg);
             else
                 pg_fatal("could not find previous WAL record at %X/%X",
                          LSN_FORMAT_ARGS(searchptr));
         }
  
         /* Detect if a new WAL file has been opened */
         if (xlogreader->seg.ws_tli != current_tli ||
             xlogreader->seg.ws_segno != current_segno)
         {
             char        xlogfname[MAXFNAMELEN];
  
             snprintf(xlogfname, MAXFNAMELEN, XLOGDIR "/");
  
             /* update curent values */
             current_tli = xlogreader->seg.ws_tli;
             current_segno = xlogreader->seg.ws_segno;
  
             XLogFileName(xlogfname + sizeof(XLOGDIR),
                          current_tli, current_segno, WalSegSz);
  
             /* Track this filename as one to not remove */
             keepwal_add_entry(xlogfname);
         }
  
         /*
          * 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;
     }
 }

References close, datadir, keepwal_add_entry(), LSN_FORMAT_ARGS, MAXFNAMELEN, pg_fatal, CheckPoint::redo, XLogReaderState::seg, SimpleXLogPageRead(), SizeOfXLogLongPHD, SizeOfXLogShortPHD, snprintf, CheckPoint::ThisTimeLineID, WalSegSz, WALOpenSegment::ws_segno, WALOpenSegment::ws_tli, XLogRecord::xl_prev, XL_ROUTINE, XLOG_CHECKPOINT_ONLINE, XLOG_CHECKPOINT_SHUTDOWN, XLogBeginRead(), XLOGDIR, XLogFileName(), xlogreader, XLogReaderAllocate(), XLogReaderFree(), xlogreadfd, XLogReadRecord(), XLogRecGetData, XLogRecGetInfo, XLogRecGetRmid, XLogSegmentOffset, and XLR_INFO_MASK.

Referenced by main().

◆ progress_report()

void progress_report ( bool finished )

Definition at line 791 of file pg_rewind.c.

 {
     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;
  
     snprintf(fetch_done_str, sizeof(fetch_done_str), UINT64_FORMAT,
              fetch_done / 1024);
     snprintf(fetch_size_str, sizeof(fetch_size_str), UINT64_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);
 }

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

Referenced by perform_rewind().

◆ readOneRecord()

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

Definition at line 124 of file parsexlog.c.

 {
     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 while allocating a WAL reading processor");
  
     XLogBeginRead(xlogreader, ptr);
     record = XLogReadRecord(xlogreader, &errormsg);
     if (record == NULL)
     {
         if (errormsg)
             pg_fatal("could not read WAL record at %X/%X: %s",
                      LSN_FORMAT_ARGS(ptr), errormsg);
         else
             pg_fatal("could not read WAL record at %X/%X",
                      LSN_FORMAT_ARGS(ptr));
     }
     endptr = xlogreader->EndRecPtr;
  
     XLogReaderFree(xlogreader);
     if (xlogreadfd != -1)
     {
         close(xlogreadfd);
         xlogreadfd = -1;
     }
  
     return endptr;
 }

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

Referenced by main().

◆ rewind_parseTimeLineHistory()

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

Definition at line 28 of file timeline.c.

 {
     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_detail("Expected a numeric timeline ID.");
             exit(1);
         }
         if (nfields != 3)
         {
             pg_log_error("syntax error in history file: %s", fline);
             pg_log_error_detail("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_detail("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_detail("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;
 }