Re: Remove page-read callback from XLogReaderState. - Mailing list pgsql-hackers

From Kyotaro Horiguchi
Subject Re: Remove page-read callback from XLogReaderState.
Date
Msg-id 20190925.155032.13779064.horikyota.ntt@gmail.com
Whole thread Raw
In response to Re: Remove page-read callback from XLogReaderState.  (Kyotaro Horiguchi <horikyota.ntt@gmail.com>)
Responses Re: Remove page-read callback from XLogReaderState.
List pgsql-hackers
Hello.

709d003fbd hit this. Rebased.

Works fine but needs detailed verification and maybe further
cosmetic fixes.

regards.

-- 
Kyotaro Horiguchi
NTT Open Source Software Center
From 6be22b10c9df068c53c98ad3106e1bd88e07aeeb Mon Sep 17 00:00:00 2001
From: Kyotaro Horiguchi <horiguchi.kyotaro@lab.ntt.co.jp>
Date: Thu, 5 Sep 2019 20:21:55 +0900
Subject: [PATCH v7 1/4] Move callback-call from ReadPageInternal to
 XLogReadRecord.

The current WAL record reader reads page data using a call back
function.  Although it is not so problematic alone, it would be a
problem if we are going to do add tasks like encryption which is
performed on page data before WAL reader reads them. To avoid that the
record reader facility has to have a new code path corresponds to
every new callback, this patch separates page reader from WAL record
reading facility by modifying the current WAL record reader to a state
machine.

As the first step of that change, this patch moves the page reader
function out of ReadPageInternal, then the remaining tasks of the
function are taken over by the new function XLogNeedData. As the
result XLogPageRead directly calls the page reader callback function
according to the feedback from XLogNeedData.
---
 src/backend/access/transam/xlog.c              |  16 +-
 src/backend/access/transam/xlogreader.c        | 332 +++++++++++++++----------
 src/backend/access/transam/xlogutils.c         |  10 +-
 src/backend/replication/logical/logicalfuncs.c |   2 +-
 src/backend/replication/walsender.c            |  10 +-
 src/bin/pg_rewind/parsexlog.c                  |  16 +-
 src/bin/pg_waldump/pg_waldump.c                |   8 +-
 src/include/access/xlogreader.h                |  23 +-
 src/include/access/xlogutils.h                 |   2 +-
 src/include/replication/logicalfuncs.h         |   2 +-
 10 files changed, 259 insertions(+), 162 deletions(-)

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 6c69eb6dd7..5dcb2e500c 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -884,7 +884,7 @@ static bool InstallXLogFileSegment(XLogSegNo *segno, char *tmppath,
 static int    XLogFileRead(XLogSegNo segno, int emode, TimeLineID tli,
                          int source, bool notfoundOk);
 static int    XLogFileReadAnyTLI(XLogSegNo segno, int emode, int source);
-static int    XLogPageRead(XLogReaderState *xlogreader, XLogRecPtr targetPagePtr,
+static bool    XLogPageRead(XLogReaderState *xlogreader, XLogRecPtr targetPagePtr,
                          int reqLen, XLogRecPtr targetRecPtr, char *readBuf);
 static bool WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
                                         bool fetching_ckpt, XLogRecPtr tliRecPtr);
@@ -4249,7 +4249,6 @@ ReadRecord(XLogReaderState *xlogreader, XLogRecPtr RecPtr, int emode,
     XLogRecord *record;
     XLogPageReadPrivate *private = (XLogPageReadPrivate *) xlogreader->private_data;
 
-    /* Pass through parameters to XLogPageRead */
     private->fetching_ckpt = fetching_ckpt;
     private->emode = emode;
     private->randAccess = (RecPtr != InvalidXLogRecPtr);
@@ -11522,7 +11521,7 @@ CancelBackup(void)
  * XLogPageRead() to try fetching the record from another source, or to
  * sleep and retry.
  */
-static int
+static bool
 XLogPageRead(XLogReaderState *xlogreader, XLogRecPtr targetPagePtr, int reqLen,
              XLogRecPtr targetRecPtr, char *readBuf)
 {
@@ -11581,7 +11580,8 @@ retry:
             readLen = 0;
             readSource = 0;
 
-            return -1;
+            xlogreader->readLen = -1;
+            return false;
         }
     }
 
@@ -11676,7 +11676,8 @@ retry:
         goto next_record_is_invalid;
     }
 
-    return readLen;
+    xlogreader->readLen = readLen;
+    return true;
 
 next_record_is_invalid:
     lastSourceFailed = true;
@@ -11690,8 +11691,9 @@ next_record_is_invalid:
     /* In standby-mode, keep trying */
     if (StandbyMode)
         goto retry;
-    else
-        return -1;
+
+    xlogreader->readLen = -1;
+    return false;
 }
 
 /*
diff --git a/src/backend/access/transam/xlogreader.c b/src/backend/access/transam/xlogreader.c
index 27c27303d6..c2bb664f07 100644
--- a/src/backend/access/transam/xlogreader.c
+++ b/src/backend/access/transam/xlogreader.c
@@ -34,9 +34,9 @@
 static void report_invalid_record(XLogReaderState *state, const char *fmt,...)
             pg_attribute_printf(2, 3);
 static bool allocate_recordbuf(XLogReaderState *state, uint32 reclength);
-static int    ReadPageInternal(XLogReaderState *state, XLogRecPtr pageptr,
-                             int reqLen);
-static void XLogReaderInvalReadState(XLogReaderState *state);
+static bool XLogNeedData(XLogReaderState *state, XLogRecPtr pageptr,
+                         int reqLen, bool header_inclusive);
+static void XLogReaderDiscardReadingPage(XLogReaderState *state);
 static bool ValidXLogRecordHeader(XLogReaderState *state, XLogRecPtr RecPtr,
                                   XLogRecPtr PrevRecPtr, XLogRecord *record, bool randAccess);
 static bool ValidXLogRecord(XLogReaderState *state, XLogRecord *record,
@@ -104,7 +104,7 @@ XLogReaderAllocate(int wal_segment_size, const char *waldir,
     /* system_identifier initialized to zeroes above */
     state->private_data = private_data;
     /* ReadRecPtr and EndRecPtr initialized to zeroes above */
-    /* readSegNo, readOff, readLen, readPageTLI initialized to zeroes above */
+    /* readSegNo, readLen, readPageTLI initialized to zeroes above */
     state->errormsg_buf = palloc_extended(MAX_ERRORMSG_LEN + 1,
                                           MCXT_ALLOC_NO_OOM);
     if (!state->errormsg_buf)
@@ -245,7 +245,6 @@ XLogReadRecord(XLogReaderState *state, XLogRecPtr RecPtr, char **errormsg)
     uint32        targetRecOff;
     uint32        pageHeaderSize;
     bool        gotheader;
-    int            readOff;
 
     /*
      * randAccess indicates whether to verify the previous-record pointer of
@@ -297,15 +296,20 @@ XLogReadRecord(XLogReaderState *state, XLogRecPtr RecPtr, char **errormsg)
      * byte to cover the whole record header, or at least the part of it that
      * fits on the same page.
      */
-    readOff = ReadPageInternal(state,
-                               targetPagePtr,
-                               Min(targetRecOff + SizeOfXLogRecord, XLOG_BLCKSZ));
-    if (readOff < 0)
+    while (XLogNeedData(state, targetPagePtr,
+                        Min(targetRecOff + SizeOfXLogRecord, XLOG_BLCKSZ),
+                        targetRecOff != 0))
+    {
+        if (!state->read_page(state, state->readPagePtr, state->readLen,
+                              RecPtr, state->readBuf))
+            break;
+    }
+
+    if (!state->page_verified)
         goto err;
 
     /*
-     * ReadPageInternal always returns at least the page header, so we can
-     * examine it now.
+     * We have loaded at least the page header, so we can examine it now.
      */
     pageHeaderSize = XLogPageHeaderSize((XLogPageHeader) state->readBuf);
     if (targetRecOff == 0)
@@ -331,8 +335,8 @@ XLogReadRecord(XLogReaderState *state, XLogRecPtr RecPtr, char **errormsg)
         goto err;
     }
 
-    /* ReadPageInternal has verified the page header */
-    Assert(pageHeaderSize <= readOff);
+    /* XLogNeedData has verified the page header */
+    Assert(pageHeaderSize <= state->readLen);
 
     /*
      * Read the record length.
@@ -405,18 +409,25 @@ XLogReadRecord(XLogReaderState *state, XLogRecPtr RecPtr, char **errormsg)
 
         do
         {
+            int rest_len = total_len - gotlen;
+
             /* Calculate pointer to beginning of next page */
             targetPagePtr += XLOG_BLCKSZ;
 
             /* Wait for the next page to become available */
-            readOff = ReadPageInternal(state, targetPagePtr,
-                                       Min(total_len - gotlen + SizeOfXLogShortPHD,
-                                           XLOG_BLCKSZ));
+            while (XLogNeedData(state, targetPagePtr,
+                                Min(rest_len, XLOG_BLCKSZ),
+                                false))
+            {
+                if (!state->read_page(state, state->readPagePtr, state->readLen,
+                                      state->ReadRecPtr, state->readBuf))
+                    break;
+            }
 
-            if (readOff < 0)
+            if (!state->page_verified)
                 goto err;
 
-            Assert(SizeOfXLogShortPHD <= readOff);
+            Assert(SizeOfXLogShortPHD <= state->readLen);
 
             /* Check that the continuation on next page looks valid */
             pageHeader = (XLogPageHeader) state->readBuf;
@@ -445,21 +456,14 @@ XLogReadRecord(XLogReaderState *state, XLogRecPtr RecPtr, char **errormsg)
             /* Append the continuation from this page to the buffer */
             pageHeaderSize = XLogPageHeaderSize(pageHeader);
 
-            if (readOff < pageHeaderSize)
-                readOff = ReadPageInternal(state, targetPagePtr,
-                                           pageHeaderSize);
-
-            Assert(pageHeaderSize <= readOff);
+            Assert (pageHeaderSize <= state->readLen);
 
             contdata = (char *) state->readBuf + pageHeaderSize;
             len = XLOG_BLCKSZ - pageHeaderSize;
             if (pageHeader->xlp_rem_len < len)
                 len = pageHeader->xlp_rem_len;
 
-            if (readOff < pageHeaderSize + len)
-                readOff = ReadPageInternal(state, targetPagePtr,
-                                           pageHeaderSize + len);
-
+            Assert (pageHeaderSize + len <= state->readLen);
             memcpy(buffer, (char *) contdata, len);
             buffer += len;
             gotlen += len;
@@ -489,9 +493,15 @@ XLogReadRecord(XLogReaderState *state, XLogRecPtr RecPtr, char **errormsg)
     else
     {
         /* Wait for the record data to become available */
-        readOff = ReadPageInternal(state, targetPagePtr,
-                                   Min(targetRecOff + total_len, XLOG_BLCKSZ));
-        if (readOff < 0)
+        while (XLogNeedData(state, targetPagePtr,
+                            Min(targetRecOff + total_len, XLOG_BLCKSZ), true))
+        {
+            if (!state->read_page(state, state->readPagePtr, state->readLen,
+                                  state->ReadRecPtr, state->readBuf))
+                break;
+        }
+
+        if (!state->page_verified)
             goto err;
 
         /* Record does not cross a page boundary */
@@ -525,7 +535,7 @@ err:
      * Invalidate the read state. We might read from a different source after
      * failure.
      */
-    XLogReaderInvalReadState(state);
+    XLogReaderDiscardReadingPage(state);
 
     if (state->errormsg_buf[0] != '\0')
         *errormsg = state->errormsg_buf;
@@ -534,120 +544,183 @@ err:
 }
 
 /*
- * Read a single xlog page including at least [pageptr, reqLen] of valid data
- * via the read_page() callback.
+ * Checks that an xlog page loaded in state->readBuf is including at least
+ * [pageptr, reqLen] and the page is valid. header_inclusive indicates that
+ * reqLen is calculated including page header length.
  *
- * Returns -1 if the required page cannot be read for some reason; errormsg_buf
- * is set in that case (unless the error occurs in the read_page callback).
+ * Returns false if the buffer already contains the requested data, or found
+ * error. state->page_verified is set to true for the former and false for the
+ * latter.
  *
- * We fetch the page from a reader-local cache if we know we have the required
- * data and if there hasn't been any error since caching the data.
+ * Otherwise returns true and requests data loaded onto state->readBuf by
+ * state->readPagePtr and state->readLen. The caller shall call this function
+ * again after filling the buffer at least with that portion of data and set
+ * state->readLen to the length of actually loaded data.
+ *
+ * If header_inclusive is false, corrects reqLen internally by adding the
+ * actual page header length and may request caller for new data.
  */
-static int
-ReadPageInternal(XLogReaderState *state, XLogRecPtr pageptr, int reqLen)
+static bool
+XLogNeedData(XLogReaderState *state, XLogRecPtr pageptr, int reqLen,
+             bool header_inclusive)
 {
-    int            readLen;
     uint32        targetPageOff;
     XLogSegNo    targetSegNo;
-    XLogPageHeader hdr;
-
-    Assert((pageptr % XLOG_BLCKSZ) == 0);
-
-    XLByteToSeg(pageptr, targetSegNo, state->segcxt.ws_segsize);
-    targetPageOff = XLogSegmentOffset(pageptr, state->segcxt.ws_segsize);
+    uint32        addLen = 0;
 
     /* check whether we have all the requested data already */
-    if (targetSegNo == state->seg.ws_segno &&
-        targetPageOff == state->seg.ws_off && reqLen <= state->readLen)
-        return state->readLen;
+    if (state->page_verified &&    pageptr == state->readPagePtr)
+    {
+        if (!header_inclusive)
+        {
+            /*
+             * calculate additional length for page header so that the total
+             * length doesn't exceed the block size.
+             */
+            uint32 pageHeaderSize =
+                XLogPageHeaderSize((XLogPageHeader) state->readBuf);
+
+            addLen = pageHeaderSize;
+            if (reqLen + pageHeaderSize <= XLOG_BLCKSZ)
+                addLen = pageHeaderSize;
+            else
+                addLen = XLOG_BLCKSZ - reqLen;
+        }
+
+        if (reqLen + addLen <= state->readLen)
+            return false;
+    }
+
+    /* Haven't loaded any data yet? Then request it. */
+    if (XLogRecPtrIsInvalid(state->readPagePtr) ||
+        state->readPagePtr != pageptr || state->readLen < 0)
+    {
+        state->readPagePtr = pageptr;
+        state->readLen = Max(reqLen, SizeOfXLogShortPHD);
+        state->page_verified = false;
+        return true;
+    }
+
+    if (!state->page_verified)
+    {
+        uint32    pageHeaderSize;
+        uint32    addLen = 0;
+
+        /* just loaded new data so needs to verify page header */
+
+        /* The caller must have loaded at least page header */
+        Assert(state->readLen >= SizeOfXLogShortPHD);
+
+        /*
+         * We have enough data to check the header length. Recheck the loaded
+         * length if it is a long header if any.
+         */
+        pageHeaderSize =  XLogPageHeaderSize((XLogPageHeader) state->readBuf);
+
+        /*
+         * If we have not loaded a page so far, readLen is zero, which is
+         * shorter than pageHeaderSize here.
+         */
+        if (state->readLen < pageHeaderSize)
+        {
+            state->readPagePtr = pageptr;
+            state->readLen = pageHeaderSize;
+            return true;
+        }
+
+        /*
+         * Now that we know we have the full header, validate it.
+         */
+        if (!XLogReaderValidatePageHeader(state, state->readPagePtr,
+                                          (char *) state->readBuf))
+        {
+            /* force reading the page again. */
+            XLogReaderDiscardReadingPage(state);
+
+            return false;
+        }
+
+        state->page_verified = true;
+
+        XLByteToSeg(state->readPagePtr, state->seg.ws_segno,
+                    state->segcxt.ws_segsize);
+
+        /*
+         * calculate additional length for page header so that the total
+         * length doesn't exceed the block size.
+         */
+        if (!header_inclusive)
+        {
+            addLen = pageHeaderSize;
+            if (reqLen + pageHeaderSize <= XLOG_BLCKSZ)
+                addLen = pageHeaderSize;
+            else
+                addLen = XLOG_BLCKSZ - reqLen;
+
+            Assert(addLen >= 0);
+        }
+
+        /* Usually we have requested data loaded in buffer here. */
+        if (pageptr == state->readPagePtr && reqLen + addLen <= state->readLen)
+            return false;
+
+        /*
+         * In the case the page is requested for the first record in the page,
+         * the previous request have been made not counting page header
+         * length. Request again for the same page with the length known to be
+         * needed. Otherwise we don't know the header length of the new page.
+         */
+        if (pageptr != state->readPagePtr)
+            addLen = 0;
+    }
+
+    /* Data is not in our buffer, make a new load request to the caller. */
+    XLByteToSeg(pageptr, targetSegNo, state->segcxt.ws_segsize);
+    targetPageOff = XLogSegmentOffset(pageptr, state->segcxt.ws_segsize);
+    Assert((pageptr % XLOG_BLCKSZ) == 0);
+
+    /*
+     * Every time we request to load new data of a page to the caller, even if
+     * we looked at a part of it before, we need to do verification on the next
+     * invocation as the caller might now be rereading data from a different
+     * source.
+     */
+    state->page_verified = false;
 
     /*
-     * Data is not in our buffer.
-     *
-     * Every time we actually read the page, even if we looked at parts of it
-     * before, we need to do verification as the read_page callback might now
-     * be rereading data from a different source.
-     *
      * Whenever switching to a new WAL segment, we read the first page of the
      * file and validate its header, even if that's not where the target
      * record is.  This is so that we can check the additional identification
      * info that is present in the first page's "long" header.
+     * Don't do this if the caller requested the first page in the segment.
      */
     if (targetSegNo != state->seg.ws_segno && targetPageOff != 0)
     {
-        XLogRecPtr    targetSegmentPtr = pageptr - targetPageOff;
-
-        readLen = state->read_page(state, targetSegmentPtr, XLOG_BLCKSZ,
-                                   state->currRecPtr,
-                                   state->readBuf);
-        if (readLen < 0)
-            goto err;
-
-        /* we can be sure to have enough WAL available, we scrolled back */
-        Assert(readLen == XLOG_BLCKSZ);
-
-        if (!XLogReaderValidatePageHeader(state, targetSegmentPtr,
-                                          state->readBuf))
-            goto err;
+        /*
+         * Then we'll see that the targetSegNo now matches the ws_segno, and
+         * will not come back here, but will request the actual target page.
+         */
+        state->readPagePtr = pageptr - targetPageOff;
+        state->readLen = XLOG_BLCKSZ;
+        return true;
     }
 
     /*
-     * First, read the requested data length, but at least a short page header
-     * so that we can validate it.
+     * Request the caller to load the requested page. We need at least a short
+     * page header so that we can validate it.
      */
-    readLen = state->read_page(state, pageptr, Max(reqLen, SizeOfXLogShortPHD),
-                               state->currRecPtr,
-                               state->readBuf);
-    if (readLen < 0)
-        goto err;
-
-    Assert(readLen <= XLOG_BLCKSZ);
-
-    /* Do we have enough data to check the header length? */
-    if (readLen <= SizeOfXLogShortPHD)
-        goto err;
-
-    Assert(readLen >= reqLen);
-
-    hdr = (XLogPageHeader) state->readBuf;
-
-    /* still not enough */
-    if (readLen < XLogPageHeaderSize(hdr))
-    {
-        readLen = state->read_page(state, pageptr, XLogPageHeaderSize(hdr),
-                                   state->currRecPtr,
-                                   state->readBuf);
-        if (readLen < 0)
-            goto err;
-    }
-
-    /*
-     * Now that we know we have the full header, validate it.
-     */
-    if (!XLogReaderValidatePageHeader(state, pageptr, (char *) hdr))
-        goto err;
-
-    /* update read state information */
-    state->seg.ws_segno = targetSegNo;
-    state->seg.ws_off = targetPageOff;
-    state->readLen = readLen;
-
-    return readLen;
-
-err:
-    XLogReaderInvalReadState(state);
-    return -1;
+    state->readPagePtr = pageptr;
+    state->readLen = Max(reqLen + addLen, SizeOfXLogShortPHD);
+    return true;
 }
 
 /*
- * Invalidate the xlogreader's read state to force a re-read.
+ * Invalidate current reading page buffer
  */
 static void
-XLogReaderInvalReadState(XLogReaderState *state)
+XLogReaderDiscardReadingPage(XLogReaderState *state)
 {
-    state->seg.ws_segno = 0;
-    state->seg.ws_off = 0;
-    state->readLen = 0;
+    state->readPagePtr = InvalidXLogRecPtr;
 }
 
 /*
@@ -925,7 +998,6 @@ XLogFindNextRecord(XLogReaderState *state, XLogRecPtr RecPtr)
         XLogRecPtr    targetPagePtr;
         int            targetRecOff;
         uint32        pageHeaderSize;
-        int            readLen;
 
         /*
          * Compute targetRecOff. It should typically be equal or greater than
@@ -933,7 +1005,7 @@ XLogFindNextRecord(XLogReaderState *state, XLogRecPtr RecPtr)
          * that, except when caller has explicitly specified the offset that
          * falls somewhere there or when we are skipping multi-page
          * continuation record. It doesn't matter though because
-         * ReadPageInternal() is prepared to handle that and will read at
+         * CheckPage() is prepared to handle that and will read at
          * least short page-header worth of data
          */
         targetRecOff = tmpRecPtr % XLOG_BLCKSZ;
@@ -941,19 +1013,23 @@ XLogFindNextRecord(XLogReaderState *state, XLogRecPtr RecPtr)
         /* scroll back to page boundary */
         targetPagePtr = tmpRecPtr - targetRecOff;
 
-        /* Read the page containing the record */
-        readLen = ReadPageInternal(state, targetPagePtr, targetRecOff);
-        if (readLen < 0)
+        while(XLogNeedData(state, targetPagePtr, targetRecOff,
+                           targetRecOff != 0))
+        {
+            if (!state->read_page(state, state->readPagePtr, state->readLen,
+                                  state->ReadRecPtr, state->readBuf))
+                break;
+        }
+
+        if (!state->page_verified)
             goto err;
 
         header = (XLogPageHeader) state->readBuf;
 
         pageHeaderSize = XLogPageHeaderSize(header);
 
-        /* make sure we have enough data for the page header */
-        readLen = ReadPageInternal(state, targetPagePtr, pageHeaderSize);
-        if (readLen < 0)
-            goto err;
+        /* we should have read the page header */
+        Assert (state->readLen >= pageHeaderSize);
 
         /* skip over potential continuation data */
         if (header->xlp_info & XLP_FIRST_IS_CONTRECORD)
@@ -1010,7 +1086,7 @@ out:
     /* Reset state to what we had before finding the record */
     state->ReadRecPtr = saved_state.ReadRecPtr;
     state->EndRecPtr = saved_state.EndRecPtr;
-    XLogReaderInvalReadState(state);
+    XLogReaderDiscardReadingPage(state);
 
     return found;
 }
diff --git a/src/backend/access/transam/xlogutils.c b/src/backend/access/transam/xlogutils.c
index 5f1e5ba75d..a19726a96e 100644
--- a/src/backend/access/transam/xlogutils.c
+++ b/src/backend/access/transam/xlogutils.c
@@ -803,7 +803,7 @@ void
 XLogReadDetermineTimeline(XLogReaderState *state, XLogRecPtr wantPage, uint32 wantLength)
 {
     const XLogRecPtr lastReadPage = state->seg.ws_segno *
-    state->segcxt.ws_segsize + state->seg.ws_off;
+    state->segcxt.ws_segsize + state->readLen;
 
     Assert(wantPage != InvalidXLogRecPtr && wantPage % XLOG_BLCKSZ == 0);
     Assert(wantLength <= XLOG_BLCKSZ);
@@ -907,7 +907,7 @@ XLogReadDetermineTimeline(XLogReaderState *state, XLogRecPtr wantPage, uint32 wa
  * exists for normal backends, so we have to do a check/sleep/repeat style of
  * loop for now.
  */
-int
+bool
 read_local_xlog_page(XLogReaderState *state, XLogRecPtr targetPagePtr,
                      int reqLen, XLogRecPtr targetRecPtr, char *cur_page)
 {
@@ -1007,7 +1007,8 @@ read_local_xlog_page(XLogReaderState *state, XLogRecPtr targetPagePtr,
     else if (targetPagePtr + reqLen > read_upto)
     {
         /* not enough data there */
-        return -1;
+        state->readLen = -1;
+        return false;
     }
     else
     {
@@ -1024,5 +1025,6 @@ read_local_xlog_page(XLogReaderState *state, XLogRecPtr targetPagePtr,
              XLOG_BLCKSZ);
 
     /* number of valid bytes in the buffer */
-    return count;
+    state->readLen = count;
+    return true;
 }
diff --git a/src/backend/replication/logical/logicalfuncs.c b/src/backend/replication/logical/logicalfuncs.c
index d1cf80d441..310cd9d8cf 100644
--- a/src/backend/replication/logical/logicalfuncs.c
+++ b/src/backend/replication/logical/logicalfuncs.c
@@ -114,7 +114,7 @@ check_permissions(void)
                  (errmsg("must be superuser or replication role to use replication slots"))));
 }
 
-int
+bool
 logical_read_local_xlog_page(XLogReaderState *state, XLogRecPtr targetPagePtr,
                              int reqLen, XLogRecPtr targetRecPtr, char *cur_page)
 {
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index eb4a98cc91..0809ceaeb8 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -760,7 +760,7 @@ StartReplication(StartReplicationCmd *cmd)
  * which has to do a plain sleep/busy loop, because the walsender's latch gets
  * set every time WAL is flushed.
  */
-static int
+static bool
 logical_read_xlog_page(XLogReaderState *state, XLogRecPtr targetPagePtr, int reqLen,
                        XLogRecPtr targetRecPtr, char *cur_page)
 {
@@ -778,7 +778,10 @@ logical_read_xlog_page(XLogReaderState *state, XLogRecPtr targetPagePtr, int req
 
     /* fail if not (implies we are going to shut down) */
     if (flushptr < targetPagePtr + reqLen)
-        return -1;
+    {
+        state->readLen = -1;
+        return false;
+    }
 
     if (targetPagePtr + XLOG_BLCKSZ <= flushptr)
         count = XLOG_BLCKSZ;    /* more than one block available */
@@ -788,7 +791,8 @@ logical_read_xlog_page(XLogReaderState *state, XLogRecPtr targetPagePtr, int req
     /* now actually read the data, we know it's there */
     XLogRead(sendCxt, cur_page, targetPagePtr, XLOG_BLCKSZ);
 
-    return count;
+    state->readLen = count;
+    return true;
 }
 
 /*
diff --git a/src/bin/pg_rewind/parsexlog.c b/src/bin/pg_rewind/parsexlog.c
index 264a8f4db5..8aecd1adc7 100644
--- a/src/bin/pg_rewind/parsexlog.c
+++ b/src/bin/pg_rewind/parsexlog.c
@@ -46,7 +46,7 @@ typedef struct XLogPageReadPrivate
     int            tliIndex;
 } XLogPageReadPrivate;
 
-static int    SimpleXLogPageRead(XLogReaderState *xlogreader,
+static bool    SimpleXLogPageRead(XLogReaderState *xlogreader,
                                XLogRecPtr targetPagePtr,
                                int reqLen, XLogRecPtr targetRecPtr, char *readBuf);
 
@@ -230,7 +230,7 @@ findLastCheckpoint(const char *datadir, XLogRecPtr forkptr, int tliIndex,
 }
 
 /* XLogReader callback function, to read a WAL page */
-static int
+static bool
 SimpleXLogPageRead(XLogReaderState *xlogreader, XLogRecPtr targetPagePtr,
                    int reqLen, XLogRecPtr targetRecPtr, char *readBuf)
 {
@@ -285,7 +285,8 @@ SimpleXLogPageRead(XLogReaderState *xlogreader, XLogRecPtr targetPagePtr,
         if (xlogreadfd < 0)
         {
             pg_log_error("could not open file \"%s\": %m", xlogfpath);
-            return -1;
+            xlogreader->readLen = -1;
+            return false;
         }
     }
 
@@ -298,7 +299,8 @@ SimpleXLogPageRead(XLogReaderState *xlogreader, XLogRecPtr targetPagePtr,
     if (lseek(xlogreadfd, (off_t) targetPageOff, SEEK_SET) < 0)
     {
         pg_log_error("could not seek in file \"%s\": %m", xlogfpath);
-        return -1;
+        xlogreader->readLen = -1;
+        return false;
     }
 
 
@@ -311,13 +313,15 @@ SimpleXLogPageRead(XLogReaderState *xlogreader, XLogRecPtr targetPagePtr,
             pg_log_error("could not read file \"%s\": read %d of %zu",
                          xlogfpath, r, (Size) XLOG_BLCKSZ);
 
-        return -1;
+        xlogreader->readLen = -1;
+        return false;
     }
 
     Assert(targetSegNo == xlogreadsegno);
 
     xlogreader->seg.ws_tli = targetHistory[private->tliIndex].tli;
-    return XLOG_BLCKSZ;
+    xlogreader->readLen = XLOG_BLCKSZ;
+    return true;
 }
 
 /*
diff --git a/src/bin/pg_waldump/pg_waldump.c b/src/bin/pg_waldump/pg_waldump.c
index b79208cd73..6e424bd8e1 100644
--- a/src/bin/pg_waldump/pg_waldump.c
+++ b/src/bin/pg_waldump/pg_waldump.c
@@ -406,7 +406,7 @@ XLogDumpXLogRead(const char *directory, TimeLineID timeline_id,
 /*
  * XLogReader read_page callback
  */
-static int
+static bool
 XLogDumpReadPage(XLogReaderState *state, XLogRecPtr targetPagePtr, int reqLen,
                  XLogRecPtr targetPtr, char *readBuff)
 {
@@ -422,14 +422,16 @@ XLogDumpReadPage(XLogReaderState *state, XLogRecPtr targetPagePtr, int reqLen,
         else
         {
             private->endptr_reached = true;
-            return -1;
+            state->readLen = -1;
+            return false;
         }
     }
 
     XLogDumpXLogRead(state->segcxt.ws_dir, private->timeline, targetPagePtr,
                      readBuff, count);
 
-    return count;
+    state->readLen = count;
+    return true;
 }
 
 /*
diff --git a/src/include/access/xlogreader.h b/src/include/access/xlogreader.h
index 1bbee386e8..8b747d465f 100644
--- a/src/include/access/xlogreader.h
+++ b/src/include/access/xlogreader.h
@@ -50,7 +50,7 @@ typedef struct WALSegmentContext
 typedef struct XLogReaderState XLogReaderState;
 
 /* Function type definition for the read_page callback */
-typedef int (*XLogPageReadCB) (XLogReaderState *xlogreader,
+typedef bool (*XLogPageReadCB) (XLogReaderState *xlogreader,
                                XLogRecPtr targetPagePtr,
                                int reqLen,
                                XLogRecPtr targetRecPtr,
@@ -132,6 +132,20 @@ struct XLogReaderState
     XLogRecPtr    ReadRecPtr;        /* start of last record read */
     XLogRecPtr    EndRecPtr;        /* end+1 of last record read */
 
+    /* ----------------------------------------
+     * Communication with page reader
+     * readBuf is XLOG_BLCKSZ bytes, valid up to at least readLen bytes.
+     *  ----------------------------------------
+     */
+    /* variables to communicate with page reader */
+    XLogRecPtr    readPagePtr;    /* page pointer to read */
+    int32        readLen;        /* bytes requested to reader, or actual bytes
+                                 * read by reader, which must be larger than
+                                 * the request, or -1 on error */
+    TimeLineID    readPageTLI;    /* TLI for data currently in readBuf */
+    char       *readBuf;        /* buffer to store data */
+    bool        page_verified;  /* is the page on the buffer verified? */
+
 
     /* ----------------------------------------
      * Decoded representation of current record
@@ -158,13 +172,6 @@ struct XLogReaderState
      * ----------------------------------------
      */
 
-    /*
-     * Buffer for currently read page (XLOG_BLCKSZ bytes, valid up to at least
-     * readLen bytes)
-     */
-    char       *readBuf;
-    uint32        readLen;
-
     /* last read XLOG position for data currently in readBuf */
     WALSegmentContext segcxt;
     WALOpenSegment seg;
diff --git a/src/include/access/xlogutils.h b/src/include/access/xlogutils.h
index 2df98e45b2..47b65463f9 100644
--- a/src/include/access/xlogutils.h
+++ b/src/include/access/xlogutils.h
@@ -47,7 +47,7 @@ extern Buffer XLogReadBufferExtended(RelFileNode rnode, ForkNumber forknum,
 extern Relation CreateFakeRelcacheEntry(RelFileNode rnode);
 extern void FreeFakeRelcacheEntry(Relation fakerel);
 
-extern int    read_local_xlog_page(XLogReaderState *state,
+extern bool    read_local_xlog_page(XLogReaderState *state,
                                  XLogRecPtr targetPagePtr, int reqLen,
                                  XLogRecPtr targetRecPtr, char *cur_page);
 
diff --git a/src/include/replication/logicalfuncs.h b/src/include/replication/logicalfuncs.h
index 012096f183..54291221c3 100644
--- a/src/include/replication/logicalfuncs.h
+++ b/src/include/replication/logicalfuncs.h
@@ -11,7 +11,7 @@
 
 #include "replication/logical.h"
 
-extern int    logical_read_local_xlog_page(XLogReaderState *state,
+extern bool    logical_read_local_xlog_page(XLogReaderState *state,
                                          XLogRecPtr targetPagePtr,
                                          int reqLen, XLogRecPtr targetRecPtr,
                                          char *cur_page);
-- 
2.16.3

From f570eef98799c4a6ad392a9e8771807051158987 Mon Sep 17 00:00:00 2001
From: Kyotaro Horiguchi <horiguchi.kyotaro@lab.ntt.co.jp>
Date: Tue, 10 Sep 2019 12:58:27 +0900
Subject: [PATCH v7 2/4] Move page-reader out of XLogReadRecord

This is the second step of removing callbacks from WAL record reader.
Since it is essential to take in additional data while reading a
record, the function have to ask caller for new data while keeping
working state. Thus the function is turned into a state machine.
---
 src/backend/access/transam/twophase.c          |  11 +-
 src/backend/access/transam/xlog.c              |  50 +-
 src/backend/access/transam/xlogreader.c        | 702 +++++++++++++++----------
 src/backend/access/transam/xlogutils.c         |  12 +-
 src/backend/replication/logical/logical.c      |  17 +-
 src/backend/replication/logical/logicalfuncs.c |  14 +-
 src/backend/replication/slotfuncs.c            |   8 +-
 src/backend/replication/walsender.c            |  14 +-
 src/bin/pg_rewind/parsexlog.c                  |  74 +--
 src/bin/pg_waldump/pg_waldump.c                |  24 +-
 src/include/access/xlogreader.h                |  91 ++--
 src/include/access/xlogutils.h                 |   4 +-
 src/include/replication/logical.h              |   9 +-
 src/include/replication/logicalfuncs.h         |   5 +-
 14 files changed, 615 insertions(+), 420 deletions(-)

diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c
index 546bd43ce8..ced11bbdae 100644
--- a/src/backend/access/transam/twophase.c
+++ b/src/backend/access/transam/twophase.c
@@ -1385,15 +1385,20 @@ XlogReadTwoPhaseData(XLogRecPtr lsn, char **buf, int *len)
     XLogReaderState *xlogreader;
     char       *errormsg;
 
-    xlogreader = XLogReaderAllocate(wal_segment_size, NULL,
-                                    &read_local_xlog_page, NULL);
+    xlogreader = XLogReaderAllocate(wal_segment_size, NULL);
     if (!xlogreader)
         ereport(ERROR,
                 (errcode(ERRCODE_OUT_OF_MEMORY),
                  errmsg("out of memory"),
                  errdetail("Failed while allocating a WAL reading processor.")));
 
-    record = XLogReadRecord(xlogreader, lsn, &errormsg);
+    while (XLogReadRecord(xlogreader, lsn, &record, &errormsg) ==
+           XLREAD_NEED_DATA)
+    {
+        if (!read_local_xlog_page(xlogreader))
+            break;
+    }
+
     if (record == NULL)
         ereport(ERROR,
                 (errcode_for_file_access(),
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 5dcb2e500c..b06e381d73 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -803,13 +803,6 @@ static XLogSource readSource = 0;    /* XLOG_FROM_* code */
 static XLogSource currentSource = 0;    /* XLOG_FROM_* code */
 static bool lastSourceFailed = false;
 
-typedef struct XLogPageReadPrivate
-{
-    int            emode;
-    bool        fetching_ckpt;    /* are we fetching a checkpoint record? */
-    bool        randAccess;
-} XLogPageReadPrivate;
-
 /*
  * These variables track when we last obtained some WAL data to process,
  * and where we got it from.  (XLogReceiptSource is initially the same as
@@ -884,8 +877,8 @@ static bool InstallXLogFileSegment(XLogSegNo *segno, char *tmppath,
 static int    XLogFileRead(XLogSegNo segno, int emode, TimeLineID tli,
                          int source, bool notfoundOk);
 static int    XLogFileReadAnyTLI(XLogSegNo segno, int emode, int source);
-static bool    XLogPageRead(XLogReaderState *xlogreader, XLogRecPtr targetPagePtr,
-                         int reqLen, XLogRecPtr targetRecPtr, char *readBuf);
+static bool XLogPageRead(XLogReaderState *xlogreader,
+                         bool fetching_ckpt, int emode, bool randAccess);
 static bool WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
                                         bool fetching_ckpt, XLogRecPtr tliRecPtr);
 static int    emode_for_corrupt_record(int emode, XLogRecPtr RecPtr);
@@ -1194,8 +1187,7 @@ XLogInsertRecord(XLogRecData *rdata,
             appendBinaryStringInfo(&recordBuf, rdata->data, rdata->len);
 
         if (!debug_reader)
-            debug_reader = XLogReaderAllocate(wal_segment_size, NULL,
-                                              NULL, NULL);
+            debug_reader = XLogReaderAllocate(wal_segment_size, NULL);
 
         if (!debug_reader)
         {
@@ -4247,11 +4239,7 @@ ReadRecord(XLogReaderState *xlogreader, XLogRecPtr RecPtr, int emode,
            bool fetching_ckpt)
 {
     XLogRecord *record;
-    XLogPageReadPrivate *private = (XLogPageReadPrivate *) xlogreader->private_data;
-
-    private->fetching_ckpt = fetching_ckpt;
-    private->emode = emode;
-    private->randAccess = (RecPtr != InvalidXLogRecPtr);
+    bool        randAccess = (RecPtr != InvalidXLogRecPtr);
 
     /* This is the first attempt to read this page. */
     lastSourceFailed = false;
@@ -4259,8 +4247,15 @@ ReadRecord(XLogReaderState *xlogreader, XLogRecPtr RecPtr, int emode,
     for (;;)
     {
         char       *errormsg;
+        XLogReadRecordResult result;
+
+        while ((result = XLogReadRecord(xlogreader, RecPtr, &record, &errormsg))
+               == XLREAD_NEED_DATA)
+        {
+            if (!XLogPageRead(xlogreader, fetching_ckpt, emode, randAccess))
+                break;
+        }
 
-        record = XLogReadRecord(xlogreader, RecPtr, &errormsg);
         ReadRecPtr = xlogreader->ReadRecPtr;
         EndRecPtr = xlogreader->EndRecPtr;
         if (record == NULL)
@@ -6210,7 +6205,6 @@ StartupXLOG(void)
     bool        backupFromStandby = false;
     DBState        dbstate_at_startup;
     XLogReaderState *xlogreader;
-    XLogPageReadPrivate private;
     bool        fast_promoted = false;
     struct stat st;
 
@@ -6351,9 +6345,7 @@ StartupXLOG(void)
         OwnLatch(&XLogCtl->recoveryWakeupLatch);
 
     /* Set up XLOG reader facility */
-    MemSet(&private, 0, sizeof(XLogPageReadPrivate));
-    xlogreader = XLogReaderAllocate(wal_segment_size, NULL,
-                                    &XLogPageRead, &private);
+    xlogreader = XLogReaderAllocate(wal_segment_size, NULL);
     if (!xlogreader)
         ereport(ERROR,
                 (errcode(ERRCODE_OUT_OF_MEMORY),
@@ -11522,12 +11514,13 @@ CancelBackup(void)
  * sleep and retry.
  */
 static bool
-XLogPageRead(XLogReaderState *xlogreader, XLogRecPtr targetPagePtr, int reqLen,
-             XLogRecPtr targetRecPtr, char *readBuf)
+XLogPageRead(XLogReaderState *xlogreader,
+             bool fetching_ckpt, int emode, bool randAccess)
 {
-    XLogPageReadPrivate *private =
-    (XLogPageReadPrivate *) xlogreader->private_data;
-    int            emode = private->emode;
+    char *readBuf                = xlogreader->readBuf;
+    XLogRecPtr targetPagePtr    = xlogreader->readPagePtr;
+    int reqLen                    = xlogreader->readLen;
+    XLogRecPtr targetRecPtr        = xlogreader->ReadRecPtr;
     uint32        targetPageOff;
     XLogSegNo    targetSegNo PG_USED_FOR_ASSERTS_ONLY;
     int            r;
@@ -11570,8 +11563,8 @@ retry:
          receivedUpto < targetPagePtr + reqLen))
     {
         if (!WaitForWALToBecomeAvailable(targetPagePtr + reqLen,
-                                         private->randAccess,
-                                         private->fetching_ckpt,
+                                         randAccess,
+                                         fetching_ckpt,
                                          targetRecPtr))
         {
             if (readFile >= 0)
@@ -11676,6 +11669,7 @@ retry:
         goto next_record_is_invalid;
     }
 
+    Assert(xlogreader->readPagePtr == targetPagePtr);
     xlogreader->readLen = readLen;
     return true;
 
diff --git a/src/backend/access/transam/xlogreader.c b/src/backend/access/transam/xlogreader.c
index c2bb664f07..9932ba3882 100644
--- a/src/backend/access/transam/xlogreader.c
+++ b/src/backend/access/transam/xlogreader.c
@@ -38,7 +38,7 @@ static bool XLogNeedData(XLogReaderState *state, XLogRecPtr pageptr,
                          int reqLen, bool header_inclusive);
 static void XLogReaderDiscardReadingPage(XLogReaderState *state);
 static bool ValidXLogRecordHeader(XLogReaderState *state, XLogRecPtr RecPtr,
-                                  XLogRecPtr PrevRecPtr, XLogRecord *record, bool randAccess);
+                                  XLogRecPtr PrevRecPtr, XLogRecord *record);
 static bool ValidXLogRecord(XLogReaderState *state, XLogRecord *record,
                             XLogRecPtr recptr);
 static void ResetDecoder(XLogReaderState *state);
@@ -68,8 +68,7 @@ report_invalid_record(XLogReaderState *state, const char *fmt,...)
  * Returns NULL if the xlogreader couldn't be allocated.
  */
 XLogReaderState *
-XLogReaderAllocate(int wal_segment_size, const char *waldir,
-                   XLogPageReadCB pagereadfunc, void *private_data)
+XLogReaderAllocate(int wal_segment_size, const char *waldir)
 {
     XLogReaderState *state;
 
@@ -100,9 +99,6 @@ XLogReaderAllocate(int wal_segment_size, const char *waldir,
     WALOpenSegmentInit(&state->seg, &state->segcxt, wal_segment_size,
                        waldir);
 
-    state->read_page = pagereadfunc;
-    /* system_identifier initialized to zeroes above */
-    state->private_data = private_data;
     /* ReadRecPtr and EndRecPtr initialized to zeroes above */
     /* readSegNo, readLen, readPageTLI initialized to zeroes above */
     state->errormsg_buf = palloc_extended(MAX_ERRORMSG_LEN + 1,
@@ -221,318 +217,464 @@ WALOpenSegmentInit(WALOpenSegment *seg, WALSegmentContext *segcxt,
 /*
  * Attempt to read an XLOG record.
  *
- * If RecPtr is valid, try to read a record at that position.  Otherwise
- * try to read a record just after the last one previously read.
+ * When starting to read a new record, valid RecPtr starts reading the record
+ * at that position. If invalid RecPtr is given try to start reading a record
+ * just after the last one previously read. Anytime (means in any internal
+ * state) when valid new RecPtr is given, starts reading the record at that
+ * position. This function may return XLREAD_NEED_DATA several times before
+ * returning a result record. The caller shall read in some new data then call
+ * this function again with the same parameters.
  *
- * If the read_page callback fails to read the requested data, NULL is
- * returned.  The callback is expected to have reported the error; errormsg
- * is set to NULL.
+ * When a record is successfully read, returns XLREAD_SUCCESS with result
+ * record being stored in *record. Otherwise *record is NULL.
  *
- * If the reading fails for some other reason, NULL is also returned, and
- * *errormsg is set to a string with details of the failure.
+ * Returns XLREAD_NEED_DATA if more data is needed to finish reading the
+ * current record.  In that case, state->readPagePtr and state->readLen inform
+ * the desired position and minimum length of data needed. The caller shall
+ * read in the requested data and set state->readBuf to point to a buffer
+ * containing it. The caller must also set state->readPageTLI and
+ * state->readLen to indicate the timeline that it was read from, and the
+ * length of data that is now available (which must be >= given readLen),
+ * respectively.
  *
- * The returned pointer (or *errormsg) points to an internal buffer that's
- * valid until the next call to XLogReadRecord.
- */
-XLogRecord *
-XLogReadRecord(XLogReaderState *state, XLogRecPtr RecPtr, char **errormsg)
-{
-    XLogRecord *record;
-    XLogRecPtr    targetPagePtr;
-    bool        randAccess;
-    uint32        len,
-                total_len;
-    uint32        targetRecOff;
-    uint32        pageHeaderSize;
-    bool        gotheader;
+ * If invalid data is encountered, returns XLREAD_FAIL with *record being set to
+ * NULL. *errormsg is set to a string with details of the failure.
+ * The returned pointer (or *errormsg) points to an internal buffer that's valid
+ * until the next call to XLogReadRecord.
+ *
+ *
+ * This function runs a state machine consists of the following states.
+ *
+ * XLREAD_NEXT_RECORD :
+ *    The initial state, if called with valid RecPtr, try to read a record at
+ *    that position.  If invalid RecPtr is given try to read a record just after
+ *    the last one previously read.
+ *    This state ens after setting ReadRecPtr. Then goes to XLREAD_TOT_LEN.
+ *
+ * XLREAD_TOT_LEN:
+ *    Examining record header. Ends after reading record total
+ *    length. recordRemainLen and recordGotLen are initialized.
+ *
+ * XLREAD_FIRST_FRAGMENT:
+ *    Reading the first fragment. Ends with finishing reading a single
+ *    record. Goes to XLREAD_NEXT_RECORD if that's all or
+ *    XLREAD_CONTINUATION if we have continuation.
 
-    /*
-     * randAccess indicates whether to verify the previous-record pointer of
-     * the record we're reading.  We only do this if we're reading
-     * sequentially, which is what we initially assume.
-     */
-    randAccess = false;
+ * XLREAD_CONTINUATION:
+ *    Reading continuation of record. Ends with finishing the whole record then
+ *    goes to XLREAD_NEXT_RECORD. During this state, recordRemainLen indicates
+ *    how much is left and readRecordBuf holds the partially assert
+ *    record.recordContRecPtr points to the beginning of the next page where to
+ *    continue.
+ *
+ * If wrong data found in any state, the state machine stays at the current
+ * state. This behavior allows to continue reading a reacord switching among
+ * different souces, while streaming replication.
+ */
+XLogReadRecordResult
+XLogReadRecord(XLogReaderState *state, XLogRecPtr RecPtr, XLogRecord **record,
+               char **errormsg)
+{
+    XLogRecord *prec;
+
+    *record = NULL;
 
     /* reset error state */
     *errormsg = NULL;
     state->errormsg_buf[0] = '\0';
 
-    ResetDecoder(state);
-
-    if (RecPtr == InvalidXLogRecPtr)
-    {
-        /* No explicit start point; read the record after the one we just read */
-        RecPtr = state->EndRecPtr;
-
-        if (state->ReadRecPtr == InvalidXLogRecPtr)
-            randAccess = true;
-
-        /*
-         * RecPtr is pointing to end+1 of the previous WAL record.  If we're
-         * at a page boundary, no more records can fit on the current page. We
-         * must skip over the page header, but we can't do that until we've
-         * read in the page, since the header size is variable.
-         */
-    }
-    else
-    {
-        /*
-         * Caller supplied a position to start at.
-         *
-         * In this case, the passed-in record pointer should already be
-         * pointing to a valid record starting position.
-         */
-        Assert(XRecOffIsValid(RecPtr));
-        randAccess = true;
-    }
-
-    state->currRecPtr = RecPtr;
-
-    targetPagePtr = RecPtr - (RecPtr % XLOG_BLCKSZ);
-    targetRecOff = RecPtr % XLOG_BLCKSZ;
-
     /*
-     * Read the page containing the record into state->readBuf. Request enough
-     * byte to cover the whole record header, or at least the part of it that
-     * fits on the same page.
+     * Reset to the initial state anytime the caller requested new record.
      */
-    while (XLogNeedData(state, targetPagePtr,
-                        Min(targetRecOff + SizeOfXLogRecord, XLOG_BLCKSZ),
-                        targetRecOff != 0))
+    if (RecPtr != InvalidXLogRecPtr && RecPtr != state->ReadRecPtr)
+        state->readRecordState = XLREAD_NEXT_RECORD;
+
+    switch (state->readRecordState)
     {
-        if (!state->read_page(state, state->readPagePtr, state->readLen,
-                              RecPtr, state->readBuf))
-            break;
-    }
+        case XLREAD_NEXT_RECORD:
+            ResetDecoder(state);
 
-    if (!state->page_verified)
-        goto err;
-
-    /*
-     * We have loaded at least the page header, so we can examine it now.
-     */
-    pageHeaderSize = XLogPageHeaderSize((XLogPageHeader) state->readBuf);
-    if (targetRecOff == 0)
-    {
-        /*
-         * At page start, so skip over page header.
-         */
-        RecPtr += pageHeaderSize;
-        targetRecOff = pageHeaderSize;
-    }
-    else if (targetRecOff < pageHeaderSize)
-    {
-        report_invalid_record(state, "invalid record offset at %X/%X",
-                              (uint32) (RecPtr >> 32), (uint32) RecPtr);
-        goto err;
-    }
-
-    if ((((XLogPageHeader) state->readBuf)->xlp_info & XLP_FIRST_IS_CONTRECORD) &&
-        targetRecOff == pageHeaderSize)
-    {
-        report_invalid_record(state, "contrecord is requested by %X/%X",
-                              (uint32) (RecPtr >> 32), (uint32) RecPtr);
-        goto err;
-    }
-
-    /* XLogNeedData has verified the page header */
-    Assert(pageHeaderSize <= state->readLen);
-
-    /*
-     * Read the record length.
-     *
-     * NB: Even though we use an XLogRecord pointer here, the whole record
-     * header might not fit on this page. xl_tot_len is the first field of the
-     * struct, so it must be on this page (the records are MAXALIGNed), but we
-     * cannot access any other fields until we've verified that we got the
-     * whole header.
-     */
-    record = (XLogRecord *) (state->readBuf + RecPtr % XLOG_BLCKSZ);
-    total_len = record->xl_tot_len;
-
-    /*
-     * If the whole record header is on this page, validate it immediately.
-     * Otherwise do just a basic sanity check on xl_tot_len, and validate the
-     * rest of the header after reading it from the next page.  The xl_tot_len
-     * check is necessary here to ensure that we enter the "Need to reassemble
-     * record" code path below; otherwise we might fail to apply
-     * ValidXLogRecordHeader at all.
-     */
-    if (targetRecOff <= XLOG_BLCKSZ - SizeOfXLogRecord)
-    {
-        if (!ValidXLogRecordHeader(state, RecPtr, state->ReadRecPtr, record,
-                                   randAccess))
-            goto err;
-        gotheader = true;
-    }
-    else
-    {
-        /* XXX: more validation should be done here */
-        if (total_len < SizeOfXLogRecord)
-        {
-            report_invalid_record(state,
-                                  "invalid record length at %X/%X: wanted %u, got %u",
-                                  (uint32) (RecPtr >> 32), (uint32) RecPtr,
-                                  (uint32) SizeOfXLogRecord, total_len);
-            goto err;
-        }
-        gotheader = false;
-    }
-
-    len = XLOG_BLCKSZ - RecPtr % XLOG_BLCKSZ;
-    if (total_len > len)
-    {
-        /* Need to reassemble record */
-        char       *contdata;
-        XLogPageHeader pageHeader;
-        char       *buffer;
-        uint32        gotlen;
-
-        /*
-         * Enlarge readRecordBuf as needed.
-         */
-        if (total_len > state->readRecordBufSize &&
-            !allocate_recordbuf(state, total_len))
-        {
-            /* We treat this as a "bogus data" condition */
-            report_invalid_record(state, "record length %u at %X/%X too long",
-                                  total_len,
-                                  (uint32) (RecPtr >> 32), (uint32) RecPtr);
-            goto err;
-        }
-
-        /* Copy the first fragment of the record from the first page. */
-        memcpy(state->readRecordBuf,
-               state->readBuf + RecPtr % XLOG_BLCKSZ, len);
-        buffer = state->readRecordBuf + len;
-        gotlen = len;
-
-        do
-        {
-            int rest_len = total_len - gotlen;
-
-            /* Calculate pointer to beginning of next page */
-            targetPagePtr += XLOG_BLCKSZ;
-
-            /* Wait for the next page to become available */
-            while (XLogNeedData(state, targetPagePtr,
-                                Min(rest_len, XLOG_BLCKSZ),
-                                false))
+            if (RecPtr != InvalidXLogRecPtr)
             {
-                if (!state->read_page(state, state->readPagePtr, state->readLen,
-                                      state->ReadRecPtr, state->readBuf))
-                    break;
+                /*
+                 * Caller supplied a position to start at.
+                 *
+                 * In this case, the passed-in record pointer should already be
+                 * pointing to a valid record starting position.
+                 */
+                state->ReadRecPtr = RecPtr;
+
+                /*
+                 * We cannot verify the previous-record pointer when we're
+                 * seeking to a particular record. Reset ReadRecPtr so that we
+                 * won't try doing that.
+                 */
+                state->PrevRecPtr = InvalidXLogRecPtr;
+                state->EndRecPtr = InvalidXLogRecPtr;         /* to be tidy */
+            }
+            else
+            {
+                /*
+                 * Otherwise, read the record after the one we just read. (Or
+                 * the first record, if this is the first call. In that case,
+                 * EndRecPtr was set to the desired starting point above.)
+                 *
+                 * EndRecPtr is pointing to end+1 of the previous WAL record.
+                 * If we're at a page boundary, no more records can fit on the
+                 * current page. We must skip over the page header on the next
+                 * page, but we can't do that until we've read in the page,
+                 * since the header size is variable.
+                 */
+                state->PrevRecPtr = state->ReadRecPtr;
+                state->ReadRecPtr = state->EndRecPtr;
             }
 
+            state->record_verified = false;
+            state->readRecordState = XLREAD_TOT_LEN;
+            /* fall through */
+
+        case XLREAD_TOT_LEN:
+        {
+            uint32        total_len;
+            uint32        pageHeaderSize;
+            XLogRecPtr    targetPagePtr;
+            uint32        targetRecOff;
+            XLogPageHeader pageHeader;
+
+            targetPagePtr =
+                state->ReadRecPtr - (state->ReadRecPtr % XLOG_BLCKSZ);
+            targetRecOff = state->ReadRecPtr % XLOG_BLCKSZ;
+
+            /*
+             * Check if we have enough data. For the first record in the page,
+             * the requesting length doesn't contain page header.
+             */
+            if (XLogNeedData(state, targetPagePtr,
+                             Min(targetRecOff + SizeOfXLogRecord, XLOG_BLCKSZ),
+                             targetRecOff != 0))
+                return XLREAD_NEED_DATA;
+
+            /* error out if caller supplied bogus page */
             if (!state->page_verified)
                 goto err;
 
-            Assert(SizeOfXLogShortPHD <= state->readLen);
-
-            /* Check that the continuation on next page looks valid */
-            pageHeader = (XLogPageHeader) state->readBuf;
-            if (!(pageHeader->xlp_info & XLP_FIRST_IS_CONTRECORD))
+            /* examine page header now. */
+            pageHeaderSize =
+                XLogPageHeaderSize((XLogPageHeader) state->readBuf);
+            if (targetRecOff == 0)
             {
-                report_invalid_record(state,
-                                      "there is no contrecord flag at %X/%X",
-                                      (uint32) (RecPtr >> 32), (uint32) RecPtr);
+                /* At page start, so skip over page header. */
+                state->ReadRecPtr += pageHeaderSize;
+                targetRecOff = pageHeaderSize;
+            }
+            else if (targetRecOff < pageHeaderSize)
+            {
+                report_invalid_record(state, "invalid record offset at %X/%X",
+                                      (uint32) (state->ReadRecPtr >> 32),
+                                      (uint32) state->ReadRecPtr);
                 goto err;
             }
 
+            pageHeader = (XLogPageHeader) state->readBuf;
+            if ((pageHeader->xlp_info & XLP_FIRST_IS_CONTRECORD) &&
+                targetRecOff == pageHeaderSize)
+            {
+                report_invalid_record(state, "contrecord is requested by %X/%X",
+                                      (uint32) (state->ReadRecPtr >> 32),
+                                      (uint32) state->ReadRecPtr);
+                goto err;
+            }
+
+            /* XLogNeedData has verified the page header */
+            Assert(pageHeaderSize <= state->readLen);
+
+            /*
+             * Read the record length.
+             *
+             * NB: Even though we use an XLogRecord pointer here, the whole
+             * record header might not fit on this page. xl_tot_len is the first
+             * field of the struct, so it must be on this page (the records are
+             * MAXALIGNed), but we cannot access any other fields until we've
+             * verified that we got the whole header.
+             */
+            prec = (XLogRecord *) (state->readBuf +
+                                   state->ReadRecPtr % XLOG_BLCKSZ);
+            total_len = prec->xl_tot_len;
+
+            /*
+             * If the whole record header is on this page, validate it
+             * immediately.  Otherwise do just a basic sanity check on
+             * xl_tot_len, and validate the rest of the header after reading it
+             * from the next page.  The xl_tot_len check is necessary here to
+             * ensure that we enter the XLREAD_CONTINUATION state below;
+             * otherwise we might fail to apply ValidXLogRecordHeader at all.
+             */
+            if (targetRecOff <= XLOG_BLCKSZ - SizeOfXLogRecord)
+            {
+                if (!ValidXLogRecordHeader(state, state->ReadRecPtr,
+                                           state->PrevRecPtr, prec))
+                    goto err;
+
+                state->record_verified = true;
+            }
+            else
+            {
+                /* XXX: more validation should be done here */
+                if (total_len < SizeOfXLogRecord)
+                {
+                    report_invalid_record(state,
+                                          "invalid record length at %X/%X: wanted %u, got %u",
+                                          (uint32) (state->ReadRecPtr >> 32),
+                                          (uint32) state->ReadRecPtr,
+                                          (uint32) SizeOfXLogRecord, total_len);
+                    goto err;
+                }
+            }
+
             /*
-             * Cross-check that xlp_rem_len agrees with how much of the record
-             * we expect there to be left.
+             * Wait for the rest of the record, or the part of the record that
+             * fit on the first page if crossed a page boundary, to become
+             * available.
              */
-            if (pageHeader->xlp_rem_len == 0 ||
-                total_len != (pageHeader->xlp_rem_len + gotlen))
+            state->recordGotLen = 0;
+            state->recordRemainLen = total_len;
+            state->readRecordState = XLREAD_FIRST_FRAGMENT;
+        }
+        /* fall through */
+
+        case XLREAD_FIRST_FRAGMENT:
+        {
+            uint32        total_len = state->recordRemainLen;
+            uint32        request_len;
+            uint32        record_len;
+            XLogRecPtr    targetPagePtr;
+            uint32        targetRecOff;
+
+            /*
+             * Wait for the rest of the record on the first page to become
+             * available
+             */
+            targetPagePtr =
+                state->ReadRecPtr - (state->ReadRecPtr % XLOG_BLCKSZ);
+            targetRecOff = state->ReadRecPtr % XLOG_BLCKSZ;
+
+            request_len = Min(targetRecOff + total_len, XLOG_BLCKSZ);
+            record_len = request_len - targetRecOff;
+
+            /* ReadRecPtr contains page header */
+            Assert (targetRecOff != 0);
+            if (XLogNeedData(state, targetPagePtr, request_len, true))
+                return XLREAD_NEED_DATA;
+
+            /* error out if caller supplied bogus page */
+            if (!state->page_verified)
+                goto err;
+
+            prec = (XLogRecord *) (state->readBuf + targetRecOff);
+
+            /* validate record header if not yet */
+            if (!state->record_verified && record_len >= SizeOfXLogRecord)
             {
+                if (!ValidXLogRecordHeader(state, state->ReadRecPtr,
+                                           state->PrevRecPtr, prec))
+                    goto err;
+
+                state->record_verified = true;
+            }
+
+
+            if (total_len == record_len)
+            {
+                /* Record does not cross a page boundary */
+                Assert(state->record_verified);
+
+                if (!ValidXLogRecord(state, prec, state->ReadRecPtr))
+                    goto err;
+
+                state->record_verified = true;  /* to be tidy */
+
+                /* We already checked the header earlier */
+                state->EndRecPtr = state->ReadRecPtr + MAXALIGN(record_len);
+
+                *record = prec;
+                state->readRecordState = XLREAD_NEXT_RECORD;
+                break;
+            }
+
+            /*
+             * The record continues on the next page. Need to reassemble
+             * record
+             */
+            Assert(total_len > record_len);
+
+            /* Enlarge readRecordBuf as needed. */
+            if (total_len > state->readRecordBufSize &&
+                !allocate_recordbuf(state, total_len))
+            {
+                /* We treat this as a "bogus data" condition */
                 report_invalid_record(state,
-                                      "invalid contrecord length %u at %X/%X",
-                                      pageHeader->xlp_rem_len,
-                                      (uint32) (RecPtr >> 32), (uint32) RecPtr);
+                                      "record length %u at %X/%X too long",
+                                      total_len,
+                                      (uint32) (state->ReadRecPtr >> 32),
+                                      (uint32) state->ReadRecPtr);
                 goto err;
             }
 
-            /* Append the continuation from this page to the buffer */
-            pageHeaderSize = XLogPageHeaderSize(pageHeader);
+            /* Copy the first fragment of the record from the first page. */
+            memcpy(state->readRecordBuf, state->readBuf + targetRecOff,
+                   record_len);
+            state->recordGotLen += record_len;
+            state->recordRemainLen -= record_len;
 
-            Assert (pageHeaderSize <= state->readLen);
+            /* Calculate pointer to beginning of next page */
+            state->recordContRecPtr = state->ReadRecPtr + record_len;
+            Assert(state->recordContRecPtr % XLOG_BLCKSZ == 0);
 
-            contdata = (char *) state->readBuf + pageHeaderSize;
-            len = XLOG_BLCKSZ - pageHeaderSize;
-            if (pageHeader->xlp_rem_len < len)
-                len = pageHeader->xlp_rem_len;
-
-            Assert (pageHeaderSize + len <= state->readLen);
-            memcpy(buffer, (char *) contdata, len);
-            buffer += len;
-            gotlen += len;
-
-            /* If we just reassembled the record header, validate it. */
-            if (!gotheader)
-            {
-                record = (XLogRecord *) state->readRecordBuf;
-                if (!ValidXLogRecordHeader(state, RecPtr, state->ReadRecPtr,
-                                           record, randAccess))
-                    goto err;
-                gotheader = true;
-            }
-        } while (gotlen < total_len);
-
-        Assert(gotheader);
-
-        record = (XLogRecord *) state->readRecordBuf;
-        if (!ValidXLogRecord(state, record, RecPtr))
-            goto err;
-
-        pageHeaderSize = XLogPageHeaderSize((XLogPageHeader) state->readBuf);
-        state->ReadRecPtr = RecPtr;
-        state->EndRecPtr = targetPagePtr + pageHeaderSize
-            + MAXALIGN(pageHeader->xlp_rem_len);
-    }
-    else
-    {
-        /* Wait for the record data to become available */
-        while (XLogNeedData(state, targetPagePtr,
-                            Min(targetRecOff + total_len, XLOG_BLCKSZ), true))
-        {
-            if (!state->read_page(state, state->readPagePtr, state->readLen,
-                                  state->ReadRecPtr, state->readBuf))
-                break;
+            state->readRecordState = XLREAD_CONTINUATION;
         }
+        /* fall through */
 
-        if (!state->page_verified)
-            goto err;
+        case XLREAD_CONTINUATION:
+        {
+            XLogPageHeader pageHeader;
+            uint32        pageHeaderSize;
+            XLogRecPtr    targetPagePtr;
 
-        /* Record does not cross a page boundary */
-        if (!ValidXLogRecord(state, record, RecPtr))
-            goto err;
+            /* we enter this state only if we haven't read the whole record. */
+            Assert (state->recordRemainLen > 0);
 
-        state->EndRecPtr = RecPtr + MAXALIGN(total_len);
+            while(state->recordRemainLen > 0)
+            {
+                char       *contdata;
+                uint32        request_len;
+                uint32        record_len;
 
-        state->ReadRecPtr = RecPtr;
+                /* Wait for the next page to become available */
+                targetPagePtr = state->recordContRecPtr;
+
+                /* this request contains page header */
+                Assert (targetPagePtr != 0);
+                if (XLogNeedData(state, targetPagePtr,
+                                 Min(state->recordRemainLen, XLOG_BLCKSZ),
+                                 false))
+                    return XLREAD_NEED_DATA;
+
+                if (!state->page_verified)
+                    goto err;
+
+                Assert(SizeOfXLogShortPHD <= state->readLen);
+
+                /* Check that the continuation on next page looks valid */
+                pageHeader = (XLogPageHeader) state->readBuf;
+                if (!(pageHeader->xlp_info & XLP_FIRST_IS_CONTRECORD))
+                {
+                    report_invalid_record(
+                        state,
+                        "there is no contrecord flag at %X/%X reading %X/%X",
+                        (uint32) (state->recordContRecPtr >> 32),
+                        (uint32) state->recordContRecPtr,
+                        (uint32) (state->ReadRecPtr >> 32),
+                        (uint32) state->ReadRecPtr);
+                    goto err;
+                }
+
+                /*
+                 * Cross-check that xlp_rem_len agrees with how much of the
+                 * record we expect there to be left.
+                 */
+                if (pageHeader->xlp_rem_len == 0 ||
+                    pageHeader->xlp_rem_len != state->recordRemainLen)
+                {
+                    report_invalid_record(
+                        state,
+                        "invalid contrecord length %u at %X/%X reading %X/%X, expected %u",
+                        pageHeader->xlp_rem_len,
+                        (uint32) (state->recordContRecPtr >> 32),
+                        (uint32) state->recordContRecPtr,
+                        (uint32) (state->ReadRecPtr >> 32),
+                        (uint32) state->ReadRecPtr,
+                        state->recordRemainLen);
+                    goto err;
+                }
+
+                /* Append the continuation from this page to the buffer */
+                pageHeaderSize = XLogPageHeaderSize(pageHeader);
+
+                /*
+                 * XLogNeedData should have ensured that the whole page header
+                 * was read
+                 */
+                Assert(state->readLen >= pageHeaderSize);
+
+                contdata = (char *) state->readBuf + pageHeaderSize;
+                record_len = XLOG_BLCKSZ - pageHeaderSize;
+                if (pageHeader->xlp_rem_len < record_len)
+                    record_len = pageHeader->xlp_rem_len;
+
+                request_len = record_len + pageHeaderSize;
+
+                /* XLogNeedData should have ensured all needed data was read */
+                Assert (state->readLen >= request_len);
+
+                memcpy(state->readRecordBuf + state->recordGotLen,
+                       (char *) contdata, record_len);
+                state->recordGotLen += record_len;
+                state->recordRemainLen -= record_len;
+
+                /* If we just reassembled the record header, validate it. */
+                if (!state->record_verified)
+                {
+                    Assert(state->recordGotLen >= SizeOfXLogRecord);
+                    if (!ValidXLogRecordHeader(state, state->ReadRecPtr,
+                                               state->PrevRecPtr,
+                                               (XLogRecord *) state->readRecordBuf))
+                        goto err;
+
+                    state->record_verified = true;
+                }
+
+                /* Calculate pointer to beginning of next page, and continue */
+                state->recordContRecPtr += XLOG_BLCKSZ;
+            }
+
+            /* targetPagePtr is pointing the last-read page here */
+            prec = (XLogRecord *) state->readRecordBuf;
+            if (!ValidXLogRecord(state, prec, state->ReadRecPtr))
+                goto err;
+
+            pageHeaderSize =
+                XLogPageHeaderSize((XLogPageHeader) state->readBuf);
+            state->EndRecPtr = targetPagePtr + pageHeaderSize
+                + MAXALIGN(pageHeader->xlp_rem_len);
+
+            *record = prec;
+            state->readRecordState = XLREAD_NEXT_RECORD;
+            break;
+        }
     }
 
     /*
      * Special processing if it's an XLOG SWITCH record
      */
-    if (record->xl_rmid == RM_XLOG_ID &&
-        (record->xl_info & ~XLR_INFO_MASK) == XLOG_SWITCH)
+    if ((*record)->xl_rmid == RM_XLOG_ID &&
+        ((*record)->xl_info & ~XLR_INFO_MASK) == XLOG_SWITCH)
     {
         /* Pretend it extends to end of segment */
         state->EndRecPtr += state->segcxt.ws_segsize - 1;
         state->EndRecPtr -= XLogSegmentOffset(state->EndRecPtr, state->segcxt.ws_segsize);
     }
 
-    if (DecodeXLogRecord(state, record, errormsg))
-        return record;
-    else
-        return NULL;
+    Assert (!*record || state->readLen >= 0);
+    if (DecodeXLogRecord(state, *record, errormsg))
+        return XLREAD_SUCCESS;
+
+    *record = NULL;
+    return XLREAD_FAIL;
 
 err:
 
     /*
-     * Invalidate the read state. We might read from a different source after
+     * Invalidate the read page. We might read from a different source after
      * failure.
      */
     XLogReaderDiscardReadingPage(state);
@@ -540,7 +682,8 @@ err:
     if (state->errormsg_buf[0] != '\0')
         *errormsg = state->errormsg_buf;
 
-    return NULL;
+    *record = NULL;
+    return XLREAD_FAIL;
 }
 
 /*
@@ -728,11 +871,12 @@ XLogReaderDiscardReadingPage(XLogReaderState *state)
  *
  * This is just a convenience subroutine to avoid duplicated code in
  * XLogReadRecord.  It's not intended for use from anywhere else.
+ *
+ * If PrevRecPtr is valid, the xl_prev is is cross-checked with it.
  */
 static bool
 ValidXLogRecordHeader(XLogReaderState *state, XLogRecPtr RecPtr,
-                      XLogRecPtr PrevRecPtr, XLogRecord *record,
-                      bool randAccess)
+                      XLogRecPtr PrevRecPtr, XLogRecord *record)
 {
     if (record->xl_tot_len < SizeOfXLogRecord)
     {
@@ -750,7 +894,7 @@ ValidXLogRecordHeader(XLogReaderState *state, XLogRecPtr RecPtr,
                               (uint32) RecPtr);
         return false;
     }
-    if (randAccess)
+    if (PrevRecPtr == InvalidXLogRecPtr)
     {
         /*
          * We can't exactly verify the prev-link, but surely it should be less
@@ -978,12 +1122,15 @@ XLogReaderValidatePageHeader(XLogReaderState *state, XLogRecPtr recptr,
  * debugging purposes.
  */
 XLogRecPtr
-XLogFindNextRecord(XLogReaderState *state, XLogRecPtr RecPtr)
+XLogFindNextRecord(XLogReaderState *state, XLogRecPtr RecPtr,
+                   XLogFindNextRecordCB read_page, void *private)
 {
     XLogReaderState saved_state = *state;
     XLogRecPtr    tmpRecPtr;
     XLogRecPtr    found = InvalidXLogRecPtr;
     XLogPageHeader header;
+    XLogRecord *record;
+    XLogReadRecordResult result;
     char       *errormsg;
 
     Assert(!XLogRecPtrIsInvalid(RecPtr));
@@ -1016,8 +1163,7 @@ XLogFindNextRecord(XLogReaderState *state, XLogRecPtr RecPtr)
         while(XLogNeedData(state, targetPagePtr, targetRecOff,
                            targetRecOff != 0))
         {
-            if (!state->read_page(state, state->readPagePtr, state->readLen,
-                                  state->ReadRecPtr, state->readBuf))
+            if (!read_page(state, private))
                 break;
         }
 
@@ -1068,11 +1214,19 @@ XLogFindNextRecord(XLogReaderState *state, XLogRecPtr RecPtr)
      * because either we're at the first record after the beginning of a page
      * or we just jumped over the remaining data of a continuation.
      */
-    while (XLogReadRecord(state, tmpRecPtr, &errormsg) != NULL)
+    while ((result = XLogReadRecord(state, tmpRecPtr, &record, &errormsg)) !=
+           XLREAD_FAIL)
     {
         /* continue after the record */
         tmpRecPtr = InvalidXLogRecPtr;
 
+        if (result == XLREAD_NEED_DATA)
+        {
+            if (!read_page(state, private))
+                goto err;
+            continue;
+        }
+
         /* past the record we've found, break out */
         if (RecPtr <= state->ReadRecPtr)
         {
diff --git a/src/backend/access/transam/xlogutils.c b/src/backend/access/transam/xlogutils.c
index a19726a96e..a2bc7b9fba 100644
--- a/src/backend/access/transam/xlogutils.c
+++ b/src/backend/access/transam/xlogutils.c
@@ -802,8 +802,7 @@ XLogRead(char *buf, int segsize, TimeLineID tli, XLogRecPtr startptr,
 void
 XLogReadDetermineTimeline(XLogReaderState *state, XLogRecPtr wantPage, uint32 wantLength)
 {
-    const XLogRecPtr lastReadPage = state->seg.ws_segno *
-    state->segcxt.ws_segsize + state->readLen;
+    const XLogRecPtr lastReadPage = state->readPagePtr;
 
     Assert(wantPage != InvalidXLogRecPtr && wantPage % XLOG_BLCKSZ == 0);
     Assert(wantLength <= XLOG_BLCKSZ);
@@ -818,7 +817,7 @@ XLogReadDetermineTimeline(XLogReaderState *state, XLogRecPtr wantPage, uint32 wa
      * current TLI has since become historical.
      */
     if (lastReadPage == wantPage &&
-        state->readLen != 0 &&
+        state->page_verified &&
         lastReadPage + state->readLen >= wantPage + Min(wantLength, XLOG_BLCKSZ - 1))
         return;
 
@@ -908,9 +907,11 @@ XLogReadDetermineTimeline(XLogReaderState *state, XLogRecPtr wantPage, uint32 wa
  * loop for now.
  */
 bool
-read_local_xlog_page(XLogReaderState *state, XLogRecPtr targetPagePtr,
-                     int reqLen, XLogRecPtr targetRecPtr, char *cur_page)
+read_local_xlog_page(XLogReaderState *state)
 {
+    XLogRecPtr    targetPagePtr = state->readPagePtr;
+    int            reqLen          = state->readLen;
+    char       *cur_page      = state->readBuf;
     XLogRecPtr    read_upto,
                 loc;
     int            count;
@@ -1025,6 +1026,7 @@ read_local_xlog_page(XLogReaderState *state, XLogRecPtr targetPagePtr,
              XLOG_BLCKSZ);
 
     /* number of valid bytes in the buffer */
+    state->readPagePtr = targetPagePtr;
     state->readLen = count;
     return true;
 }
diff --git a/src/backend/replication/logical/logical.c b/src/backend/replication/logical/logical.c
index da265f5294..db3e8f9dc0 100644
--- a/src/backend/replication/logical/logical.c
+++ b/src/backend/replication/logical/logical.c
@@ -124,7 +124,7 @@ StartupDecodingContext(List *output_plugin_options,
                        TransactionId xmin_horizon,
                        bool need_full_snapshot,
                        bool fast_forward,
-                       XLogPageReadCB read_page,
+                       LogicalDecodingXLogReadPageCB read_page,
                        LogicalOutputPluginWriterPrepareWrite prepare_write,
                        LogicalOutputPluginWriterWrite do_write,
                        LogicalOutputPluginWriterUpdateProgress update_progress)
@@ -173,11 +173,12 @@ StartupDecodingContext(List *output_plugin_options,
 
     ctx->slot = slot;
 
-    ctx->reader = XLogReaderAllocate(wal_segment_size, NULL, read_page, ctx);
+    ctx->reader = XLogReaderAllocate(wal_segment_size, NULL);
     if (!ctx->reader)
         ereport(ERROR,
                 (errcode(ERRCODE_OUT_OF_MEMORY),
                  errmsg("out of memory")));
+    ctx->read_page = read_page;
 
     ctx->reorder = ReorderBufferAllocate();
     ctx->snapshot_builder =
@@ -232,7 +233,7 @@ CreateInitDecodingContext(char *plugin,
                           List *output_plugin_options,
                           bool need_full_snapshot,
                           XLogRecPtr restart_lsn,
-                          XLogPageReadCB read_page,
+                          LogicalDecodingXLogReadPageCB read_page,
                           LogicalOutputPluginWriterPrepareWrite prepare_write,
                           LogicalOutputPluginWriterWrite do_write,
                           LogicalOutputPluginWriterUpdateProgress update_progress)
@@ -374,7 +375,7 @@ LogicalDecodingContext *
 CreateDecodingContext(XLogRecPtr start_lsn,
                       List *output_plugin_options,
                       bool fast_forward,
-                      XLogPageReadCB read_page,
+                      LogicalDecodingXLogReadPageCB read_page,
                       LogicalOutputPluginWriterPrepareWrite prepare_write,
                       LogicalOutputPluginWriterWrite do_write,
                       LogicalOutputPluginWriterUpdateProgress update_progress)
@@ -482,7 +483,13 @@ DecodingContextFindStartpoint(LogicalDecodingContext *ctx)
         char       *err = NULL;
 
         /* the read_page callback waits for new WAL */
-        record = XLogReadRecord(ctx->reader, startptr, &err);
+        while (XLogReadRecord(ctx->reader, startptr, &record, &err) ==
+               XLREAD_NEED_DATA)
+        {
+            if (!ctx->read_page(ctx))
+                break;
+        }
+
         if (err)
             elog(ERROR, "%s", err);
         if (!record)
diff --git a/src/backend/replication/logical/logicalfuncs.c b/src/backend/replication/logical/logicalfuncs.c
index 310cd9d8cf..5270f646bd 100644
--- a/src/backend/replication/logical/logicalfuncs.c
+++ b/src/backend/replication/logical/logicalfuncs.c
@@ -115,11 +115,9 @@ check_permissions(void)
 }
 
 bool
-logical_read_local_xlog_page(XLogReaderState *state, XLogRecPtr targetPagePtr,
-                             int reqLen, XLogRecPtr targetRecPtr, char *cur_page)
+logical_read_local_xlog_page(LogicalDecodingContext *ctx)
 {
-    return read_local_xlog_page(state, targetPagePtr, reqLen,
-                                targetRecPtr, cur_page);
+    return read_local_xlog_page(ctx->reader);
 }
 
 /*
@@ -289,7 +287,13 @@ pg_logical_slot_get_changes_guts(FunctionCallInfo fcinfo, bool confirm, bool bin
             XLogRecord *record;
             char       *errm = NULL;
 
-            record = XLogReadRecord(ctx->reader, startptr, &errm);
+            while (XLogReadRecord(ctx->reader, startptr, &record, &errm) ==
+                   XLREAD_NEED_DATA)
+            {
+                if (!ctx->read_page(ctx))
+                    break;
+            }
+
             if (errm)
                 elog(ERROR, "%s", errm);
 
diff --git a/src/backend/replication/slotfuncs.c b/src/backend/replication/slotfuncs.c
index 42da631823..74e213b8e1 100644
--- a/src/backend/replication/slotfuncs.c
+++ b/src/backend/replication/slotfuncs.c
@@ -433,7 +433,13 @@ pg_logical_replication_slot_advance(XLogRecPtr moveto)
              * Read records.  No changes are generated in fast_forward mode,
              * but snapbuilder/slot statuses are updated properly.
              */
-            record = XLogReadRecord(ctx->reader, startlsn, &errm);
+            while (XLogReadRecord(ctx->reader, startlsn, &record, &errm) ==
+                   XLREAD_NEED_DATA)
+            {
+                if (!ctx->read_page(ctx))
+                    break;
+            }
+
             if (errm)
                 elog(ERROR, "%s", errm);
 
diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index 0809ceaeb8..21e6c47317 100644
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -761,9 +761,12 @@ StartReplication(StartReplicationCmd *cmd)
  * set every time WAL is flushed.
  */
 static bool
-logical_read_xlog_page(XLogReaderState *state, XLogRecPtr targetPagePtr, int reqLen,
-                       XLogRecPtr targetRecPtr, char *cur_page)
+logical_read_xlog_page(LogicalDecodingContext *ctx)
 {
+    XLogReaderState *state = ctx->reader;
+    XLogRecPtr        targetPagePtr = state->readPagePtr;
+    int                reqLen          = state->readLen;
+    char           *cur_page      = state->readBuf;
     XLogRecPtr    flushptr;
     int            count;
 
@@ -2827,7 +2830,12 @@ XLogSendLogical(void)
      */
     WalSndCaughtUp = false;
 
-    record = XLogReadRecord(logical_decoding_ctx->reader, logical_startptr, &errm);
+    while (XLogReadRecord(logical_decoding_ctx->reader,
+                          logical_startptr, &record, &errm) == XLREAD_NEED_DATA)
+    {
+        if (!logical_decoding_ctx->read_page(logical_decoding_ctx))
+            break;
+    }
     logical_startptr = InvalidXLogRecPtr;
 
     /* xlog record was invalid */
diff --git a/src/bin/pg_rewind/parsexlog.c b/src/bin/pg_rewind/parsexlog.c
index 8aecd1adc7..c5e5d75a87 100644
--- a/src/bin/pg_rewind/parsexlog.c
+++ b/src/bin/pg_rewind/parsexlog.c
@@ -41,14 +41,8 @@ static int    xlogreadfd = -1;
 static XLogSegNo xlogreadsegno = -1;
 static char xlogfpath[MAXPGPATH];
 
-typedef struct XLogPageReadPrivate
-{
-    int            tliIndex;
-} XLogPageReadPrivate;
-
-static bool    SimpleXLogPageRead(XLogReaderState *xlogreader,
-                               XLogRecPtr targetPagePtr,
-                               int reqLen, XLogRecPtr targetRecPtr, char *readBuf);
+static bool SimpleXLogPageRead(XLogReaderState *xlogreader,
+                               const char *datadir, int *tliIndex);
 
 /*
  * Read WAL from the datadir/pg_wal, starting from 'startpoint' on timeline
@@ -62,23 +56,26 @@ extractPageMap(const char *datadir, XLogRecPtr startpoint, int tliIndex,
     XLogRecord *record;
     XLogReaderState *xlogreader;
     char       *errormsg;
-    XLogPageReadPrivate private;
 
-    private.tliIndex = tliIndex;
-    xlogreader = XLogReaderAllocate(WalSegSz, datadir, &SimpleXLogPageRead,
-                                    &private);
+    xlogreader = XLogReaderAllocate(WalSegSz, datadir);
     if (xlogreader == NULL)
         pg_fatal("out of memory");
 
     do
     {
-        record = XLogReadRecord(xlogreader, startpoint, &errormsg);
+        while (XLogReadRecord(xlogreader, startpoint, &record, &errormsg) ==
+               XLREAD_NEED_DATA)
+        {
+            if (!SimpleXLogPageRead(xlogreader, datadir, &tliIndex))
+                break;
+        }
 
         if (record == NULL)
         {
-            XLogRecPtr    errptr;
+            XLogRecPtr    errptr = xlogreader->EndRecPtr;
 
-            errptr = startpoint ? startpoint : xlogreader->EndRecPtr;
+            if (startpoint)
+                errptr = startpoint;
 
             if (errormsg)
                 pg_fatal("could not read WAL record at %X/%X: %s",
@@ -113,16 +110,18 @@ readOneRecord(const char *datadir, XLogRecPtr ptr, int tliIndex)
     XLogRecord *record;
     XLogReaderState *xlogreader;
     char       *errormsg;
-    XLogPageReadPrivate private;
     XLogRecPtr    endptr;
 
-    private.tliIndex = tliIndex;
-    xlogreader = XLogReaderAllocate(WalSegSz, datadir, &SimpleXLogPageRead,
-                                    &private);
+    xlogreader = XLogReaderAllocate(WalSegSz, datadir);
     if (xlogreader == NULL)
         pg_fatal("out of memory");
 
-    record = XLogReadRecord(xlogreader, ptr, &errormsg);
+    while (XLogReadRecord(xlogreader, ptr, &record, &errormsg) ==
+           XLREAD_NEED_DATA)
+    {
+        if (!SimpleXLogPageRead(xlogreader, datadir, &tliIndex))
+            break;
+    }
     if (record == NULL)
     {
         if (errormsg)
@@ -157,7 +156,6 @@ findLastCheckpoint(const char *datadir, XLogRecPtr forkptr, int tliIndex,
     XLogRecPtr    searchptr;
     XLogReaderState *xlogreader;
     char       *errormsg;
-    XLogPageReadPrivate private;
 
     /*
      * The given fork pointer points to the end of the last common record,
@@ -173,9 +171,7 @@ findLastCheckpoint(const char *datadir, XLogRecPtr forkptr, int tliIndex,
             forkptr += SizeOfXLogShortPHD;
     }
 
-    private.tliIndex = tliIndex;
-    xlogreader = XLogReaderAllocate(WalSegSz, datadir, &SimpleXLogPageRead,
-                                    &private);
+    xlogreader = XLogReaderAllocate(WalSegSz, datadir);
     if (xlogreader == NULL)
         pg_fatal("out of memory");
 
@@ -184,7 +180,12 @@ findLastCheckpoint(const char *datadir, XLogRecPtr forkptr, int tliIndex,
     {
         uint8        info;
 
-        record = XLogReadRecord(xlogreader, searchptr, &errormsg);
+        while (XLogReadRecord(xlogreader, searchptr, &record, &errormsg) ==
+               XLREAD_NEED_DATA)
+        {
+            if (!SimpleXLogPageRead(xlogreader, datadir, &tliIndex))
+                break;
+        }
 
         if (record == NULL)
         {
@@ -231,10 +232,11 @@ findLastCheckpoint(const char *datadir, XLogRecPtr forkptr, int tliIndex,
 
 /* XLogReader callback function, to read a WAL page */
 static bool
-SimpleXLogPageRead(XLogReaderState *xlogreader, XLogRecPtr targetPagePtr,
-                   int reqLen, XLogRecPtr targetRecPtr, char *readBuf)
+SimpleXLogPageRead(XLogReaderState *xlogreader, const char *datadir,
+                   int *tliIndex)
 {
-    XLogPageReadPrivate *private = (XLogPageReadPrivate *) xlogreader->private_data;
+    XLogRecPtr    targetPagePtr = xlogreader->readPagePtr;
+    char       *readBuf          = xlogreader->readBuf;
     uint32        targetPageOff;
     XLogRecPtr    targetSegEnd;
     XLogSegNo    targetSegNo;
@@ -267,14 +269,14 @@ SimpleXLogPageRead(XLogReaderState *xlogreader, XLogRecPtr targetPagePtr,
          * be done both forward and backward, consider also switching timeline
          * accordingly.
          */
-        while (private->tliIndex < targetNentries - 1 &&
-               targetHistory[private->tliIndex].end < targetSegEnd)
-            private->tliIndex++;
-        while (private->tliIndex > 0 &&
-               targetHistory[private->tliIndex].begin >= targetSegEnd)
-            private->tliIndex--;
+        while (*tliIndex < targetNentries - 1 &&
+               targetHistory[*tliIndex].end < targetSegEnd)
+            (*tliIndex)++;
+        while (*tliIndex > 0 &&
+               targetHistory[*tliIndex].begin >= targetSegEnd)
+            (*tliIndex)--;
 
-        XLogFileName(xlogfname, targetHistory[private->tliIndex].tli,
+        XLogFileName(xlogfname, targetHistory[*tliIndex].tli,
                      xlogreadsegno, WalSegSz);
 
         snprintf(xlogfpath, MAXPGPATH, "%s/" XLOGDIR "/%s",
@@ -319,7 +321,7 @@ SimpleXLogPageRead(XLogReaderState *xlogreader, XLogRecPtr targetPagePtr,
 
     Assert(targetSegNo == xlogreadsegno);
 
-    xlogreader->seg.ws_tli = targetHistory[private->tliIndex].tli;
+    xlogreader->seg.ws_tli = targetHistory[*tliIndex].tli;
     xlogreader->readLen = XLOG_BLCKSZ;
     return true;
 }
diff --git a/src/bin/pg_waldump/pg_waldump.c b/src/bin/pg_waldump/pg_waldump.c
index 6e424bd8e1..ee49712830 100644
--- a/src/bin/pg_waldump/pg_waldump.c
+++ b/src/bin/pg_waldump/pg_waldump.c
@@ -407,10 +407,12 @@ XLogDumpXLogRead(const char *directory, TimeLineID timeline_id,
  * XLogReader read_page callback
  */
 static bool
-XLogDumpReadPage(XLogReaderState *state, XLogRecPtr targetPagePtr, int reqLen,
-                 XLogRecPtr targetPtr, char *readBuff)
+XLogDumpReadPage(XLogReaderState *state, void *priv)
 {
-    XLogDumpPrivate *private = state->private_data;
+    XLogRecPtr    targetPagePtr = state->readPagePtr;
+    int            reqLen          = state->readLen;
+    char       *readBuff      = state->readBuf;
+    XLogDumpPrivate *private  = (XLogDumpPrivate *) priv;
     int            count = XLOG_BLCKSZ;
 
     if (private->endptr != InvalidXLogRecPtr)
@@ -430,6 +432,7 @@ XLogDumpReadPage(XLogReaderState *state, XLogRecPtr targetPagePtr, int reqLen,
     XLogDumpXLogRead(state->segcxt.ws_dir, private->timeline, targetPagePtr,
                      readBuff, count);
 
+    Assert(count >= state->readLen);
     state->readLen = count;
     return true;
 }
@@ -1088,13 +1091,13 @@ main(int argc, char **argv)
     /* done with argument parsing, do the actual work */
 
     /* we have everything we need, start reading */
-    xlogreader_state = XLogReaderAllocate(WalSegSz, waldir, XLogDumpReadPage,
-                                          &private);
+    xlogreader_state = XLogReaderAllocate(WalSegSz, waldir);
     if (!xlogreader_state)
         fatal_error("out of memory");
 
     /* first find a valid recptr to start from */
-    first_record = XLogFindNextRecord(xlogreader_state, private.startptr);
+    first_record = XLogFindNextRecord(xlogreader_state, private.startptr,
+                                      &XLogDumpReadPage, (void*) &private);
 
     if (first_record == InvalidXLogRecPtr)
         fatal_error("could not find a valid record after %X/%X",
@@ -1118,7 +1121,14 @@ main(int argc, char **argv)
     for (;;)
     {
         /* try to read the next record */
-        record = XLogReadRecord(xlogreader_state, first_record, &errormsg);
+        while (XLogReadRecord(xlogreader_state,
+                              first_record, &record, &errormsg) ==
+               XLREAD_NEED_DATA)
+        {
+            if (!XLogDumpReadPage(xlogreader_state, (void *) &private))
+                break;
+        }
+
         if (!record)
         {
             if (!config.follow || private.endptr_reached)
diff --git a/src/include/access/xlogreader.h b/src/include/access/xlogreader.h
index 8b747d465f..8e39b5c1f6 100644
--- a/src/include/access/xlogreader.h
+++ b/src/include/access/xlogreader.h
@@ -49,13 +49,6 @@ typedef struct WALSegmentContext
 
 typedef struct XLogReaderState XLogReaderState;
 
-/* Function type definition for the read_page callback */
-typedef bool (*XLogPageReadCB) (XLogReaderState *xlogreader,
-                               XLogRecPtr targetPagePtr,
-                               int reqLen,
-                               XLogRecPtr targetRecPtr,
-                               char *readBuf);
-
 typedef struct
 {
     /* Is this block ref in use? */
@@ -85,6 +78,29 @@ typedef struct
     uint16        data_bufsz;
 } DecodedBkpBlock;
 
+/* Return code from XLogReadRecord */
+typedef enum XLogReadRecordResult
+{
+    XLREAD_SUCCESS,        /* record is successfully read */
+    XLREAD_NEED_DATA,    /* need more data. see XLogReadRecord. */
+    XLREAD_FAIL            /* failed during reading a record */
+} XLogReadRecordResult;
+
+/*
+ * internal state of XLogReadRecord
+ *
+ * XLogReadState runs a state machine while reading a record. Theses states
+ * are not seen outside the function. Each state may repeat several times
+ * exiting requesting caller for new data. See the comment of XLogReadRecrod
+ * for details.
+ */
+typedef enum XLogReadRecordState {
+    XLREAD_NEXT_RECORD,
+    XLREAD_TOT_LEN,
+    XLREAD_FIRST_FRAGMENT,
+    XLREAD_CONTINUATION
+} XLogReadRecordState;
+
 struct XLogReaderState
 {
     /* ----------------------------------------
@@ -92,45 +108,19 @@ struct XLogReaderState
      * ----------------------------------------
      */
 
-    /*
-     * Data input callback (mandatory).
-     *
-     * This callback shall read at least reqLen valid bytes of the xlog page
-     * starting at targetPagePtr, and store them in readBuf.  The callback
-     * shall return the number of bytes read (never more than XLOG_BLCKSZ), or
-     * -1 on failure.  The callback shall sleep, if necessary, to wait for the
-     * requested bytes to become available.  The callback will not be invoked
-     * again for the same page unless more than the returned number of bytes
-     * are needed.
-     *
-     * targetRecPtr is the position of the WAL record we're reading.  Usually
-     * it is equal to targetPagePtr + reqLen, but sometimes xlogreader needs
-     * to read and verify the page or segment header, before it reads the
-     * actual WAL record it's interested in.  In that case, targetRecPtr can
-     * be used to determine which timeline to read the page from.
-     *
-     * The callback shall set ->seg.ws_tli to the TLI of the file the page was
-     * read from.
-     */
-    XLogPageReadCB read_page;
-
     /*
      * System identifier of the xlog files we're about to read.  Set to zero
      * (the default value) if unknown or unimportant.
      */
     uint64        system_identifier;
 
-    /*
-     * Opaque data for callbacks to use.  Not used by XLogReader.
-     */
-    void       *private_data;
-
     /*
      * Start and end point of last record read.  EndRecPtr is also used as the
      * position to read next, if XLogReadRecord receives an invalid recptr.
      */
-    XLogRecPtr    ReadRecPtr;        /* start of last record read */
+    XLogRecPtr    ReadRecPtr;        /* start of last record read or being read */
     XLogRecPtr    EndRecPtr;        /* end+1 of last record read */
+    XLogRecPtr    PrevRecPtr;        /* start of previous record read */
 
     /* ----------------------------------------
      * Communication with page reader
@@ -144,7 +134,9 @@ struct XLogReaderState
                                  * the request, or -1 on error */
     TimeLineID    readPageTLI;    /* TLI for data currently in readBuf */
     char       *readBuf;        /* buffer to store data */
-    bool        page_verified;  /* is the page on the buffer verified? */
+    bool        page_verified;  /* is the page header on the buffer verified? */
+    bool        record_verified;/* is the current record header verified? */
+
 
 
     /* ----------------------------------------
@@ -183,8 +175,6 @@ struct XLogReaderState
     XLogRecPtr    latestPagePtr;
     TimeLineID    latestPageTLI;
 
-    /* beginning of the WAL record being read. */
-    XLogRecPtr    currRecPtr;
     /* timeline to read it from, 0 if a lookup is required */
     TimeLineID    currTLI;
 
@@ -211,15 +201,22 @@ struct XLogReaderState
     char       *readRecordBuf;
     uint32        readRecordBufSize;
 
+    /*
+     * XLogReadRecord() state
+     */
+    XLogReadRecordState    readRecordState;/* state machine state */
+    int            recordGotLen;        /* amount of current record that has
+                                     * already been read */
+    int            recordRemainLen;    /* length of current record that remains */
+    XLogRecPtr    recordContRecPtr;    /* where the current record continues */
+
     /* Buffer to hold error message */
     char       *errormsg_buf;
 };
 
 /* Get a new XLogReader */
 extern XLogReaderState *XLogReaderAllocate(int wal_segment_size,
-                                           const char *waldir,
-                                           XLogPageReadCB pagereadfunc,
-                                           void *private_data);
+                                           const char *waldir);
 
 /* Free an XLogReader */
 extern void XLogReaderFree(XLogReaderState *state);
@@ -229,15 +226,21 @@ extern void WALOpenSegmentInit(WALOpenSegment *seg, WALSegmentContext *segcxt,
                                int segsize, const char *waldir);
 
 /* Read the next XLog record. Returns NULL on end-of-WAL or failure */
-extern struct XLogRecord *XLogReadRecord(XLogReaderState *state,
-                                         XLogRecPtr recptr, char **errormsg);
+extern XLogReadRecordResult XLogReadRecord(XLogReaderState *state,
+                                           XLogRecPtr recptr,
+                                           XLogRecord **record,
+                                           char **errormsg);
 
 /* Validate a page */
 extern bool XLogReaderValidatePageHeader(XLogReaderState *state,
                                          XLogRecPtr recptr, char *phdr);
 
 #ifdef FRONTEND
-extern XLogRecPtr XLogFindNextRecord(XLogReaderState *state, XLogRecPtr RecPtr);
+/* Function type definition for the read_page callback */
+typedef bool (*XLogFindNextRecordCB) (XLogReaderState *xlogreader,
+                                      void *private);
+extern XLogRecPtr XLogFindNextRecord(XLogReaderState *state, XLogRecPtr RecPtr,
+                                     XLogFindNextRecordCB read_page, void *private);
 #endif                            /* FRONTEND */
 /* Functions for decoding an XLogRecord */
 
diff --git a/src/include/access/xlogutils.h b/src/include/access/xlogutils.h
index 47b65463f9..55a9b6237a 100644
--- a/src/include/access/xlogutils.h
+++ b/src/include/access/xlogutils.h
@@ -47,9 +47,7 @@ extern Buffer XLogReadBufferExtended(RelFileNode rnode, ForkNumber forknum,
 extern Relation CreateFakeRelcacheEntry(RelFileNode rnode);
 extern void FreeFakeRelcacheEntry(Relation fakerel);
 
-extern bool    read_local_xlog_page(XLogReaderState *state,
-                                 XLogRecPtr targetPagePtr, int reqLen,
-                                 XLogRecPtr targetRecPtr, char *cur_page);
+extern bool read_local_xlog_page(XLogReaderState *state);
 
 extern void XLogReadDetermineTimeline(XLogReaderState *state,
                                       XLogRecPtr wantPage, uint32 wantLength);
diff --git a/src/include/replication/logical.h b/src/include/replication/logical.h
index 31c796b765..482d3d311c 100644
--- a/src/include/replication/logical.h
+++ b/src/include/replication/logical.h
@@ -30,6 +30,10 @@ typedef void (*LogicalOutputPluginWriterUpdateProgress) (struct LogicalDecodingC
                                                          TransactionId xid
 );
 
+typedef struct LogicalDecodingContext LogicalDecodingContext;
+
+typedef bool (*LogicalDecodingXLogReadPageCB)(LogicalDecodingContext *ctx);
+
 typedef struct LogicalDecodingContext
 {
     /* memory context this is all allocated in */
@@ -40,6 +44,7 @@ typedef struct LogicalDecodingContext
 
     /* infrastructure pieces for decoding */
     XLogReaderState *reader;
+    LogicalDecodingXLogReadPageCB read_page;
     struct ReorderBuffer *reorder;
     struct SnapBuild *snapshot_builder;
 
@@ -96,14 +101,14 @@ extern LogicalDecodingContext *CreateInitDecodingContext(char *plugin,
                                                          List *output_plugin_options,
                                                          bool need_full_snapshot,
                                                          XLogRecPtr restart_lsn,
-                                                         XLogPageReadCB read_page,
+                                                         LogicalDecodingXLogReadPageCB read_page,
                                                          LogicalOutputPluginWriterPrepareWrite prepare_write,
                                                          LogicalOutputPluginWriterWrite do_write,
                                                          LogicalOutputPluginWriterUpdateProgress update_progress);
 extern LogicalDecodingContext *CreateDecodingContext(XLogRecPtr start_lsn,
                                                      List *output_plugin_options,
                                                      bool fast_forward,
-                                                     XLogPageReadCB read_page,
+                                                     LogicalDecodingXLogReadPageCB read_page,
                                                      LogicalOutputPluginWriterPrepareWrite prepare_write,
                                                      LogicalOutputPluginWriterWrite do_write,
                                                      LogicalOutputPluginWriterUpdateProgress update_progress);
diff --git a/src/include/replication/logicalfuncs.h b/src/include/replication/logicalfuncs.h
index 54291221c3..25fa68d5b9 100644
--- a/src/include/replication/logicalfuncs.h
+++ b/src/include/replication/logicalfuncs.h
@@ -11,9 +11,6 @@
 
 #include "replication/logical.h"
 
-extern bool    logical_read_local_xlog_page(XLogReaderState *state,
-                                         XLogRecPtr targetPagePtr,
-                                         int reqLen, XLogRecPtr targetRecPtr,
-                                         char *cur_page);
+extern bool logical_read_local_xlog_page(LogicalDecodingContext *ctx);
 
 #endif
-- 
2.16.3

From 8a933e3991ab98bc4497a9ecd77c9d262fd66cb0 Mon Sep 17 00:00:00 2001
From: Kyotaro Horiguchi <horiguchi.kyotaro@lab.ntt.co.jp>
Date: Tue, 10 Sep 2019 17:28:48 +0900
Subject: [PATCH v7 3/4] Remove globals readSegNo, readOff, readLen

These global variables is functionally duplicated with them in
XLogReaderState. Remove the globals.
---
 src/backend/access/transam/xlog.c | 77 ++++++++++++++++++---------------------
 src/include/access/xlogreader.h   |  1 +
 2 files changed, 36 insertions(+), 42 deletions(-)

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index b06e381d73..49e8ca486e 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -783,14 +783,10 @@ static XLogSegNo openLogSegNo = 0;
  * These variables are used similarly to the ones above, but for reading
  * the XLOG.  Note, however, that readOff generally represents the offset
  * of the page just read, not the seek position of the FD itself, which
- * will be just past that page. readLen indicates how much of the current
- * page has been read into readBuf, and readSource indicates where we got
- * the currently open file from.
+ * will be just past that page. readSource indicates where we got the
+ * currently open file from.
  */
 static int    readFile = -1;
-static XLogSegNo readSegNo = 0;
-static uint32 readOff = 0;
-static uint32 readLen = 0;
 static XLogSource readSource = 0;    /* XLOG_FROM_* code */
 
 /*
@@ -877,10 +873,12 @@ static bool InstallXLogFileSegment(XLogSegNo *segno, char *tmppath,
 static int    XLogFileRead(XLogSegNo segno, int emode, TimeLineID tli,
                          int source, bool notfoundOk);
 static int    XLogFileReadAnyTLI(XLogSegNo segno, int emode, int source);
-static bool XLogPageRead(XLogReaderState *xlogreader,
+static bool XLogPageRead(XLogReaderState *state,
                          bool fetching_ckpt, int emode, bool randAccess);
 static bool WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
-                                        bool fetching_ckpt, XLogRecPtr tliRecPtr);
+                                        bool fetching_ckpt,
+                                        XLogRecPtr tliRecPtr,
+                                        XLogSegNo readSegNo);
 static int    emode_for_corrupt_record(int emode, XLogRecPtr RecPtr);
 static void XLogFileClose(void);
 static void PreallocXlogFiles(XLogRecPtr endptr);
@@ -7494,7 +7492,8 @@ StartupXLOG(void)
         XLogRecPtr    pageBeginPtr;
 
         pageBeginPtr = EndOfLog - (EndOfLog % XLOG_BLCKSZ);
-        Assert(readOff == XLogSegmentOffset(pageBeginPtr, wal_segment_size));
+        Assert(XLogSegmentOffset(xlogreader->readPagePtr, wal_segment_size) ==
+               XLogSegmentOffset(pageBeginPtr, wal_segment_size));
 
         firstIdx = XLogRecPtrToBufIdx(EndOfLog);
 
@@ -11514,13 +11513,14 @@ CancelBackup(void)
  * sleep and retry.
  */
 static bool
-XLogPageRead(XLogReaderState *xlogreader,
+XLogPageRead(XLogReaderState *state,
              bool fetching_ckpt, int emode, bool randAccess)
 {
-    char *readBuf                = xlogreader->readBuf;
-    XLogRecPtr targetPagePtr    = xlogreader->readPagePtr;
-    int reqLen                    = xlogreader->readLen;
-    XLogRecPtr targetRecPtr        = xlogreader->ReadRecPtr;
+    char *readBuf                = state->readBuf;
+    XLogRecPtr    targetPagePtr    = state->readPagePtr;
+    int            reqLen            = state->readLen;
+    int            readLen            = 0;
+    XLogRecPtr    targetRecPtr    = state->ReadRecPtr;
     uint32        targetPageOff;
     XLogSegNo    targetSegNo PG_USED_FOR_ASSERTS_ONLY;
     int            r;
@@ -11533,7 +11533,7 @@ XLogPageRead(XLogReaderState *xlogreader,
      * is not in the currently open one.
      */
     if (readFile >= 0 &&
-        !XLByteInSeg(targetPagePtr, readSegNo, wal_segment_size))
+        !XLByteInSeg(targetPagePtr, state->readSegNo, wal_segment_size))
     {
         /*
          * Request a restartpoint if we've replayed too much xlog since the
@@ -11541,10 +11541,10 @@ XLogPageRead(XLogReaderState *xlogreader,
          */
         if (bgwriterLaunched)
         {
-            if (XLogCheckpointNeeded(readSegNo))
+            if (XLogCheckpointNeeded(state->readSegNo))
             {
                 (void) GetRedoRecPtr();
-                if (XLogCheckpointNeeded(readSegNo))
+                if (XLogCheckpointNeeded(state->readSegNo))
                     RequestCheckpoint(CHECKPOINT_CAUSE_XLOG);
             }
         }
@@ -11554,7 +11554,7 @@ XLogPageRead(XLogReaderState *xlogreader,
         readSource = 0;
     }
 
-    XLByteToSeg(targetPagePtr, readSegNo, wal_segment_size);
+    XLByteToSeg(targetPagePtr, state->readSegNo, wal_segment_size);
 
 retry:
     /* See if we need to retrieve more data */
@@ -11563,17 +11563,14 @@ retry:
          receivedUpto < targetPagePtr + reqLen))
     {
         if (!WaitForWALToBecomeAvailable(targetPagePtr + reqLen,
-                                         randAccess,
-                                         fetching_ckpt,
-                                         targetRecPtr))
+                                         randAccess, fetching_ckpt,
+                                         targetRecPtr, state->readSegNo))
         {
             if (readFile >= 0)
                 close(readFile);
             readFile = -1;
-            readLen = 0;
             readSource = 0;
-
-            xlogreader->readLen = -1;
+            state->readLen = -1;
             return false;
         }
     }
@@ -11601,40 +11598,36 @@ retry:
     else
         readLen = XLOG_BLCKSZ;
 
-    /* Read the requested page */
-    readOff = targetPageOff;
-
     pgstat_report_wait_start(WAIT_EVENT_WAL_READ);
-    r = pg_pread(readFile, readBuf, XLOG_BLCKSZ, (off_t) readOff);
+    r = pg_pread(readFile, readBuf, XLOG_BLCKSZ, (off_t) targetPageOff);
     if (r != XLOG_BLCKSZ)
     {
         char        fname[MAXFNAMELEN];
         int            save_errno = errno;
 
         pgstat_report_wait_end();
-        XLogFileName(fname, curFileTLI, readSegNo, wal_segment_size);
+        XLogFileName(fname, curFileTLI, state->readSegNo, wal_segment_size);
         if (r < 0)
         {
             errno = save_errno;
             ereport(emode_for_corrupt_record(emode, targetPagePtr + reqLen),
                     (errcode_for_file_access(),
                      errmsg("could not read from log segment %s, offset %u: %m",
-                            fname, readOff)));
+                            fname, targetPageOff)));
         }
         else
             ereport(emode_for_corrupt_record(emode, targetPagePtr + reqLen),
                     (errcode(ERRCODE_DATA_CORRUPTED),
                      errmsg("could not read from log segment %s, offset %u: read %d of %zu",
-                            fname, readOff, r, (Size) XLOG_BLCKSZ)));
+                            fname, targetPageOff, r, (Size) XLOG_BLCKSZ)));
         goto next_record_is_invalid;
     }
     pgstat_report_wait_end();
 
-    Assert(targetSegNo == readSegNo);
-    Assert(targetPageOff == readOff);
+    Assert(targetSegNo == state->readSegNo);
     Assert(reqLen <= readLen);
 
-    xlogreader->seg.ws_tli = curFileTLI;
+    state->seg.ws_tli = curFileTLI;
 
     /*
      * Check the page header immediately, so that we can retry immediately if
@@ -11662,15 +11655,15 @@ retry:
      * Validating the page header is cheap enough that doing it twice
      * shouldn't be a big deal from a performance point of view.
      */
-    if (!XLogReaderValidatePageHeader(xlogreader, targetPagePtr, readBuf))
+    if (!XLogReaderValidatePageHeader(state, targetPagePtr, readBuf))
     {
-        /* reset any error XLogReaderValidatePageHeader() might have set */
-        xlogreader->errormsg_buf[0] = '\0';
+        /* reset any error StateValidatePageHeader() might have set */
+        state->errormsg_buf[0] = '\0';
         goto next_record_is_invalid;
     }
 
-    Assert(xlogreader->readPagePtr == targetPagePtr);
-    xlogreader->readLen = readLen;
+    Assert(state->readPagePtr == targetPagePtr);
+    state->readLen = readLen;
     return true;
 
 next_record_is_invalid:
@@ -11679,14 +11672,13 @@ next_record_is_invalid:
     if (readFile >= 0)
         close(readFile);
     readFile = -1;
-    readLen = 0;
     readSource = 0;
 
     /* In standby-mode, keep trying */
     if (StandbyMode)
         goto retry;
 
-    xlogreader->readLen = -1;
+    state->readLen = -1;
     return false;
 }
 
@@ -11718,7 +11710,8 @@ next_record_is_invalid:
  */
 static bool
 WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
-                            bool fetching_ckpt, XLogRecPtr tliRecPtr)
+                            bool fetching_ckpt, XLogRecPtr tliRecPtr,
+                            XLogSegNo readSegNo)
 {
     static TimestampTz last_fail_time = 0;
     TimestampTz now;
diff --git a/src/include/access/xlogreader.h b/src/include/access/xlogreader.h
index 8e39b5c1f6..dc84d39f60 100644
--- a/src/include/access/xlogreader.h
+++ b/src/include/access/xlogreader.h
@@ -133,6 +133,7 @@ struct XLogReaderState
                                  * read by reader, which must be larger than
                                  * the request, or -1 on error */
     TimeLineID    readPageTLI;    /* TLI for data currently in readBuf */
+    XLogSegNo    readSegNo;        /* Segment # for data currently in readBuf */
     char       *readBuf;        /* buffer to store data */
     bool        page_verified;  /* is the page header on the buffer verified? */
     bool        record_verified;/* is the current record header verified? */
-- 
2.16.3

From c5dbdb0f633f5e4b03e3c18d285c91fc106ace9c Mon Sep 17 00:00:00 2001
From: Kyotaro Horiguchi <horiguchi.kyotaro@lab.ntt.co.jp>
Date: Thu, 5 Sep 2019 21:29:32 +0900
Subject: [PATCH v7 4/4] Change policy of XLog read-buffer allocation

Page buffer in XLogReaderState was allocated by XLogReaderAllcoate but
actually it'd be the responsibility to the callers of XLogReadRecord,
which now actually reads in pages. This patch does that.
---
 src/backend/access/transam/twophase.c     | 2 ++
 src/backend/access/transam/xlog.c         | 2 ++
 src/backend/access/transam/xlogreader.c   | 3 ---
 src/backend/replication/logical/logical.c | 2 ++
 src/bin/pg_rewind/parsexlog.c             | 6 ++++++
 src/bin/pg_waldump/pg_waldump.c           | 2 ++
 6 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c
index ced11bbdae..9e80a2cdb1 100644
--- a/src/backend/access/transam/twophase.c
+++ b/src/backend/access/transam/twophase.c
@@ -1391,6 +1391,7 @@ XlogReadTwoPhaseData(XLogRecPtr lsn, char **buf, int *len)
                 (errcode(ERRCODE_OUT_OF_MEMORY),
                  errmsg("out of memory"),
                  errdetail("Failed while allocating a WAL reading processor.")));
+    xlogreader->readBuf = palloc(XLOG_BLCKSZ);
 
     while (XLogReadRecord(xlogreader, lsn, &record, &errormsg) ==
            XLREAD_NEED_DATA)
@@ -1420,6 +1421,7 @@ XlogReadTwoPhaseData(XLogRecPtr lsn, char **buf, int *len)
     *buf = palloc(sizeof(char) * XLogRecGetDataLen(xlogreader));
     memcpy(*buf, XLogRecGetData(xlogreader), sizeof(char) * XLogRecGetDataLen(xlogreader));
 
+    pfree(xlogreader->readBuf);
     XLogReaderFree(xlogreader);
 }
 
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 49e8ca486e..4cbb6de1bb 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -6349,6 +6349,7 @@ StartupXLOG(void)
                 (errcode(ERRCODE_OUT_OF_MEMORY),
                  errmsg("out of memory"),
                  errdetail("Failed while allocating a WAL reading processor.")));
+    xlogreader->readBuf = palloc(XLOG_BLCKSZ);
     xlogreader->system_identifier = ControlFile->system_identifier;
 
     /*
@@ -7721,6 +7722,7 @@ StartupXLOG(void)
         close(readFile);
         readFile = -1;
     }
+    pfree(xlogreader->readBuf);
     XLogReaderFree(xlogreader);
 
     /*
diff --git a/src/backend/access/transam/xlogreader.c b/src/backend/access/transam/xlogreader.c
index 9932ba3882..b8ad4ffcd7 100644
--- a/src/backend/access/transam/xlogreader.c
+++ b/src/backend/access/transam/xlogreader.c
@@ -105,7 +105,6 @@ XLogReaderAllocate(int wal_segment_size, const char *waldir)
                                           MCXT_ALLOC_NO_OOM);
     if (!state->errormsg_buf)
     {
-        pfree(state->readBuf);
         pfree(state);
         return NULL;
     }
@@ -118,7 +117,6 @@ XLogReaderAllocate(int wal_segment_size, const char *waldir)
     if (!allocate_recordbuf(state, 0))
     {
         pfree(state->errormsg_buf);
-        pfree(state->readBuf);
         pfree(state);
         return NULL;
     }
@@ -142,7 +140,6 @@ XLogReaderFree(XLogReaderState *state)
     pfree(state->errormsg_buf);
     if (state->readRecordBuf)
         pfree(state->readRecordBuf);
-    pfree(state->readBuf);
     pfree(state);
 }
 
diff --git a/src/backend/replication/logical/logical.c b/src/backend/replication/logical/logical.c
index db3e8f9dc0..99cb9bcc54 100644
--- a/src/backend/replication/logical/logical.c
+++ b/src/backend/replication/logical/logical.c
@@ -178,6 +178,7 @@ StartupDecodingContext(List *output_plugin_options,
         ereport(ERROR,
                 (errcode(ERRCODE_OUT_OF_MEMORY),
                  errmsg("out of memory")));
+    ctx->reader->readBuf = palloc(XLOG_BLCKSZ);
     ctx->read_page = read_page;
 
     ctx->reorder = ReorderBufferAllocate();
@@ -523,6 +524,7 @@ FreeDecodingContext(LogicalDecodingContext *ctx)
 
     ReorderBufferFree(ctx->reorder);
     FreeSnapshotBuilder(ctx->snapshot_builder);
+    pfree(ctx->reader->readBuf);
     XLogReaderFree(ctx->reader);
     MemoryContextDelete(ctx->context);
 }
diff --git a/src/bin/pg_rewind/parsexlog.c b/src/bin/pg_rewind/parsexlog.c
index c5e5d75a87..d0e408c0a8 100644
--- a/src/bin/pg_rewind/parsexlog.c
+++ b/src/bin/pg_rewind/parsexlog.c
@@ -60,6 +60,7 @@ extractPageMap(const char *datadir, XLogRecPtr startpoint, int tliIndex,
     xlogreader = XLogReaderAllocate(WalSegSz, datadir);
     if (xlogreader == NULL)
         pg_fatal("out of memory");
+    xlogreader->readBuf = pg_malloc(XLOG_BLCKSZ);
 
     do
     {
@@ -92,6 +93,7 @@ extractPageMap(const char *datadir, XLogRecPtr startpoint, int tliIndex,
 
     } while (xlogreader->ReadRecPtr != endpoint);
 
+    pg_free(xlogreader->readBuf);
     XLogReaderFree(xlogreader);
     if (xlogreadfd != -1)
     {
@@ -115,6 +117,7 @@ readOneRecord(const char *datadir, XLogRecPtr ptr, int tliIndex)
     xlogreader = XLogReaderAllocate(WalSegSz, datadir);
     if (xlogreader == NULL)
         pg_fatal("out of memory");
+    xlogreader->readBuf = pg_malloc(XLOG_BLCKSZ);
 
     while (XLogReadRecord(xlogreader, ptr, &record, &errormsg) ==
            XLREAD_NEED_DATA)
@@ -133,6 +136,7 @@ readOneRecord(const char *datadir, XLogRecPtr ptr, int tliIndex)
     }
     endptr = xlogreader->EndRecPtr;
 
+    pg_free(xlogreader->readBuf);
     XLogReaderFree(xlogreader);
     if (xlogreadfd != -1)
     {
@@ -174,6 +178,7 @@ findLastCheckpoint(const char *datadir, XLogRecPtr forkptr, int tliIndex,
     xlogreader = XLogReaderAllocate(WalSegSz, datadir);
     if (xlogreader == NULL)
         pg_fatal("out of memory");
+    xlogreader->readBuf = pg_malloc(XLOG_BLCKSZ);
 
     searchptr = forkptr;
     for (;;)
@@ -222,6 +227,7 @@ findLastCheckpoint(const char *datadir, XLogRecPtr forkptr, int tliIndex,
         searchptr = record->xl_prev;
     }
 
+    pg_free(xlogreader->readBuf);
     XLogReaderFree(xlogreader);
     if (xlogreadfd != -1)
     {
diff --git a/src/bin/pg_waldump/pg_waldump.c b/src/bin/pg_waldump/pg_waldump.c
index ee49712830..e17e66e688 100644
--- a/src/bin/pg_waldump/pg_waldump.c
+++ b/src/bin/pg_waldump/pg_waldump.c
@@ -1094,6 +1094,7 @@ main(int argc, char **argv)
     xlogreader_state = XLogReaderAllocate(WalSegSz, waldir);
     if (!xlogreader_state)
         fatal_error("out of memory");
+    xlogreader_state->readBuf = palloc(XLOG_BLCKSZ);
 
     /* first find a valid recptr to start from */
     first_record = XLogFindNextRecord(xlogreader_state, private.startptr,
@@ -1174,6 +1175,7 @@ main(int argc, char **argv)
                     (uint32) xlogreader_state->ReadRecPtr,
                     errormsg);
 
+    pfree(xlogreader_state->readBuf);
     XLogReaderFree(xlogreader_state);
 
     return EXIT_SUCCESS;
-- 
2.16.3


pgsql-hackers by date:

Previous
From: Amit Langote
Date:
Subject: Re: Fix example in partitioning documentation
Next
From: Michael Paquier
Date:
Subject: Re: PostgreSQL12 and older versions of OpenSSL