Streaming replication and pg_xlogfile_name()

*** a/doc/src/sgml/func.sgml
--- b/doc/src/sgml/func.sgml
***************
*** 13152,13157 **** postgres=# SELECT * FROM pg_xlogfile_name_offset(pg_stop_backup());
--- 13152,13161 ----
      This is usually the desired behavior for managing transaction log archiving
      behavior, since the preceding file is the last one that currently
      needs to be archived.
+     These functions also accept as a parameter the string that consists of timeline and
+     location, separated by a slash. In this case a transaction log file name is computed
+     by using the given timeline. On the other hand, if timeline is not supplied, the
+     current timeline is used for the computation.
     </para>
  
     <para>
***************
*** 13198,13210 **** postgres=# SELECT * FROM pg_xlogfile_name_offset(pg_stop_backup());
          <literal><function>pg_last_xlog_receive_location</function>()</literal>
          </entry>
         <entry><type>text</type></entry>
!        <entry>Get last transaction log location received and synced to disk during
!         streaming recovery. If streaming recovery is still in progress
          this will increase monotonically. If streaming recovery has completed
          then this value will remain static at the value of the last WAL record
          received and synced to disk during that recovery. When the server has
          been started without a streaming recovery then the return value will be
!         InvalidXLogRecPtr (0/0).
         </entry>
        </row>
        <row>
--- 13202,13216 ----
          <literal><function>pg_last_xlog_receive_location</function>()</literal>
          </entry>
         <entry><type>text</type></entry>
!        <entry>Get timeline and location of last transaction log received and synced
!         to disk during streaming recovery. The return string is separated by a slash,
!         the first value indicates the timeline and the other the location.
!         If streaming recovery is still in progress
          this will increase monotonically. If streaming recovery has completed
          then this value will remain static at the value of the last WAL record
          received and synced to disk during that recovery. When the server has
          been started without a streaming recovery then the return value will be
!         <literal>0/0/0</>.
         </entry>
        </row>
        <row>
***************
*** 13212,13223 **** postgres=# SELECT * FROM pg_xlogfile_name_offset(pg_stop_backup());
          <literal><function>pg_last_xlog_replay_location</function>()</literal>
          </entry>
         <entry><type>text</type></entry>
!        <entry>Get last transaction log location replayed during recovery.
          If recovery is still in progress this will increase monotonically.
          If recovery has completed then this value will remain static at
          the value of the last WAL record applied during that recovery.
          When the server has been started normally without a recovery
!         then the return value will be InvalidXLogRecPtr (0/0).
         </entry>
        </row>
       </tbody>
--- 13218,13231 ----
          <literal><function>pg_last_xlog_replay_location</function>()</literal>
          </entry>
         <entry><type>text</type></entry>
!        <entry>Get timeline and location of last transaction log replayed during
!         recovery. The return string is separated by a slash, the first value
!         indicates the timeline and the other the location.
          If recovery is still in progress this will increase monotonically.
          If recovery has completed then this value will remain static at
          the value of the last WAL record applied during that recovery.
          When the server has been started normally without a recovery
!         then the return value will be <literal>0/0/0</>.
         </entry>
        </row>
       </tbody>
*** a/src/backend/access/transam/xlog.c
--- b/src/backend/access/transam/xlog.c
***************
*** 395,400 **** typedef struct XLogCtlData
--- 395,402 ----
  	TimestampTz	recoveryLastXTime;
  	/* end+1 of the last record replayed */
  	XLogRecPtr	recoveryLastRecPtr;
+ 	/* tli of last record replayed */
+ 	TimeLineID	recoveryLastTLI;
  
  	slock_t		info_lck;		/* locks shared variables shown above */
  } XLogCtlData;
***************
*** 5864,5873 **** StartupXLOG(void)
  			/* use volatile pointer to prevent code rearrangement */
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			/* initialize shared replayEndRecPtr and recoveryLastRecPtr */
  			SpinLockAcquire(&xlogctl->info_lck);
  			xlogctl->replayEndRecPtr = ReadRecPtr;
  			xlogctl->recoveryLastRecPtr = ReadRecPtr;
  			SpinLockRelease(&xlogctl->info_lck);
  
  			InRedo = true;
--- 5866,5882 ----
  			/* use volatile pointer to prevent code rearrangement */
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			/*
! 			 * initialize shared replayEndRecPtr, recoveryLastRecPtr and
! 			 * recoveryLastTLI. Actually, the latter two variables don't need to
! 			 * be initialized here since they are expected to be updated at least
! 			 * once until read only connections will have read them. But just in
! 			 * case.
! 			 */
  			SpinLockAcquire(&xlogctl->info_lck);
  			xlogctl->replayEndRecPtr = ReadRecPtr;
  			xlogctl->recoveryLastRecPtr = ReadRecPtr;
+ 			xlogctl->recoveryLastTLI = curFileTLI;
  			SpinLockRelease(&xlogctl->info_lck);
  
  			InRedo = true;
***************
*** 5995,6005 **** StartupXLOG(void)
  				error_context_stack = errcontext.previous;
  
  				/*
! 				 * Update shared recoveryLastRecPtr after this record has been
! 				 * replayed.
  				 */
  				SpinLockAcquire(&xlogctl->info_lck);
  				xlogctl->recoveryLastRecPtr = EndRecPtr;
  				SpinLockRelease(&xlogctl->info_lck);
  
  				LastRec = ReadRecPtr;
--- 6004,6015 ----
  				error_context_stack = errcontext.previous;
  
  				/*
! 				 * Update shared recoveryLastRecPtr and recoveryLastTLI
! 				 * after this record has been replayed.
  				 */
  				SpinLockAcquire(&xlogctl->info_lck);
  				xlogctl->recoveryLastRecPtr = EndRecPtr;
+ 				xlogctl->recoveryLastTLI = curFileTLI;
  				SpinLockRelease(&xlogctl->info_lck);
  
  				LastRec = ReadRecPtr;
***************
*** 8334,8340 **** pg_current_xlog_insert_location(PG_FUNCTION_ARGS)
  }
  
  /*
!  * Report the last WAL receive location (same format as pg_start_backup etc)
   *
   * This is useful for determining how much of WAL is guaranteed to be received
   * and synced to disk by walreceiver.
--- 8344,8350 ----
  }
  
  /*
!  * Report the last WAL receive tli and location
   *
   * This is useful for determining how much of WAL is guaranteed to be received
   * and synced to disk by walreceiver.
***************
*** 8347,8359 **** pg_last_xlog_receive_location(PG_FUNCTION_ARGS)
  
  	recptr = GetWalRcvWriteRecPtr();
  
! 	snprintf(location, sizeof(location), "%X/%X",
  			 recptr.xlogid, recptr.xrecoff);
  	PG_RETURN_TEXT_P(cstring_to_text(location));
  }
  
  /*
!  * Report the last WAL replay location (same format as pg_start_backup etc)
   *
   * This is useful for determining how much of WAL is visible to read-only
   * connections during recovery.
--- 8357,8370 ----
  
  	recptr = GetWalRcvWriteRecPtr();
  
! 	snprintf(location, sizeof(location), "%X/%X/%X",
! 			 XLogRecPtrIsInvalid(recptr) ? 0 : GetRecoveryTargetTLI(),
  			 recptr.xlogid, recptr.xrecoff);
  	PG_RETURN_TEXT_P(cstring_to_text(location));
  }
  
  /*
!  * Report the last WAL replay tli and location
   *
   * This is useful for determining how much of WAL is visible to read-only
   * connections during recovery.
***************
*** 8363,8377 **** pg_last_xlog_replay_location(PG_FUNCTION_ARGS)
  {
  	/* use volatile pointer to prevent code rearrangement */
  	volatile XLogCtlData *xlogctl = XLogCtl;
  	XLogRecPtr	recptr;
  	char		location[MAXFNAMELEN];
  
  	SpinLockAcquire(&xlogctl->info_lck);
  	recptr = xlogctl->recoveryLastRecPtr;
  	SpinLockRelease(&xlogctl->info_lck);
  
! 	snprintf(location, sizeof(location), "%X/%X",
! 			 recptr.xlogid, recptr.xrecoff);
  	PG_RETURN_TEXT_P(cstring_to_text(location));
  }
  
--- 8374,8390 ----
  {
  	/* use volatile pointer to prevent code rearrangement */
  	volatile XLogCtlData *xlogctl = XLogCtl;
+ 	TimeLineID	tli;
  	XLogRecPtr	recptr;
  	char		location[MAXFNAMELEN];
  
  	SpinLockAcquire(&xlogctl->info_lck);
+ 	tli = xlogctl->recoveryLastTLI;
  	recptr = xlogctl->recoveryLastRecPtr;
  	SpinLockRelease(&xlogctl->info_lck);
  
! 	snprintf(location, sizeof(location), "%X/%X/%X",
! 			 tli, recptr.xlogid, recptr.xrecoff);
  	PG_RETURN_TEXT_P(cstring_to_text(location));
  }
  
***************
*** 8379,8384 **** pg_last_xlog_replay_location(PG_FUNCTION_ARGS)
--- 8392,8401 ----
   * Compute an xlog file name and decimal byte offset given a WAL location,
   * such as is returned by pg_stop_backup() or pg_xlog_switch().
   *
+  * Also use the tli for the computation if it's given with a location,
+  * such as is returned by pg_last_xlog_receive_location() or
+  * pg_last_xlog_replay_location().
+  *
   * Note that a location exactly at a segment boundary is taken to be in
   * the previous segment.  This is usually the right thing, since the
   * expected usage is to determine which xlog file(s) are ready to archive.
***************
*** 8388,8398 **** pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
--- 8405,8417 ----
  {
  	text	   *location = PG_GETARG_TEXT_P(0);
  	char	   *locationstr;
+ 	unsigned int utli;
  	unsigned int uxlogid;
  	unsigned int uxrecoff;
  	uint32		xlogid;
  	uint32		xlogseg;
  	uint32		xrecoff;
+ 	TimeLineID	tli = ThisTimeLineID;
  	XLogRecPtr	locationpoint;
  	char		xlogfilename[MAXFNAMELEN];
  	Datum		values[2];
***************
*** 8406,8412 **** pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
  	 */
  	locationstr = text_to_cstring(location);
  
! 	if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  				 errmsg("could not parse transaction log location \"%s\"",
--- 8425,8433 ----
  	 */
  	locationstr = text_to_cstring(location);
  
! 	if (sscanf(locationstr, "%X/%X/%X", &utli, &uxlogid, &uxrecoff) == 3)
! 		tli = (TimeLineID) utli;
! 	else if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  				 errmsg("could not parse transaction log location \"%s\"",
***************
*** 8431,8437 **** pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
  	 * xlogfilename
  	 */
  	XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
! 	XLogFileName(xlogfilename, ThisTimeLineID, xlogid, xlogseg);
  
  	values[0] = CStringGetTextDatum(xlogfilename);
  	isnull[0] = false;
--- 8452,8458 ----
  	 * xlogfilename
  	 */
  	XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
! 	XLogFileName(xlogfilename, tli, xlogid, xlogseg);
  
  	values[0] = CStringGetTextDatum(xlogfilename);
  	isnull[0] = false;
***************
*** 8457,8478 **** pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
  /*
   * Compute an xlog file name given a WAL location,
   * such as is returned by pg_stop_backup() or pg_xlog_switch().
   */
  Datum
  pg_xlogfile_name(PG_FUNCTION_ARGS)
  {
  	text	   *location = PG_GETARG_TEXT_P(0);
  	char	   *locationstr;
  	unsigned int uxlogid;
  	unsigned int uxrecoff;
  	uint32		xlogid;
  	uint32		xlogseg;
  	XLogRecPtr	locationpoint;
  	char		xlogfilename[MAXFNAMELEN];
  
  	locationstr = text_to_cstring(location);
  
! 	if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  				 errmsg("could not parse transaction log location \"%s\"",
--- 8478,8507 ----
  /*
   * Compute an xlog file name given a WAL location,
   * such as is returned by pg_stop_backup() or pg_xlog_switch().
+  *
+  * Also use the tli for the computation if it's given with a location,
+  * such as is returned by pg_last_xlog_receive_location() or
+  * pg_last_xlog_replay_location().
   */
  Datum
  pg_xlogfile_name(PG_FUNCTION_ARGS)
  {
  	text	   *location = PG_GETARG_TEXT_P(0);
  	char	   *locationstr;
+ 	unsigned int utli;
  	unsigned int uxlogid;
  	unsigned int uxrecoff;
  	uint32		xlogid;
  	uint32		xlogseg;
+ 	TimeLineID	tli = ThisTimeLineID;
  	XLogRecPtr	locationpoint;
  	char		xlogfilename[MAXFNAMELEN];
  
  	locationstr = text_to_cstring(location);
  
! 	if (sscanf(locationstr, "%X/%X/%X", &utli, &uxlogid, &uxrecoff) == 3)
! 		tli = (TimeLineID) utli;
! 	else if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  				 errmsg("could not parse transaction log location \"%s\"",
***************
*** 8482,8488 **** pg_xlogfile_name(PG_FUNCTION_ARGS)
  	locationpoint.xrecoff = uxrecoff;
  
  	XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
! 	XLogFileName(xlogfilename, ThisTimeLineID, xlogid, xlogseg);
  
  	PG_RETURN_TEXT_P(cstring_to_text(xlogfilename));
  }
--- 8511,8517 ----
  	locationpoint.xrecoff = uxrecoff;
  
  	XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
! 	XLogFileName(xlogfilename, tli, xlogid, xlogseg);
  
  	PG_RETURN_TEXT_P(cstring_to_text(xlogfilename));
  }

*** a/doc/src/sgml/func.sgml
--- b/doc/src/sgml/func.sgml
***************
*** 13199,13204 **** postgres=# SELECT * FROM pg_xlogfile_name_offset(pg_stop_backup());
--- 13199,13208 ----
      This is usually the desired behavior for managing transaction log archiving
      behavior, since the preceding file is the last one that currently
      needs to be archived.
+     These functions also accept as a parameter the string that consists of timeline and
+     location, separated by a slash. In this case a transaction log file name is computed
+     by using the given timeline. On the other hand, if timeline is not supplied, the
+     current timeline is used for the computation.
     </para>
  
     <para>
***************
*** 13245,13257 **** postgres=# SELECT * FROM pg_xlogfile_name_offset(pg_stop_backup());
          <literal><function>pg_last_xlog_receive_location</function>()</literal>
          </entry>
         <entry><type>text</type></entry>
!        <entry>Get last transaction log location received and synced to disk during
!         streaming recovery. If streaming recovery is still in progress
          this will increase monotonically. If streaming recovery has completed
          then this value will remain static at the value of the last WAL record
          received and synced to disk during that recovery. When the server has
          been started without a streaming recovery then the return value will be
!         InvalidXLogRecPtr (0/0).
         </entry>
        </row>
        <row>
--- 13249,13263 ----
          <literal><function>pg_last_xlog_receive_location</function>()</literal>
          </entry>
         <entry><type>text</type></entry>
!        <entry>Get timeline and location of last transaction log received and synced
!         to disk during streaming recovery. The return string is separated by a slash,
!         the first value indicates the timeline and the other the location.
!         If streaming recovery is still in progress
          this will increase monotonically. If streaming recovery has completed
          then this value will remain static at the value of the last WAL record
          received and synced to disk during that recovery. When the server has
          been started without a streaming recovery then the return value will be
!         <literal>0/0/0</>.
         </entry>
        </row>
        <row>
***************
*** 13259,13270 **** postgres=# SELECT * FROM pg_xlogfile_name_offset(pg_stop_backup());
          <literal><function>pg_last_xlog_replay_location</function>()</literal>
          </entry>
         <entry><type>text</type></entry>
!        <entry>Get last transaction log location replayed during recovery.
          If recovery is still in progress this will increase monotonically.
          If recovery has completed then this value will remain static at
          the value of the last WAL record applied during that recovery.
          When the server has been started normally without a recovery
!         then the return value will be InvalidXLogRecPtr (0/0).
         </entry>
        </row>
       </tbody>
--- 13265,13278 ----
          <literal><function>pg_last_xlog_replay_location</function>()</literal>
          </entry>
         <entry><type>text</type></entry>
!        <entry>Get timeline and location of last transaction log replayed during
!         recovery. The return string is separated by a slash, the first value
!         indicates the timeline and the other the location.
          If recovery is still in progress this will increase monotonically.
          If recovery has completed then this value will remain static at
          the value of the last WAL record applied during that recovery.
          When the server has been started normally without a recovery
!         then the return value will be <literal>0/0/0</>.
         </entry>
        </row>
       </tbody>
*** a/src/backend/access/transam/xlog.c
--- b/src/backend/access/transam/xlog.c
***************
*** 392,397 **** typedef struct XLogCtlData
--- 392,399 ----
  	TimestampTz	recoveryLastXTime;
  	/* end+1 of the last record replayed */
  	XLogRecPtr	recoveryLastRecPtr;
+ 	/* tli of last record replayed */
+ 	TimeLineID	recoveryLastTLI;
  
  	slock_t		info_lck;		/* locks shared variables shown above */
  } XLogCtlData;
***************
*** 5776,5785 **** StartupXLOG(void)
  			/* use volatile pointer to prevent code rearrangement */
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			/* initialize shared replayEndRecPtr and recoveryLastRecPtr */
  			SpinLockAcquire(&xlogctl->info_lck);
  			xlogctl->replayEndRecPtr = ReadRecPtr;
  			xlogctl->recoveryLastRecPtr = ReadRecPtr;
  			SpinLockRelease(&xlogctl->info_lck);
  
  			InRedo = true;
--- 5778,5794 ----
  			/* use volatile pointer to prevent code rearrangement */
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			/*
! 			 * initialize shared replayEndRecPtr, recoveryLastRecPtr and
! 			 * recoveryLastTLI. Actually, the latter two variables don't need to
! 			 * be initialized here since they are expected to be updated at least
! 			 * once until read only connections will have read them. But just in
! 			 * case.
! 			 */
  			SpinLockAcquire(&xlogctl->info_lck);
  			xlogctl->replayEndRecPtr = ReadRecPtr;
  			xlogctl->recoveryLastRecPtr = ReadRecPtr;
+ 			xlogctl->recoveryLastTLI = lastPageTLI;
  			SpinLockRelease(&xlogctl->info_lck);
  
  			InRedo = true;
***************
*** 5907,5917 **** StartupXLOG(void)
  				error_context_stack = errcontext.previous;
  
  				/*
! 				 * Update shared recoveryLastRecPtr after this record has been
! 				 * replayed.
  				 */
  				SpinLockAcquire(&xlogctl->info_lck);
  				xlogctl->recoveryLastRecPtr = EndRecPtr;
  				SpinLockRelease(&xlogctl->info_lck);
  
  				LastRec = ReadRecPtr;
--- 5916,5927 ----
  				error_context_stack = errcontext.previous;
  
  				/*
! 				 * Update shared recoveryLastRecPtr and recoveryLastTLI
! 				 * after this record has been replayed.
  				 */
  				SpinLockAcquire(&xlogctl->info_lck);
  				xlogctl->recoveryLastRecPtr = EndRecPtr;
+ 				xlogctl->recoveryLastTLI = lastPageTLI;
  				SpinLockRelease(&xlogctl->info_lck);
  
  				LastRec = ReadRecPtr;
***************
*** 8269,8275 **** pg_current_xlog_insert_location(PG_FUNCTION_ARGS)
  }
  
  /*
!  * Report the last WAL receive location (same format as pg_start_backup etc)
   *
   * This is useful for determining how much of WAL is guaranteed to be received
   * and synced to disk by walreceiver.
--- 8279,8285 ----
  }
  
  /*
!  * Report the last WAL receive tli and location
   *
   * This is useful for determining how much of WAL is guaranteed to be received
   * and synced to disk by walreceiver.
***************
*** 8282,8294 **** pg_last_xlog_receive_location(PG_FUNCTION_ARGS)
  
  	recptr = GetWalRcvWriteRecPtr();
  
! 	snprintf(location, sizeof(location), "%X/%X",
  			 recptr.xlogid, recptr.xrecoff);
  	PG_RETURN_TEXT_P(cstring_to_text(location));
  }
  
  /*
!  * Report the last WAL replay location (same format as pg_start_backup etc)
   *
   * This is useful for determining how much of WAL is visible to read-only
   * connections during recovery.
--- 8292,8305 ----
  
  	recptr = GetWalRcvWriteRecPtr();
  
! 	snprintf(location, sizeof(location), "%X/%X/%X",
! 			 XLogRecPtrIsInvalid(recptr) ? 0 : GetRecoveryTargetTLI(),
  			 recptr.xlogid, recptr.xrecoff);
  	PG_RETURN_TEXT_P(cstring_to_text(location));
  }
  
  /*
!  * Report the last WAL replay tli and location
   *
   * This is useful for determining how much of WAL is visible to read-only
   * connections during recovery.
***************
*** 8298,8312 **** pg_last_xlog_replay_location(PG_FUNCTION_ARGS)
  {
  	/* use volatile pointer to prevent code rearrangement */
  	volatile XLogCtlData *xlogctl = XLogCtl;
  	XLogRecPtr	recptr;
  	char		location[MAXFNAMELEN];
  
  	SpinLockAcquire(&xlogctl->info_lck);
  	recptr = xlogctl->recoveryLastRecPtr;
  	SpinLockRelease(&xlogctl->info_lck);
  
! 	snprintf(location, sizeof(location), "%X/%X",
! 			 recptr.xlogid, recptr.xrecoff);
  	PG_RETURN_TEXT_P(cstring_to_text(location));
  }
  
--- 8309,8325 ----
  {
  	/* use volatile pointer to prevent code rearrangement */
  	volatile XLogCtlData *xlogctl = XLogCtl;
+ 	TimeLineID	tli;
  	XLogRecPtr	recptr;
  	char		location[MAXFNAMELEN];
  
  	SpinLockAcquire(&xlogctl->info_lck);
+ 	tli = xlogctl->recoveryLastTLI;
  	recptr = xlogctl->recoveryLastRecPtr;
  	SpinLockRelease(&xlogctl->info_lck);
  
! 	snprintf(location, sizeof(location), "%X/%X/%X",
! 			 tli, recptr.xlogid, recptr.xrecoff);
  	PG_RETURN_TEXT_P(cstring_to_text(location));
  }
  
***************
*** 8314,8319 **** pg_last_xlog_replay_location(PG_FUNCTION_ARGS)
--- 8327,8336 ----
   * Compute an xlog file name and decimal byte offset given a WAL location,
   * such as is returned by pg_stop_backup() or pg_xlog_switch().
   *
+  * Also use the tli for the computation if it's given with a location,
+  * such as is returned by pg_last_xlog_receive_location() or
+  * pg_last_xlog_replay_location().
+  *
   * Note that a location exactly at a segment boundary is taken to be in
   * the previous segment.  This is usually the right thing, since the
   * expected usage is to determine which xlog file(s) are ready to archive.
***************
*** 8323,8333 **** pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
--- 8340,8352 ----
  {
  	text	   *location = PG_GETARG_TEXT_P(0);
  	char	   *locationstr;
+ 	unsigned int utli;
  	unsigned int uxlogid;
  	unsigned int uxrecoff;
  	uint32		xlogid;
  	uint32		xlogseg;
  	uint32		xrecoff;
+ 	TimeLineID	tli = ThisTimeLineID;
  	XLogRecPtr	locationpoint;
  	char		xlogfilename[MAXFNAMELEN];
  	Datum		values[2];
***************
*** 8341,8347 **** pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
  	 */
  	locationstr = text_to_cstring(location);
  
! 	if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  				 errmsg("could not parse transaction log location \"%s\"",
--- 8360,8368 ----
  	 */
  	locationstr = text_to_cstring(location);
  
! 	if (sscanf(locationstr, "%X/%X/%X", &utli, &uxlogid, &uxrecoff) == 3)
! 		tli = (TimeLineID) utli;
! 	else if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  				 errmsg("could not parse transaction log location \"%s\"",
***************
*** 8366,8372 **** pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
  	 * xlogfilename
  	 */
  	XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
! 	XLogFileName(xlogfilename, ThisTimeLineID, xlogid, xlogseg);
  
  	values[0] = CStringGetTextDatum(xlogfilename);
  	isnull[0] = false;
--- 8387,8393 ----
  	 * xlogfilename
  	 */
  	XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
! 	XLogFileName(xlogfilename, tli, xlogid, xlogseg);
  
  	values[0] = CStringGetTextDatum(xlogfilename);
  	isnull[0] = false;
***************
*** 8392,8413 **** pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
  /*
   * Compute an xlog file name given a WAL location,
   * such as is returned by pg_stop_backup() or pg_xlog_switch().
   */
  Datum
  pg_xlogfile_name(PG_FUNCTION_ARGS)
  {
  	text	   *location = PG_GETARG_TEXT_P(0);
  	char	   *locationstr;
  	unsigned int uxlogid;
  	unsigned int uxrecoff;
  	uint32		xlogid;
  	uint32		xlogseg;
  	XLogRecPtr	locationpoint;
  	char		xlogfilename[MAXFNAMELEN];
  
  	locationstr = text_to_cstring(location);
  
! 	if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  				 errmsg("could not parse transaction log location \"%s\"",
--- 8413,8442 ----
  /*
   * Compute an xlog file name given a WAL location,
   * such as is returned by pg_stop_backup() or pg_xlog_switch().
+  *
+  * Also use the tli for the computation if it's given with a location,
+  * such as is returned by pg_last_xlog_receive_location() or
+  * pg_last_xlog_replay_location().
   */
  Datum
  pg_xlogfile_name(PG_FUNCTION_ARGS)
  {
  	text	   *location = PG_GETARG_TEXT_P(0);
  	char	   *locationstr;
+ 	unsigned int utli;
  	unsigned int uxlogid;
  	unsigned int uxrecoff;
  	uint32		xlogid;
  	uint32		xlogseg;
+ 	TimeLineID	tli = ThisTimeLineID;
  	XLogRecPtr	locationpoint;
  	char		xlogfilename[MAXFNAMELEN];
  
  	locationstr = text_to_cstring(location);
  
! 	if (sscanf(locationstr, "%X/%X/%X", &utli, &uxlogid, &uxrecoff) == 3)
! 		tli = (TimeLineID) utli;
! 	else if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  				 errmsg("could not parse transaction log location \"%s\"",
***************
*** 8417,8423 **** pg_xlogfile_name(PG_FUNCTION_ARGS)
  	locationpoint.xrecoff = uxrecoff;
  
  	XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
! 	XLogFileName(xlogfilename, ThisTimeLineID, xlogid, xlogseg);
  
  	PG_RETURN_TEXT_P(cstring_to_text(xlogfilename));
  }
--- 8446,8452 ----
  	locationpoint.xrecoff = uxrecoff;
  
  	XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
! 	XLogFileName(xlogfilename, tli, xlogid, xlogseg);
  
  	PG_RETURN_TEXT_P(cstring_to_text(xlogfilename));
  }

*** a/doc/src/sgml/func.sgml
--- b/doc/src/sgml/func.sgml
***************
*** 13199,13204 **** postgres=# SELECT * FROM pg_xlogfile_name_offset(pg_stop_backup());
--- 13199,13208 ----
      This is usually the desired behavior for managing transaction log archiving
      behavior, since the preceding file is the last one that currently
      needs to be archived.
+     These functions also accept as a parameter the string that consists of timeline and
+     location, separated by a slash. In this case a transaction log file name is computed
+     by using the given timeline. On the other hand, if timeline is not supplied, the
+     current timeline is used for the computation.
     </para>
  
     <para>
***************
*** 13245,13257 **** postgres=# SELECT * FROM pg_xlogfile_name_offset(pg_stop_backup());
          <literal><function>pg_last_xlog_receive_location</function>()</literal>
          </entry>
         <entry><type>text</type></entry>
!        <entry>Get last transaction log location received and synced to disk during
!         streaming recovery. If streaming recovery is still in progress
          this will increase monotonically. If streaming recovery has completed
          then this value will remain static at the value of the last WAL record
          received and synced to disk during that recovery. When the server has
          been started without a streaming recovery then the return value will be
!         InvalidXLogRecPtr (0/0).
         </entry>
        </row>
        <row>
--- 13249,13263 ----
          <literal><function>pg_last_xlog_receive_location</function>()</literal>
          </entry>
         <entry><type>text</type></entry>
!        <entry>Get timeline and location of last transaction log received and synced
!         to disk during streaming recovery. The return string is separated by a slash,
!         the first value indicates the timeline and the other the location.
!         If streaming recovery is still in progress
          this will increase monotonically. If streaming recovery has completed
          then this value will remain static at the value of the last WAL record
          received and synced to disk during that recovery. When the server has
          been started without a streaming recovery then the return value will be
!         <literal>0/0/0</>.
         </entry>
        </row>
        <row>
***************
*** 13259,13270 **** postgres=# SELECT * FROM pg_xlogfile_name_offset(pg_stop_backup());
          <literal><function>pg_last_xlog_replay_location</function>()</literal>
          </entry>
         <entry><type>text</type></entry>
!        <entry>Get last transaction log location replayed during recovery.
          If recovery is still in progress this will increase monotonically.
          If recovery has completed then this value will remain static at
          the value of the last WAL record applied during that recovery.
          When the server has been started normally without a recovery
!         then the return value will be InvalidXLogRecPtr (0/0).
         </entry>
        </row>
       </tbody>
--- 13265,13278 ----
          <literal><function>pg_last_xlog_replay_location</function>()</literal>
          </entry>
         <entry><type>text</type></entry>
!        <entry>Get timeline and location of last transaction log replayed during
!         recovery. The return string is separated by a slash, the first value
!         indicates the timeline and the other the location.
          If recovery is still in progress this will increase monotonically.
          If recovery has completed then this value will remain static at
          the value of the last WAL record applied during that recovery.
          When the server has been started normally without a recovery
!         then the return value will be <literal>0/0/0</>.
         </entry>
        </row>
       </tbody>
*** a/src/backend/access/transam/xlog.c
--- b/src/backend/access/transam/xlog.c
***************
*** 392,397 **** typedef struct XLogCtlData
--- 392,399 ----
  	TimestampTz recoveryLastXTime;
  	/* end+1 of the last record replayed */
  	XLogRecPtr	recoveryLastRecPtr;
+ 	/* tli of last record replayed */
+ 	TimeLineID	recoveryLastTLI;
  
  	slock_t		info_lck;		/* locks shared variables shown above */
  } XLogCtlData;
***************
*** 3581,3594 **** ReadRecord(XLogRecPtr *RecPtr, int emode_arg, bool fetching_ckpt)
  							RecPtr->xlogid, RecPtr->xrecoff)));
  
  		/*
! 		 * Since we are going to a random position in WAL, forget any prior
! 		 * state about what timeline we were in, and allow it to be any
! 		 * timeline in expectedTLIs.  We also set a flag to allow curFileTLI
! 		 * to go backwards (but we can't reset that variable right here, since
! 		 * we might not change files at all).
  		 */
! 		lastPageTLI = 0;		/* see comment in ValidXLOGHeader */
! 		randAccess = true;		/* allow curFileTLI to go backwards too */
  	}
  
  	/* Read the page containing the record */
--- 3583,3593 ----
  							RecPtr->xlogid, RecPtr->xrecoff)));
  
  		/*
! 		 * Since we are going to a random position in WAL, set a flag
! 		 * to allow curFileTLI to go backwards (but we can't reset that
! 		 * variable right here, since we might not change files at all).
  		 */
! 		randAccess = true;		/* allow curFileTLI to go backwards */
  	}
  
  	/* Read the page containing the record */
***************
*** 5782,5791 **** StartupXLOG(void)
  			/* use volatile pointer to prevent code rearrangement */
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			/* initialize shared replayEndRecPtr and recoveryLastRecPtr */
  			SpinLockAcquire(&xlogctl->info_lck);
  			xlogctl->replayEndRecPtr = ReadRecPtr;
  			xlogctl->recoveryLastRecPtr = ReadRecPtr;
  			SpinLockRelease(&xlogctl->info_lck);
  
  			InRedo = true;
--- 5781,5797 ----
  			/* use volatile pointer to prevent code rearrangement */
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			/*
! 			 * initialize shared replayEndRecPtr, recoveryLastRecPtr and
! 			 * recoveryLastTLI. Actually, the latter two variables don't need to
! 			 * be initialized here since they are expected to be updated at least
! 			 * once until read only connections will have read them. But just in
! 			 * case.
! 			 */
  			SpinLockAcquire(&xlogctl->info_lck);
  			xlogctl->replayEndRecPtr = ReadRecPtr;
  			xlogctl->recoveryLastRecPtr = ReadRecPtr;
+ 			xlogctl->recoveryLastTLI = lastPageTLI;
  			SpinLockRelease(&xlogctl->info_lck);
  
  			InRedo = true;
***************
*** 5913,5923 **** StartupXLOG(void)
  				error_context_stack = errcontext.previous;
  
  				/*
! 				 * Update shared recoveryLastRecPtr after this record has been
! 				 * replayed.
  				 */
  				SpinLockAcquire(&xlogctl->info_lck);
  				xlogctl->recoveryLastRecPtr = EndRecPtr;
  				SpinLockRelease(&xlogctl->info_lck);
  
  				LastRec = ReadRecPtr;
--- 5919,5930 ----
  				error_context_stack = errcontext.previous;
  
  				/*
! 				 * Update shared recoveryLastRecPtr and recoveryLastTLI
! 				 * after this record has been replayed.
  				 */
  				SpinLockAcquire(&xlogctl->info_lck);
  				xlogctl->recoveryLastRecPtr = EndRecPtr;
+ 				xlogctl->recoveryLastTLI = lastPageTLI;
  				SpinLockRelease(&xlogctl->info_lck);
  
  				LastRec = ReadRecPtr;
***************
*** 8274,8280 **** pg_current_xlog_insert_location(PG_FUNCTION_ARGS)
  }
  
  /*
!  * Report the last WAL receive location (same format as pg_start_backup etc)
   *
   * This is useful for determining how much of WAL is guaranteed to be received
   * and synced to disk by walreceiver.
--- 8281,8287 ----
  }
  
  /*
!  * Report the last WAL receive tli and location
   *
   * This is useful for determining how much of WAL is guaranteed to be received
   * and synced to disk by walreceiver.
***************
*** 8287,8299 **** pg_last_xlog_receive_location(PG_FUNCTION_ARGS)
  
  	recptr = GetWalRcvWriteRecPtr();
  
! 	snprintf(location, sizeof(location), "%X/%X",
  			 recptr.xlogid, recptr.xrecoff);
  	PG_RETURN_TEXT_P(cstring_to_text(location));
  }
  
  /*
!  * Report the last WAL replay location (same format as pg_start_backup etc)
   *
   * This is useful for determining how much of WAL is visible to read-only
   * connections during recovery.
--- 8294,8307 ----
  
  	recptr = GetWalRcvWriteRecPtr();
  
! 	snprintf(location, sizeof(location), "%X/%X/%X",
! 			 XLogRecPtrIsInvalid(recptr) ? 0 : GetRecoveryTargetTLI(),
  			 recptr.xlogid, recptr.xrecoff);
  	PG_RETURN_TEXT_P(cstring_to_text(location));
  }
  
  /*
!  * Report the last WAL replay tli and location
   *
   * This is useful for determining how much of WAL is visible to read-only
   * connections during recovery.
***************
*** 8303,8317 **** pg_last_xlog_replay_location(PG_FUNCTION_ARGS)
  {
  	/* use volatile pointer to prevent code rearrangement */
  	volatile XLogCtlData *xlogctl = XLogCtl;
  	XLogRecPtr	recptr;
  	char		location[MAXFNAMELEN];
  
  	SpinLockAcquire(&xlogctl->info_lck);
  	recptr = xlogctl->recoveryLastRecPtr;
  	SpinLockRelease(&xlogctl->info_lck);
  
! 	snprintf(location, sizeof(location), "%X/%X",
! 			 recptr.xlogid, recptr.xrecoff);
  	PG_RETURN_TEXT_P(cstring_to_text(location));
  }
  
--- 8311,8327 ----
  {
  	/* use volatile pointer to prevent code rearrangement */
  	volatile XLogCtlData *xlogctl = XLogCtl;
+ 	TimeLineID	tli;
  	XLogRecPtr	recptr;
  	char		location[MAXFNAMELEN];
  
  	SpinLockAcquire(&xlogctl->info_lck);
+ 	tli = xlogctl->recoveryLastTLI;
  	recptr = xlogctl->recoveryLastRecPtr;
  	SpinLockRelease(&xlogctl->info_lck);
  
! 	snprintf(location, sizeof(location), "%X/%X/%X",
! 			 tli, recptr.xlogid, recptr.xrecoff);
  	PG_RETURN_TEXT_P(cstring_to_text(location));
  }
  
***************
*** 8319,8324 **** pg_last_xlog_replay_location(PG_FUNCTION_ARGS)
--- 8329,8338 ----
   * Compute an xlog file name and decimal byte offset given a WAL location,
   * such as is returned by pg_stop_backup() or pg_xlog_switch().
   *
+  * Also use the tli for the computation if it's given with a location,
+  * such as is returned by pg_last_xlog_receive_location() or
+  * pg_last_xlog_replay_location().
+  *
   * Note that a location exactly at a segment boundary is taken to be in
   * the previous segment.  This is usually the right thing, since the
   * expected usage is to determine which xlog file(s) are ready to archive.
***************
*** 8328,8338 **** pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
--- 8342,8354 ----
  {
  	text	   *location = PG_GETARG_TEXT_P(0);
  	char	   *locationstr;
+ 	unsigned int utli;
  	unsigned int uxlogid;
  	unsigned int uxrecoff;
  	uint32		xlogid;
  	uint32		xlogseg;
  	uint32		xrecoff;
+ 	TimeLineID	tli = ThisTimeLineID;
  	XLogRecPtr	locationpoint;
  	char		xlogfilename[MAXFNAMELEN];
  	Datum		values[2];
***************
*** 8346,8352 **** pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
  	 */
  	locationstr = text_to_cstring(location);
  
! 	if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  				 errmsg("could not parse transaction log location \"%s\"",
--- 8362,8370 ----
  	 */
  	locationstr = text_to_cstring(location);
  
! 	if (sscanf(locationstr, "%X/%X/%X", &utli, &uxlogid, &uxrecoff) == 3)
! 		tli = (TimeLineID) utli;
! 	else if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  				 errmsg("could not parse transaction log location \"%s\"",
***************
*** 8371,8377 **** pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
  	 * xlogfilename
  	 */
  	XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
! 	XLogFileName(xlogfilename, ThisTimeLineID, xlogid, xlogseg);
  
  	values[0] = CStringGetTextDatum(xlogfilename);
  	isnull[0] = false;
--- 8389,8395 ----
  	 * xlogfilename
  	 */
  	XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
! 	XLogFileName(xlogfilename, tli, xlogid, xlogseg);
  
  	values[0] = CStringGetTextDatum(xlogfilename);
  	isnull[0] = false;
***************
*** 8397,8418 **** pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
  /*
   * Compute an xlog file name given a WAL location,
   * such as is returned by pg_stop_backup() or pg_xlog_switch().
   */
  Datum
  pg_xlogfile_name(PG_FUNCTION_ARGS)
  {
  	text	   *location = PG_GETARG_TEXT_P(0);
  	char	   *locationstr;
  	unsigned int uxlogid;
  	unsigned int uxrecoff;
  	uint32		xlogid;
  	uint32		xlogseg;
  	XLogRecPtr	locationpoint;
  	char		xlogfilename[MAXFNAMELEN];
  
  	locationstr = text_to_cstring(location);
  
! 	if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  				 errmsg("could not parse transaction log location \"%s\"",
--- 8415,8444 ----
  /*
   * Compute an xlog file name given a WAL location,
   * such as is returned by pg_stop_backup() or pg_xlog_switch().
+  *
+  * Also use the tli for the computation if it's given with a location,
+  * such as is returned by pg_last_xlog_receive_location() or
+  * pg_last_xlog_replay_location().
   */
  Datum
  pg_xlogfile_name(PG_FUNCTION_ARGS)
  {
  	text	   *location = PG_GETARG_TEXT_P(0);
  	char	   *locationstr;
+ 	unsigned int utli;
  	unsigned int uxlogid;
  	unsigned int uxrecoff;
  	uint32		xlogid;
  	uint32		xlogseg;
+ 	TimeLineID	tli = ThisTimeLineID;
  	XLogRecPtr	locationpoint;
  	char		xlogfilename[MAXFNAMELEN];
  
  	locationstr = text_to_cstring(location);
  
! 	if (sscanf(locationstr, "%X/%X/%X", &utli, &uxlogid, &uxrecoff) == 3)
! 		tli = (TimeLineID) utli;
! 	else if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  				 errmsg("could not parse transaction log location \"%s\"",
***************
*** 8422,8428 **** pg_xlogfile_name(PG_FUNCTION_ARGS)
  	locationpoint.xrecoff = uxrecoff;
  
  	XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
! 	XLogFileName(xlogfilename, ThisTimeLineID, xlogid, xlogseg);
  
  	PG_RETURN_TEXT_P(cstring_to_text(xlogfilename));
  }
--- 8448,8454 ----
  	locationpoint.xrecoff = uxrecoff;
  
  	XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
! 	XLogFileName(xlogfilename, tli, xlogid, xlogseg);
  
  	PG_RETURN_TEXT_P(cstring_to_text(xlogfilename));
  }
***************
*** 8721,8726 **** XLogPageRead(XLogRecPtr *RecPtr, int emode, bool fetching_ckpt,
--- 8747,8760 ----
  		return true;
  
  	/*
+ 	 * Since we are going to a random position in WAL, forget any prior
+ 	 * state about what timeline we were in, and allow it to be any
+ 	 * timeline in expectedTLIs.
+ 	 */
+ 	if (randAccess)
+ 		lastPageTLI = 0;		/* see comment in ValidXLOGHeader */
+ 
+ 	/*
  	 * See if we need to switch to a new segment because the requested record
  	 * is not in the currently open one.
  	 */

*** a/doc/src/sgml/func.sgml
--- b/doc/src/sgml/func.sgml
***************
*** 13199,13204 **** postgres=# SELECT * FROM pg_xlogfile_name_offset(pg_stop_backup());
--- 13199,13208 ----
      This is usually the desired behavior for managing transaction log archiving
      behavior, since the preceding file is the last one that currently
      needs to be archived.
+     These functions also accept as a parameter the string that consists of timeline and
+     location, separated by a slash. In this case a transaction log file name is computed
+     by using the given timeline. On the other hand, if timeline is not supplied, the
+     current timeline is used for the computation.
     </para>
  
     <para>
***************
*** 13245,13257 **** postgres=# SELECT * FROM pg_xlogfile_name_offset(pg_stop_backup());
          <literal><function>pg_last_xlog_receive_location</function>()</literal>
          </entry>
         <entry><type>text</type></entry>
!        <entry>Get last transaction log location received and synced to disk during
!         streaming recovery. If streaming recovery is still in progress
          this will increase monotonically. If streaming recovery has completed
          then this value will remain static at the value of the last WAL record
          received and synced to disk during that recovery. When the server has
          been started without a streaming recovery then the return value will be
!         InvalidXLogRecPtr (0/0).
         </entry>
        </row>
        <row>
--- 13249,13263 ----
          <literal><function>pg_last_xlog_receive_location</function>()</literal>
          </entry>
         <entry><type>text</type></entry>
!        <entry>Get timeline and location of last transaction log received and synced
!         to disk during streaming recovery. The return string is separated by a slash,
!         the first value indicates the timeline and the other the location.
!         If streaming recovery is still in progress
          this will increase monotonically. If streaming recovery has completed
          then this value will remain static at the value of the last WAL record
          received and synced to disk during that recovery. When the server has
          been started without a streaming recovery then the return value will be
!         <literal>0/0/0</>.
         </entry>
        </row>
        <row>
***************
*** 13259,13270 **** postgres=# SELECT * FROM pg_xlogfile_name_offset(pg_stop_backup());
          <literal><function>pg_last_xlog_replay_location</function>()</literal>
          </entry>
         <entry><type>text</type></entry>
!        <entry>Get last transaction log location replayed during recovery.
          If recovery is still in progress this will increase monotonically.
          If recovery has completed then this value will remain static at
          the value of the last WAL record applied during that recovery.
          When the server has been started normally without a recovery
!         then the return value will be InvalidXLogRecPtr (0/0).
         </entry>
        </row>
       </tbody>
--- 13265,13278 ----
          <literal><function>pg_last_xlog_replay_location</function>()</literal>
          </entry>
         <entry><type>text</type></entry>
!        <entry>Get timeline and location of last transaction log replayed during
!         recovery. The return string is separated by a slash, the first value
!         indicates the timeline and the other the location.
          If recovery is still in progress this will increase monotonically.
          If recovery has completed then this value will remain static at
          the value of the last WAL record applied during that recovery.
          When the server has been started normally without a recovery
!         then the return value will be <literal>0/0/0</>.
         </entry>
        </row>
       </tbody>
*** a/src/backend/access/transam/xlog.c
--- b/src/backend/access/transam/xlog.c
***************
*** 392,397 **** typedef struct XLogCtlData
--- 392,399 ----
  	TimestampTz recoveryLastXTime;
  	/* end+1 of the last record replayed */
  	XLogRecPtr	recoveryLastRecPtr;
+ 	/* tli of last record replayed */
+ 	TimeLineID	recoveryLastTLI;
  
  	slock_t		info_lck;		/* locks shared variables shown above */
  } XLogCtlData;
***************
*** 471,476 **** static uint32 readRecordBufSize = 0;
--- 473,479 ----
  static XLogRecPtr ReadRecPtr;	/* start of last record read */
  static XLogRecPtr EndRecPtr;	/* end+1 of last record read */
  static TimeLineID lastPageTLI = 0;
+ static TimeLineID lastRecTLI = 0;	/* tli of last record read */
  
  static XLogRecPtr minRecoveryPoint;		/* local copy of
  										 * ControlFile->minRecoveryPoint */
***************
*** 3943,3949 **** ValidXLOGHeader(XLogPageHeader hdr, int emode)
  						readId, readSeg, readOff)));
  		return false;
  	}
! 	lastPageTLI = hdr->xlp_tli;
  	return true;
  }
  
--- 3946,3952 ----
  						readId, readSeg, readOff)));
  		return false;
  	}
! 	lastRecTLI = lastPageTLI = hdr->xlp_tli;
  	return true;
  }
  
***************
*** 5782,5791 **** StartupXLOG(void)
  			/* use volatile pointer to prevent code rearrangement */
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			/* initialize shared replayEndRecPtr and recoveryLastRecPtr */
  			SpinLockAcquire(&xlogctl->info_lck);
  			xlogctl->replayEndRecPtr = ReadRecPtr;
  			xlogctl->recoveryLastRecPtr = ReadRecPtr;
  			SpinLockRelease(&xlogctl->info_lck);
  
  			InRedo = true;
--- 5785,5801 ----
  			/* use volatile pointer to prevent code rearrangement */
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			/*
! 			 * initialize shared replayEndRecPtr, recoveryLastRecPtr and
! 			 * recoveryLastTLI. Actually, the latter two variables don't need to
! 			 * be initialized here since they are expected to be updated at least
! 			 * once until read only connections will have read them. But just in
! 			 * case.
! 			 */
  			SpinLockAcquire(&xlogctl->info_lck);
  			xlogctl->replayEndRecPtr = ReadRecPtr;
  			xlogctl->recoveryLastRecPtr = ReadRecPtr;
+ 			xlogctl->recoveryLastTLI = lastRecTLI;
  			SpinLockRelease(&xlogctl->info_lck);
  
  			InRedo = true;
***************
*** 5913,5923 **** StartupXLOG(void)
  				error_context_stack = errcontext.previous;
  
  				/*
! 				 * Update shared recoveryLastRecPtr after this record has been
! 				 * replayed.
  				 */
  				SpinLockAcquire(&xlogctl->info_lck);
  				xlogctl->recoveryLastRecPtr = EndRecPtr;
  				SpinLockRelease(&xlogctl->info_lck);
  
  				LastRec = ReadRecPtr;
--- 5923,5934 ----
  				error_context_stack = errcontext.previous;
  
  				/*
! 				 * Update shared recoveryLastRecPtr and recoveryLastTLI
! 				 * after this record has been replayed.
  				 */
  				SpinLockAcquire(&xlogctl->info_lck);
  				xlogctl->recoveryLastRecPtr = EndRecPtr;
+ 				xlogctl->recoveryLastTLI = lastRecTLI;
  				SpinLockRelease(&xlogctl->info_lck);
  
  				LastRec = ReadRecPtr;
***************
*** 7479,7484 **** xlog_redo(XLogRecPtr lsn, XLogRecord *record)
--- 7490,7496 ----
  			/* Following WAL records should be run with new TLI */
  			ThisTimeLineID = checkPoint.ThisTimeLineID;
  		}
+ 		lastRecTLI = ThisTimeLineID;
  
  		RecoveryRestartPoint(&checkPoint);
  	}
***************
*** 8274,8280 **** pg_current_xlog_insert_location(PG_FUNCTION_ARGS)
  }
  
  /*
!  * Report the last WAL receive location (same format as pg_start_backup etc)
   *
   * This is useful for determining how much of WAL is guaranteed to be received
   * and synced to disk by walreceiver.
--- 8286,8292 ----
  }
  
  /*
!  * Report the last WAL receive tli and location
   *
   * This is useful for determining how much of WAL is guaranteed to be received
   * and synced to disk by walreceiver.
***************
*** 8287,8299 **** pg_last_xlog_receive_location(PG_FUNCTION_ARGS)
  
  	recptr = GetWalRcvWriteRecPtr();
  
! 	snprintf(location, sizeof(location), "%X/%X",
  			 recptr.xlogid, recptr.xrecoff);
  	PG_RETURN_TEXT_P(cstring_to_text(location));
  }
  
  /*
!  * Report the last WAL replay location (same format as pg_start_backup etc)
   *
   * This is useful for determining how much of WAL is visible to read-only
   * connections during recovery.
--- 8299,8312 ----
  
  	recptr = GetWalRcvWriteRecPtr();
  
! 	snprintf(location, sizeof(location), "%X/%X/%X",
! 			 XLogRecPtrIsInvalid(recptr) ? 0 : GetRecoveryTargetTLI(),
  			 recptr.xlogid, recptr.xrecoff);
  	PG_RETURN_TEXT_P(cstring_to_text(location));
  }
  
  /*
!  * Report the last WAL replay tli and location
   *
   * This is useful for determining how much of WAL is visible to read-only
   * connections during recovery.
***************
*** 8303,8317 **** pg_last_xlog_replay_location(PG_FUNCTION_ARGS)
  {
  	/* use volatile pointer to prevent code rearrangement */
  	volatile XLogCtlData *xlogctl = XLogCtl;
  	XLogRecPtr	recptr;
  	char		location[MAXFNAMELEN];
  
  	SpinLockAcquire(&xlogctl->info_lck);
  	recptr = xlogctl->recoveryLastRecPtr;
  	SpinLockRelease(&xlogctl->info_lck);
  
! 	snprintf(location, sizeof(location), "%X/%X",
! 			 recptr.xlogid, recptr.xrecoff);
  	PG_RETURN_TEXT_P(cstring_to_text(location));
  }
  
--- 8316,8332 ----
  {
  	/* use volatile pointer to prevent code rearrangement */
  	volatile XLogCtlData *xlogctl = XLogCtl;
+ 	TimeLineID	tli;
  	XLogRecPtr	recptr;
  	char		location[MAXFNAMELEN];
  
  	SpinLockAcquire(&xlogctl->info_lck);
+ 	tli = xlogctl->recoveryLastTLI;
  	recptr = xlogctl->recoveryLastRecPtr;
  	SpinLockRelease(&xlogctl->info_lck);
  
! 	snprintf(location, sizeof(location), "%X/%X/%X",
! 			 tli, recptr.xlogid, recptr.xrecoff);
  	PG_RETURN_TEXT_P(cstring_to_text(location));
  }
  
***************
*** 8319,8324 **** pg_last_xlog_replay_location(PG_FUNCTION_ARGS)
--- 8334,8343 ----
   * Compute an xlog file name and decimal byte offset given a WAL location,
   * such as is returned by pg_stop_backup() or pg_xlog_switch().
   *
+  * Also use the tli for the computation if it's given with a location,
+  * such as is returned by pg_last_xlog_receive_location() or
+  * pg_last_xlog_replay_location().
+  *
   * Note that a location exactly at a segment boundary is taken to be in
   * the previous segment.  This is usually the right thing, since the
   * expected usage is to determine which xlog file(s) are ready to archive.
***************
*** 8328,8338 **** pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
--- 8347,8359 ----
  {
  	text	   *location = PG_GETARG_TEXT_P(0);
  	char	   *locationstr;
+ 	unsigned int utli;
  	unsigned int uxlogid;
  	unsigned int uxrecoff;
  	uint32		xlogid;
  	uint32		xlogseg;
  	uint32		xrecoff;
+ 	TimeLineID	tli = ThisTimeLineID;
  	XLogRecPtr	locationpoint;
  	char		xlogfilename[MAXFNAMELEN];
  	Datum		values[2];
***************
*** 8346,8352 **** pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
  	 */
  	locationstr = text_to_cstring(location);
  
! 	if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  				 errmsg("could not parse transaction log location \"%s\"",
--- 8367,8375 ----
  	 */
  	locationstr = text_to_cstring(location);
  
! 	if (sscanf(locationstr, "%X/%X/%X", &utli, &uxlogid, &uxrecoff) == 3)
! 		tli = (TimeLineID) utli;
! 	else if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  				 errmsg("could not parse transaction log location \"%s\"",
***************
*** 8371,8377 **** pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
  	 * xlogfilename
  	 */
  	XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
! 	XLogFileName(xlogfilename, ThisTimeLineID, xlogid, xlogseg);
  
  	values[0] = CStringGetTextDatum(xlogfilename);
  	isnull[0] = false;
--- 8394,8400 ----
  	 * xlogfilename
  	 */
  	XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
! 	XLogFileName(xlogfilename, tli, xlogid, xlogseg);
  
  	values[0] = CStringGetTextDatum(xlogfilename);
  	isnull[0] = false;
***************
*** 8397,8418 **** pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
  /*
   * Compute an xlog file name given a WAL location,
   * such as is returned by pg_stop_backup() or pg_xlog_switch().
   */
  Datum
  pg_xlogfile_name(PG_FUNCTION_ARGS)
  {
  	text	   *location = PG_GETARG_TEXT_P(0);
  	char	   *locationstr;
  	unsigned int uxlogid;
  	unsigned int uxrecoff;
  	uint32		xlogid;
  	uint32		xlogseg;
  	XLogRecPtr	locationpoint;
  	char		xlogfilename[MAXFNAMELEN];
  
  	locationstr = text_to_cstring(location);
  
! 	if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  				 errmsg("could not parse transaction log location \"%s\"",
--- 8420,8449 ----
  /*
   * Compute an xlog file name given a WAL location,
   * such as is returned by pg_stop_backup() or pg_xlog_switch().
+  *
+  * Also use the tli for the computation if it's given with a location,
+  * such as is returned by pg_last_xlog_receive_location() or
+  * pg_last_xlog_replay_location().
   */
  Datum
  pg_xlogfile_name(PG_FUNCTION_ARGS)
  {
  	text	   *location = PG_GETARG_TEXT_P(0);
  	char	   *locationstr;
+ 	unsigned int utli;
  	unsigned int uxlogid;
  	unsigned int uxrecoff;
  	uint32		xlogid;
  	uint32		xlogseg;
+ 	TimeLineID	tli = ThisTimeLineID;
  	XLogRecPtr	locationpoint;
  	char		xlogfilename[MAXFNAMELEN];
  
  	locationstr = text_to_cstring(location);
  
! 	if (sscanf(locationstr, "%X/%X/%X", &utli, &uxlogid, &uxrecoff) == 3)
! 		tli = (TimeLineID) utli;
! 	else if (sscanf(locationstr, "%X/%X", &uxlogid, &uxrecoff) != 2)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  				 errmsg("could not parse transaction log location \"%s\"",
***************
*** 8422,8428 **** pg_xlogfile_name(PG_FUNCTION_ARGS)
  	locationpoint.xrecoff = uxrecoff;
  
  	XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
! 	XLogFileName(xlogfilename, ThisTimeLineID, xlogid, xlogseg);
  
  	PG_RETURN_TEXT_P(cstring_to_text(xlogfilename));
  }
--- 8453,8459 ----
  	locationpoint.xrecoff = uxrecoff;
  
  	XLByteToPrevSeg(locationpoint, xlogid, xlogseg);
! 	XLogFileName(xlogfilename, tli, xlogid, xlogseg);
  
  	PG_RETURN_TEXT_P(cstring_to_text(xlogfilename));
  }