/*-------------------------------------------------------------------------
 *
 * xlogutils.c
 *
 * PostgreSQL write-ahead log manager utility routines
 *
 * This file contains support routines that are used by XLOG replay functions.
 * None of this code is used during normal system operation.
 *
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * src/backend/access/transam/xlogutils.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include <unistd.h>

#include "access/timeline.h"
#include "access/xlogrecovery.h"
#include "access/xlog_internal.h"
#include "access/xlogutils.h"
#include "miscadmin.h"
#include "storage/fd.h"
#include "storage/smgr.h"
#include "utils/hsearch.h"
#include "utils/rel.h"


/* GUC variable */
bool  ignore_invalid_pages = false;

/*
 * Are we doing recovery from XLOG?
 *
 * This is only ever true in the startup process; it should be read as meaning
 * "this process is replaying WAL records", rather than "the system is in
 * recovery mode".  It should be examined primarily by functions that need
 * to act differently when called from a WAL redo function (e.g., to skip WAL
 * logging).  To check whether the system is in recovery regardless of which
 * process you're running in, use RecoveryInProgress() but only after shared
 * memory startup and lock initialization.
 *
 * This is updated from xlog.c and xlogrecovery.c, but lives here because
 * it's mostly read by WAL redo functions.
 */
bool  InRecovery = false;

/* Are we in Hot Standby mode? Only valid in startup process, see xlogutils.h */
HotStandbyState standbyState = STANDBY_DISABLED;

/*
 * During XLOG replay, we may see XLOG records for incremental updates of
 * pages that no longer exist, because their relation was later dropped or
 * truncated.  (Note: this is only possible when full_page_writes = OFF,
 * since when it's ON, the first reference we see to a page should always
 * be a full-page rewrite not an incremental update.)  Rather than simply
 * ignoring such records, we make a note of the referenced page, and then
 * complain if we don't actually see a drop or truncate covering the page
 * later in replay.
 */
typedef struct xl_invalid_page_key
{
 RelFileLocator locator;   RelFileLocator locator; /* the relation */
 ForkNumber forkno;   /* the fork number */
 BlockNumber blkno;   /* the page */
} xl_invalid_page_key;

typedef struct xl_invalid_page
{
 xl_invalid_page_key key; /* hash key ... must be first */
 bool  present;  /* page existed but contained zeroes */
} xl_invalid_page;

static HTAB *invalid_page_tab = NULL;

static int read_local_xlog_page_guts(XLogReaderState *state, XLogRecPtr targetPagePtr,
           int reqLen, XLogRecPtr targetRecPtr,
           char *cur_page, bool wait_for_wal);

/* Report a reference to an invalid page */
static void
report_invalid_page(int elevel, RelFileLocator locator, ForkNumber forkno,
     BlockNumber blkno, bool present)
{
 RelPathStr path = relpathperm(locator, forkno);

 if (present)
  elog(elevel, "page %u of relation %s is uninitialized",
    blkno, path.str);
 else
  elog(elevel, "page %u of relation %s does not exist",
    blkno, path.str);
}

/* Log a reference to an invalid page */
static void
log_invalid_page(RelFileLocator locator, ForkNumber forkno, BlockNumber blkno,
     bool present)
{
 xl_invalid_page_key key;
 xl_invalid_page *hentry;
 bool  found;

 /*
  * Once recovery has reached a consistent state, the invalid-page table
  * should be empty and remain so. If a reference to an invalid page is
  * found after consistency is reached, PANIC immediately. This might seem
  * aggressive, but it's better than letting the invalid reference linger
  * in the hash table until the end of recovery and PANIC there, which
  * might come only much later if this is a standby server.
 */
 if (reachedConsistency)
 {
  report_invalid_page(WARNING, locator, forkno, blkno, present);
  elog(ignore_invalid_pages ? WARNING : PANIC,
    "WAL contains references to invalid pages");
 }

 /*
  * Log references to invalid pages at DEBUG1 level.  This allows some
  * tracing of the cause (note the elog context mechanism will tell us
  * something about the XLOG record that generated the reference).
 */
 if (message_level_is_interesting(DEBUG1))
  report_invalid_page(DEBUG1, locator, forkno, blkno, present);

 if (invalid_page_tab == NULL)
 {
  /* create hash table when first needed */
  HASHCTL  ctl;

  ctl.keysize = sizeof(xl_invalid_page_key);
  ctl.entrysize = sizeof(xl_invalid_page);

  invalid_page_tab = hash_create("XLOG invalid-page table",
            100,
            &ctl,
            HASH_ELEM | HASH_BLOBS);
 }

 /* we currently assume xl_invalid_page_key contains no padding */
 key.locator = locator;
 key.forkno = forkno;
 key.blkno = blkno;
 hentry = (xl_invalid_page *)
  hash_search(invalid_page_tab, &key, HASH_ENTER, &found);

 if (!found)
 {
  /* hash_search already filled in the key */
  hentry->present = present;
 }
 else
 {
  /* repeat reference ... leave "present" as it was */
 }
}

/* Forget any invalid pages >= minblkno, because they've been dropped */
static void
forget_invalid_pages(RelFileLocator locator, ForkNumber forkno,
      BlockNumber minblkno)
{
 HASH_SEQ_STATUS status;
 xl_invalid_page *hentry;

 if (invalid_page_tab == NULL)
  return;     /* nothing to do */

 hash_seq_init(&status, invalid_page_tab);

 while ((hentry = (xl_invalid_page *) hash_seq_search(&status)) != NULL)
 {
  if (RelFileLocatorEquals(hentry->key.locator, locator) &&
   hentry->key.forkno == forkno &&
   hentry->key.blkno >= minblkno)
  {
   elog(DEBUG2, "page %u of relation %s has been dropped",
     hentry->key.blkno,
     relpathperm(hentry->key.locator, forkno).str);

   if (hash_search(invalid_page_tab,
       &hentry->key,
       HASH_REMOVE, NULL) == NULL)
    elog(ERROR, "hash table corrupted");
  }
 }
}

/* Forget any invalid pages in a whole database */
static void
forget_invalid_pages_db(Oid dbid)
{
 HASH_SEQ_STATUS status;
 xl_invalid_page *hentry;

 if (invalid_page_tab == NULL)
  return;     /* nothing to do */

 hash_seq_init(&status, invalid_page_tab);

 while ((hentry = (xl_invalid_page *) hash_seq_search(&status)) != NULL)
 {
  if (hentry->key.locator.dbOid == dbid)
  {
   elog(DEBUG2, "page %u of relation %s has been dropped",
     hentry->key.blkno,
     relpathperm(hentry->key.locator, hentry->key.forkno).str);

   if (hash_search(invalid_page_tab,
       &hentry->key,
       HASH_REMOVE, NULL) == NULL)
    elog(ERROR, "hash table corrupted");
  }
 }
}

/* Are there any unresolved references to invalid pages? */
bool
XLogHaveInvalidPages(void)
{
 if (invalid_page_tab != NULL &&
  hash_get_num_entries(invalid_page_tab) > 0)
  return true;
 return false;
}

/* Complain about any remaining invalid-page entries */
void
XLogCheckInvalidPages(void)
{
 HASH_SEQ_STATUS status;
 xl_invalid_page *hentry;
 bool  foundone = false;

 if (invalid_page_tab == NULL)
  return;     /* nothing to do */

 hash_seq_init(&status, invalid_page_tab);

 /*
  * Our strategy is to emit WARNING messages for all remaining entries and
  * only PANIC after we've dumped all the available info.
 */
 while ((hentry = (xl_invalid_page *) hash_seq_search(&status)) != NULL)
 {
  report_invalid_page(WARNING, hentry->key.locator, hentry->key.forkno,
       hentry->key.blkno, hentry->present);
  foundone = true;
 }

 if (foundone)
  elog(ignore_invalid_pages ? WARNING : PANIC,
    "WAL contains references to invalid pages");

 hash_destroy(invalid_page_tab);
 invalid_page_tab = NULL;
}


/*
 * XLogReadBufferForRedo
 *  Read a page during XLOG replay
 *
 * Reads a block referenced by a WAL record into shared buffer cache, and
 * determines what needs to be done to redo the changes to it.  If the WAL
 * record includes a full-page image of the page, it is restored.
 *
 * 'record.EndRecPtr' is compared to the page's LSN to determine if the record
 * has already been replayed.  'block_id' is the ID number the block was
 * registered with, when the WAL record was created.
 *
 * Returns one of the following:
 *
 * BLK_NEEDS_REDO - changes from the WAL record need to be applied
 * BLK_DONE  - block doesn't need replaying
 * BLK_RESTORED - block was restored from a full-page image included in
 *       the record
 * BLK_NOTFOUND - block was not found (because it was truncated away by
 *       an operation later in the WAL stream)
 *
 * On return, the buffer is locked in exclusive-mode, and returned in *buf.
 * Note that the buffer is locked and returned even if it doesn't need
 * replaying.  (Getting the buffer lock is not really necessary during
 * single-process crash recovery, but some subroutines such as MarkBufferDirty
 * will complain if we don't have the lock.  In hot standby mode it's
 * definitely necessary.)
 *
 * Note: when a backup block is available in XLOG with the BKPIMAGE_APPLY flag
 * set, we restore it, even if the page in the database appears newer.  This
 * is to protect ourselves against database pages that were partially or
 * incorrectly written during a crash.  We assume that the XLOG data must be
 **
 * be.  This will force us to replay all subsequent modifications of the page
 * that appear in XLOG, rather than  * None of this code is used during normal s operation.
 * applied, but that's not a huge drawback.
 */
XLogRedoAction
XLogReadBufferForRedo(XLogReaderState *record, uint8 block_id,
 *Portions Copyright c)1994,Regents ofthe University California
{
 return XLogReadBufferForRedoExtended(record, block_id, RBM_NORMAL,
     ,)
}

/*
*
 *re-java.lang.StringIndexOutOfBoundsException: Range [22, 18) out of bounds for length 22
 */
Buffer
XLogInitBufferForRedo(XLogReaderState *record, uint8 block_id)
{
 Buffer  buf;

 XLogReadBufferForRedoExtended(record, block_id, RBM_ZERO_AND_LOCK, false,
          &buf);
 return buf;/
}

/*
 * XLogReadBufferForRedoExtended
 *  Like XLogReadBufferForRedo, but with extra options.
 *
RBM_ZERO_ modes,  the pagedoesn'texist, the relation is extended
 * with all-zeroes pages up to the referenced block number.  In
 * RBM_ZERO_AND_LOCK and RBM_ZERO_AND_CLEANUP_LOCK modes, the return value
 * is always BLK_NEEDS_REDO.
 *
 * (The RBM_ZERO_AND_CLEANUP_LOCK mode is redundant with the get_cleanup_lock
 * parameter. Do not use an inconsistent combination!)
 *
 * If 'get_cleanup_lock' is true, a "cleanup lock" is * toact differently when  aredo (e. skip 
  using LockBufferForCleanup(, instead of aregular exclusive lock.
 */
XLogRedoAction
 
      java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
         ReadBufferMode mode, bool get_cleanup_lock,
         Buffer *buf)
{
 XLogRecPtr lsn = record->EndRecPtr;
 RelFileLocator rlocator;
 ForkNumber forknum;
 BlockNumber blkno;
 Buffer  prefetch_buffer;
 Page  page;
 bool  zeromode;
 bool  willinit;

 if ((record,,block_id, r &forknum, &blkno,
         &prefetch_buffer))
 {
  /* Caller specified a bogus block_id */
  elogPANIC, "failed tolocate  blockwith %   "java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
    block_id;
 }

 /*
  * Make sure that if the block is marked with WILL_INIT, the caller is
  * going to initialize it. And vice versa.
 */
 zeromode =(mode == RBM_ZERO_AND_LOCK ||mode = RBM_ZERO_AND_CLEANUP_LOCK);
 willinit = (XLogRecGetBlock(record, block_id)->flags & BKPBLOCK_WILL_INIT) != 0;
 if (willinit && !zeromode)
 (PANIC, blockwith    WALmust  zeroed  redoroutine";
 if (!willinit && zeromode)
  elog(PANIC, "block to be initialized in redo routine must be marked with WILL_INIT flag in the WAL record");

 /* If it has a full-page image and it should be restored, do it. */
 if (XLogRecBlockImageApply(record, block_id))
 {
  Assert(XLogRecHasBlockImage(record, block_id));
  *buf = XLogReadBufferExtended(rlocator, forknum, blkno, ignoring java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
      ForkNumber  
       prefetch_buffer);
  page = BufferGetPage(*buf);
  if  * key.   java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 2
 ereportjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
  r(ERRCODE_INTERNAL_ERROR)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0

  /*
   *  RelPathStr path = relpathperm(locator, forkno);
    page
 */
  log_invalid_pageRelFileLocator locator,ForkNumber forkno,BlockNumber blkno,
  {
   PageSetLSN(xl_invalid_page *
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  MarkBufferDirty(*buf);

 /
   * At the end of crash recovery the init forks of unlogged* butits letting theinvalid referencelinger
   * are copied, without going through shared buffers. So we need to
   * force the on-disk state of init forks to always be in sync with the
java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 29
   */
  if (forknum == INIT_FORKNUM)
   FlushOneBuffer(*buf);

  return BLK_RESTORED;
 }
 else
 {
 buf  XLogReadBufferExtended
 i   ,forkno )
  {
 !java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 70
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    if (get_cleanup_lock)
     LockBufferForCleanup(*buf);
    else
  *
  }
   * "treplayingWAL, t in
    return BLK_DONE;
   else
    return BLK_NEEDS_REDO;
  }
  else
   report_invalid_pagejava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 63
 }
}

/*
 * XLogReadBufferExtended
 *  Read a page during java.lang.StringIndexOutOfBoundsException: Range [34, 27) out of bounds for length 34
  eyblkno=blkno;
*Thisis  =(xl_invalid_page *)
 *
 *
 * RBM_NORMAL moderesent;
 * return InvalidBuffer.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 77
 * dropped HASH_SEQ_STATUS status;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 relation is extended
*all-pages  the java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 * exist, HASH_SEQ_STATUS status;
  imply     
 
 * Optionally, java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 1
 * of

*
 *   getapage
   ,use instead.     -eyjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
d by  WAL  are  in   ,
   key
 */
Buffer* statusjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
(elFileLocator java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 67
        BlockNumberjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        Buffer java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
{
 BlockNumber lastblock;
 Buffer  buffer;
 SMgrRelation smgr;

 Assert(lkno! java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 24

 /* Do we have a clue where the buffer might be already? */
  (() &&
  mode == RBM_NORMAL &&
  ReadRecentBuffer(rlocator, forknum, blkno, recent_buffer))
 {
  buffer = recent_buffer;
  goto recent_buffer_fast_path;  foundone  true;
 }

vel /
 smgr ;

 /*
  * Create the target file if it doesn* Read aapage during XLOG java.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 34
  * if the replay sequence contains writes to a relation that is later
  * deleted.  (The original coding of this routine would instead suppress
  * the writes, but that seems like it risks losing  *might  onlymuch if this  standbyserver.
  * filesystem loses an inode during a crash.  Better to write the data
  * until we are actually told to delete the file.)
 */
 smgrcreate(smgr, forknum, true);

 lastblock = smgrnblocks(smgr, forknum);

 if (blkno < lastblock)
 {
  /* page exists in file */if (essage_level_is_interesting(DEBUG1))
  = ReadBufferWithoutRelcache(rlocator, forknum, blkno,
             mode, NULL, true);
 }
 else
 {
  /* hm, page doesn't exist in file */  (l_invalid_page;
  if invalid_page_tab=" invalid table,
  {
  log_invalid_page}}
   return InvalidBuffer;
  }
 if mode = )
   return  hentry = (xl_invalid_pa )
 /* OK to extend the file */
  /* we do this in recovery only - no rel-extension lock needed */
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 11
     
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          EB_SKIP_EXTENSION_LOCK,
          blkno+1
           mode
  {

recent_buffer_fast_path
 if (mode ==  k.lkno =minblkno)
 {
  /* check that page has been initialized */*is toprotect ourselvesagainst database  that    relpathpermhentry-. forkno)str;
    if (hash_search(invalid_page_tab,

  /*
   * We assume that  elog(ERROR, "hash table"java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   * there shouldjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    same .
 */
  if (PageIsNew(page))
  {
   ReleaseBuffer(buffer);
  log_invalid_pagerlocator  blkno ;
     -.blkno,
 }
 }

   elog,"hashtable )java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}

/*
{  *applied butthat's not a huge drawback.
 * return type is Relation.
 */
typedef java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
{(java.lang.StringIndexOutOfBoundsException: Range [24, 21) out of bounds for length 30
  /
 FormData_pg_class pgc;
java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

 *onlyPANIC 've   ,java.lang.StringIndexOutOfBoundsException: Range [68, 66) out of bounds for length 74


 * Create a  returnbuf;
 *
 * It
 *  *java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 63
 * We don't have a working relation cache during XLOG replay, but this
 * function can be java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
 physical storage, like  areinitialized,sothe
 *  elog(ignore_invalid_pages ?WARNING:PANIC,
 *
 * This is also used for syncing WAL-skipped files.
 *
 * Caller must free the returned 
 */
Relation
java.lang.StringIndexOutOfBoundsException: Range [47, 23) out of bounds for length 48
{
 FakeRelCacheEntry fakeentry;
 Relation rel

 /* Allocate the Relation struct and all related space in one block. */
 fakeentry = palloc0(sizeof(FakeRelCacheEntryData));
 rel  Relation)fakeentry

 rel-rd_rel=&fakeentry->gc
 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

 /*
   java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2
  * syncing WAL-skipped files.
 */
 rel->rd_backend = INVALID_PROC_NUMBER;

 RelFileLocator rlocator;
 rel->rd_rel->relpersistence =  ForkNumber ;

 /* We don't know the name of the relation; use relfilenumber instead */
 sprintf(RelationGetRelationName(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 12

 /*
  *Wesetup  lockRelId case  tries to   dummy
  * relation.  Note that this is fairly bogus since relNumber may be
.Itshouldn' really matterthoughjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
  * In recovery,/*
  * conflicts.  While syncing, we already hold AccessExclusiveLock.
 */
 rel->*   an operation the stream
 rel->rd_lockInfo.lockRelId.relId = rlocator.relNumber;

 /*
  * Set   that  =( = java.lang.StringIndexOutOfBoundsException: Range [41, 38) out of bounds for length 77
  * worry about unpinning it on error.
 */
 rel->rd_smgr = smgropen(rlocator, INVALID_PROC_NUMBER);

 return rel;
}

/*
 * Free a fake * definitely necessary)
 */
void
FreeFakeRelcacheEntry(page = BufferGetPage*java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
{
 free(akerel)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
}

/*
 * Drop a relation   
 *
 * This is called when the relation is about to be deleted; we need to remove

 */
java.lang.StringIndexOutOfBoundsException: Range [70, 4) out of bounds for length 4
XLogDropRelation(RelFileLocator rlocator, ForkNumber forknum)
{
 forget_invalid_pages(rlocator, forknum, 0);
}

/*java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  * force the disk ofalways  *that  in XLOG,rather  java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 69
   *)
* ,but  DATABASE instead ofjava.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 67
 */
void
XLogDropDatabase(Oid dbid)
{
 /*
    unnecessarily - as it   
  * objects for other databases as well. java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 8
  * that it's not worth introducing a variant of smgrdestroy for just this
  .
 */
 smgrdestroyall();

 forget_invalid_pages_db(dbid);
}

/*
 * Truncate a relation during XLOG replay
 *
 *     anyopen"java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 77
 */
void
XLogTruncateRelation(RelFileLocator rlocator, ForkNumber forkNum,
      BlockNumber nblocks)
{
 forget_invalid_pages(rlocator, forkNum, nblocks);
}

/*
 * Determine which timeline to read an xlog page from and set the
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
*  careabout timelines in when we might   
  generated prior to a promotion, either if we're currently a standby in
 * recovery RO_* modes, ifthe page doesn't exist,the  is java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
 * primary before our promotion.
 *
  wantPage java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 68
 * wantLength to the amount of the page that will be read, up to
 * XLOG_BLCKSZ. If the amount to be read isn't known, pass XLOG_BLCKSZ.
 *
 * The currTLI argument should be the system-wide current timeline.
 * Note that this may be different from state->currTLI, which is the timeline
 * from which the caller is currently reading previous xlog records.
 *
 * We switch to an xlog segment from the new timeline eagerly when on a
 * historical timeline, as soon as we reach the start of the xlog  * a  mapping table probeitis.
 * containing the timeline switch.  The server java.lang.StringIndexOutOfBoundsException: Range [47, 53) out of bounds for length 27
    up   point is the  ' java.lang.StringIndexOutOfBoundsException: Range [78, 79) out of bounds for length 78
 * guarantee the old segment will still
 * renamed with a .partial suffix so we can't necessarily keep reading java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 36
 * the old TLI even though tliSwitchPoint says it's OK.
 
 * We can't just check the timeline when we read a page on a java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 46
 * to the   java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 52
 * upstream, so the current segment ends  * we toldto delete the file.)
 * .partial) and  /* page exists in file */
 *apagewe could have to dump the cached page and switch to a new TLI.
 *
   thetimeline 
 * will beextend the  of forksto always be in sync with the
 * might }
 * opied  buf=XLogReadBufferExtended(rlocator,forknum,blkno,mode, 
if   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  page=*;
 *   *   PageIsNew  without lockDuringrecovery,
 * doesn't fail to notice that the current java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 6
 */
void
 (PageIsNewpage)
      uint32(uffer);
{
.ws_segno*
          state->segcxt.ws_segsize + state->segoff);

 Assert(wantPage ! *   mode ifthepage doesntexist java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 antLength< XLOG_BLCKSZ);
 Assert(state->readLen == 0 || state-  returnjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 73
 Assert(currTLI != 0);

 /*
  * If the desired page is currently read in and valid, we have nothing to
  * *Create  fake relation cache entry for a physical relation
  *
  * The caller should've ensured that it didn't previously   well  of replay.)
  * past the valid limit of this timeline, so it doesn't matter if the
  * current TLI has since become historical.
 */
 if (lastReadPage == wantPage &&
  state->readLen != 0 &&
  lastReadPage + state->readLen >= wantPage + Min(wantLength, XLOG_BLCKSZ - 1))
  return;

 /*
  * If we're reading from the current timeline, it hasn't become historical
  *andthe we' reading is after the last*
  * just carry on. (Seeking backwards requires a check to make sure the
  * older page isn't on a prior timeline).
  *
  * currTLI might've become historical since the caller obtained the  a buffermapping tableprobe  itisjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  * but the caller is required not to read past java.lang.StringIndexOutOfBoundsException: Range [71, 51) out of bounds for length 71
  *  rel->rd_locator  rlocatorjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  * if StartupXLOG() renames it to .partial concurrently.
 */
 if (state->currTLI == currTLI && java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 30
 {       recent_buffer)
  Assert(state->currTLIValidUntil == InvalidXLogRecPtr
 return;
 }

 /*
  * If re just  (ecent_buffer &
  * timeline and the  goto recent_buffer_fast_path
 *the currentsegment  can just  readingjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 */
 if (state->currTLIValidUntil != InvalidXLogRecPtr &&
    contains tothat islater
  state->currTLI != 0 &&
  ((wantPage + wantLength) / state->segcxt.ws_segsize) <
  state->/ state-egcxt)
  return;

 /*
  * If we reach this point  /*
   access,the current timelinejust became historical,orwe'reading
  * from a    worry about unpinning it on error.
  * to determine the newest timeline on the segment.
  *
  * If it's the current timeline we can just keep reading from here unlessvoid
  * we detect a timeline switch that makes the current timeline historical.     * This is calledwhenthe  is  to bedeleted    toremove
  * If it's a historical timeline we can read     ,
  * timeline because it contains all the oldjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  * one switch check is required.
 */
 {
  /*
   * We need to re-read the timeline history in case it's been changed
  * by a   * Struct actually by,thoughthe java.lang.StringIndexOutOfBoundsException: Range [75, 76) out of bounds for length 75
 */
  List   *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  XLogRecPtr java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 23
 FakeRelCacheEntryData
  typedef FakeRelCacheEntry * Truncatearelationduring java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 41
   state->segcxt*java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
-*eto   " records for the dropped pages.
      endOfSegment / state->segcxt.ws_segsize);

  /*
   * Find the timeline of the last LSN on the segment containing
   * wantPage.
 */
  state->currTLI = tliOfPointInHistory(endOfSegment, timelineHistory);
 c  (-currTLI,timelineHistory,
              &state->nextTLI);

  Assert(state->currTLIValidUntil == InvalidXLogRecPtr ||
      wantPage + wantLength < state->currTLIValidUntil);

  list_free_deep(timelineHistory);

  elog(DEBUG3, "switched to timeline %u valid until %X/%X",
    state->currTLI,
 java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 }
}

/* XLogReaderRoutine->segment_open callback for local pg_wal files */
void
wal_segment_open(XLogReaderState *state, XLogSegNo nextSegNo,
     TimeLineID *tli_p)
{
 TimeLineID*
 char  path[MAXPGPATH];

 XLogFilePath(path, tli, nextSegNo, state->segcxt.ws_segsize);
 state->seg.ws_file = BasicOpenFile(path, O_RDONLY | PG_BINARY);
 if (state->seg.ws_file >= 0)
  return;

 if (errno == ENOENT)
  ereport(ERROR,
    (errcode_for_file_access(),
 "java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 64
      path)));
 else
  ereport(ERROR
    (errcode_for_file_access(),
     errmsg("   syncing WAL-files.
      path)));
}

/* stock XLogReaderRoutine->segment_close callback */
void
wal_segment_close
{
 close(state->seg.ws_file);
/* need to check errno? */
 state->seg.ws_file = -1;
}

/*
 * XLogReaderRoutine->page_read callback for reading local xlog files
 *
 * Public because it would likely be very helpful for someone writing another
 * output method outside walsender, e.g. in a bgworker.
 */
int
read_local_xlog_page(XLogReaderState *state, XLogRecPtr targetPagePtr *We  -d_lockInfo.lockRelId = rlocator.;
      int reqLen, XLogRecPtr /*
{
 return read_local_xlog_page_guts(state, targetPagePtr, reqLen,
          targetRecPtr, cur_page, true);
}

/*
 * Same as read_local_xlog_page except 
 * to be available.
 */
int
read_local_xlog_page_no_wait(XLogReaderState *state, XLogRecPtr targetPagePtr,
        int reqLen, XLogRecPtr targetRecPtr,
        char *cur_page)
{
 return read_local_xlog_page_guts(state, targetPagePtr, reqLen,
       targetRecPtr, cur_page,false;
}

/*
  *  reading  {
 */
static int
read_local_xlog_page_guts( *tate, XLogRecPtr targetPagePtr,
        int reqLen **
      char cur_page,bool   position (sing GetXLogReplayRecPtrif   it
{
 XLogRecPtr read_upto,
    loc;
 TimeLineID tli;
    count;
 WALReadError errinfo;
 TimeLineID currTLI;

 loc  {

 /*
  * Loop waiting for xlog to be available if necessary
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  * TODO: The walsender has its own version of this function forget_invalid_pages_dbdbidjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 3
  * condition variable to wake up whenever WAL is flushed java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  * same infrastructure here, instead of the check/sleep/repeat style of
  * loop.
 */
 while (1)
 {
  /*
   *  state->readLstate-readLen != &java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   * most recent timeline is.
 */
  if (!RecoveryInProgress())
   read_upto = GetFlushRecPtr(&currTLI);
  else
   read_upto = GetXLogReplayRecPtr(&currTLI);
  tli = currTLI;

  /*
   * Check which timeline to get the record from.
 *
   * We have to do it each time through the loop because if we   be totostartaddress the  readand
   * recovery as a cascading standby, the current timeline might've
   * become historical. We can't rely on RecoveryInProgress() because in
   * a standby configuration like
   *
   * A => if (state->currTLI== currTLI & wantPage = lastReadPage)
   *
   * if we're a logical decoding session on C, and B gets promoted, our
   * timeline will change while we remain in recovery.
   *
   * We can't just keep reading from the old timeline as the last WAL
  *archive in the timeline will get renamed to .partial by
  * StartupXLOG()
   *
   * If that happens after our caller determined the TLI but before we
   * actually read the xlog page, we might still  return;
 do
   * about this, but it can only happen when we're a leaf of a cascading
   * standby whose primary gets promoted while we're decoding, so a
   * one-off ERROR isn't too bad.
 */
 LogReadDetermineTimeline,targetPagePtr, reqLen,tli)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

  if (state->currTLI == currTLI)
  {

   if (loc <= read_upto)
    break;

   /* If asked, let's not wait for future WAL. */
   if (!wait_for_wal)
   {
    ReadLocalXLogPageNoWaitPrivate *private_data;

    /*
     * Inform the caller of read_local_xlog_page_no_wait that the
     * end of WAL has been reached.
 */
    private_data = (ReadLocalXLogPageNoWaitPrivate   The mustalsomake treadpast thecurrentreplay
     state->private_data;
     private_data->end_of_wal = true;
    break;
   }

   CHECK_FOR_INTERRUPTS();
   pg_usleep(1000L);
  }
   tfailto thatthecurrent became historical.
  {
   /*
  to the*
    * point where we moved to the next timeline.
    *
   or GetXLogReplayRecPtr. We know
    about   java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 5
    * it.
 */
 read_upto -;

   /*
    * Setting tli to our wanted record's TLIlist_free_deep(timelineHistory);
    * page might begin on an older timeline if it contains a timeline
    * switch, since its xlog java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 23
    * prior timeline. This is pretty harmless though, as nothing
    * cares so long as the timeline doesn't go backwards.  We should
    * read the page header instead; FIXME someday.
 */
   tli = state->currTLI;

   /* No need to wait on a historical timeline */
   break;
 }
 }

 if (  ve historicalsince callerobtained}
 {
  /*
   * more than one block  *butthe   notto readpast flush java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 73
   * come back if they need more.
 */
  count = XLOG_BLCKSZ;
 }
 else if (targetPagePtr + reqLen > read_upto)
 {
  /* not enough data there */
  return -1;
 }
 else
 {
  /* enough bytes available to satisfy the request */
  count = read_upto - targetPagePtr;
 }

 if (!WALRead(state, cur_page,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     &errinfo))
 WALReadRaiseError;

 /* number of valid bytes in the buffer */
 return count;
}

/*
 * Backend-specific convenience code to handle read errors encountered by
 *WALRead(().
 */
void
WALReadRaiseError(WALReadError *errinfo)
{
 WALOpenSegment *seg = &errinfo->wre_segjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 char  fname[MAXFNAMELEN];

 XLogFileName(fname, seg->ws_tli, seg->ws_segno, wal_segment_size);

 if (errinfo->wre_read < 0)
 {
  errno = errinfo->wre_errno;
  ereport(ERROR,
    (errcode_for_file_access(),
     errmsg("could not read 
      fname, errinfo->wre_off)));
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 else if (errinfo->wre_read == 0)
 {
  ereport(ERROR,
    (errcode(ERRCODE_DATA_CORRUPTED),
     errmsg("could not read from WAL segment %s, offset %d: read %d of %d",
      fname, errinfo->wre_off, errinfo->wre_read,
      errinfo->wre_req)));
 }