#include "datapagemap.h"
#include "access/timeline.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.

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)

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

Variables
char *	datadir_target

char *	datadir_source

char *	connstr_source

bool	debug

bool	showprogress

bool	dry_run

int	WalSegSz

TimeLineHistoryEntry *	targetHistory

int	targetNentries

Function Documentation

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

Definition at line 62 of file parsexlog.c.

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

Referenced by main().

 {
     XLogRecord *record;
     XLogReaderState *xlogreader;
     char       *errormsg;
     XLogPageReadPrivate private;
 
     private.datadir = datadir;
     private.tliIndex = tliIndex;
     xlogreader = XLogReaderAllocate(WalSegSz, &SimpleXLogPageRead,
                                     &private);
     if (xlogreader == NULL)
         pg_fatal("out of memory\n");
 
     do
     {
         record = XLogReadRecord(xlogreader, startpoint, &errormsg);
 
         if (record == NULL)
         {
             XLogRecPtr  errptr;
 
             errptr = startpoint ? startpoint : xlogreader->EndRecPtr;
 
             if (errormsg)
                 pg_fatal("could not read WAL record at %X/%X: %s\n",
                          (uint32) (errptr >> 32), (uint32) (errptr),
                          errormsg);
             else
                 pg_fatal("could not read WAL record at %X/%X\n",
                          (uint32) (startpoint >> 32),
                          (uint32) (startpoint));
         }
 
         extractPageInfo(xlogreader);
 
         startpoint = InvalidXLogRecPtr; /* continue reading at next record */
 
     } while (xlogreader->ReadRecPtr != endpoint);
 
     XLogReaderFree(xlogreader);
     if (xlogreadfd != -1)
     {
         close(xlogreadfd);
         xlogreadfd = -1;
     }
 }

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

Definition at line 157 of file parsexlog.c.

References close, datadir, pg_fatal(), CheckPoint::redo, SimpleXLogPageRead(), SizeOfXLogLongPHD, SizeOfXLogShortPHD, CheckPoint::ThisTimeLineID, WalSegSz, XLogRecord::xl_prev, XLOG_CHECKPOINT_ONLINE, XLOG_CHECKPOINT_SHUTDOWN, 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.datadir = datadir;
     private.tliIndex = tliIndex;
     xlogreader = XLogReaderAllocate(WalSegSz, &SimpleXLogPageRead,
                                     &private);
     if (xlogreader == NULL)
         pg_fatal("out of memory\n");
 
     searchptr = forkptr;
     for (;;)
     {
         uint8       info;
 
         record = XLogReadRecord(xlogreader, searchptr, &errormsg);
 
         if (record == NULL)
         {
             if (errormsg)
                 pg_fatal("could not find previous WAL record at %X/%X: %s\n",
                          (uint32) (searchptr >> 32), (uint32) (searchptr),
                          errormsg);
             else
                 pg_fatal("could not find previous WAL record at %X/%X\n",
                          (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;
     }
 }

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

Definition at line 116 of file parsexlog.c.

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

Referenced by main().

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

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

Definition at line 30 of file timeline.c.

References _, TimeLineHistoryEntry::begin, buffer, TimeLineHistoryEntry::end, InvalidXLogRecPtr, 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 */
             fprintf(stderr, _("syntax error in history file: %s\n"), fline);
             fprintf(stderr, _("Expected a numeric timeline ID.\n"));
             exit(1);
         }
         if (nfields != 3)
         {
             fprintf(stderr, _("syntax error in history file: %s\n"), fline);
             fprintf(stderr, _("Expected a write-ahead log switchpoint location.\n"));
             exit(1);
         }
         if (entries && tli <= lasttli)
         {
             fprintf(stderr, _("invalid data in history file: %s\n"), fline);
             fprintf(stderr, _("Timeline IDs must be in increasing sequence.\n"));
             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)
     {
         fprintf(stderr, _("invalid data in history file\n"));
         fprintf(stderr, _("Timeline IDs must be less than child timeline's ID.\n"));
         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;
 }