2015-03-23 18:47:52 +01:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* parsexlog.c
|
|
|
|
* Functions for reading Write-Ahead-Log
|
|
|
|
*
|
2017-01-03 19:48:53 +01:00
|
|
|
* Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
|
2015-03-23 18:47:52 +01:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "postgres_fe.h"
|
|
|
|
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
#include "pg_rewind.h"
|
|
|
|
#include "filemap.h"
|
|
|
|
#include "logging.h"
|
|
|
|
|
|
|
|
#include "access/rmgr.h"
|
|
|
|
#include "access/xlog_internal.h"
|
|
|
|
#include "access/xlogreader.h"
|
|
|
|
#include "catalog/pg_control.h"
|
|
|
|
#include "catalog/storage_xlog.h"
|
|
|
|
#include "commands/dbcommands_xlog.h"
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* RmgrNames is an array of resource manager names, to make error messages
|
|
|
|
* a bit nicer.
|
|
|
|
*/
|
2017-02-08 21:45:30 +01:00
|
|
|
#define PG_RMGR(symname,name,redo,desc,identify,startup,cleanup,mask) \
|
2015-03-23 18:47:52 +01:00
|
|
|
name,
|
|
|
|
|
|
|
|
static const char *RmgrNames[RM_MAX_ID + 1] = {
|
|
|
|
#include "access/rmgrlist.h"
|
|
|
|
};
|
|
|
|
|
|
|
|
static void extractPageInfo(XLogReaderState *record);
|
|
|
|
|
|
|
|
static int xlogreadfd = -1;
|
|
|
|
static XLogSegNo xlogreadsegno = -1;
|
|
|
|
static char xlogfpath[MAXPGPATH];
|
|
|
|
|
|
|
|
typedef struct XLogPageReadPrivate
|
|
|
|
{
|
|
|
|
const char *datadir;
|
2015-12-01 16:56:44 +01:00
|
|
|
int tliIndex;
|
2015-03-23 18:47:52 +01:00
|
|
|
} XLogPageReadPrivate;
|
|
|
|
|
|
|
|
static int SimpleXLogPageRead(XLogReaderState *xlogreader,
|
|
|
|
XLogRecPtr targetPagePtr,
|
|
|
|
int reqLen, XLogRecPtr targetRecPtr, char *readBuf,
|
|
|
|
TimeLineID *pageTLI);
|
|
|
|
|
|
|
|
/*
|
2016-10-20 17:24:37 +02:00
|
|
|
* Read WAL from the datadir/pg_wal, starting from 'startpoint' on timeline
|
2015-12-01 16:56:44 +01:00
|
|
|
* index 'tliIndex' in target timeline history, until 'endpoint'. Make note of
|
|
|
|
* the data blocks touched by the WAL records, and return them in a page map.
|
2015-03-23 18:47:52 +01:00
|
|
|
*/
|
|
|
|
void
|
2015-12-01 16:56:44 +01:00
|
|
|
extractPageMap(const char *datadir, XLogRecPtr startpoint, int tliIndex,
|
2015-03-23 18:47:52 +01:00
|
|
|
XLogRecPtr endpoint)
|
|
|
|
{
|
|
|
|
XLogRecord *record;
|
|
|
|
XLogReaderState *xlogreader;
|
|
|
|
char *errormsg;
|
|
|
|
XLogPageReadPrivate private;
|
|
|
|
|
|
|
|
private.datadir = datadir;
|
2015-12-01 16:56:44 +01:00
|
|
|
private.tliIndex = tliIndex;
|
Make WAL segment size configurable at initdb time.
For performance reasons a larger segment size than the default 16MB
can be useful. A larger segment size has two main benefits: Firstly,
in setups using archiving, it makes it easier to write scripts that
can keep up with higher amounts of WAL, secondly, the WAL has to be
written and synced to disk less frequently.
But at the same time large segment size are disadvantageous for
smaller databases. So far the segment size had to be configured at
compile time, often making it unrealistic to choose one fitting to a
particularly load. Therefore change it to a initdb time setting.
This includes a breaking changes to the xlogreader.h API, which now
requires the current segment size to be configured. For that and
similar reasons a number of binaries had to be taught how to recognize
the current segment size.
Author: Beena Emerson, editorialized by Andres Freund
Reviewed-By: Andres Freund, David Steele, Kuntal Ghosh, Michael
Paquier, Peter Eisentraut, Robert Hass, Tushar Ahuja
Discussion: https://postgr.es/m/CAOG9ApEAcQ--1ieKbhFzXSQPw_YLmepaa4hNdnY5+ZULpt81Mw@mail.gmail.com
2017-09-20 07:03:48 +02:00
|
|
|
xlogreader = XLogReaderAllocate(WalSegSz, &SimpleXLogPageRead,
|
|
|
|
&private);
|
2015-04-03 14:55:37 +02:00
|
|
|
if (xlogreader == NULL)
|
2015-04-16 08:18:00 +02:00
|
|
|
pg_fatal("out of memory\n");
|
2015-03-23 18:47:52 +01:00
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
record = XLogReadRecord(xlogreader, startpoint, &errormsg);
|
|
|
|
|
|
|
|
if (record == NULL)
|
|
|
|
{
|
|
|
|
XLogRecPtr errptr;
|
|
|
|
|
|
|
|
errptr = startpoint ? startpoint : xlogreader->EndRecPtr;
|
|
|
|
|
|
|
|
if (errormsg)
|
2015-06-23 02:40:01 +02:00
|
|
|
pg_fatal("could not read WAL record at %X/%X: %s\n",
|
2015-03-23 18:47:52 +01:00
|
|
|
(uint32) (errptr >> 32), (uint32) (errptr),
|
|
|
|
errormsg);
|
|
|
|
else
|
2015-06-23 02:40:01 +02:00
|
|
|
pg_fatal("could not read WAL record at %X/%X\n",
|
2015-03-23 18:47:52 +01:00
|
|
|
(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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reads one WAL record. Returns the end position of the record, without
|
|
|
|
* doing anything with the record itself.
|
|
|
|
*/
|
|
|
|
XLogRecPtr
|
2015-12-01 16:56:44 +01:00
|
|
|
readOneRecord(const char *datadir, XLogRecPtr ptr, int tliIndex)
|
2015-03-23 18:47:52 +01:00
|
|
|
{
|
|
|
|
XLogRecord *record;
|
|
|
|
XLogReaderState *xlogreader;
|
|
|
|
char *errormsg;
|
|
|
|
XLogPageReadPrivate private;
|
|
|
|
XLogRecPtr endptr;
|
|
|
|
|
|
|
|
private.datadir = datadir;
|
2015-12-01 16:56:44 +01:00
|
|
|
private.tliIndex = tliIndex;
|
Make WAL segment size configurable at initdb time.
For performance reasons a larger segment size than the default 16MB
can be useful. A larger segment size has two main benefits: Firstly,
in setups using archiving, it makes it easier to write scripts that
can keep up with higher amounts of WAL, secondly, the WAL has to be
written and synced to disk less frequently.
But at the same time large segment size are disadvantageous for
smaller databases. So far the segment size had to be configured at
compile time, often making it unrealistic to choose one fitting to a
particularly load. Therefore change it to a initdb time setting.
This includes a breaking changes to the xlogreader.h API, which now
requires the current segment size to be configured. For that and
similar reasons a number of binaries had to be taught how to recognize
the current segment size.
Author: Beena Emerson, editorialized by Andres Freund
Reviewed-By: Andres Freund, David Steele, Kuntal Ghosh, Michael
Paquier, Peter Eisentraut, Robert Hass, Tushar Ahuja
Discussion: https://postgr.es/m/CAOG9ApEAcQ--1ieKbhFzXSQPw_YLmepaa4hNdnY5+ZULpt81Mw@mail.gmail.com
2017-09-20 07:03:48 +02:00
|
|
|
xlogreader = XLogReaderAllocate(WalSegSz, &SimpleXLogPageRead,
|
|
|
|
&private);
|
2015-04-03 14:55:37 +02:00
|
|
|
if (xlogreader == NULL)
|
2015-04-16 08:18:00 +02:00
|
|
|
pg_fatal("out of memory\n");
|
2015-03-23 18:47:52 +01:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2017-05-12 19:51:27 +02:00
|
|
|
* Find the previous checkpoint preceding given WAL location.
|
2015-03-23 18:47:52 +01:00
|
|
|
*/
|
|
|
|
void
|
2015-12-01 16:56:44 +01:00
|
|
|
findLastCheckpoint(const char *datadir, XLogRecPtr forkptr, int tliIndex,
|
2015-03-23 18:47:52 +01:00
|
|
|
XLogRecPtr *lastchkptrec, TimeLineID *lastchkpttli,
|
|
|
|
XLogRecPtr *lastchkptredo)
|
|
|
|
{
|
|
|
|
/* 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)
|
Make WAL segment size configurable at initdb time.
For performance reasons a larger segment size than the default 16MB
can be useful. A larger segment size has two main benefits: Firstly,
in setups using archiving, it makes it easier to write scripts that
can keep up with higher amounts of WAL, secondly, the WAL has to be
written and synced to disk less frequently.
But at the same time large segment size are disadvantageous for
smaller databases. So far the segment size had to be configured at
compile time, often making it unrealistic to choose one fitting to a
particularly load. Therefore change it to a initdb time setting.
This includes a breaking changes to the xlogreader.h API, which now
requires the current segment size to be configured. For that and
similar reasons a number of binaries had to be taught how to recognize
the current segment size.
Author: Beena Emerson, editorialized by Andres Freund
Reviewed-By: Andres Freund, David Steele, Kuntal Ghosh, Michael
Paquier, Peter Eisentraut, Robert Hass, Tushar Ahuja
Discussion: https://postgr.es/m/CAOG9ApEAcQ--1ieKbhFzXSQPw_YLmepaa4hNdnY5+ZULpt81Mw@mail.gmail.com
2017-09-20 07:03:48 +02:00
|
|
|
{
|
|
|
|
if (XLogSegmentOffset(forkptr, WalSegSz) == 0)
|
|
|
|
forkptr += SizeOfXLogLongPHD;
|
|
|
|
else
|
|
|
|
forkptr += SizeOfXLogShortPHD;
|
|
|
|
}
|
2015-03-23 18:47:52 +01:00
|
|
|
|
|
|
|
private.datadir = datadir;
|
2015-12-01 16:56:44 +01:00
|
|
|
private.tliIndex = tliIndex;
|
Make WAL segment size configurable at initdb time.
For performance reasons a larger segment size than the default 16MB
can be useful. A larger segment size has two main benefits: Firstly,
in setups using archiving, it makes it easier to write scripts that
can keep up with higher amounts of WAL, secondly, the WAL has to be
written and synced to disk less frequently.
But at the same time large segment size are disadvantageous for
smaller databases. So far the segment size had to be configured at
compile time, often making it unrealistic to choose one fitting to a
particularly load. Therefore change it to a initdb time setting.
This includes a breaking changes to the xlogreader.h API, which now
requires the current segment size to be configured. For that and
similar reasons a number of binaries had to be taught how to recognize
the current segment size.
Author: Beena Emerson, editorialized by Andres Freund
Reviewed-By: Andres Freund, David Steele, Kuntal Ghosh, Michael
Paquier, Peter Eisentraut, Robert Hass, Tushar Ahuja
Discussion: https://postgr.es/m/CAOG9ApEAcQ--1ieKbhFzXSQPw_YLmepaa4hNdnY5+ZULpt81Mw@mail.gmail.com
2017-09-20 07:03:48 +02:00
|
|
|
xlogreader = XLogReaderAllocate(WalSegSz, &SimpleXLogPageRead,
|
|
|
|
&private);
|
2015-04-03 14:55:37 +02:00
|
|
|
if (xlogreader == NULL)
|
2015-04-16 08:18:00 +02:00
|
|
|
pg_fatal("out of memory\n");
|
2015-03-23 18:47:52 +01:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* XLogreader callback function, to read a WAL page */
|
2015-04-07 22:56:21 +02:00
|
|
|
static int
|
2015-03-23 18:47:52 +01:00
|
|
|
SimpleXLogPageRead(XLogReaderState *xlogreader, XLogRecPtr targetPagePtr,
|
|
|
|
int reqLen, XLogRecPtr targetRecPtr, char *readBuf,
|
|
|
|
TimeLineID *pageTLI)
|
|
|
|
{
|
|
|
|
XLogPageReadPrivate *private = (XLogPageReadPrivate *) xlogreader->private_data;
|
|
|
|
uint32 targetPageOff;
|
2015-12-01 16:56:44 +01:00
|
|
|
XLogRecPtr targetSegEnd;
|
|
|
|
XLogSegNo targetSegNo;
|
2015-03-23 18:47:52 +01:00
|
|
|
|
Make WAL segment size configurable at initdb time.
For performance reasons a larger segment size than the default 16MB
can be useful. A larger segment size has two main benefits: Firstly,
in setups using archiving, it makes it easier to write scripts that
can keep up with higher amounts of WAL, secondly, the WAL has to be
written and synced to disk less frequently.
But at the same time large segment size are disadvantageous for
smaller databases. So far the segment size had to be configured at
compile time, often making it unrealistic to choose one fitting to a
particularly load. Therefore change it to a initdb time setting.
This includes a breaking changes to the xlogreader.h API, which now
requires the current segment size to be configured. For that and
similar reasons a number of binaries had to be taught how to recognize
the current segment size.
Author: Beena Emerson, editorialized by Andres Freund
Reviewed-By: Andres Freund, David Steele, Kuntal Ghosh, Michael
Paquier, Peter Eisentraut, Robert Hass, Tushar Ahuja
Discussion: https://postgr.es/m/CAOG9ApEAcQ--1ieKbhFzXSQPw_YLmepaa4hNdnY5+ZULpt81Mw@mail.gmail.com
2017-09-20 07:03:48 +02:00
|
|
|
XLByteToSeg(targetPagePtr, targetSegNo, WalSegSz);
|
|
|
|
XLogSegNoOffsetToRecPtr(targetSegNo + 1, 0, targetSegEnd, WalSegSz);
|
|
|
|
targetPageOff = XLogSegmentOffset(targetPagePtr, WalSegSz);
|
2015-03-23 18:47:52 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* See if we need to switch to a new segment because the requested record
|
|
|
|
* is not in the currently open one.
|
|
|
|
*/
|
Make WAL segment size configurable at initdb time.
For performance reasons a larger segment size than the default 16MB
can be useful. A larger segment size has two main benefits: Firstly,
in setups using archiving, it makes it easier to write scripts that
can keep up with higher amounts of WAL, secondly, the WAL has to be
written and synced to disk less frequently.
But at the same time large segment size are disadvantageous for
smaller databases. So far the segment size had to be configured at
compile time, often making it unrealistic to choose one fitting to a
particularly load. Therefore change it to a initdb time setting.
This includes a breaking changes to the xlogreader.h API, which now
requires the current segment size to be configured. For that and
similar reasons a number of binaries had to be taught how to recognize
the current segment size.
Author: Beena Emerson, editorialized by Andres Freund
Reviewed-By: Andres Freund, David Steele, Kuntal Ghosh, Michael
Paquier, Peter Eisentraut, Robert Hass, Tushar Ahuja
Discussion: https://postgr.es/m/CAOG9ApEAcQ--1ieKbhFzXSQPw_YLmepaa4hNdnY5+ZULpt81Mw@mail.gmail.com
2017-09-20 07:03:48 +02:00
|
|
|
if (xlogreadfd >= 0 &&
|
|
|
|
!XLByteInSeg(targetPagePtr, xlogreadsegno, WalSegSz))
|
2015-03-23 18:47:52 +01:00
|
|
|
{
|
|
|
|
close(xlogreadfd);
|
|
|
|
xlogreadfd = -1;
|
|
|
|
}
|
|
|
|
|
Make WAL segment size configurable at initdb time.
For performance reasons a larger segment size than the default 16MB
can be useful. A larger segment size has two main benefits: Firstly,
in setups using archiving, it makes it easier to write scripts that
can keep up with higher amounts of WAL, secondly, the WAL has to be
written and synced to disk less frequently.
But at the same time large segment size are disadvantageous for
smaller databases. So far the segment size had to be configured at
compile time, often making it unrealistic to choose one fitting to a
particularly load. Therefore change it to a initdb time setting.
This includes a breaking changes to the xlogreader.h API, which now
requires the current segment size to be configured. For that and
similar reasons a number of binaries had to be taught how to recognize
the current segment size.
Author: Beena Emerson, editorialized by Andres Freund
Reviewed-By: Andres Freund, David Steele, Kuntal Ghosh, Michael
Paquier, Peter Eisentraut, Robert Hass, Tushar Ahuja
Discussion: https://postgr.es/m/CAOG9ApEAcQ--1ieKbhFzXSQPw_YLmepaa4hNdnY5+ZULpt81Mw@mail.gmail.com
2017-09-20 07:03:48 +02:00
|
|
|
XLByteToSeg(targetPagePtr, xlogreadsegno, WalSegSz);
|
2015-03-23 18:47:52 +01:00
|
|
|
|
|
|
|
if (xlogreadfd < 0)
|
|
|
|
{
|
|
|
|
char xlogfname[MAXFNAMELEN];
|
|
|
|
|
2015-12-01 16:56:44 +01:00
|
|
|
/*
|
|
|
|
* Since incomplete segments are copied into next timelines, switch to
|
2016-06-10 00:02:36 +02:00
|
|
|
* the timeline holding the required segment. Assuming this scan can
|
|
|
|
* be done both forward and backward, consider also switching timeline
|
2015-12-01 16:56:44 +01:00
|
|
|
* accordingly.
|
|
|
|
*/
|
|
|
|
while (private->tliIndex < targetNentries - 1 &&
|
2016-06-10 00:02:36 +02:00
|
|
|
targetHistory[private->tliIndex].end < targetSegEnd)
|
2015-12-01 16:56:44 +01:00
|
|
|
private->tliIndex++;
|
|
|
|
while (private->tliIndex > 0 &&
|
2016-06-10 00:02:36 +02:00
|
|
|
targetHistory[private->tliIndex].begin >= targetSegEnd)
|
2015-12-01 16:56:44 +01:00
|
|
|
private->tliIndex--;
|
|
|
|
|
Make WAL segment size configurable at initdb time.
For performance reasons a larger segment size than the default 16MB
can be useful. A larger segment size has two main benefits: Firstly,
in setups using archiving, it makes it easier to write scripts that
can keep up with higher amounts of WAL, secondly, the WAL has to be
written and synced to disk less frequently.
But at the same time large segment size are disadvantageous for
smaller databases. So far the segment size had to be configured at
compile time, often making it unrealistic to choose one fitting to a
particularly load. Therefore change it to a initdb time setting.
This includes a breaking changes to the xlogreader.h API, which now
requires the current segment size to be configured. For that and
similar reasons a number of binaries had to be taught how to recognize
the current segment size.
Author: Beena Emerson, editorialized by Andres Freund
Reviewed-By: Andres Freund, David Steele, Kuntal Ghosh, Michael
Paquier, Peter Eisentraut, Robert Hass, Tushar Ahuja
Discussion: https://postgr.es/m/CAOG9ApEAcQ--1ieKbhFzXSQPw_YLmepaa4hNdnY5+ZULpt81Mw@mail.gmail.com
2017-09-20 07:03:48 +02:00
|
|
|
XLogFileName(xlogfname, targetHistory[private->tliIndex].tli,
|
|
|
|
xlogreadsegno, WalSegSz);
|
2015-03-23 18:47:52 +01:00
|
|
|
|
|
|
|
snprintf(xlogfpath, MAXPGPATH, "%s/" XLOGDIR "/%s", private->datadir, xlogfname);
|
|
|
|
|
|
|
|
xlogreadfd = open(xlogfpath, O_RDONLY | PG_BINARY, 0);
|
|
|
|
|
|
|
|
if (xlogreadfd < 0)
|
|
|
|
{
|
|
|
|
printf(_("could not open file \"%s\": %s\n"), xlogfpath,
|
|
|
|
strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* At this point, we have the right segment open.
|
|
|
|
*/
|
|
|
|
Assert(xlogreadfd != -1);
|
|
|
|
|
|
|
|
/* Read the requested page */
|
|
|
|
if (lseek(xlogreadfd, (off_t) targetPageOff, SEEK_SET) < 0)
|
|
|
|
{
|
|
|
|
printf(_("could not seek in file \"%s\": %s\n"), xlogfpath,
|
|
|
|
strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (read(xlogreadfd, readBuf, XLOG_BLCKSZ) != XLOG_BLCKSZ)
|
|
|
|
{
|
|
|
|
printf(_("could not read from file \"%s\": %s\n"), xlogfpath,
|
|
|
|
strerror(errno));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
Assert(targetSegNo == xlogreadsegno);
|
|
|
|
|
2015-12-01 16:56:44 +01:00
|
|
|
*pageTLI = targetHistory[private->tliIndex].tli;
|
2015-03-23 18:47:52 +01:00
|
|
|
return XLOG_BLCKSZ;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Extract information on which blocks the current record modifies.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
extractPageInfo(XLogReaderState *record)
|
|
|
|
{
|
|
|
|
int block_id;
|
|
|
|
RmgrId rmid = XLogRecGetRmid(record);
|
|
|
|
uint8 info = XLogRecGetInfo(record);
|
|
|
|
uint8 rminfo = info & ~XLR_INFO_MASK;
|
|
|
|
|
|
|
|
/* Is this a special record type that I recognize? */
|
|
|
|
|
|
|
|
if (rmid == RM_DBASE_ID && rminfo == XLOG_DBASE_CREATE)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* New databases can be safely ignored. It won't be present in the
|
2015-04-15 21:52:00 +02:00
|
|
|
* source system, so it will be deleted. There's one corner-case,
|
2015-05-24 03:35:49 +02:00
|
|
|
* though: if a new, different, database is also created in the source
|
|
|
|
* system, we'll see that the files already exist and not copy them.
|
|
|
|
* That's OK, though; WAL replay of creating the new database, from
|
|
|
|
* the source systems's WAL, will re-copy the new database,
|
2015-04-15 21:52:00 +02:00
|
|
|
* overwriting the database created in the target system.
|
2015-03-23 18:47:52 +01:00
|
|
|
*/
|
|
|
|
}
|
|
|
|
else if (rmid == RM_DBASE_ID && rminfo == XLOG_DBASE_DROP)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* An existing database was dropped. We'll see that the files don't
|
2015-04-15 21:52:00 +02:00
|
|
|
* exist in the target data dir, and copy them in toto from the source
|
2015-03-23 18:47:52 +01:00
|
|
|
* system. No need to do anything special here.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
else if (rmid == RM_SMGR_ID && rminfo == XLOG_SMGR_CREATE)
|
|
|
|
{
|
|
|
|
/*
|
2015-04-15 21:52:00 +02:00
|
|
|
* We can safely ignore these. The file will be removed from the
|
|
|
|
* target, if it doesn't exist in source system. If a file with same
|
|
|
|
* name is created in source system, too, there will be WAL records
|
|
|
|
* for all the blocks in it.
|
2015-03-23 18:47:52 +01:00
|
|
|
*/
|
|
|
|
}
|
|
|
|
else if (rmid == RM_SMGR_ID && rminfo == XLOG_SMGR_TRUNCATE)
|
|
|
|
{
|
|
|
|
/*
|
2015-04-15 21:52:00 +02:00
|
|
|
* We can safely ignore these. When we compare the sizes later on,
|
|
|
|
* we'll notice that they differ, and copy the missing tail from
|
|
|
|
* source system.
|
2015-03-23 18:47:52 +01:00
|
|
|
*/
|
|
|
|
}
|
|
|
|
else if (info & XLR_SPECIAL_REL_UPDATE)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* This record type modifies a relation file in some special way, but
|
|
|
|
* we don't recognize the type. That's bad - we don't know how to
|
|
|
|
* track that change.
|
|
|
|
*/
|
|
|
|
pg_fatal("WAL record modifies a relation, but record type is not recognized\n"
|
|
|
|
"lsn: %X/%X, rmgr: %s, info: %02X\n",
|
Phase 3 of pgindent updates.
Don't move parenthesized lines to the left, even if that means they
flow past the right margin.
By default, BSD indent lines up statement continuation lines that are
within parentheses so that they start just to the right of the preceding
left parenthesis. However, traditionally, if that resulted in the
continuation line extending to the right of the desired right margin,
then indent would push it left just far enough to not overrun the margin,
if it could do so without making the continuation line start to the left of
the current statement indent. That makes for a weird mix of indentations
unless one has been completely rigid about never violating the 80-column
limit.
This behavior has been pretty universally panned by Postgres developers.
Hence, disable it with indent's new -lpl switch, so that parenthesized
lines are always lined up with the preceding left paren.
This patch is much less interesting than the first round of indent
changes, but also bulkier, so I thought it best to separate the effects.
Discussion: https://postgr.es/m/E1dAmxK-0006EE-1r@gemulon.postgresql.org
Discussion: https://postgr.es/m/30527.1495162840@sss.pgh.pa.us
2017-06-21 21:35:54 +02:00
|
|
|
(uint32) (record->ReadRecPtr >> 32), (uint32) (record->ReadRecPtr),
|
2015-03-23 18:47:52 +01:00
|
|
|
RmgrNames[rmid], info);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (block_id = 0; block_id <= record->max_block_id; block_id++)
|
|
|
|
{
|
|
|
|
RelFileNode rnode;
|
|
|
|
ForkNumber forknum;
|
|
|
|
BlockNumber blkno;
|
|
|
|
|
|
|
|
if (!XLogRecGetBlockTag(record, block_id, &rnode, &forknum, &blkno))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* We only care about the main fork; others are copied in toto */
|
|
|
|
if (forknum != MAIN_FORKNUM)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
process_block_change(forknum, rnode, blkno);
|
|
|
|
}
|
|
|
|
}
|