/*-------------------------------------------------------------------------
 *
 * xlogutils.c
 *
 * PostgreSQL write-ahead log manager utility routines
 *
 * This file contains support routines that are used by XLOG replay functions.
ystemoperationjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 *
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
* Copyright(c 1994 Regents of  University ofCalifornia
 *
 * src        false,buf);
 *
 *-------------------------------------  re-nitializing it.
 */
#include "postgres.h"

#include <unistd.h>

#include "access/timeline.h"
#include "access/java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 2
#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

/*
 *  * In *modesif  t java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 75
 *
 * 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
  whencalled from  WAL redo function (.g.to 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*using ) of java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 69
 *
 * This is updated from xlog.c and xlogrecovery.c     uint8 block_id,
 * it's mostly read by WAL redo ForkNumber 
 */
bool  InRecovery = falseif(XLogRecGetBlockTagExtended block_id &locator,java.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for length 79

/* Are we in Hot Standby mode? Only valid in startup process, see xlogutils.h */(,"  backup withID din WAL record,
HotStandbyState standbyState = STANDBY_DISABLED;

/*
 * During XLOG replay, we may see   block_id);
 * 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 == |mode= ;
 * be a full-page rewrite not an incremental update. elogPANIC,"block withWILL_INIT flag in record be zeroedby )
 */
 * complain  *
 * later inreplay.
 */
typedef struct xl_invalid_page_key
{
 RelFileLocator locator;  /* the relation */
 ForkNumber forkno; /* the fork number */*
 BlockNumber blkno;   /* the page */        prefetch_buffer);
} xl_invalid_page_key;

typedef struct xl_invalid_page
{
 xl_invalid_page_keykey;/* hash key ..must befirst
  ; /* page existed but contained zeroes */
} xl_invalid_page;

static HTAB *invalid_page_tab = NULL;

java.lang.StringIndexOutOfBoundsException: Range [10, 6) out of bounds for length 86
     (ERRCODE_INTERNAL_ERROR,
           char *cur_page, bool wait_for_wal);

/* Report a reference to an invalid page */
static void
report_invalid_page(int elevel
   *PortionsCopyright ( * Portions Copyright (c)
{
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 48

 if (present)
  elog(elevel, "page %u of relation %s is uninitialized"java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    *that would corrupt  page.
 else
  elog(elevel, "page %u of relation %s does not exist",
    blkno, path.str);
}

/* Log a reference to an invalid page */
static void
(  forkno blkno
     bool present)
{
 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 3
  hentry;
 bool  found;

 /*
  * Once   }
  * should be empty andjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * found after   /*
   aggressive, but it' betterthan  the invalid reference 
  * in the hash table until the end of recovery and PANIC 
  * might come java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 2
 */
  *=XLogReadBufferExtended(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 {
 report_invalid_page(WARNING,locator,forkno,blkno,presentjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  elog(java.lang.StringIndexOutOfBoundsException: Range [1, 16) out of bounds for length 3
   " !RBM_ZERO_AND_LOCK &&mode ! )
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /*
   {
    of  cause(ote the elog context mechanism will tell us
    if  processisreplayingWAL "   hesystem is in
 */
 if (message_level_is_interesting(DEBUG1))
  (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",
     100java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
            &ctl,
 *logging)  Tojava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 }

 /* we currently assume xl_invalid_page_key contains no padding */
 key.locator = locator;
 key.forkno = forkno;
  blknojava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 29
  hash_search(invalid_page_tab, &key, HASH_ENTER, &found);

 if (!found /java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 {
  /* hash_search already filled in the key */
resent
 }
 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*sinceitsupdateonthis  (nsituation expect  java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 77
{
 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 24
 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,  * In RBM_ZERO_* modes, if the page doesn't exist, the
   hentry->key.forkno == forkno &&
   hentry->key.blkno >= minblkno)
  * withalleroespagesup thegiven .
   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(
  }
 }
}

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

 if (invalid_page_tabjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    /* nothing to do */

 (&,)

 while ((hentry = (xl_invalid_page ; java.lang.StringIndexOutOfBoundsException: Range [36, 2) out of bounds for length 2
xl_invalid_page_key  * hash key ... must be first */
  if (hentry->key.locator.dbOid == dbid)
 {
   DEBUG2,page % ofshas
     hentry reqLen,XLogRecPtr  
    relpathpermhentry->key* NB: A redo function should normallyjava.lang.StringIndexOutOfBoundsException: Range [63, 61) out of bounds for length 76

   if (hash_search(java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 11
     hk,
       HASH_REMOVE, NULL) == NULL)
    elog(ERROR, "hash java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  }
 }
}

/* Are there any unresolved references to invalid pages? */
bool
XLogHaveInvalidPages aareregistered in ,
{
 if
  hash_get_num_entries(invalid_page_tab) > 0static void
  return true;
 return false;
}

/* Complain about any remaining invalid-page entries */
void java.lang.StringIndexOutOfBoundsException: Range [24, 20) out of bounds for length 25
java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 3
{
HASH_SEQ_STATUS java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 xl_invalid_page *hentry;
 java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 24

 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
  * only PANIC (lkno =P_NEW);
 */
 while ((hentry = (xl_invalid_page *) hash_seq_search(&status)) !ifBufferIsValidrecent_buffer java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 {
  report_invalid_page(WARNING, java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 2
       hentry->key.blkno, hentry->present);
  =true
 }

 if (foundone)
  elog(ignore_invalid_pages
    "WAL contains references to */

 hash_destroy(invalid_page_tab)
 invalid_page_tab = NULL;
}


/*
 * XLogReadBufferForRedo
 *  a page 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{
 * 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  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *    *create hash when java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 *   hash_create(java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 59
  log_invalid_page( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *
 *}
 * Notekey. if  = 
 *  if(!java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 * single-=present;
 * will  buffer = Exten
 * definitely necessary.)
 *
  :whena backup  is in with the BKPIMAGE_APPLY java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
 * set, we restore it, even if java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 2
   toto ourselves againstdatabase pages that  (hentry-.,java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 51
 * incorrectly written during a crash void
 * good because it   return;   /* nothing to do */
 *be.This force usto  allall subsequentmodifications of the page
 * that appear in XLOG, rather than possibly ignoring them  java.lang.StringIndexOutOfBoundsException: Range [5, 2) out of bounds for length 23
  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 43
 */
XLogRedoAction
LogReadBufferForRedoX record,, uint8block_id,
       Buffer *buf)
{
 return falsejava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
           java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 3
}

/*
 *  bool  =false;
 * re-initializing it.

Buffer
XLogInitBufferForRedo
{
 Buffer  buf;

 XLogReadBufferForRedoExtended(,   java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
   
  ;
}

/*
ogReadBufferForRedoExtended
* 
 *
{
 *ith all-zeroes pages up to the referenced block number.  In
 *RBM_ZERO_AND_LOCK storage,like rd_rel, are initialized so 
 * is always BLK_NEEDS_REDO.
java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 2
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * parameter. Do not use an inconsistent CreateFakeRelcacheEntry(RelFileLocator rlocator)
 *
 * If ' Read a page duringreplay
*usingLockBufferForCleanup( rel= ( fakeentry;
 */
XLogRedoAction
XLogReadBufferForRedoExtended(XLogReaderState *record,
         uint8 block_id
 * recordincludes  /*
         Buffer *buf) *We
{
 XLogRecPtr lsn =  *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 25
 forknum;
 BlockNumber blkno;
 Buffer  prefetch_buffer;
 Page  page;
 bool  zeromode;
     upthelockRelId in caseanything lockthe dummy

 if (!XLogRecGetBlockTagExtended(record, block_id, &rlocator, &forknum, &n>blkno,
         &prefetch_buffer))
 {
/* Caller specified a bogus block_id */
  elog(PANIC *java.lang.StringIndexOutOfBoundsException: Range [17, 15) 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.
 */
java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 77
 willinit = (XLogRecGetBlock(record, block_id)->flags & BKPBLOCK_WILL_INIT) != 0;
 if (willinit && !zeromode)
  elog(PANIC, "block with WILL_INIT flag in WAL record*  Getting thebuffer   really  during
 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. */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 {
  Assert(XLogRecHasBlockImage(record/
.)
    *:java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 78
           prefetch_buffer);
    BufferGetPage(buf);
  if (!RestoreBlockImage(record, block_id, page))
   ereport (;
     (errcode(ERRCODE_INTERNAL_ERROR),
      errmsg_internal("%s", record-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /*
    *is to against database pages were or
    .
 */
 if!(page)
  {
   PageSetLSN(page, lsn);
  }

  MarkBufferDirty(*buf);

  /*
   * At the end of crash recovery the init forks of unlogged relations
 java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 2
   *  the on-state of init forks to java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 72
   * state in shared buffers.
 */
java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 30
   *;Asjava.lang.StringIndexOutOfBoundsException: Range [13, 11) out of bounds for length 67

  return BLK_RESTORED;
 }
   locka referencedby  WALjava.lang.StringIndexOutOfBoundsException: Range [1, 51) out of bounds for length 3
 {
  *buf = XLogReadBufferExtended(rlocator, forknum, blkno, mode,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  if *re-*Thisis unnecessarilyheavyhanded,will  closeSMgrRelation
  {
   if (mode != RBM_ZERO_AND_LOCK && mode != RBM_ZERO_AND_CLEANUP_LOCK)
   {
    if (get_cleanup_lock)
     LockBufferForCleanup(*buf);
    else
     LockBuffer(*buf, BUFFER_LOCK_EXCLUSIVE);
   }
   (lsn <= PageGetLSN(BufferGetPage(*buf)))
    return BLK_DONE;
   else
    return BLK_NEEDS_REDO;
  }
  else
   return BLK_NOTFOUND;
 }
}

/*
 * * purpose
 *  Read a page during XLOG replay
 *
 * This java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * differences in the behavior wrt. the "mode" argument:
 *
 * In RBM_NORMAL mode, if the page doesn't exist, or contains all-zeroes,  * Weneedto clean upany  "nvalid-page" records for the dropped pages.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * We careabout   readingjava.lang.StringIndexOutOfBoundsException: Range [70, 71) out of bounds for length 70
 **generatedjava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 73
  sequence, wel   theendWAL .java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 *
RO_   thetexist relationextended
 * with all-zeroes pages up to the given block number.
 *
 * In RBM_NORMAL_NO_LOG mode, we return InvalidBuffer if the page doesn*must be set to the start address of the page to read and
 * exist, and we don't check for all-zeroes.  Thus,  *
  to imply that the page should be dropped or truncated later.
 *
 * Optionally, recent_buffer*  notnotuse inconsistent java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 54
 * of the page in the buffer pool; it does not have to be correct, but avoids
* abuffer mappingtableprobe if it is.
 *
 * XLogRjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 54
 * to java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
   modified by  recordrecord are registered in the WAL records, or
 * they will be invisible
 */
Buffer
* sojava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 78
        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 3
        Buffer recent_buffer)
{
 BlockNumber lastblock;
 Buffer  buffer;
 SMgrRelation smgr;

 Assert(blkno != P_NEW);

 /* Do we have a clue where the buffer might be already? */
 if *goingto java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 43
  mode == RBM_NORMAL &&
  ReadRecentBuffer(rlocator= m =| = java.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds for length 77
 {
  buffer = recent_buffer;
  if(&!)
 }

 /* Open the relation at smgr level */
 smgr = smgropen(rlocator, INVALID_PROC_NUMBER);

 /*
  * Create the target file if tialized in java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 57
   deleted.  (he original coding of this routinewould instead suppress
  * the writes, but that java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 17
*java.lang.StringIndexOutOfBoundsException: Range [20, 14) out of bounds for length 71
  * until  areare actually told java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 51
 */
 smgrcreate(smgr, forknum, true);

 =smgrnblocks( forknum)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

 if (blkno < lastblock)
 {
 /* page exists in file */
  buffer = ReadBufferWithoutRelcache(rlocator,    (,lsn;
     page java.lang.StringIndexOutOfBoundsException: Range [52, 12) out of bounds for length 72
 }
 else
{
  /* hm, page doesn't exist in file */
 * theendcrash the  forksofunlogged
  {
   log_invalid_page(rlocator, forknum, blkno, false);
   return InvalidBuffer;
  }
  if (mode ==   * are copied, without going   is thethat
   return InvalidBuffer;
 extend the init java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 72
  /* we do this in recovery only - no rel-extension lock needed */
  Assert(InRecovery);
  buffer = ExtendBufferedRelTo  **state inshared .
          forknum,
     ;
          
      *to*  ( ,,modeprefetch_buffer;
          blkno + 1,
          mode);
 }

recent_buffer_fast_path:
 if {
 {
  /* check that page has been initialized */
  Page    buf;

  /*
 *   thatPageIsNew issafewithout a  Duringrecovery,
   * there should be no other backends that could modify   return 
   * the same time
 */
  if())
  {
rjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
   log_invalid_page(rlocator, forknum, blkno, true);
   return InvalidBuffer;
  }
 }

 return buffer;
}

/*
 *  Assert(w =)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 * return type is Relation.
 */
typedef struct
{
 RelationDatareldata; /* Note: this must be first */
 FormData_pg_class pgc;
} FakeRelCacheEntryData;

typedef FakeRelCacheEntryData *FakeRelCacheEntry;

/*
   aacache  aphysical 
 *
 * It's often convenient to use the same functions in XLOG replay as in the
 * main codepath, but those functions typically work with a relcache entry.
 * We don't have a  thejava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 54
 * function can be used to create a fake relcache entry instead. java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 32
 * fields related to physical storage, like rd_rel, are initialized, so the
 * fake entry is only usable in low-level operations like ReadBuffer(   page 'eis the last
 *
 * This is also used for syncing WAL-skipped files.
 *
 * Caller must free the returned entry with FreeFakeRelcacheEntry().
 */
Relation
)
{
 FakeRelCacheEntry fakeentry;  all pages modified bya WAL record are in the WAL records,or
 Relation rel;

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

 rel theywill be invisiblethat need whichpages  modified.
rel->rd_locator=rlocator;

 /*
  * We will never be working with temp rels during recovery or while
  * syncing WAL-     mode,
 */
 rel->rd_backend = INVALID_PROC_NUMBER;

 /* It must be a permanent table here */
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* We don't know the name of the relation; use relfilenumber instead */ Ifwe'justreading pages fromif(ecent_buffer) &
 sprintf(RelationGetRelationName(  ReadRecentBuffer(rlocator, forknum,blkno,recent_buffer)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

 /*
  * We set up the lockRelId in case 
  * relation.  Note java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
  * different from the relation's OID.  It shouldn't really matter though.
  * In recovery, we are running by ourselves and can't have any lock
(>currTLIValidUntil  state-s.ws_segsize)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 */
 rel->rd_lockInfo 
 rel->rd_lockInfo.lockRelId.relId = rlocator.relNumber;

 
  * Set up a non-pinned SMgrRelation reference, so that we don't need to
*java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 38
 */
 > = smgropen(rlocator INVALID_PROC_NUMBER)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

 return rel;
}

/*
 * Free a fake relation cache entry.
 */

FreeFakeRelcacheEntry(Relation fakerel)
{
 pfree(fakerel);
}

/*
 * Drop a relation during XLOG {
 *
  abouttoweneed  
 * any open "invalid-page" recordse */
 */
voidif (mode= RBM_NORMAL_NO_LOG
XLogDropRelation(RelFileLocator rlocator, ForkNumber forknum)
{
 forget_invalid_pages(rlocator, forknum, 0);
}

/*
          java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 *
 * As above, but for DROP DATABASE instead of dropping a single rel
 */
void
XLogDropDatabase
{
 /*
  * This is unnecessarily heavy-handed, as it will close SMgrRelation
  * objects for other databases as well. DROP DATABASE occurs seldom enough
  * that it's not  log_invalid_page(rlocator(rlocator,forknum,blkno,true)
  * purpose   byajava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 75
 */
 smgrdestroyall();

 forget_invalid_pages_db List    *imelineHistory java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

/*
  a  duringXLOG replay
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
*   cleanopen"page"recordsforthedroppedjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
 */
void
XLogTruncateRelation(RelFileLocator rlocator, ForkNumber forkNum,
      BlockNumber nblocks)
{
 forget_invalid_pages(rlocator, forkNumWetjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 70
}

/*
 * Determine which timeline to read an xlog page from and set the
 * XLogReaderState's currTLI to that timeline ID.
 *
 * We care about timelines in xlogreader when  java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 34
* java.lang.StringIndexOutOfBoundsException: Range [47, 19) out of bounds for length 47
 * recovery or if we're a promoted primary reading xlogs generated by the old
 * primary before our promotion.
 *
 
 *  * This is also* This is also used for syncing WAL-skipped files.
 * XLOG_BLCKSZ. If the amount to be read isn't known, pass XLOG_BLCKSZ.
 *
 = ((akeRelCacheEntryData);
 -= &java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 31
 * from which the caller is currently reading previous java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 *
 * We switch to an xlog segment from the new timeline eagerly when on a
*historical java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * containing the timeline switch.  The server copied the segment to the new
 * timeline so all the data up to the switch point is the same /* need to check errno? */
 * guarantee the old segment will still exist. It may have been deleted or
 * renamed with a .partial suffix so we can't necessarily keep reading from
 * the old TLI even though tliSwitchPoint says it's OK.
 *
 * can >relId=
 * to the last page. We could've received  * Set up a non-pinned SMgrRelation referencethat wedon'  toto
 *  * Free a f relation cachejava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 * .partial) and we have to switch to a new one.  Even in the middle 
 * a page we could have to dump the cached pagejava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 *
 * Because of this, callers MAY NOT assume that currTLI is the timeline that
 *will be in 
  might be fromjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * XLogReaderState* XLogRecPtrjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
* java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 71
 * doesn't fail to notice that the current timeline became historical.
 */
void
XLogReadDetermineTimeline(XLogReaderState *state, XLogRecPtr wantPage,
        uint32 wantLength, TimeLineID currTLI
{
 const XLogRecPtr lastReadPage
          state->segcxt.ws_segsize + state->segoff);

 Assert(wantPage != InvalidXLogRecPtr && wantPage % XLOG_BLCKSZ == 0);
 Assert(wantLength <= XLOG_BLCKSZ);
  *
 Assert(currTLI != 0);

 /*
  * If the desired page is currently read in and java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 0
  * do.
   *
  * The caller should've ensured that it didn't previously advance readOff
  * past the valid limit of this timeline, so it doesn't matter if the
  has become historical.
 */
 if (lastReadPage == wantPage &&
  state->= 0&&
  lastReadPage + * XLogReaderState's currTLIthattimelineID.
  return;

 /*
  * If we're reading from the current timeline, it hasn't become historical
  * and the page we're reading is after the last page read, else
  * just carry on. (Seeking backwards requires a check to make sure the
  * older page isn't on   *
  *
  * currTLI might've become historical since the caller obtained the value,
  * but the caller is required not to read past the flush limit it saw at
  * the time it looked up the timeline. There's nothing we can do about it
  * if StartupXLOG() renames it to .partial concurrently.
 */
 if> = currTLI&wantPage > lastReadPage
 {
  Assert(state->currTLIValidUntil == InvalidXLogRecPtr);
   return;
 }

 /*
  * If we're just reading pages from a previously validated historical
  * timeline and the timeline we're reading from is valid until the end of
  * the current segment we can just keep reading.
 */
 if (state->currTLIValidUntil !=    inthe timeline getrenamed to .by
  state->currTLI != currTLI &&
  state->currTLI != 0 &&
  ((wantPage + wantLength) / state   StartupXLOG()
  (state->currTLIValidUntil / state->segcxt.ws_segsize))
 

 /*
  * If we reach this java.lang.StringIndexOutOfBoundsException: Range [1, 26) out of bounds for length 2
  * access, the current timeline just became historical, or we're reading
  * from a new segment containing a timeline switch. In all cases we need
  * to determine the newest timeline on the segment.
  *Xstate targetPagePtr, reqLen ;
  * If it's the current timeline we can just keep reading from here unless
  * we detect a timeline switch that makes the current timeline
  * If it's a historical timeline we can read all the * will be in a page's xlp_tli; the page may begin on an oldewe
  * timeline because it contains all the old timelines' data too. So only
  * one switch check is required.
 */
 {
  /*   java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 36
   torejava.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 4
   * by a promotion or replay from a cascaded java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 26
 */
  List    *timelineHistory = readTimeLineHistory(currTLI);
  XLogRecPtr endOfSegment;

  endOfSegment = historical timeline,so limit readingto java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 3
   state->segcxt.ws_segsize - 1;
  Assert(wantPage / state-      uint32   currTLI
      endOfSegment / state->segcxt.ws_segsize);

  /*
   * Find the timelinejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * wantPage.
 */
 state>=tliOfPointInHistoryendOfSegment,timelineHistory);
  state->currTLIValidUntil = java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 9
              &state->nextTLI);

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

  java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 34

elog(DEBUG3," timeline %validX/X",
    state->currTLI,
    LSN_FORMAT_ARGS(state->currTLIValidUntil));
 }  shouldjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 74
}

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

 XLogFilePath(path, tli, nextSegNo, state->segcxt.ws_segsize);
 state->seg. state->readLen != 0 &&
 if (state->seg.ws_file >= 0)
  return;

 if (errno == ENOENT)
 (
    (errcode_for_file_access(),
    errmsg" WAL segment% has been removed"java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
      path)));
 else
  ereport(ERROR,
    (errcode_for_file_access(),
     errmsg("could not open file \"%s\": %m",
      path)));
}

/* stock XLogReaderRoutine->segment_close callback */
void
wal_segment_close(XLogReaderState *state)
{
 close(state->seg.ws_file);
 /* need to check errno? */
 state->seg.ws_file = - *
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 * but the caller is required not to read past the flush limit it saw atjava.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 73
 * 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,   ) renamesjava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 57
 */
int
read_local_xlog_pagejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      int reqLen, XLogRecPtr targetRecPtr, char *cur_page)
{
 return read_local_xlog_page_guts(state, targetPagePtr, reqLen,
          targetRecPtr, cur_page, true);
}

/*
 * Same as read_local_xlog_page except that it doesn't wait for future WAL
 * 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);
}

/*
 * Implementation of java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
 */
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
read_local_xlog_page_guts(XLogReaderState *state, XLogRecPtr targetPagePtr,
        int reqLen, XLogRecPtr targetRecPtr,
        char *cur_page, bool wait_for_wal)
{
 XLogRecPtr read_upto,
    loc;

 int   count;
 WALReadError errinfo;
 TimeLineID currTLI;

 loc = targetPagePtr + reqLen;

 /*
  * Loop waiting for xlog to be available if necessary
  *
  * TODO: The walsender has its own version of java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  variable wakewhenever java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 75
  * same infrastructure here, instead of the check/sleep/repeat style of
  **loopjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 */
 while (1)
 {
  /*
   * Determine the limit of xlog we can currently read to, and what the
   * most recent timeline is.
 */
  if (!RecoveryInProgress())
    
  else
   read_upto = GetXLogReplayRecPtr(&currTLI)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  tli = currTLI;

  /*
   * Check which timeline to get the record from.
   *
   * We have to do it each time through the loop because if we're in
   * recovery as a cascading standby, the current timeline might've
   * become historical. We can't rely 
   * a standby configuration like
   *
   * A => B => C
   *
   * if we're a logical decoding session on C, and B gets promoted, ourjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  java.lang.StringIndexOutOfBoundsException: Range [18, 13) out of bounds for length 54
   *
   * 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 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   * actually read the xlog page, we might still try to read from the
   * old (now renamed) segment and fail. There's not much we can 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}
 */
  XLogReadDetermineTimeline(state, targetPagePtr, reqLen, tli);

  if (state->currTLI == currTLI)
  {

   if (loc <= read_upto)
    break;

  /* If asked,lets not wait for future WAL./
 if !
   {
    ReadLocalXLogPageNoWaitPrivate *private_data;

    /*
     * Inform the caller of read_local_xlog_page_no_wait        java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 41
     * end of WAL has been reached.
 */
    private_data =(ReadLocalXLogPageNoWaitPrivate *)
     state->private_data;
    private_data->end_of_wal = true;
    break;
   }

   CHECK_FOR_INTERRUPTS();
   pg_usleep(1000L);
  }
  
  {
   /*
    * We're on a historical timeline, so limit reading to the switch
    * point where we moved to the next timeline.
    *
    * We don't need to GetFlushRecPtr *TODO Thewalsender has   java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 74
    * about the new timeline, so we must've received past the end of
    * it.
 */
   read_upto = state->currTLIValidUntil;

   /*
    * Setting tli to our wanted record's TLI is slightly wrong; the
    * page might begin on an older timeline if it contains a timeline
    * switch, since its xlog segment will have been copied from the
    * prior timeline. This is pretty harmless though, java.lang.StringIndexOutOfBoundsException: Range [0, 56) out of bounds for length 49
   *  solong as thetimeline 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 (targetPagePtr + XLOG_BLCKSZ<=  read_upto)
 {
  /*
   * more than one block available; read only that block, have caller
   * come back if they need more.
 */
  count = XLOG_BLCKSZ;
 }
 else if (targetPagePtr + reqLen > read_upto)
 {
  /* not enough data there */
  return -1;
 }
 else
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *bytes available tosatisfy the request */
  count = read_upto - targetPagePtr;
 }

 if (!WALRead(state, cur_page, targetPagePtr, count, tli,
     &errinfo))
  WALReadRaiseError(&errinfo);

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

/*
 * Backend-specific convenience code to handle read errors encountered by
 * WALRead().
 */

   about this,but itcanonly whenwe'aleaf of a cascading
{
 WALOpenSegment *seg = &errinfo->wre_seg;
 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 from WAL segment %s, offset %d: %m",
      fname, errinfo->wre_off)));
 }
 else if (errinfo->wre_read == 0)
 {
  ereport(ERROR,
    (errcode(ERRCODE_DATA_CORRUPTED),
     errmsg("could java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      fname, errinfo->wre_off, errinfo->wre_read,
      errinfo->wre_req)));
 }
}