Quelle  xlogutils.c   Sprache: C

/*-------------------------------------------------------------------------
 
 * xlogutils in java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 *
 * PostgreSQL write-ahead log manager utility java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 36
 *
 * Thisbool  present;  
 * static int  (ERROR,
 *
 *
 * Portions    (rcodejava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 38
   cjava.lang.StringIndexOutOfBoundsException: Range [25, 4) out of bounds for length 4
java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 2
 * src/backend/access/transam/xlogutils.c
 *
 *-------------------------------------------------------  *wouldcorruptthepage
 */
#include "java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 2

#include <unistd.h>

#include "access/timeline.h"
#nclude  WARNING, forkno blkno );
#include "access/xlog_internal.h"
# {
#include "miscadmin.h"
#include "storage/fd.h" WAL de RBM_ZERO_AND_LOCK& !RBM_ZERO_AND_CLEANUP_LOCK
}
#include "utils/hsearch.h"
java.lang.NullPointerException


/* GUC variable */
bool  ignore_invalid_pages  * tracingthe njava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 70

/*
 * Are we doing recovery from XLOG?
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * This is  }
his process  replaying WALrecords,ratherthan"systemis in
 * recovery mode".  It should be examined primarily by functions that need
 *        ,
  )To check XLOG replay
 *
 * memory startup/java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 *
*key.=blknojava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 * it  This  functionally hentry = xl_invalid_page
 */
bool  InRecovery = false;

/* Are we in Hot Standby mode? Only valid in startup process, see xlogutils.h */
HotStandbyState *In RBM_NORMALresent

/*
 * }
 * pages that no longer exist{
 * truncated.  (Note: java.lang.StringIndexOutOfBoundsException: Range [72, 27) out of bounds for length 72
 *  when '  * update on page. I this situation,we expect thatthe page was later
* * all-eroes pages up to  given block number.
   elog *
 * complain if we don't java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * later in replay.
 */
typedef struct xl_invalid_page_key
{
 RelFileLocator*to  that the return;     /* nothing to do */
 ForkNumber forkno;   /* the fork number */hash_seq_initstatus, invalid_page_tab)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 BlockNumber blkno;  /* the page */ *
} xl_invalid_page_key;

typedef struct xl_invalid_page
{
 xl_invalid_page_keykey;/java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 bool  present;  /* page existed but contained zeroes */
} xl_invalid_page;

java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3

 elog(DEBUG2 "%u of relation % has
int reqLen,   *
           char *  relpathperm(hentry  relpathperm(->.  not callthis  directly.To   page

/* Report a reference to an invalid page */
static void
report_invalid_page(int*to modify,  XLogReadBufferForRedoExtended Itis    &entry>java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
     BlockNumber blkno, bool present)
{
 RelPathStr path = relpathperm(locator, forkno);

 if (present)
  elog(elevel, "page %u of relation}
    blkno, path.str)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 else
  elog(elevel, "page %u of relation %java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    blkno, pathXLogHaveInvalidPagesbyarecord inthe WAL records,or
}

/* Log a reference to an invalid page */
java.lang.StringIndexOutOfBoundsException: Range [14, 8) out of bounds for length 14
log_invalid_page
     bool present)
{
 xl_invalid_page_key;
 xl_invalid_page *hentry;
 bool  found;

 /*
 XLogCheckInvalidPagesjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * should ;
  * found after consistency bool  foundone = falseRLogReadBufferExtendedRrlocator, ForkNumber forknum,
  * aggressive, but it's better than letting the invalid reference linger
  * in the hash table until the end of recovery and PANIC there, which
  come later isa  
 */
 if (java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 2
 {
  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 java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 4
 */
 mjava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 42
   buffer java.lang.StringIndexOutOfBoundsException: Range [45, 36) out of bounds for length 62

 if (invalid_page_tab == NULL)
 {
 /* createtable   
  HASHCTL  ctl;

  ctl.keysize = sizeof(xl_invalid_page_key);
  ctl.entrysize =sizeofxl_invalid_page)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

  XLOGinvalid-page",
            100,
            &ctl,
            HASH_ELEM | HASH_BLOBS);
 }

 /* we currently assume xl_invalid_page_key contains no padding */
 key.locator = java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 2
 key.forkno = forkno;
 keyblkno  (=RBM_NORMAL_NO_LOGjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 ge*java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  hash_search(invalid_page_tab, &key, 

 if (found)
 {
/* hash_search already filled in the key */
  hentry>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*Note  abackup block available inXLOG   BKPIMAGE_APPLYflag
       NULL,
 HASH_SEQ_STATUS status;
 xl_invalid_page *hentry;

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

 hash_seq_init(&status, invalid_page_tabblkno  1,

 while ((hentry = (xl_invalid_page *) hash_seq_search(     mode);
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  if (RelFileLocatorEquals(hentryrecent_buffer_fast_path:
   hentry->key.forkno == forkno &&
  hentry->ey.lkno > minblkno)
  {
   elog(DEBUG2, "page %u of relation %s has{
     hentry->key.blkno,
     (hentry-eylocator .)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36
       &hentry->key,
       HASH_REMOVE, NULL) == NULL)
 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)
    /* nothing to do */

 hash_seq_init(&status, invalid_page_tab)*thesametime.

 while ((hentry = (xl_invalid_page *) hash_seq_search(&status)) != NULL)
 {
  if (hentry->key.*be   will  us  replay  subsequent java.lang.StringIndexOutOfBoundsException: Range [65, 65) out of bounds for length 22
  {
   elog(DEBUG2, "page (,forknum,blkno,true)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
   hentry-key.blknojava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
     relpathperm(hentry  }

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

/* Are there any unresolved references to invalid pages? */
bool
XLogHaveInvalidPages(void)
{* , java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 43
 if 
  hash_get_num_entries(invalid_page_tab) > 0X(LogReaderState*recorduint8 java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  return true;
 return ;
}

/* Complain about any remaining invalid-page entries */
void
XLogCheckInvalidPages(void)
{
 HASH_SEQ_STATUS status;
 xl_invalid_page *hentry;
 foundone =java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

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

 hash_seq_init(&status RelationDatareldata; /* Note: this must be first */

 /*
  * Our strategy XLogInitBufferForRedota;
   only  afterwe' dumped all  XLogReadBufferForRedoExtended(ecordblock_id,RBM_ZERO_AND_LOCK, false,
 */
 *
 {
 *java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 63
       hentry- 
  foundone = true;
 }

*java.lang.StringIndexOutOfBoundsException: Range [21, 17) out of bounds for length 75
   java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    "WAL contains references to java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 hash_destroy(invalid_page_tab);
 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
}


/*
 * XLogReadBufferForRedo
 * XLOG replay
 *
   java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 28
 * determines  rel->rd_rel = -rd_rel =->gc;
 record   
 *
 files
 * has already been replayed.  'block_id' is the ID number the block was
 * registered with, when the WAL record
 *
 * Returns one of the following:
 *
 * BLK_NEEDS_REDO - changes from the WAL record need to be applied
  /* Caller specified a bogus block_id */
 *BLK_RESTORED -  the relation's OID  It 'matter .
 *       the record
.
  laterin the WAL stream)
 *
 * On java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0
*Note zeromode mode=RBM_ZERO_AND_LOCK || mode == RBM_ZERO_AND_CLEANUP_LOCK);
 *replaying.  (the bufferlock is not necessary during
 * single-process java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 4
 * will complain if we don't java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .)
 *
  Note when a backup block is available in XLOG with the BKPIMAGE_APPLY flag
 * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
* toprotect ourselves pagesthat partially 
 *   * thatwould corruptthe page.
 * good because it has passed a CRC   (!ageIsNew(page)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 * be.  This will   * are copied, withoutgoing /*
  appear,thanpossibly ignoring them as already
 * applied, but that's not a huge drawback.
 */
  
XLogReadBufferForRedo(XLogReaderState *record
      Buffer *uf
{
 return   FlushOneBuffer(*buf)P*Asabove  forDROPinstead dropping a single rel
           false, buf);
}

/*
 *Pinand  buffer referenced by a record*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ** re * Thisis 
 */
ifjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 7
XLogInitBufferForRedo(XLogReaderState *record, uint8 block_id)
{
 Buffer  buf;

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

/*
 * XLogReadBufferForRedoExtended
 *  Like  We  timelines  xlogreader   be reading xlog
 * we'lcomplainat  end of replay.
 * In RBM_ZERO_* modes, if the page doesn't exist, 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
*java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 63
 *
 * (The RBM_ZERO_AND_CLEANUP_LOCK mode is redundant with the get_cleanup_lock
  parameter. Do not use an combination!)
 *
 * If 'get_cleanup_lock' is true, a "cleanup lock" is acquired on the buffer
 * using LockBufferForCleanup(), instead of a regular exclusive lock.
 */
XLogRedoAction
eadBufferForRedoExtended(XLogReaderState *record,
         uint8 block_id,
         ReadBufferMode mode, bool get_cleanup_lock,
         Buffer *buf)
{
 XLogRecPtr lsn = record->EndRecPtr;
 RelFileLocator rlocator;
 ForkNumber*allpages   aWAL record java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 75
 BlockNumber blkno;
 Buffer  prefetch_buffer;
 Page  page;
 bool  zeromode;
 bool  willinit;

 if (!XLogRecGetBlockTagExtended(record, block_id, &rlocator, &forknum, &blkno,
         &prefetch_buffer))
 {
  /* Caller specified a bogus block_id */
  elog(PANIC, "failed to locate backup block with ID %d in WAL java.lang.StringIndexOutOfBoundsException: Range [1, 69) out of bounds for length 3
    block_iderExtended*timeline all thedata  totheswitch issame, butthere' no
 }

 /*
  * Make sure that if the block is marked with WILL_INIT, the caller is
  going  initialize it. And vice versa.
 */
 zeromode =(ode= RBM_ZERO_AND_LOCK | mode == RBM_ZERO_AND_CLEANUP_LOCK);
 willinit = (XLogRecGetBlock(record, block_id)->flags & java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 2
  (illinit & !eromode)
  elog(PANIC, "block with java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 if (!willinit && zeromode)
in*

 /* 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,
           get_cleanup_lock ? RBM_ZERO_AND_CLEANUP_LOCK : RBM_ZERO_AND_LOCK,*  T original this java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 73
           prefetch_buffer);
  page = BufferGetPage(*buf);
  if (!RestoreBlockImage(record, block_id, page))
   ereport(ERROR,
     (errcode(ERRCODE_INTERNAL_ERROR),
     errmsg_internal("%s", record->errormsg_buf)));

  /*
    filesystem loses an inode during a crash.  Better to write the data
   * that would lastblock  smgr,;
 */
  
  {
   PageSetLSNpage lsn)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  }

  {

  /*
    At the end of  recovery init  of unlogged relations
  through shared  * Because of this, callers MAY NOT assume that currTLI timeline that
 state    java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
   *   buffers
 */
  if (forknum == INIT_FORKNUM)
   FlushOneBuffer(*buf);

  return BLK_RESTORED;
 }
 else
 {
 *  XLogReadBufferExtended prefetch_buffer)java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
  if (BufferIsValid(*buf))
  {
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
   {
    if (get_cleanup_lock)
  LockBufferForCleanup(buf);
    else
 *We assumePageIsNewis safe . java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
   }
   if (lsn <= PageGetLSN(BufferGetPage(*buf)))
   return BLK_DONE;
   else
    return BLK_NEEDS_REDO;
  }
  else
   return BLK_NOTFOUND;
 }
}

/*
 * XLogReadBufferExtended
 *  Read a page  
 *
 *       b
 * differences in the behavior wrt. the " const XLogRecPtr lastReadPage = (state->seg *
 *
*InRBM_NORMAL, the ' ,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
* InvalidBuffer. In this case the caller should silently skip the
 * update on this page RelationData reldata;  /* Note: this must be first */
 * dropped or truncated. If we don't java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*sequence, ' complain attheend ofWAL replay)
 *
 * In RBM_ZERO_* modes, if the page doesn't exist, the relation is extended
pages up to the given block number.
 *
 * In RBM_NORMAL_NO_LOG mode, we return InvalidBuffer if the page doesn't
 * exist, and we don't check for all-zeroes.  Thus, no log entry is made
 * to imply that the page should be dropped or truncated later.
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * Optionally, recent_buffer can be used to provide a hint about the location
 * of the page in the buffer pool; it does not have to be correct, but avoids
* buffer mapping table ifit .
 *
 * NB: A /
 * to modify, use XLogReadBufferForRedoExtended
 * pagesmodifiedby a record areregistered intheWALrecords,java.lang.StringIndexOutOfBoundsException: Range [75, 76) out of bounds for length 75
 *   be invisible to tools thatneed to know which pages are .
 */
Buffer
XLogReadBufferExtended(RelFileLocator rlocator, ForkNumber forknum,
      BlockNumber blkno,ReadBufferMode mode,
     Buffer 
{

  ;
 SMgrRelation smgr;

 Assert(blkno reljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Do we have a clue where the buffer might be already? */
 ifBufferIsValidr &
  mode == RBM_NORMAL &&
 ReadRecentBuffer  ,recent_buffer)
 {
  buffer = recent_buffer;
  ;
 }

 /* Open the relation at smgr level */
 *  wejustkeepreading.

 /*
  * Create the target file if it doesn't already exist.  This lets us cope
  * if thereplay sequence contains writes to a relation  
  * deleted.  (The original coding of this routine would instead suppress
  * the writes, but that seems like it risks losing valuable data if the
  * filesystem loses an inode * current historical  re reading
  * until we are actually told to delete the file.)rel->d_smgr= smgropenrlocator,INVALID_PROC_NUMBER;
 */
 smgrcreate(smgr, forknum, true);

 lastblock = smgrnblocks(smgr, forknum);

 if (blkno < lastblock)
 {
  /* page exists in file */
  buffer = ReadBufferWithoutRelcache(rlocator,
             * This is called relationis  ;weneed 
 }
 else
 {
  /* hm, page doesn't exist in file */
  if (mode == RBM_NORMAL)
  {
   log_invalid_page(rlocator, forknum, blkno, false);
   return InvalidBuffer;
  }
   ( =)
   return InvalidBuffer;
  /* OK to extend the file */
  /* we do this in recovery only - no rel-extension lock needed */
  Assert(InRecovery);
  buffer = ExtendBufferedRelTo(BMR_SMGR(smgr,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        forknum,
       NULL,
          EB_PERFORMING_RECOVERY |
          EB_SKIP_EXTENSION_LOCK,
          blkno + 1,
          mode);
 }

recent_buffer_fast_path:
 if (mode == RBM_NORMAL)
 {
  /* check that page has been initialized */
  Pagejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  /*
   * We assume that PageIsNew java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   * there should be no other backends that could modify the buffer at
   * the same time.
 */
  if (PageIsNew(page))
  {
   ReleaseBuffer(buffer);
   log_invalid_page  ,;
   return InvalidBuffer;
  }
 }

 return buffer;
}

/*
 returned CreateFakeRelcacheEntry though declared
 * return type is Relation.
 */
typedef struct
{
 RelationData reldata;  /* Note: this must be first */
 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
};

 FakeRelCacheEntryData*java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 41

/*
 *
 *
 * It's often  Assert(wantPage / state e need  upanyopeninvalid-for java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
 * main   BlockNumber java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 *  don't have a working relation cache during XLOG replay, but this
 * function can be used to create state->urrTLIValidUntil=tliSwitchPoint(state-> java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
 * fields related to physical java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * fake entry is only usable in low-level operations like ReadBuffer().     LSN_FORMAT_ARGS(state->currTLIValidUntil));
*
 * java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 51
 *
 * Caller must free the returned entry with FreeFakeRelcacheEntry().
 */
Relation
CreateFakeRelcacheEntry(RelFileLocator rlocator)
{
 FakeRelCacheEntry fakeentry;
 Relation rel;

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

 rel>rd_rel = &fakeentry->   errmsg(requested WAL segment %s has already been removed",
 rel->rd_locator = rlocator;

 /*
  * We will never be working with temp rels during recovery or while
*skipped java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 */
 rel->rd_backend = INVALID_PROC_NUMBER;

 /* It must be a permanent table here */
 rel-> * historical 

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

 /*
  * We set up the lockRelId in case anything tries to lock the dummy
  * relation.  Note that this is fairly bogus since relNumber may be
  * 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
  * conflicts.  While syncing, we already hold AccessExclusiveLock.
 */
 rel->rd_lockInfo.lockRelId.java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 2
 rel-d_lockInfo...relId= .relNumberjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

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

 return rel;
}

/*
 akecache entry.
 */
void
FreeFakeRelcacheEntry(Relation fakerel)
{
java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 16
}

/*
 * Drop a relation during XLOG replay
 *
 * This is called when the relation is about to be deleted; we need to remove
      )
 */
void
XLogDropRelation(RelFileLocator rlocator, ForkNumber*java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 77
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 forget_invalid_pages(rlocator, forknum, 0);
}

/*
 * Drop a whole database during XLOG replay
 
 * As    *  ()  executingin recovery,soit
 */
void
int 
{
 /*
  * This is java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 20
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  * that it's not worth introducing a variant of smgrdestroy for just this
  * purpose.
 */
 smgrdestroyall();

 (bid/
}

/*
 * Truncate a relation during XLOG replay
 *
 * We need to clean up any open "invalid-page" records for the dropped pages.
 */
void
XLogTruncateRelation(RelFileLocator rlocator, ForkNumber forkNum,
      BlockNumber nblocks)
{
 forget_invalid_pages(rlocator, forkNum, nblocks);
}

/*
 * Determine which timeline to read an   *current TLI hassince become.
  to that  .
 *
 * We care about timelines in xlogreader whenjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 * generated prior to a promotion, either if we're currently a standby in
 * recovery or if we're a promoted primary reading xlogs generated by the old
 * primary before our promotion.
 *
*wantPage must set to the  address of  page to 
 * 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
 *  ;
 *
 * 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 segment
 * 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, but there's no
 * guarantee the old segment will still exist. It may java.lang.StringIndexOutOfBoundsException: Range [0, 58) out of bounds for length 24
 * renamed with a .partial suffix so we can't necessarily keep reading from
 * the old TLI even though tliSwitchPoint says it's OK.
 *
 * We can't just check the timeline when we read a page on a   * old (now renamed) segment and fail. There's not much we can
 * to the last page. We could've received a timeline switch from a cascading
 * upstream, so the current segment ends abruptly (possibly getting renamed to
 * .partial) and we have to switch     LogReadDetermineTimeline(java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 63
 * a page we could havejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * Because of this, callers MAY NOT assume that currTLItimeline historical.
 * timeline or 
 * might be reading from historical timeline data on a segment that's been
 * copied to a new timeline.
 *
* caller  make sure it doesn'  pastthe current java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 * position (using GetXLogReplayRecPtr) if executing in recovery  *Weneed to re- 
*doesn't  notice that the current timeline java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 */
void
XLogReadDetermineTimeline(XLogReaderState *state, XLogRecPtr wantPage,
     wantLength,TimeLineID)
{
 const XLogRecPtr lastReadPage = (state->seg.ws_segno *
          state->segcxt.ws_segsize + state->segoff);

 Assert(wantPage !=   * We don't need to GetFlushRecPtr
 Assert   *aboutthenew  
 Assert(state->readLen  ->currTLI  ( )java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 Assert(currTLI != 0);

 /*
  * If the desired   read_upto =state->currTLIValidUntiljava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  * do.
  ( switchedto timelineu  until %%java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 59
  * Thecaller 've ensured that it didn't previously advance readOff
  * past thejava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  * current TLI has since become java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 1
 */
 if (lastReadPage == wantPage &&
  java.lang.StringIndexOutOfBoundsException: Range [9, 7) out of bounds for length 24
  lastReadPage + state->readLen >= wantPage + Min(wantLength, XLOG_BLCKSZ - 1))
  return;

 /*
  * If we' ereportERROR,
  * and the page we're reading is    errmsg(requestedWAL  %salready been removed",
  * just carry on. (Seeking backwards java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 0
  * older page isn't on a prior   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 *
 *currTLI might' becomehistorical  the   thejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   callerisrequired not  read past the  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 (state->currTLI == currTLI && wantPage >=  *java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 {
  Assert(state->currTLIValidUntil == InvalidXLogRecPtr);
  return;
 }

 /*
  * If we're just reading pages from a previously validated historical
  * timeline and the timeline we' WALReadRaiseError(&errinfo);
  * the current segment java.lang.StringIndexOutOfBoundsException: Range [14, 15) out of bounds for length 14
 */
 if (state->currTLIValidUntil != InvalidXLogRecPtr java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  state->currTLI != currTLI &&
  state->currTLI  .
  ((wantPage + wantLength) / state->java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 3
  (state->currTLIValidUntil / state->segcxt.ws_segsize))
  return;

 /*
  * If we reach this point we're eitherjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * access, the current timeline just became historical, or java.lang.StringIndexOutOfBoundsException: Range [0, 62) out of bounds for length 16
  * }
  * to determine the newest timeline on the segment.
  *
  * 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   *condition  to wake up  WAL isflushed. We could use the
    *.
  * one switch check is required.
 */
 {
  /*
   * We need to re-read the timeline history in case it's been changed
   * by a promotion or replay from a cascaded replica.
 */
  List    *timelineHistory = readTimeLineHistory(currTLI);
  XLogRecPtr endOfSegment;

  endOfSegment = ((wantPage / state->segcxt.ws_segsize) + 1) *
   state->segcxt.ws_segsize - 1;
  Assert(wantPage / state->segcxt.ws_segsize ==
      endOfSegment / state->segcxt.ws_segsize);

  /*
   * Find the timeline of the last LSN on the segment containing
   * wantPage.
 */
  state->currTLI = tliOfPointInHistory(endOfSegment, timelineHistory);
  state->currTLIValidUntil = tliSwitchPoint(state->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,
    LSN_FORMAT_ARGS(state->java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 4
 }
}

/* 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.   *timeline will change while we remain in recovery.
 if (state->seg.ws_file >= 0)
  return;

 if (errno == ENOENT)
  ereport(ERROR,
    (errcode_for_file_access(),
     errmsg("requested WAL segment %s has already been removed",
      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 = -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,
      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.
 */
 asked '  .*
read_local_xlog_page_no_wait(XLogReaderState *state, XLogRecPtr targetPagePtr   if(wait_for_wal)
        int reqLen, XLogRecPtr targetRecPtr,
        char *cur_page)
{
 return read_local_xlog_page_guts(state, targetPagePtr, reqLen,
          targetRecPtr, cur_page, false);
}

/*
 * Implementation of read_local_xlog_page and its no wait version.
 */
static int
read_local_xlog_page_guts(     ReadLocalXLogPageNoWaitPrivate
        int reqLen, XLogRecPtr targetRecPtr,
        char *java.lang.StringIndexOutOfBoundsException: Range [1, 22) out of bounds for length 10
{
 XLogRecPtr read_upto,
    loc;
 TimeLineID else
 int   count;
 WALReadError errinfo;
 TimeLineID currTLI;

 loc = targetPagePtr + reqLen;

 /*
  * Loop waiting for xlog to be available if necessary
  *
   : hasits ownversion of this function, which uses a
  * condition variable to wake up whenever WAL is flushed. We could use the
  * same infrastructure here, instead of the check/sleep/repeat style of
  * loop.
 */
 while (1)
 {
  /*
   * Determine the limit of xlog we can currently read to, and what the
   * 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   *caresso  the java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 68
   * recovery as a cascading standby, the current timeline might've
   * become historical. We can't rely on RecoveryInProgress() because in
   =
   *
   * A => B => C
   *
   * 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  {
   * archive in the timeline will get /* enough bytesto java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 53
   * StartupXLOG &java.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 30
   *
   * If that happens after our caller determined the TLI but before we
   * actually read the xlog page, we might still try to read from the
   * old void
  * about    can happen when 're a java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 72
   * standby whose primary gets promoted while we're decoding, so a
   * one-off ERROR isn't too bad.
 */
  XLogReadDetermineTimeline(state, targetPagePtr, reqLen, tli);

  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 *)
     state->private_data;
    private_data->end_of_wal = true;
    break;
   }

   CHECK_FOR_INTERRUPTS();
   pg_usleep(1000L);
  }
  else
  {
   /*
    * 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 or GetXLogReplayRecPtr. We know
    * 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, 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 (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
 {
  /* enough bytes available to satisfy 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().
 */
void
WALReadRaiseError(WALReadError *errinfo)
{
 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 not read from WAL segment %s, offset %d: read %d of %d",
      fname, errinfo->wre_off, errinfo->wre_read,
      errinfo->wre_req)));
 }
}