Moving more work outside WALInsertLock

*** a/src/backend/access/transam/xlog.c
--- b/src/backend/access/transam/xlog.c
***************
*** 42,47 ****
--- 42,48 ----
  #include "postmaster/startup.h"
  #include "replication/walreceiver.h"
  #include "replication/walsender.h"
+ #include "storage/barrier.h"
  #include "storage/bufmgr.h"
  #include "storage/fd.h"
  #include "storage/ipc.h"
***************
*** 272,277 **** static XLogRecPtr RedoRecPtr;
--- 273,290 ----
   */
  static XLogRecPtr RedoStartLSN = {0, 0};
  
+ /*
+  * We have one of these for each backend, plus one that is shared by all
+  * auxiliary processes. WALAuxSlotLock is used to coordinate access to the
+  * shared slot.
+  */
+ typedef struct
+ {
+ 	XLogRecPtr	CurrPos;	/* current position this process is inserting to */
+ } BackendXLogInsertSlot;
+ 
+ #define NumXLogInsertSlots	(MaxBackends + 1)
+ 
  /*----------
   * Shared-memory data structures for XLOG control
   *
***************
*** 282,292 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There are actually three shared-memory copies of
   * LogwrtResult, plus one unshared copy in each backend.  Here's how it works:
   *		XLogCtl->LogwrtResult is protected by info_lck
   *		XLogCtl->Write.LogwrtResult is protected by WALWriteLock
-  *		XLogCtl->Insert.LogwrtResult is protected by WALInsertLock
   * One must hold the associated lock to read or write any of these, but
   * of course no lock is needed to read/write the unshared LogwrtResult.
   *
--- 295,304 ----
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There are actually two shared-memory copies of
   * LogwrtResult, plus one unshared copy in each backend.  Here's how it works:
   *		XLogCtl->LogwrtResult is protected by info_lck
   *		XLogCtl->Write.LogwrtResult is protected by WALWriteLock
   * One must hold the associated lock to read or write any of these, but
   * of course no lock is needed to read/write the unshared LogwrtResult.
   *
***************
*** 296,307 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * is that it can be examined/modified by code that already holds WALWriteLock
   * without needing to grab info_lck as well.
   *
!  * XLogCtl->Insert.LogwrtResult may lag behind the reality of the other two,
!  * but is updated when convenient.	Again, it exists for the convenience of
!  * code that is already holding WALInsertLock but not the other locks.
!  *
!  * The unshared LogwrtResult may lag behind any or all of these, and again
!  * is updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
--- 308,315 ----
   * is that it can be examined/modified by code that already holds WALWriteLock
   * without needing to grab info_lck as well.
   *
!  * The unshared LogwrtResult may lag behind either or both of these, and is
!  * updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
***************
*** 311,320 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  The other locks are held longer (potentially
!  * over I/O operations), so we use LWLocks for them.  These locks are:
   *
!  * WALInsertLock: must be held to insert a record into the WAL buffers.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
--- 319,333 ----
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  insertpos_lck protects the current logical
!  * insert location, ie. the head of reserved WAL space.  The other locks are
!  * held longer (potentially over I/O operations), so we use LWLocks for them.
!  * These locks are:
   *
!  * WALBufMappingLock: must be held to replace a page in the WAL buffer cache.
!  * This is only held while initializing and changing the mapping. If the
!  * contents of the buffer being replaced haven't been written yet, the mapping
!  * lock is released while the write is done, and reacquired afterwards.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
***************
*** 326,331 **** static XLogRecPtr RedoStartLSN = {0, 0};
--- 339,392 ----
   * only one checkpointer at a time; currently, with all checkpoints done by
   * the checkpointer, this is just pro forma).
   *
+  *
+  *
+  * Inserting a new WAL record is a two-step process:
+  *
+  * 1. Reserve the right amount of space from the WAL. The current head
+  *    of reserved space is kept in Insert->CurrPos, and is protected by
+  *    infopos_lck. Try to keep this section as short as possible, infopos_lck
+  *    can be heavily contended on a busy system
+  *
+  * 2. Copy the record to the reserved WAL space. This involves finding the
+  *    correct WAL buffer containing the reserved space, and copying the
+  *    record in place. This can be done concurrently in multiple processes.
+  *
+  * To allow as much parallelism as possible for step 2, we try hard to avoid
+  * lock contention in that code path. Each backend has its own "XLog insertion
+  * slot", which is used to indicate the position the backend is writing to.
+  * The slot is marked as in-use in step 1, while holding infopos_lck, by
+  * setting the position field in the slot. When the backend is finished with
+  * the insertion, it can clear its slot without a lock.
+  *
+  * Before 9.2, WAL insertion was serialized on one big lock, so that once
+  * you finished inserting your record you knew that all the previous records
+  * were inserted too. That is no longer true, there can be insertions to
+  * earlier positions still in-progress when your insertion finishes. To wait
+  * for them to finish, use WaitXLogInsertionsToFinish(). It polls (FIXME:
+  * busy-waiting is bad) the array of per-backend XLog insertion slots until
+  * it sees that all of the insertions to earlier locations have finished.
+  *
+  *
+  * Deadlock analysis
+  * -----------------
+  *
+  * It's important to call WaitXLogInsertionsToFinish() *before* acquiring
+  * WALWriteLock. Otherwise you might get stuck waiting for a backend to finish
+  * (or at least advance to next uninitialized page), while you're holding
+  * WALWriteLock. That would be bad, because the backend you're waiting for
+  * might need to acquire WALWriteLock, too, to evict an old buffer, so you'd
+  * get deadlock.
+  *
+  * WaitXLogInsertionsToFinish() will not get stuck indefinitely, as long as
+  * its called with a location that's known to be already allocated in the WAL
+  * buffers. Calling it with the position of a record you've already inserted
+  * satisfies that condition. It can't get stuck, because an insertion to a
+  * WAL page that's already initialized in cache can always proceed without
+  * waiting on a lock. However, if the page has *just* been initialized, the
+  * insertion might still briefly acquire WALBufMappingLock to observe that
+  * fact.
+  *
   *----------
   */
  
***************
*** 346,356 **** typedef struct XLogwrtResult
   */
  typedef struct XLogCtlInsert
  {
! 	XLogwrtResult LogwrtResult; /* a recent value of LogwrtResult */
! 	XLogRecPtr	PrevRecord;		/* start of previously-inserted record */
! 	int			curridx;		/* current block index in cache */
! 	XLogPageHeader currpage;	/* points to header of block in cache */
! 	char	   *currpos;		/* current insertion point in cache */
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
--- 407,431 ----
   */
  typedef struct XLogCtlInsert
  {
! 	slock_t		insertpos_lck;	/* protects all the fields in this struct. */
! 
! 	/*
! 	 * CurrPos is the very tip of the reserved WAL space at the moment. The
! 	 * next record will be inserted there (or somewhere after it if there's
! 	 * not enough space on the current page). PrevRecord points to the
! 	 * beginning of the last record already reserved. It might not be fully
! 	 * copied into place yet, but we know its exact location.
! 	 */
! 	XLogRecPtr	CurrPos;
! 	XLogRecPtr	PrevRecord;
! 
! 	/*
! 	 * padding to push RedoRecPtr and forcePageWrites, which rarely change,
! 	 * to a different cache line than the rapidly-changing CurrPos and
! 	 * PrevRecord values.
! 	 */
! 	char		padding[128];
! 
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
***************
*** 381,389 **** typedef struct XLogCtlWrite
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by WALInsertLock: */
  	XLogCtlInsert Insert;
  
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
--- 456,466 ----
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by insertpos_lck: */
  	XLogCtlInsert Insert;
  
+ 	BackendXLogInsertSlot *BackendXLogInsertSlots;
+ 
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
***************
*** 397,405 **** typedef struct XLogCtlData
  	XLogCtlWrite Write;
  
  	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALInsertLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
--- 474,492 ----
  	XLogCtlWrite Write;
  
  	/*
+ 	 * To change curridx and the identity of a buffer, you need to hold
+ 	 * WALBufMappingLock. To change the identity of a buffer that's
+ 	 * still dirty, the old page needs to be written out first, and for that
+ 	 * you need WALWriteLock, and you need to ensure that there's no
+ 	 * in-progress insertions to the page by calling
+ 	 * WaitXLogInsertionsToFinish().
+ 	 */
+ 	int			curridx;		/* current (latest) block index in cache */
+ 
+ 	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALBufMappingLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
***************
*** 468,497 **** static XLogCtlData *XLogCtl = NULL;
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Macros for managing XLogInsert state.  In most cases, the calling routine
!  * has local copies of XLogCtl->Insert and/or XLogCtl->Insert->curridx,
!  * so these are passed as parameters instead of being fetched via XLogCtl.
   */
! 
! /* Free space remaining in the current xlog page buffer */
! #define INSERT_FREESPACE(Insert)  \
! 	(XLOG_BLCKSZ - ((Insert)->currpos - (char *) (Insert)->currpage))
! 
! /* Construct XLogRecPtr value for current insertion point */
! #define INSERT_RECPTR(recptr,Insert,curridx)  \
! 	( \
! 	  (recptr).xlogid = XLogCtl->xlblocks[curridx].xlogid, \
! 	  (recptr).xrecoff = \
! 		XLogCtl->xlblocks[curridx].xrecoff - INSERT_FREESPACE(Insert) \
! 	)
! 
! #define PrevBufIdx(idx)		\
! 		(((idx) == 0) ? XLogCtl->XLogCacheBlck : ((idx) - 1))
  
  #define NextBufIdx(idx)		\
  		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
   * See discussion above.
   */
--- 555,583 ----
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Calculate the amount of space left on the page after 'endptr'.
!  * Beware multiple evaluation!
   */
! #define INSERT_FREESPACE(endptr)	\
! 	(((endptr).xrecoff % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr).xrecoff % XLOG_BLCKSZ))
  
  #define NextBufIdx(idx)		\
  		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  /*
+  * XLogRecPtrToBufIdx returns the index of the WAL buffer that holds, or
+  * would hold if it was in cache, the page containing 'recptr'.
+  *
+  * XLogRecEndPtrToBufIdx is the same, but a pointer to the first byte of a
+  * page is taken to mean the previous page.
+  */
+ #define XLogRecPtrToBufIdx(recptr)	\
+ 	((((((uint64) (recptr).xlogid * (uint64) XLogSegsPerFile * XLogSegSize) + (recptr).xrecoff)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
+ 
+ #define XLogRecEndPtrToBufIdx(recptr)	\
+ 	((((((uint64) (recptr).xlogid * (uint64) XLogSegsPerFile * XLogSegSize) + (recptr).xrecoff - 1)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
+ 
+ /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
   * See discussion above.
   */
***************
*** 614,620 **** static void KeepLogSeg(XLogRecPtr recptr, uint32 *logId, uint32 *logSeg);
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static bool AdvanceXLInsertBuffer(bool new_segment);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
  static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
--- 700,706 ----
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static void AdvanceXLInsertBuffer(bool new_segment, XLogRecPtr upto, bool opportunistic);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
  static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
***************
*** 663,668 **** static bool read_backup_label(XLogRecPtr *checkPointLoc,
--- 749,766 ----
  static void rm_redo_error_callback(void *arg);
  static int	get_sync_bit(int method);
  
+ static XLogRecPtr PerformXLogInsert(int write_len, XLogRecord *rechdr,
+ 				  XLogRecData *rdata, pg_crc32 rdata_crc,
+ 				  bool forcePageWrites);
+ static bool ReserveXLogInsertLocation(int reqsize, bool forcePageWrites,
+ 						  XLogRecPtr *PrevRecord, XLogRecPtr *StartPos,
+ 						  XLogRecPtr *EndPos,
+ 						  volatile BackendXLogInsertSlot *myslot);
+ static XLogRecPtr WaitXLogInsertionsToFinish(XLogRecPtr upto,
+ 						   XLogRecPtr CurrPos);
+ static char *GetXLogBuffer(XLogRecPtr ptr);
+ static XLogRecPtr AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr);
+ 
  
  /*
   * Insert an XLOG record having the specified RMID and info bytes,
***************
*** 683,695 **** XLogRecPtr
  XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
- 	XLogRecord *record;
- 	XLogContRecord *contrecord;
  	XLogRecPtr	RecPtr;
- 	XLogRecPtr	WriteRqst;
- 	uint32		freespace;
- 	int			curridx;
  	XLogRecData *rdt;
  	Buffer		dtbuf[XLR_MAX_BKP_BLOCKS];
  	bool		dtbuf_bkp[XLR_MAX_BKP_BLOCKS];
  	BkpBlock	dtbuf_xlg[XLR_MAX_BKP_BLOCKS];
--- 781,789 ----
  XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	RecPtr;
  	XLogRecData *rdt;
+ 	XLogRecData *rdt_lastnormal;
  	Buffer		dtbuf[XLR_MAX_BKP_BLOCKS];
  	bool		dtbuf_bkp[XLR_MAX_BKP_BLOCKS];
  	BkpBlock	dtbuf_xlg[XLR_MAX_BKP_BLOCKS];
***************
*** 701,709 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  	uint32		len,
  				write_len;
  	unsigned	i;
- 	bool		updrqst;
  	bool		doPageWrites;
  	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
--- 795,805 ----
  	uint32		len,
  				write_len;
  	unsigned	i;
  	bool		doPageWrites;
+ 	bool		forcePageWrites;
  	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
+ 	uint8		info_final;
+ 	XLogRecord	rechdr;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
***************
*** 726,751 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  		return RecPtr;
  	}
  
  	/*
  	 * Here we scan the rdata chain, determine which buffers must be backed
! 	 * up, and compute the CRC values for the data.  Note that the record
! 	 * header isn't added into the CRC initially since we don't know the final
! 	 * length or info bits quite yet.  Thus, the CRC will represent the CRC of
! 	 * the whole record in the order "rdata, then backup blocks, then record
! 	 * header".
  	 *
  	 * We may have to loop back to here if a race condition is detected below.
  	 * We could prevent the race by doing all this work while holding the
  	 * insert lock, but it seems better to avoid doing CRC calculations while
! 	 * holding the lock.  This means we have to be careful about modifying the
! 	 * rdata chain until we know we aren't going to loop back again.  The only
! 	 * change we allow ourselves to make earlier is to set rdt->data = NULL in
! 	 * chain items we have decided we will have to back up the whole buffer
! 	 * for.  This is OK because we will certainly decide the same thing again
! 	 * for those items if we do it over; doing it here saves an extra pass
! 	 * over the chain later.
  	 */
  begin:;
  	for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
  	{
  		dtbuf[i] = InvalidBuffer;
--- 822,850 ----
  		return RecPtr;
  	}
  
+ 	/* TODO */
+ 	if (isLogSwitch)
+ 	{
+ 		elog(LOG, "log switch not implemented");
+ 		return InvalidXLogRecPtr;
+ 	}
+ 
  	/*
  	 * Here we scan the rdata chain, determine which buffers must be backed
! 	 * up.
  	 *
  	 * We may have to loop back to here if a race condition is detected below.
  	 * We could prevent the race by doing all this work while holding the
  	 * insert lock, but it seems better to avoid doing CRC calculations while
! 	 * holding the lock.
! 	 *
! 	 * To avoid modifying the original rdata chain, we copy it into
! 	 * rdata_final. Later we will also add entries for the backup blocks into
! 	 * rdata_final, so that they don't need any special treatment in the
! 	 * critical section where the chunks are copied into the WAL buffers.
  	 */
  begin:;
+ 	info_final = info;
  	for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
  	{
  		dtbuf[i] = InvalidBuffer;
***************
*** 758,766 **** begin:;
  	 * don't yet have the insert lock, forcePageWrites could change under us,
  	 * but we'll recheck it once we have the lock.
  	 */
! 	doPageWrites = fullPageWrites || Insert->forcePageWrites;
  
- 	INIT_CRC32(rdata_crc);
  	len = 0;
  	for (rdt = rdata;;)
  	{
--- 857,865 ----
  	 * don't yet have the insert lock, forcePageWrites could change under us,
  	 * but we'll recheck it once we have the lock.
  	 */
! 	forcePageWrites = Insert->forcePageWrites;
! 	doPageWrites = fullPageWrites || forcePageWrites;
  
  	len = 0;
  	for (rdt = rdata;;)
  	{
***************
*** 768,774 **** begin:;
  		{
  			/* Simple data, just include it */
  			len += rdt->len;
- 			COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  		}
  		else
  		{
--- 867,872 ----
***************
*** 779,790 **** begin:;
  				{
  					/* Buffer already referenced by earlier chain item */
  					if (dtbuf_bkp[i])
  						rdt->data = NULL;
  					else if (rdt->data)
- 					{
  						len += rdt->len;
- 						COMP_CRC32(rdata_crc, rdt->data, rdt->len);
- 					}
  					break;
  				}
  				if (dtbuf[i] == InvalidBuffer)
--- 877,888 ----
  				{
  					/* Buffer already referenced by earlier chain item */
  					if (dtbuf_bkp[i])
+ 					{
  						rdt->data = NULL;
+ 						rdt->len = 0;
+ 					}
  					else if (rdt->data)
  						len += rdt->len;
  					break;
  				}
  				if (dtbuf[i] == InvalidBuffer)
***************
*** 796,807 **** begin:;
  					{
  						dtbuf_bkp[i] = true;
  						rdt->data = NULL;
  					}
  					else if (rdt->data)
- 					{
  						len += rdt->len;
- 						COMP_CRC32(rdata_crc, rdt->data, rdt->len);
- 					}
  					break;
  				}
  			}
--- 894,903 ----
  					{
  						dtbuf_bkp[i] = true;
  						rdt->data = NULL;
+ 						rdt->len = 0;
  					}
  					else if (rdt->data)
  						len += rdt->len;
  					break;
  				}
  			}
***************
*** 814,852 **** begin:;
  			break;
  		rdt = rdt->next;
  	}
! 
! 	/*
! 	 * Now add the backup block headers and data into the CRC
! 	 */
! 	for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
! 	{
! 		if (dtbuf_bkp[i])
! 		{
! 			BkpBlock   *bkpb = &(dtbuf_xlg[i]);
! 			char	   *page;
! 
! 			COMP_CRC32(rdata_crc,
! 					   (char *) bkpb,
! 					   sizeof(BkpBlock));
! 			page = (char *) BufferGetBlock(dtbuf[i]);
! 			if (bkpb->hole_length == 0)
! 			{
! 				COMP_CRC32(rdata_crc,
! 						   page,
! 						   BLCKSZ);
! 			}
! 			else
! 			{
! 				/* must skip the hole */
! 				COMP_CRC32(rdata_crc,
! 						   page,
! 						   bkpb->hole_offset);
! 				COMP_CRC32(rdata_crc,
! 						   page + (bkpb->hole_offset + bkpb->hole_length),
! 						   BLCKSZ - (bkpb->hole_offset + bkpb->hole_length));
! 			}
! 		}
! 	}
  
  	/*
  	 * NOTE: We disallow len == 0 because it provides a useful bit of extra
--- 910,917 ----
  			break;
  		rdt = rdt->next;
  	}
! 	/* Remember that this was the last regular rdata entry */
! 	rdt_lastnormal = rdt;
  
  	/*
  	 * NOTE: We disallow len == 0 because it provides a useful bit of extra
***************
*** 858,922 **** begin:;
  	if (len == 0 && !isLogSwitch)
  		elog(PANIC, "invalid xlog record length %u", len);
  
- 	START_CRIT_SECTION();
- 
- 	/* Now wait to get insert lock */
- 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
- 
- 	/*
- 	 * Check to see if my RedoRecPtr is out of date.  If so, may have to go
- 	 * back and recompute everything.  This can only happen just after a
- 	 * checkpoint, so it's better to be slow in this case and fast otherwise.
- 	 *
- 	 * If we aren't doing full-page writes then RedoRecPtr doesn't actually
- 	 * affect the contents of the XLOG record, so we'll update our local copy
- 	 * but not force a recomputation.
- 	 */
- 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr))
- 	{
- 		Assert(XLByteLT(RedoRecPtr, Insert->RedoRecPtr));
- 		RedoRecPtr = Insert->RedoRecPtr;
- 
- 		if (doPageWrites)
- 		{
- 			for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
- 			{
- 				if (dtbuf[i] == InvalidBuffer)
- 					continue;
- 				if (dtbuf_bkp[i] == false &&
- 					XLByteLE(dtbuf_lsn[i], RedoRecPtr))
- 				{
- 					/*
- 					 * Oops, this buffer now needs to be backed up, but we
- 					 * didn't think so above.  Start over.
- 					 */
- 					LWLockRelease(WALInsertLock);
- 					END_CRIT_SECTION();
- 					goto begin;
- 				}
- 			}
- 		}
- 	}
- 
- 	/*
- 	 * Also check to see if forcePageWrites was just turned on; if we weren't
- 	 * already doing full-page writes then go back and recompute. (If it was
- 	 * just turned off, we could recompute the record without full pages, but
- 	 * we choose not to bother.)
- 	 */
- 	if (Insert->forcePageWrites && !doPageWrites)
- 	{
- 		/* Oops, must redo it with full-page data */
- 		LWLockRelease(WALInsertLock);
- 		END_CRIT_SECTION();
- 		goto begin;
- 	}
- 
  	/*
  	 * Make additional rdata chain entries for the backup blocks, so that we
! 	 * don't need to special-case them in the write loop.  Note that we have
! 	 * now irrevocably changed the input rdata chain.  At the exit of this
! 	 * loop, write_len includes the backup block data.
  	 *
  	 * Also set the appropriate info bits to show which buffers were backed
  	 * up. The i'th XLR_SET_BKP_BLOCK bit corresponds to the i'th distinct
--- 923,936 ----
  	if (len == 0 && !isLogSwitch)
  		elog(PANIC, "invalid xlog record length %u", len);
  
  	/*
  	 * Make additional rdata chain entries for the backup blocks, so that we
! 	 * don't need to special-case them in the write loop.  We have now
! 	 * modified the original rdata chain, but we remembered the last regular
! 	 * entry in rdt_lastnormal, so we can undo this if we have to loop back
! 	 * to the beginning.
! 	 *
! 	 * At the exit of this loop, write_len includes the backup block data.
  	 *
  	 * Also set the appropriate info bits to show which buffers were backed
  	 * up. The i'th XLR_SET_BKP_BLOCK bit corresponds to the i'th distinct
***************
*** 931,943 **** begin:;
  		if (!dtbuf_bkp[i])
  			continue;
  
! 		info |= XLR_SET_BKP_BLOCK(i);
  
  		bkpb = &(dtbuf_xlg[i]);
  		page = (char *) BufferGetBlock(dtbuf[i]);
  
  		rdt->next = &(dtbuf_rdt1[i]);
! 		rdt = rdt->next;
  
  		rdt->data = (char *) bkpb;
  		rdt->len = sizeof(BkpBlock);
--- 945,957 ----
  		if (!dtbuf_bkp[i])
  			continue;
  
! 		info_final |= XLR_SET_BKP_BLOCK(i);
  
  		bkpb = &(dtbuf_xlg[i]);
  		page = (char *) BufferGetBlock(dtbuf[i]);
  
  		rdt->next = &(dtbuf_rdt1[i]);
! 		rdt = &(dtbuf_rdt1[i]);
  
  		rdt->data = (char *) bkpb;
  		rdt->len = sizeof(BkpBlock);
***************
*** 971,1044 **** begin:;
  	}
  
  	/*
! 	 * If there isn't enough space on the current XLOG page for a record
! 	 * header, advance to the next page (leaving the unused space as zeroes).
  	 */
! 	updrqst = false;
! 	freespace = INSERT_FREESPACE(Insert);
! 	if (freespace < SizeOfXLogRecord)
! 	{
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		freespace = INSERT_FREESPACE(Insert);
! 	}
! 
! 	/* Compute record's XLOG location */
! 	curridx = Insert->curridx;
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
! 	 * segment, we need not insert it (and don't want to because we'd like
! 	 * consecutive switch requests to be no-ops).  Instead, make sure
! 	 * everything is written and flushed through the end of the prior segment,
! 	 * and return the prior segment's end address.
  	 */
! 	if (isLogSwitch &&
! 		(RecPtr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
! 	{
! 		/* We can release insert lock immediately */
! 		LWLockRelease(WALInsertLock);
! 
! 		RecPtr.xrecoff -= SizeOfXLogLongPHD;
! 		if (RecPtr.xrecoff == 0)
! 		{
! 			/* crossing a logid boundary */
! 			RecPtr.xlogid -= 1;
! 			RecPtr.xrecoff = XLogFileSize;
! 		}
! 
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 		LogwrtResult = XLogCtl->Write.LogwrtResult;
! 		if (!XLByteLE(RecPtr, LogwrtResult.Flush))
! 		{
! 			XLogwrtRqst FlushRqst;
! 
! 			FlushRqst.Write = RecPtr;
! 			FlushRqst.Flush = RecPtr;
! 			XLogWrite(FlushRqst, false, false);
! 		}
! 		LWLockRelease(WALWriteLock);
! 
! 		END_CRIT_SECTION();
! 
! 		return RecPtr;
! 	}
! 
! 	/* Insert record header */
! 
! 	record = (XLogRecord *) Insert->currpos;
! 	record->xl_prev = Insert->PrevRecord;
! 	record->xl_xid = GetCurrentTransactionIdIfAny();
! 	record->xl_tot_len = SizeOfXLogRecord + write_len;
! 	record->xl_len = len;		/* doesn't include backup blocks */
! 	record->xl_info = info;
! 	record->xl_rmid = rmid;
! 
! 	/* Now we can finish computing the record's CRC */
! 	COMP_CRC32(rdata_crc, (char *) record + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	record->xl_crc = rdata_crc;
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
--- 985,1013 ----
  	}
  
  	/*
! 	 * Calculate CRC of the data, including all the backup blocks
! 	 *
! 	 * Note that the record header isn't added into the CRC initially since
! 	 * we don't know the prev-link yet.  Thus, the CRC will represent the CRC
! 	 * of the whole record in the order "rdata, then backup blocks, then
! 	 * record header".
  	 */
! 	INIT_CRC32(rdata_crc);
! 	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
! 		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
  	/*
! 	 * Construct record header. We can't CRC it yet, because the prev-link
! 	 * needs to be covered by the CRC and we don't know that yet. We will
! 	 * finish computing the CRC when we do.
  	 */
! 	MemSet(&rechdr, 0, sizeof(rechdr));
! 	rechdr.xl_prev = InvalidXLogRecPtr; /* TO BE DETERMINED */
! 	rechdr.xl_xid = GetCurrentTransactionIdIfAny();
! 	rechdr.xl_tot_len = SizeOfXLogRecord + write_len;
! 	rechdr.xl_len = len;		/* doesn't include backup blocks */
! 	rechdr.xl_info = info;
! 	rechdr.xl_rmid = rmid;
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
***************
*** 1059,1231 **** begin:;
  	}
  #endif
  
! 	/* Record begin of record in appropriate places */
! 	ProcLastRecPtr = RecPtr;
! 	Insert->PrevRecord = RecPtr;
! 
! 	Insert->currpos += SizeOfXLogRecord;
! 	freespace -= SizeOfXLogRecord;
  
  	/*
! 	 * Append the data, including backup blocks if any
  	 */
! 	while (write_len)
! 	{
! 		while (rdata->data == NULL)
! 			rdata = rdata->next;
  
! 		if (freespace > 0)
! 		{
! 			if (rdata->len > freespace)
! 			{
! 				memcpy(Insert->currpos, rdata->data, freespace);
! 				rdata->data += freespace;
! 				rdata->len -= freespace;
! 				write_len -= freespace;
! 			}
! 			else
! 			{
! 				memcpy(Insert->currpos, rdata->data, rdata->len);
! 				freespace -= rdata->len;
! 				write_len -= rdata->len;
! 				Insert->currpos += rdata->len;
! 				rdata = rdata->next;
! 				continue;
! 			}
! 		}
  
! 		/* Use next buffer */
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		curridx = Insert->curridx;
! 		/* Insert cont-record header */
! 		Insert->currpage->xlp_info |= XLP_FIRST_IS_CONTRECORD;
! 		contrecord = (XLogContRecord *) Insert->currpos;
! 		contrecord->xl_rem_len = write_len;
! 		Insert->currpos += SizeOfXLogContRecord;
! 		freespace = INSERT_FREESPACE(Insert);
  	}
  
- 	/* Ensure next record will be properly aligned */
- 	Insert->currpos = (char *) Insert->currpage +
- 		MAXALIGN(Insert->currpos - (char *) Insert->currpage);
- 	freespace = INSERT_FREESPACE(Insert);
- 
  	/*
  	 * The recptr I return is the beginning of the *next* record. This will be
  	 * stored as LSN for changed data pages...
  	 */
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, we must now write and flush all the
! 	 * existing data, and then forcibly advance to the start of the next
! 	 * segment.  It's not good to do this I/O while holding the insert lock,
! 	 * but there seems too much risk of confusion if we try to release the
! 	 * lock sooner.  Fortunately xlog switch needn't be a high-performance
! 	 * operation anyway...
  	 */
! 	if (isLogSwitch)
  	{
! 		XLogCtlWrite *Write = &XLogCtl->Write;
! 		XLogwrtRqst FlushRqst;
! 		XLogRecPtr	OldSegEnd;
  
! 		TRACE_POSTGRESQL_XLOG_SWITCH();
  
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  
! 		/*
! 		 * Flush through the end of the page containing XLOG_SWITCH, and
! 		 * perform end-of-segment actions (eg, notifying archiver).
! 		 */
! 		WriteRqst = XLogCtl->xlblocks[curridx];
! 		FlushRqst.Write = WriteRqst;
! 		FlushRqst.Flush = WriteRqst;
! 		XLogWrite(FlushRqst, false, true);
! 
! 		/* Set up the next buffer as first page of next segment */
! 		/* Note: AdvanceXLInsertBuffer cannot need to do I/O here */
! 		(void) AdvanceXLInsertBuffer(true);
! 
! 		/* There should be no unwritten data */
! 		curridx = Insert->curridx;
! 		Assert(curridx == Write->curridx);
! 
! 		/* Compute end address of old segment */
! 		OldSegEnd = XLogCtl->xlblocks[curridx];
! 		OldSegEnd.xrecoff -= XLOG_BLCKSZ;
! 		if (OldSegEnd.xrecoff == 0)
! 		{
! 			/* crossing a logid boundary */
! 			OldSegEnd.xlogid -= 1;
! 			OldSegEnd.xrecoff = XLogFileSize;
! 		}
  
! 		/* Make it look like we've written and synced all of old segment */
! 		LogwrtResult.Write = OldSegEnd;
! 		LogwrtResult.Flush = OldSegEnd;
  
! 		/*
! 		 * Update shared-memory status --- this code should match XLogWrite
! 		 */
  		{
! 			/* use volatile pointer to prevent code rearrangement */
! 			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			SpinLockAcquire(&xlogctl->info_lck);
! 			xlogctl->LogwrtResult = LogwrtResult;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, LogwrtResult.Write))
! 				xlogctl->LogwrtRqst.Write = LogwrtResult.Write;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Flush, LogwrtResult.Flush))
! 				xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
! 			SpinLockRelease(&xlogctl->info_lck);
! 		}
  
! 		Write->LogwrtResult = LogwrtResult;
  
! 		LWLockRelease(WALWriteLock);
  
! 		updrqst = false;		/* done already */
! 	}
! 	else
! 	{
! 		/* normal case, ie not xlog switch */
  
! 		/* Need to update shared LogwrtRqst if some block was filled up */
! 		if (freespace < SizeOfXLogRecord)
! 		{
! 			/* curridx is filled and available for writing out */
! 			updrqst = true;
! 		}
! 		else
! 		{
! 			/* if updrqst already set, write through end of previous buf */
! 			curridx = PrevBufIdx(curridx);
  		}
! 		WriteRqst = XLogCtl->xlblocks[curridx];
  	}
  
! 	LWLockRelease(WALInsertLock);
  
! 	if (updrqst)
  	{
  		/* use volatile pointer to prevent code rearrangement */
  		volatile XLogCtlData *xlogctl = XLogCtl;
  
  		SpinLockAcquire(&xlogctl->info_lck);
  		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, WriteRqst))
! 			xlogctl->LogwrtRqst.Write = WriteRqst;
  		/* update local result copy while I have the chance */
  		LogwrtResult = xlogctl->LogwrtResult;
  		SpinLockRelease(&xlogctl->info_lck);
  	}
  
! 	XactLastRecEnd = RecPtr;
  
- 	END_CRIT_SECTION();
  
! 	return RecPtr;
  }
  
  /*
--- 1028,1505 ----
  	}
  #endif
  
! 	START_CRIT_SECTION();
  
  	/*
! 	 * Try to do the insertion.
  	 */
! 	RecPtr = PerformXLogInsert(write_len, &rechdr, rdata, rdata_crc,
! 							forcePageWrites);
! 	END_CRIT_SECTION();
  
! 	if (XLogRecPtrIsInvalid(RecPtr))
! 	{
! 		/*
! 		 * Oops, have to retry. Unlink the backup blocks from the chain,
! 		 * restoring it to its original state.
! 		 */
! 		rdt_lastnormal->next = NULL;
  
! 		goto begin;
  	}
  
  	/*
  	 * The recptr I return is the beginning of the *next* record. This will be
  	 * stored as LSN for changed data pages...
  	 */
! 	return RecPtr;
! }
! 
! /*
!  * Subroutine of XLogInsert. All the changes to shared state are done here,
!  * XLogInsert only prepares the record for insertion.
!  *
!  * On success, returns pointer to end of inserted record like XLogInsert().
!  * If RedoRecPtr or forcePageWrites had changed, returns InvalidRecPtr, and
!  * the caller must recalculate full-page-images and retry.
!  */
! static XLogRecPtr
! PerformXLogInsert(int write_len, XLogRecord *rechdr,
! 				  XLogRecData *rdata, pg_crc32 rdata_crc,
! 				  bool forcePageWrites)
! {
! 	volatile BackendXLogInsertSlot *myslot;
! 	char	   *currpos;
! 	XLogRecord *record;
! 	int			tot_len;
! 	int			freespace;
! 	int			tot_left;
! 	XLogRecPtr	PrevRecord;
! 	XLogRecPtr	StartPos;
! 	XLogRecPtr	EndPos;
! 	XLogRecPtr	CurrPos;
  
  	/*
! 	 * Our fast insertion method requires each process to have its own
! 	 * "slot", to tell others that it's still busy doing the insertion. Each
! 	 * regular backend has a dedicated slot, but auxiliary processes share
! 	 * one extra slot. Aux processes don't write a lot of WAL so they can
! 	 * well share. WALAuxSlotLock is used to coordinate access to the slot
! 	 * between aux processes.
  	 */
! 	if (MyBackendId == InvalidBackendId)
  	{
! 		LWLockAcquire(WALAuxSlotLock, LW_EXCLUSIVE);
! 		myslot = &XLogCtl->BackendXLogInsertSlots[MaxBackends];
! 	}
! 	else
! 		myslot = &XLogCtl->BackendXLogInsertSlots[MyBackendId];
  
! 	/* Get an insert location  */
! 	tot_len = SizeOfXLogRecord + write_len;
! 	if (!ReserveXLogInsertLocation(tot_len, forcePageWrites,
! 								   &PrevRecord, &StartPos, &EndPos, myslot))
! 	{
! 		if (MyBackendId == InvalidBackendId)
! 			LWLockRelease(WALAuxSlotLock);
! 		return InvalidXLogRecPtr;
! 	}
  
! 	/*
! 	 * Got an insertion location! Now that we know the prev-link, we can
! 	 * finish computing the record's CRC
! 	 */
! 	rechdr->xl_prev = PrevRecord;
! 	COMP_CRC32(rdata_crc, ((char *) rechdr) + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	rechdr->xl_crc = rdata_crc;
  
! 	/* Get the right WAL page to start inserting to */
! 	CurrPos = StartPos;
! 	currpos = GetXLogBuffer(CurrPos);
! 	freespace = XLOG_BLCKSZ - CurrPos.xrecoff % XLOG_BLCKSZ;
  
! 	/* Copy the record header and data */
! 	record = (XLogRecord *) currpos;
  
! 	memcpy(record, rechdr, sizeof(XLogRecord));
! 	currpos += SizeOfXLogRecord;
! 	CurrPos.xrecoff += SizeOfXLogRecord;
! 	freespace -= SizeOfXLogRecord;
! 
! 	tot_left = write_len;
! 	while (rdata != NULL)
! 	{
! 		while (rdata->len > freespace)
  		{
! 			/*
! 			 * Write what fits on this page, then write the continuation
! 			 * record, and continue.
! 			 */
! 			XLogContRecord *contrecord;
  
! 			memcpy(currpos, rdata->data, freespace);
! 			rdata->data += freespace;
! 			rdata->len -= freespace;
! 			tot_left -= freespace;
  
! 			CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
  
! 			/*
! 			 * Make sure the memcpy is visible to others before we claim
! 			 * it to be done. It's important to update CurrPos before calling
! 			 * GetXLogBuffer(), because GetXLogBuffer() might need to wait
! 			 * for some insertions to finish so that it can write out a
! 			 * buffer to make room for the new page. Updating CurrPos before
! 			 * waiting for a new buffer ensures that we don't deadlock with
! 			 * ourselves if we run out of clean buffers.
! 			 */
! 			pg_write_barrier();
! 			myslot->CurrPos = CurrPos;
  
! 			currpos = GetXLogBuffer(CurrPos);
  
! 			contrecord = (XLogContRecord *) currpos;
! 			contrecord->xl_rem_len = tot_len - tot_left;
! 
! 			currpos += SizeOfXLogContRecord;
! 			CurrPos.xrecoff += SizeOfXLogContRecord;
! 
! 			freespace = XLOG_BLCKSZ - CurrPos.xrecoff % XLOG_BLCKSZ;
  		}
! 
! 		memcpy(currpos, rdata->data, rdata->len);
! 		currpos += rdata->len;
! 		CurrPos.xrecoff += rdata->len;
! 		freespace -= rdata->len;
! 		tot_left -= rdata->len;
! 
! 		rdata = rdata->next;
  	}
+ 	Assert(tot_left == 0);
+ 
+ 	CurrPos.xrecoff = MAXALIGN(CurrPos.xrecoff);
+ 	Assert(XLByteEQ(CurrPos, EndPos));
+ 
+ 	/*
+ 	 * Done! Clear CurrPos in our slot to let others know that we're finished,
+ 	 * but first make sure the changes we made to the WAL pages are visible
+ 	 * to everyone.
+ 	 */
+ 	pg_write_barrier();
+ 	myslot->CurrPos = InvalidXLogRecPtr;
+ 	if (MyBackendId == InvalidBackendId)
+ 		LWLockRelease(WALAuxSlotLock);
  
! 	/* update our global variables */
! 	ProcLastRecPtr = StartPos;
! 	XactLastRecEnd = EndPos;
  
! 	/* update shared LogwrtRqst.Write, if we crossed page boundary */
! 	if (StartPos.xrecoff / XLOG_BLCKSZ != EndPos.xrecoff / XLOG_BLCKSZ)
  	{
  		/* use volatile pointer to prevent code rearrangement */
  		volatile XLogCtlData *xlogctl = XLogCtl;
  
  		SpinLockAcquire(&xlogctl->info_lck);
  		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, EndPos))
! 			xlogctl->LogwrtRqst.Write = EndPos;
  		/* update local result copy while I have the chance */
  		LogwrtResult = xlogctl->LogwrtResult;
  		SpinLockRelease(&xlogctl->info_lck);
  	}
  
! 	return EndPos;
! }
  
  
! /*
!  * Reserves the right amount of space for a record of the given size from
!  * the WAL. *StartPos_p is set to the beginning of the reserved section,
!  * *EndPos_p to its end, and *Prev_record_p points to the beginning of the
!  * previous record to set to the prev-link of the record header.
!  *
!  * While holding insertpos_lck, sets myslot->CurrPos to the starting position,
!  * to let others know that we're busy inserting to the reserved area. The
!  * caller must clear it when the insertion is finished.
!  *
!  * Returns true on success, or false if RedoRecPtr or forcePageWrites was
!  * changed. On failure, the shared state is not modified.
!  *
!  * This is the performance critical part of XLogInsert that must be
!  * serialized across backends. The rest can happen mostly in parallel.
!  *
!  * NB: The space calculation here must match the code in PerformXLogInsert,
!  * where we actually copy the record to the reserved space.
!  */
! static bool
! ReserveXLogInsertLocation(int size, bool forcePageWrites,
! 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
! 						  XLogRecPtr *EndPos_p,
! 						  volatile BackendXLogInsertSlot *myslot)
! {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			freespace;
! 	XLogRecPtr	ptr;
! 	XLogRecPtr	StartPos;
! 	int			sizeleft;
! 
! 	sizeleft = size;
! 
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 
! 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr) ||
! 		Insert->forcePageWrites != forcePageWrites)
! 	{
! 		/*
! 		 * Oops, forcePageWrites was just turned on, or a checkpoint
! 		 * just happened. Loop back to the beginning, because we might have
! 		 * to include more full-page images in the record
! 		 */
! 		RedoRecPtr = Insert->RedoRecPtr;
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		return false;
! 	}
! 
! 	/*
! 	 * Now reserve the right amount of space from the WAL for our record.
! 	 */
! 	ptr = Insert->CurrPos;
! 	*PrevRecord_p = Insert->PrevRecord;
! 
! 	/*
! 	 * If there isn't enough space on the current XLOG page for a record
! 	 * header, advance to the next page (leaving the unused space as zeroes).
! 	 */
! 	freespace = INSERT_FREESPACE(ptr);
! 	if (freespace < SizeOfXLogRecord)
! 	{
! 		ptr = AdvanceXLogRecPtrToNextPage(ptr);
! 		freespace = INSERT_FREESPACE(ptr);
! 	}
! 	StartPos = ptr;
! 
! 	/*
! 	 * Set our slot's CurrPos to the starting position, to let others know
! 	 * that we're busy inserting to this area.
! 	 */
! 	myslot->CurrPos = StartPos;
! 
! 	while (freespace < sizeleft)
! 	{
! 		/* fill this page, and continue on next page */
! 		sizeleft -= freespace;
! 		ptr = AdvanceXLogRecPtrToNextPage(ptr);
! 
! 		/* account for continuation record header */
! 		ptr.xrecoff += SizeOfXLogContRecord;
! 		freespace = INSERT_FREESPACE(ptr);
! 	}
! 	/* the rest fits on this page */
! 	ptr.xrecoff += sizeleft;
! 	sizeleft = 0;
! 
! 	/* Align the end position, so that the next record starts aligned */
! 	ptr.xrecoff = MAXALIGN(ptr.xrecoff);
! 
! 	/* Update the shared state, and our slot, before releasing the lock */
! 	Insert->CurrPos = ptr;
! 	Insert->PrevRecord = StartPos;
! 
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! #ifdef RESERVE_XLOGINSERT_LOCATION_DEBUG
! 	elog(DEBUG2, "reserved xlog: prev %X/%X, start %X/%X, end %X/%X (len %d)",
! 		 result->PrevRecord.xlogid, result->PrevRecord.xrecoff,
! 		 StartPos.xlogid, StartPos.xrecoff,
! 		 ptr.xlogid, ptr.xrecoff,
! 		 reqsize);
! #endif
! 
! 	*EndPos_p = ptr;
! 	*StartPos_p = StartPos;
! 
! 	return true;
! }
! 
! /*
!  * Get a pointer to the right location in the WAL buffer corresponding a
!  * given XLogRecPtr.
!  *
!  * If the page is not initialized yet, it is initialized. That might also
!  * require evicting an old diry buffer from the buffer cache, which means I/O.
!  *
!  * The caller must ensure that the page containing the requested location
!  * isn't evicted yet, and won't be evicted, by holding onto a
!  * BackendXLogInsertSlot with CurrPos set to 'ptr'. Setting it to some value
!  * less than 'ptr' would suffice for GetXLogBuffer(), but risks deadlock:
!  * if we have to evict a buffer, we might have to wait for someone else to
!  * finish a write. And that someone else might not be able to finish the write
!  * if our CurrPos points to a buffer that's still in the buffer cache.
!  */
! static char *
! GetXLogBuffer(XLogRecPtr ptr)
! {
! 	int			idx;
! 	XLogRecPtr	endptr;
! 
! 	/*
! 	 * The XLog buffer cache is organized so that we can easily calculate the
! 	 * buffer a given page must be loaded into from the XLogRecPtr alone.
! 	 * A page must always be loaded to a particular buffer.
! 	 */
! 	idx = XLogRecPtrToBufIdx(ptr);
! 
! 	/*
! 	 * See what page is loaded in the buffer at the moment. It could be the
! 	 * page we're looking for, or something older. It can't be anything
! 	 * newer - that would imply the page we're looking for has already
! 	 * been written out to disk, which shouldn't happen as long as the caller
! 	 * has set its slot's CurrPos correctly.
! 	 *
! 	 * However, we don't hold a lock while we read the value. If someone has
! 	 * just initialized the page, it's possible that we get a "torn read",
! 	 * and read a bogus value. That's ok, we'll grab the mapping lock (in
! 	 * AdvanceXLInsertBuffer) and retry if we see anything else than the page
! 	 * we're looking for. But it means that when we do this unlocked read, we
! 	 * might see a value that *is* ahead of the page we're looking for. So
! 	 * don't PANIC on that, until we've verified the value while holding the
! 	 * lock.
! 	 */
! 	endptr = XLogCtl->xlblocks[idx];
! 	if (ptr.xlogid != endptr.xlogid ||
! 		!(ptr.xrecoff < endptr.xrecoff &&
! 		  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
! 	{
! 		AdvanceXLInsertBuffer(false, ptr, false);
! 		endptr = XLogCtl->xlblocks[idx];
! 
! 		if (ptr.xlogid != endptr.xlogid ||
! 			!(ptr.xrecoff < endptr.xrecoff &&
! 			  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
! 		{
! 			elog(PANIC, "could not find WAL buffer for %X/%X", ptr.xlogid, ptr.xrecoff);
! 		}
! 	}
! 
! 	/*
! 	 * Found the buffer holding this page. Return a pointer to the right
! 	 * offset within the page.
! 	 */
! 	return (char *) XLogCtl->pages + idx * (Size) XLOG_BLCKSZ +
! 		ptr.xrecoff % XLOG_BLCKSZ;
! }
! 
! /*
!  * Advance an XLogRecPtr to the first valid insertion location on the next
!  * page, right after the page header. An XLogRecPtr pointing to a boundary,
!  * ie. the first byte of a page, is taken to belong to the previous page, 
!  */
! static XLogRecPtr
! AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr)
! {
! 	int			freespace;
! 
! 	freespace = INSERT_FREESPACE(ptr);
! 	XLByteAdvance(ptr, freespace);
! 	if (ptr.xrecoff % XLogSegSize == 0)
! 		ptr.xrecoff += SizeOfXLogLongPHD;
! 	else
! 		ptr.xrecoff += SizeOfXLogShortPHD;
! 
! 	return ptr;
! }
! 
! /*
!  * Wait for any insertions < upto to finish.
!  *
!  * Returns a value >= upto, which indicates the oldest in-progress insertion
!  * that we saw in the array. All insertions upto that point are guaranteed to
!  * be finished. Note that it is just a conservative guess, there are race
!  * conditions where we return a bogus, too-low, value. If you care about the
!  * return value, you must get the current Insert->CurrPos value *before*
!  * calling this function, and pass that as the CurrPos argument.
!  */
! static XLogRecPtr
! WaitXLogInsertionsToFinish(XLogRecPtr upto, XLogRecPtr CurrPos)
! {
! 	int			i;
! 	int			nbusyslots = 0;
! 	/* FIXME: it's safe to palloc here, would PANIC on OOM */
! 	int		   *busyslots = palloc0(sizeof(int) * NumXLogInsertSlots);
! 	int			cycles = 0;
! 
! 	/*
! 	 * Get a list of backend slots that are still inserting to a point earlier
! 	 * than 'upto'.
! 	 *
! 	 * This is a bit sloppy because we don't do any locking here. A slot's
! 	 * CurrPos that we read might get split if 8-byte loads are not atomic,
! 	 * but that's harmless. All slots with values <= upto, which we really do
! 	 * have to wait for, must be in the array before this function is called.
! 	 * That's because the 'upto' value must've been obtained by reading the
! 	 * current insert position, either directly or indirectly. It can never
! 	 * be > Insert->CurrPos. So we shouldn't miss anything that we genuinely
! 	 * need to wait for. OTOH, if someone is just storing an XLogRecPtr in a
! 	 * slot while we read it, we might incorrectly think that we have to wait
! 	 * for it. But that's OK, because in the loop that follows, we'll retry
! 	 * and see that it's actually > upto.
! 	 *
! 	 * XXX: that's bogus. You might see a too-new value if a slot's CurrPos is
! 	 * advanced at the same instant.
! 	 */
! 	for (i = 0; i < NumXLogInsertSlots; i++)
! 	{
! 		volatile BackendXLogInsertSlot *slot = &XLogCtl->BackendXLogInsertSlots[i];
! 		XLogRecPtr slotptr = slot->CurrPos;
! 
! 		if (XLogRecPtrIsInvalid(slotptr))
! 			continue;
! 
! 		if (XLByteLT(slotptr, upto))
! 			busyslots[nbusyslots++] = i;
! 		else if (XLByteLT(slotptr, CurrPos))
! 			CurrPos = slotptr;
! 	}
! 
! 	/*
! 	 * Busy-wait until the insertion is done.
! 	 *
! 	 * TODO: This needs to be replaced with something smarter. I don't think
! 	 * it's possible that we'd have to wait for I/O here, though. As the code
! 	 * stands, the caller never passes an 'upto' pointer that points to an
! 	 * uninitialized page. It always points to an already inserted record, in
! 	 * which case the page must already be initialized in the WAL buffer
! 	 * cache. Nevertheless, busy-waiting is not good.
! 	 */
! 	while (nbusyslots > 0)
! 	{
! 		pg_read_barrier();
! 		for (i = 0; i < nbusyslots; i++)
! 		{
! 			volatile BackendXLogInsertSlot *slot = &XLogCtl->BackendXLogInsertSlots[busyslots[i]];
! 			XLogRecPtr slotptr = slot->CurrPos;
! 
! 			if (XLogRecPtrIsInvalid(slot->CurrPos) || !XLByteLT(slotptr, upto))
! 			{
! 				if (nbusyslots > 1)
! 				{
! 					busyslots[i] = busyslots[nbusyslots - 1];
! 					i--;
! 				}
! 				nbusyslots--;
! 			}
! 		}
! 
! 		/* a debugging aid */
! 		if (++cycles == 1000000)
! 			elog(LOG, "stuck waiting upto %X/%X", upto.xlogid, upto.xrecoff);
! 	}
! 	pfree(busyslots);
! 
! 	return CurrPos;
  }
  
  /*
***************
*** 1458,1486 **** XLogArchiveCleanup(const char *xlog)
   * If new_segment is TRUE then we set up the next buffer page as the first
   * page of the next xlog segment file, possibly but not usually the next
   * consecutive file page.
-  *
-  * The global LogwrtRqst.Write pointer needs to be advanced to include the
-  * just-filled page.  If we can do this for free (without an extra lock),
-  * we do so here.  Otherwise the caller must do it.  We return TRUE if the
-  * request update still needs to be done, FALSE if we did it internally.
-  *
-  * Must be called with WALInsertLock held.
   */
! static bool
! AdvanceXLInsertBuffer(bool new_segment)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogCtlWrite *Write = &XLogCtl->Write;
! 	int			nextidx = NextBufIdx(Insert->curridx);
! 	bool		update_needed = true;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
  	XLogRecPtr	NewPageEndPtr;
  	XLogPageHeader NewPage;
  
! 	/* Use Insert->LogwrtResult copy if it's more fresh */
! 	if (XLByteLT(LogwrtResult.Write, Insert->LogwrtResult.Write))
! 		LogwrtResult = Insert->LogwrtResult;
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
--- 1732,1763 ----
   * If new_segment is TRUE then we set up the next buffer page as the first
   * page of the next xlog segment file, possibly but not usually the next
   * consecutive file page.
   */
! static void
! AdvanceXLInsertBuffer(bool new_segment, XLogRecPtr upto, bool opportunistic)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogCtlWrite *Write = &XLogCtl->Write;
! 	int			nextidx;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
  	XLogRecPtr	NewPageEndPtr;
  	XLogPageHeader NewPage;
+ 	bool		needflush;
+ 	int			npages = 0;
+ 	XLogRecPtr	EvictedPtr;
+ 
+ 	Assert(!new_segment); /* FIXME: not implemented */
+ 
+ 	LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
  
! 	/*
! 	 * Now that we have the lock, check if someone initialized the page
! 	 * already.
! 	 */
! while (!XLByteLT(upto, XLogCtl->xlblocks[XLogCtl->curridx]) || opportunistic)
! {
! 	nextidx = NextBufIdx(XLogCtl->curridx);
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
***************
*** 1488,1499 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
! 	if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  	{
  		/* nope, got work to do... */
  		XLogRecPtr	FinishedPageRqstPtr;
  
! 		FinishedPageRqstPtr = XLogCtl->xlblocks[Insert->curridx];
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
--- 1765,1779 ----
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
! 
! 	needflush = !XLByteLE(OldPageRqstPtr, LogwrtResult.Write);
! 
! 	if (needflush)
  	{
  		/* nope, got work to do... */
  		XLogRecPtr	FinishedPageRqstPtr;
  
! 		FinishedPageRqstPtr = XLogCtl->xlblocks[XLogCtl->curridx];
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
***************
*** 1502,1534 **** AdvanceXLInsertBuffer(bool new_segment)
  
  			SpinLockAcquire(&xlogctl->info_lck);
  			if (XLByteLT(xlogctl->LogwrtRqst.Write, FinishedPageRqstPtr))
  				xlogctl->LogwrtRqst.Write = FinishedPageRqstPtr;
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		update_needed = false;	/* Did the shared-request update */
! 
! 		if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
! 		{
! 			/* OK, someone wrote it already */
! 			Insert->LogwrtResult = LogwrtResult;
! 		}
! 		else
  		{
! 			/* Must acquire write lock */
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  			LogwrtResult = Write->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding insert lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
--- 1782,1824 ----
  
  			SpinLockAcquire(&xlogctl->info_lck);
  			if (XLByteLT(xlogctl->LogwrtRqst.Write, FinishedPageRqstPtr))
+ 			{
+ 				Assert(XLByteLE(FinishedPageRqstPtr, XLogCtl->Insert.CurrPos));
  				xlogctl->LogwrtRqst.Write = FinishedPageRqstPtr;
+ 			}
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/*
! 			 * If we just want to pre-initialize as much as we can without
! 			 * flushing, give up now.
! 			 */
! 			if (opportunistic)
! 				break;
! 
! 			/*
! 			 * Must acquire write lock. Release WALBufMappingLock first, to
! 			 * make sure that all insertions that we need to wait for can
! 			 * finish (up to this same position). Otherwise we risk deadlock.
! 			 */
! 			LWLockRelease(WALBufMappingLock);
! 
! 			WaitXLogInsertionsToFinish(OldPageRqstPtr, InvalidXLogRecPtr);
! 
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  			LogwrtResult = Write->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding mapping lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
***************
*** 1537,1560 **** AdvanceXLInsertBuffer(bool new_segment)
  				WriteRqst.Flush.xrecoff = 0;
  				XLogWrite(WriteRqst, false, false);
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
  		}
  	}
  
  	/*
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[Insert->curridx];
  
  	if (new_segment)
  	{
  		/* force it to a segment start point */
  		NewPageEndPtr.xrecoff += XLogSegSize - 1;
  		NewPageEndPtr.xrecoff -= NewPageEndPtr.xrecoff % XLogSegSize;
  	}
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
--- 1827,1856 ----
  				WriteRqst.Flush.xrecoff = 0;
  				XLogWrite(WriteRqst, false, false);
  				LWLockRelease(WALWriteLock);
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
+ 			/* Re-acquire WALBufMappingLock and retry */
+ 			LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
+ 			continue;
  		}
  	}
  
+ 	EvictedPtr = OldPageRqstPtr;
+ 
  	/*
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[XLogCtl->curridx];
  
+ #ifdef BROKEN
  	if (new_segment)
  	{
  		/* force it to a segment start point */
  		NewPageEndPtr.xrecoff += XLogSegSize - 1;
  		NewPageEndPtr.xrecoff -= NewPageEndPtr.xrecoff % XLogSegSize;
  	}
+ #endif
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
***************
*** 1564,1577 **** AdvanceXLInsertBuffer(bool new_segment)
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
  	XLogCtl->xlblocks[nextidx] = NewPageEndPtr;
  	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
- 	Insert->curridx = nextidx;
- 	Insert->currpage = NewPage;
- 
- 	Insert->currpos = ((char *) NewPage) +SizeOfXLogShortPHD;
- 
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
  	 * will look like zeroes and not valid XLOG records...
--- 1860,1871 ----
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
+ 	Assert(NewPageEndPtr.xrecoff % XLOG_BLCKSZ == 0);
+ 	Assert(XLogRecEndPtrToBufIdx(NewPageEndPtr) == nextidx);
+ 
  	XLogCtl->xlblocks[nextidx] = NewPageEndPtr;
  	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
  	 * will look like zeroes and not valid XLOG records...
***************
*** 1614,1624 **** AdvanceXLInsertBuffer(bool new_segment)
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
- 
- 		Insert->currpos = ((char *) NewPage) +SizeOfXLogLongPHD;
  	}
  
! 	return update_needed;
  }
  
  /*
--- 1908,1938 ----
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
  	}
  
! 	/*
! 	 * make sure the xlblocks update becomes visible to others before the
! 	 * curridx update.
! 	 */
! 	pg_write_barrier();
! 
! 	XLogCtl->curridx = nextidx;
! 
! 	npages++;
! }
! 
! 	Assert(opportunistic || XLByteLT(upto, XLogCtl->xlblocks[XLogCtl->curridx]));
! 	LWLockRelease(WALBufMappingLock);
! 
! 
! #ifdef WAL_DEBUG
! 	if (npages > 0)
! 		elog(LOG, "initialized %d pages, upto %X/%X (evicted upto %X/%X) in slot %d (backend %d)",
! 			 npages,
! 			 NewPageEndPtr.xlogid, NewPageEndPtr.xrecoff,
! 			 EvictedPtr.xlogid, EvictedPtr.xrecoff,
! 			 nextidx, MyBackendId);
! #endif
  }
  
  /*
***************
*** 1669,1675 **** XLogCheckpointNeeded(uint32 logid, uint32 logseg)
   * only if caller specifies WriteRqst == page-end and flexible == false,
   * and there is some data to write.)
   *
!  * Must be called with WALWriteLock held.
   */
  static void
  XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
--- 1983,1991 ----
   * only if caller specifies WriteRqst == page-end and flexible == false,
   * and there is some data to write.)
   *
!  * Must be called with WALWriteLock held. And you must've called
!  * WaitXLogInsertionsToFinish(WriteRqst) to make sure the data is ready to
!  * write.
   */
  static void
  XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
***************
*** 1722,1731 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
  		if (!XLByteLT(LogwrtResult.Write, XLogCtl->xlblocks[curridx]))
! 			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  				 XLogCtl->xlblocks[curridx].xlogid,
! 				 XLogCtl->xlblocks[curridx].xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
  		LogwrtResult.Write = XLogCtl->xlblocks[curridx];
--- 2038,2047 ----
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
  		if (!XLByteLT(LogwrtResult.Write, XLogCtl->xlblocks[curridx]))
! 			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X (slot %d)",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  				 XLogCtl->xlblocks[curridx].xlogid,
! 				 XLogCtl->xlblocks[curridx].xrecoff, curridx);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
  		LogwrtResult.Write = XLogCtl->xlblocks[curridx];
***************
*** 2097,2129 **** XLogFlush(XLogRecPtr record)
  	/* done already? */
  	if (!XLByteLE(record, LogwrtResult.Flush))
  	{
  		/* now wait for the write lock */
  		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  		LogwrtResult = XLogCtl->Write.LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			/* try to write/flush later additions to XLOG as well */
! 			if (LWLockConditionalAcquire(WALInsertLock, LW_EXCLUSIVE))
! 			{
! 				XLogCtlInsert *Insert = &XLogCtl->Insert;
! 				uint32		freespace = INSERT_FREESPACE(Insert);
  
- 				if (freespace < SizeOfXLogRecord)		/* buffer is full */
- 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
- 				else
- 				{
- 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
- 					WriteRqstPtr.xrecoff -= freespace;
- 				}
- 				LWLockRelease(WALInsertLock);
- 				WriteRqst.Write = WriteRqstPtr;
- 				WriteRqst.Flush = WriteRqstPtr;
- 			}
- 			else
- 			{
- 				WriteRqst.Write = WriteRqstPtr;
- 				WriteRqst.Flush = record;
- 			}
  			XLogWrite(WriteRqst, false, false);
  		}
  		LWLockRelease(WALWriteLock);
--- 2413,2460 ----
  	/* done already? */
  	if (!XLByteLE(record, LogwrtResult.Flush))
  	{
+ 		/* try to write/flush later additions to XLOG as well */
+ 		volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 		uint32		freespace;
+ 		XLogRecPtr	insertpos;
+ 
+ 		/*
+ 		 * Get the current insert position.
+ 		 *
+ 		 * XXX: This used to use LWLockConditionalAcquire, and fall back
+ 		 * to writing just up to 'record' if we couldn't get the lock. I
+ 		 * wonder if it would be a good idea to have a
+ 		 * SpinLockConditionalAcquire function and use that? On one hand,
+ 		 * it would be good to not cause more contention on the lock if it's
+ 		 * busy, but on the other hand, this spinlock is much more lightweight
+ 		 * than the WALInsertLock was, so maybe it's better to just grab the
+ 		 * spinlock. Also note that if we stored the XLogRecPtr as one 64-bit
+ 		 * integer, we could just read it with no lock on platforms where
+ 		 * 64-bit integer accesses are atomic, which covers many common
+ 		 * platforms nowadays.
+ 		 */
+ 		SpinLockAcquire(&Insert->insertpos_lck);
+ 		insertpos = Insert->CurrPos;
+ 		SpinLockRelease(&Insert->insertpos_lck);
+ 
+ 		freespace = INSERT_FREESPACE(insertpos);
+ 		if (freespace < SizeOfXLogRecord)		/* buffer is full */
+ 			insertpos.xrecoff += freespace;
+ 
+ 		/*
+ 		 * Before actually performing the write, wait for all in-flight
+ 		 * insertions to the pages we're about to write to finish.
+ 		 */
+ 		insertpos = WaitXLogInsertionsToFinish(WriteRqstPtr, insertpos);
+ 
  		/* now wait for the write lock */
  		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  		LogwrtResult = XLogCtl->Write.LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			WriteRqst.Write = insertpos;
! 			WriteRqst.Flush = insertpos;
  
  			XLogWrite(WriteRqst, false, false);
  		}
  		LWLockRelease(WALWriteLock);
***************
*** 2234,2243 **** XLogBackgroundFlush(void)
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
- 
  	START_CRIT_SECTION();
  
  	/* now wait for the write lock */
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  	LogwrtResult = XLogCtl->Write.LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
--- 2565,2576 ----
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
  	START_CRIT_SECTION();
  
  	/* now wait for the write lock */
+ 
+ 	WaitXLogInsertionsToFinish(WriteRqstPtr, InvalidXLogRecPtr);
+ 
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  	LogwrtResult = XLogCtl->Write.LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
***************
*** 2248,2256 **** XLogBackgroundFlush(void)
  		WriteRqst.Flush = WriteRqstPtr;
  		XLogWrite(WriteRqst, flexible, false);
  	}
! 	LWLockRelease(WALWriteLock);
  
  	END_CRIT_SECTION();
  }
  
  /*
--- 2581,2600 ----
  		WriteRqst.Flush = WriteRqstPtr;
  		XLogWrite(WriteRqst, flexible, false);
  	}
! 	LogwrtResult = XLogCtl->Write.LogwrtResult;
  
  	END_CRIT_SECTION();
+ 
+ 	LWLockRelease(WALWriteLock);
+ 
+ 	/*
+ 	 * Great, done. To take some work off the critical path, try to initialize
+ 	 * as many of the no-longer-needed WAL buffers for future use as we can.
+ 	 *
+ 	 * Before we release the write lock, calculate the location of the last
+ 	 * fully written page.
+ 	 */
+ 	AdvanceXLInsertBuffer(false, InvalidXLogRecPtr, true);
  }
  
  /*
***************
*** 5044,5049 **** XLOGShmemSize(void)
--- 5388,5396 ----
  	/* and the buffers themselves */
  	size = add_size(size, mul_size(XLOG_BLCKSZ, XLOGbuffers));
  
+ 	/* XLog insertion slots */
+ 	size = add_size(size, mul_size(sizeof(BackendXLogInsertSlot), NumXLogInsertSlots));
+ 
  	/*
  	 * Note: we don't count ControlFileData, it comes out of the "slop factor"
  	 * added by CreateSharedMemoryAndSemaphores.  This lets us use this
***************
*** 5059,5064 **** XLOGShmemInit(void)
--- 5406,5412 ----
  	bool		foundCFile,
  				foundXLog;
  	char	   *allocptr;
+ 	int			i;
  
  	ControlFile = (ControlFileData *)
  		ShmemInitStruct("Control File", sizeof(ControlFileData), &foundCFile);
***************
*** 5084,5089 **** XLOGShmemInit(void)
--- 5432,5445 ----
  	memset(XLogCtl->xlblocks, 0, sizeof(XLogRecPtr) * XLOGbuffers);
  	allocptr += sizeof(XLogRecPtr) * XLOGbuffers;
  
+ 	/* Initialize per-backend buffers */
+ 	XLogCtl->BackendXLogInsertSlots = (BackendXLogInsertSlot *) allocptr;
+ 	for (i = 0; i < NumXLogInsertSlots; i++)
+ 	{
+ 		XLogCtl->BackendXLogInsertSlots[i].CurrPos = InvalidXLogRecPtr;
+ 	}
+ 	allocptr += sizeof(BackendXLogInsertSlot) * NumXLogInsertSlots;
+ 
  	/*
  	 * Align the start of the page buffers to an ALIGNOF_XLOG_BUFFER boundary.
  	 */
***************
*** 5098,5108 **** XLOGShmemInit(void)
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
- 	XLogCtl->Insert.currpage = (XLogPageHeader) (XLogCtl->pages);
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
--- 5454,5465 ----
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
+ 	SpinLockInit(&XLogCtl->Insert.insertpos_lck);
+ 
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
***************
*** 5942,5947 **** StartupXLOG(void)
--- 6299,6305 ----
  	uint32		freespace;
  	TransactionId oldestActiveXID;
  	bool		backupEndRequired = false;
+ 	int			firstIdx;
  
  	/*
  	 * Read control file and check XLOG status looks valid.
***************
*** 6697,6704 **** StartupXLOG(void)
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 	XLogCtl->xlblocks[0].xlogid = openLogId;
! 	XLogCtl->xlblocks[0].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
--- 7055,7066 ----
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 
! 	firstIdx = XLogRecPtrToBufIdx(EndOfLog);
! 	XLogCtl->curridx = firstIdx;
! 
! 	XLogCtl->xlblocks[firstIdx].xlogid = openLogId;
! 	XLogCtl->xlblocks[firstIdx].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
***************
*** 6706,6731 **** StartupXLOG(void)
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[0].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) Insert->currpage, readBuf, XLOG_BLCKSZ);
! 	Insert->currpos = (char *) Insert->currpage +
! 		(EndOfLog.xrecoff + XLOG_BLCKSZ - XLogCtl->xlblocks[0].xrecoff);
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
  	XLogCtl->Write.LogwrtResult = LogwrtResult;
- 	Insert->LogwrtResult = LogwrtResult;
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(Insert->currpos, 0, freespace);
! 		XLogCtl->Write.curridx = 0;
  	}
  	else
  	{
--- 7068,7091 ----
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[firstIdx].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) &XLogCtl->pages[firstIdx * XLOG_BLCKSZ], readBuf, XLOG_BLCKSZ);
! 	Insert->CurrPos = EndOfLog;
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
  	XLogCtl->Write.LogwrtResult = LogwrtResult;
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = XLOG_BLCKSZ - EndRecPtr.xrecoff % XLOG_BLCKSZ;
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(&XLogCtl->pages[firstIdx * XLOG_BLCKSZ] + EndRecPtr.xrecoff % XLOG_BLCKSZ, 0, freespace);
! 		XLogCtl->Write.curridx = firstIdx;
  	}
  	else
  	{
***************
*** 6737,6743 **** StartupXLOG(void)
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(0);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
--- 7097,7103 ----
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(firstIdx);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
***************
*** 7231,7239 **** GetRedoRecPtr(void)
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire WALInsertLock which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
  XLogRecPtr
  GetInsertRecPtr(void)
--- 7591,7603 ----
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire insertpos_lck which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
+  *
+  * XXX: now that there can be several insertions "in-flight", what should
+  * this return? The position a new insertion would got to? Or the the oldest
+  * still in-progress insertion, perhaps?
   */
  XLogRecPtr
  GetInsertRecPtr(void)
***************
*** 7507,7512 **** CreateCheckPoint(int flags)
--- 7871,7877 ----
  	uint32		insert_logSeg;
  	TransactionId *inCommitXids;
  	int			nInCommit;
+ 	XLogRecPtr	curInsert;
  
  	/*
  	 * An end-of-recovery checkpoint is really a shutdown checkpoint, just
***************
*** 7574,7584 **** CreateCheckPoint(int flags)
  	else
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * We must hold WALInsertLock while examining insert state to determine
! 	 * the checkpoint REDO pointer.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
--- 7939,7950 ----
  	else
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
+ 
  	/*
! 	 * Determine the checkpoint REDO pointer.
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	curInsert = Insert->CurrPos;
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
***************
*** 7590,7596 **** CreateCheckPoint(int flags)
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding the WALInsertLock we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
--- 7956,7962 ----
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding insertpos_lck we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
***************
*** 7599,7613 **** CreateCheckPoint(int flags)
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
- 		XLogRecPtr	curInsert;
- 
- 		INSERT_RECPTR(curInsert, Insert, Insert->curridx);
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			LWLockRelease(WALInsertLock);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
--- 7965,7976 ----
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
***************
*** 7633,7646 **** CreateCheckPoint(int flags)
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace < SizeOfXLogRecord)
! 	{
! 		(void) AdvanceXLInsertBuffer(false);
! 		/* OK to ignore update return flag, since we will do flush anyway */
! 		freespace = INSERT_FREESPACE(Insert);
! 	}
! 	INSERT_RECPTR(checkPoint.redo, Insert, Insert->curridx);
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
--- 7996,8005 ----
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = XLOG_BLCKSZ - curInsert.xrecoff % XLOG_BLCKSZ;
  	if (freespace < SizeOfXLogRecord)
! 		curInsert = AdvanceXLogRecPtrToNextPage(curInsert);
! 	checkPoint.redo = curInsert;
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
***************
*** 7666,7672 **** CreateCheckPoint(int flags)
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
--- 8025,8031 ----
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
***************
*** 7686,7692 **** CreateCheckPoint(int flags)
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released WALInsertLock, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
--- 8045,8051 ----
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released insertpos_lck, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
***************
*** 7798,7804 **** CreateCheckPoint(int flags)
  	 */
  	if (shutdown && !XLByteEQ(checkPoint.redo, ProcLastRecPtr))
  		ereport(PANIC,
! 				(errmsg("concurrent transaction log activity while database system is shutting down")));
  
  	/*
  	 * Select point at which we can truncate the log, which we base on the
--- 8157,8165 ----
  	 */
  	if (shutdown && !XLByteEQ(checkPoint.redo, ProcLastRecPtr))
  		ereport(PANIC,
! 				(errmsg("concurrent transaction log activity while database system is shutting down (redo %X/%X, ProcLastRecPtr %X/%X",
! 						checkPoint.redo.xlogid, checkPoint.redo.xrecoff,
! 						ProcLastRecPtr.xlogid, ProcLastRecPtr.xrecoff)));
  
  	/*
  	 * Select point at which we can truncate the log, which we base on the
***************
*** 8053,8067 **** CreateRestartPoint(int flags)
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * You need to hold WALInsertLock and info_lck to update it, although
! 	 * during recovery acquiring WALInsertLock is just pro forma, because
! 	 * there is no other processes updating Insert.RedoRecPtr.
  	 */
- 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
- 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * Prepare to accumulate statistics.
--- 8414,8425 ----
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * You need to hold info_lck to update it. There is no other processes
! 	 * updating Insert.RedoRecPtr, so we don't need a lock to protect that.
  	 */
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
  
  	/*
  	 * Prepare to accumulate statistics.
***************
*** 8816,8821 **** issue_xlog_fsync(int fd, uint32 log, uint32 seg)
--- 9174,9180 ----
  XLogRecPtr
  do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	XLogRecPtr	checkpointloc;
  	XLogRecPtr	startpoint;
***************
*** 8865,8890 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  	 * since we expect that any pages not modified during the backup interval
  	 * must have been correctly captured by the backup.)
  	 *
! 	 * We must hold WALInsertLock to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
! 		if (XLogCtl->Insert.exclusiveBackup)
  		{
! 			LWLockRelease(WALInsertLock);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		XLogCtl->Insert.exclusiveBackup = true;
  	}
  	else
! 		XLogCtl->Insert.nonExclusiveBackups++;
! 	XLogCtl->Insert.forcePageWrites = true;
! 	LWLockRelease(WALInsertLock);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
--- 9224,9249 ----
  	 * since we expect that any pages not modified during the backup interval
  	 * must have been correctly captured by the backup.)
  	 *
! 	 * We must hold insertpos_lck to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
! 		if (Insert->exclusiveBackup)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		Insert->exclusiveBackup = true;
  	}
  	else
! 		Insert->nonExclusiveBackups++;
! 	Insert->forcePageWrites = true;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
***************
*** 8946,8958 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			LWLockAcquire(WALInsertLock, LW_SHARED);
! 			if (XLByteLT(XLogCtl->Insert.lastBackupStart, startpoint))
  			{
! 				XLogCtl->Insert.lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			LWLockRelease(WALInsertLock);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
--- 9305,9317 ----
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			SpinLockAcquire(&Insert->insertpos_lck);
! 			if (XLByteLT(Insert->lastBackupStart, startpoint))
  			{
! 				Insert->lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			SpinLockRelease(&Insert->insertpos_lck);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
***************
*** 9034,9043 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
  		Assert(XLogCtl->Insert.exclusiveBackup);
--- 9393,9403 ----
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
  		Assert(XLogCtl->Insert.exclusiveBackup);
***************
*** 9054,9060 **** pg_start_backup_callback(int code, Datum arg)
  	{
  		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 9414,9420 ----
  	{
  		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9067,9072 **** pg_start_backup_callback(int code, Datum arg)
--- 9427,9433 ----
  XLogRecPtr
  do_pg_stop_backup(char *labelfile, bool waitforarchive)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	XLogRecPtr	startpoint;
  	XLogRecPtr	stoppoint;
***************
*** 9108,9116 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
! 		XLogCtl->Insert.exclusiveBackup = false;
  	else
  	{
  		/*
--- 9469,9477 ----
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
! 		Insert->exclusiveBackup = false;
  	else
  	{
  		/*
***************
*** 9119,9134 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 		XLogCtl->Insert.nonExclusiveBackups--;
  	}
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  
  	if (exclusive)
  	{
--- 9480,9495 ----
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(Insert->nonExclusiveBackups > 0);
! 		Insert->nonExclusiveBackups--;
  	}
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	if (exclusive)
  	{
***************
*** 9330,9345 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  void
  do_pg_abort_backup(void)
  {
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 	Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 	XLogCtl->Insert.nonExclusiveBackups--;
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 9691,9708 ----
  void
  do_pg_abort_backup(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	Assert(Insert->nonExclusiveBackups > 0);
! 	Insert->nonExclusiveBackups--;
! 
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9391,9406 **** GetStandbyFlushRecPtr(void)
   * Get latest WAL insert pointer
   */
  XLogRecPtr
! GetXLogInsertRecPtr(bool needlock)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	if (needlock)
! 		LWLockAcquire(WALInsertLock, LW_SHARED);
! 	INSERT_RECPTR(current_recptr, Insert, Insert->curridx);
! 	if (needlock)
! 		LWLockRelease(WALInsertLock);
  
  	return current_recptr;
  }
--- 9754,9767 ----
   * Get latest WAL insert pointer
   */
  XLogRecPtr
! GetXLogInsertRecPtr(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	current_recptr = Insert->CurrPos;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	return current_recptr;
  }
*** a/src/backend/access/transam/xlogfuncs.c
--- b/src/backend/access/transam/xlogfuncs.c
***************
*** 200,206 **** pg_current_xlog_insert_location(PG_FUNCTION_ARGS)
  				 errmsg("recovery is in progress"),
  				 errhint("WAL control functions cannot be executed during recovery.")));
  
! 	current_recptr = GetXLogInsertRecPtr(true);
  
  	snprintf(location, sizeof(location), "%X/%X",
  			 current_recptr.xlogid, current_recptr.xrecoff);
--- 200,206 ----
  				 errmsg("recovery is in progress"),
  				 errhint("WAL control functions cannot be executed during recovery.")));
  
! 	current_recptr = GetXLogInsertRecPtr();
  
  	snprintf(location, sizeof(location), "%X/%X",
  			 current_recptr.xlogid, current_recptr.xrecoff);
*** a/src/include/access/xlog.h
--- b/src/include/access/xlog.h
***************
*** 288,294 **** extern bool XLogInsertAllowed(void);
  extern void GetXLogReceiptTime(TimestampTz *rtime, bool *fromStream);
  extern XLogRecPtr GetXLogReplayRecPtr(XLogRecPtr *restoreLastRecPtr);
  extern XLogRecPtr GetStandbyFlushRecPtr(void);
! extern XLogRecPtr GetXLogInsertRecPtr(bool needlock);
  extern XLogRecPtr GetXLogWriteRecPtr(void);
  extern bool RecoveryIsPaused(void);
  extern void SetRecoveryPause(bool recoveryPause);
--- 288,294 ----
  extern void GetXLogReceiptTime(TimestampTz *rtime, bool *fromStream);
  extern XLogRecPtr GetXLogReplayRecPtr(XLogRecPtr *restoreLastRecPtr);
  extern XLogRecPtr GetStandbyFlushRecPtr(void);
! extern XLogRecPtr GetXLogInsertRecPtr(void);
  extern XLogRecPtr GetXLogWriteRecPtr(void);
  extern bool RecoveryIsPaused(void);
  extern void SetRecoveryPause(bool recoveryPause);
*** a/src/include/storage/lwlock.h
--- b/src/include/storage/lwlock.h
***************
*** 53,59 **** typedef enum LWLockId
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALInsertLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
--- 53,59 ----
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALBufMappingLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
***************
*** 79,84 **** typedef enum LWLockId
--- 79,85 ----
  	SerializablePredicateLockListLock,
  	OldSerXidLock,
  	SyncRepLock,
+ 	WALAuxSlotLock,
  	/* Individual lock IDs end here */
  	FirstBufMappingLock,
  	FirstLockMgrLock = FirstBufMappingLock + NUM_BUFFER_PARTITIONS,

*** a/src/backend/access/transam/xlog.c
--- b/src/backend/access/transam/xlog.c
***************
*** 42,47 ****
--- 42,48 ----
  #include "postmaster/startup.h"
  #include "replication/walreceiver.h"
  #include "replication/walsender.h"
+ #include "storage/barrier.h"
  #include "storage/bufmgr.h"
  #include "storage/fd.h"
  #include "storage/ipc.h"
***************
*** 272,277 **** static XLogRecPtr RedoRecPtr;
--- 273,290 ----
   */
  static XLogRecPtr RedoStartLSN = {0, 0};
  
+ /*
+  * We have one of these for each backend, plus one that is shared by all
+  * auxiliary processes. WALAuxSlotLock is used to coordinate access to the
+  * shared slot.
+  */
+ typedef struct
+ {
+ 	XLogRecPtr	CurrPos;	/* current position this process is inserting to */
+ } BackendXLogInsertSlot;
+ 
+ #define NumXLogInsertSlots	(MaxBackends + 1)
+ 
  /*----------
   * Shared-memory data structures for XLOG control
   *
***************
*** 282,292 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There are actually three shared-memory copies of
   * LogwrtResult, plus one unshared copy in each backend.  Here's how it works:
   *		XLogCtl->LogwrtResult is protected by info_lck
   *		XLogCtl->Write.LogwrtResult is protected by WALWriteLock
-  *		XLogCtl->Insert.LogwrtResult is protected by WALInsertLock
   * One must hold the associated lock to read or write any of these, but
   * of course no lock is needed to read/write the unshared LogwrtResult.
   *
--- 295,304 ----
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There are actually two shared-memory copies of
   * LogwrtResult, plus one unshared copy in each backend.  Here's how it works:
   *		XLogCtl->LogwrtResult is protected by info_lck
   *		XLogCtl->Write.LogwrtResult is protected by WALWriteLock
   * One must hold the associated lock to read or write any of these, but
   * of course no lock is needed to read/write the unshared LogwrtResult.
   *
***************
*** 296,307 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * is that it can be examined/modified by code that already holds WALWriteLock
   * without needing to grab info_lck as well.
   *
!  * XLogCtl->Insert.LogwrtResult may lag behind the reality of the other two,
!  * but is updated when convenient.	Again, it exists for the convenience of
!  * code that is already holding WALInsertLock but not the other locks.
!  *
!  * The unshared LogwrtResult may lag behind any or all of these, and again
!  * is updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
--- 308,315 ----
   * is that it can be examined/modified by code that already holds WALWriteLock
   * without needing to grab info_lck as well.
   *
!  * The unshared LogwrtResult may lag behind either or both of these, and is
!  * updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
***************
*** 311,320 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  The other locks are held longer (potentially
!  * over I/O operations), so we use LWLocks for them.  These locks are:
   *
!  * WALInsertLock: must be held to insert a record into the WAL buffers.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
--- 319,333 ----
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  insertpos_lck protects the current logical
!  * insert location, ie. the head of reserved WAL space.  The other locks are
!  * held longer (potentially over I/O operations), so we use LWLocks for them.
!  * These locks are:
   *
!  * WALBufMappingLock: must be held to replace a page in the WAL buffer cache.
!  * This is only held while initializing and changing the mapping. If the
!  * contents of the buffer being replaced haven't been written yet, the mapping
!  * lock is released while the write is done, and reacquired afterwards.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
***************
*** 326,331 **** static XLogRecPtr RedoStartLSN = {0, 0};
--- 339,392 ----
   * only one checkpointer at a time; currently, with all checkpoints done by
   * the checkpointer, this is just pro forma).
   *
+  *
+  *
+  * Inserting a new WAL record is a two-step process:
+  *
+  * 1. Reserve the right amount of space from the WAL. The current head
+  *    of reserved space is kept in Insert->CurrPos, and is protected by
+  *    infopos_lck. Try to keep this section as short as possible, infopos_lck
+  *    can be heavily contended on a busy system
+  *
+  * 2. Copy the record to the reserved WAL space. This involves finding the
+  *    correct WAL buffer containing the reserved space, and copying the
+  *    record in place. This can be done concurrently in multiple processes.
+  *
+  * To allow as much parallelism as possible for step 2, we try hard to avoid
+  * lock contention in that code path. Each backend has its own "XLog insertion
+  * slot", which is used to indicate the position the backend is writing to.
+  * The slot is marked as in-use in step 1, while holding infopos_lck, by
+  * setting the position field in the slot. When the backend is finished with
+  * the insertion, it can clear its slot without a lock.
+  *
+  * Before 9.2, WAL insertion was serialized on one big lock, so that once
+  * you finished inserting your record you knew that all the previous records
+  * were inserted too. That is no longer true, there can be insertions to
+  * earlier positions still in-progress when your insertion finishes. To wait
+  * for them to finish, use WaitXLogInsertionsToFinish(). It polls (FIXME:
+  * busy-waiting is bad) the array of per-backend XLog insertion slots until
+  * it sees that all of the insertions to earlier locations have finished.
+  *
+  *
+  * Deadlock analysis
+  * -----------------
+  *
+  * It's important to call WaitXLogInsertionsToFinish() *before* acquiring
+  * WALWriteLock. Otherwise you might get stuck waiting for a backend to finish
+  * (or at least advance to next uninitialized page), while you're holding
+  * WALWriteLock. That would be bad, because the backend you're waiting for
+  * might need to acquire WALWriteLock, too, to evict an old buffer, so you'd
+  * get deadlock.
+  *
+  * WaitXLogInsertionsToFinish() will not get stuck indefinitely, as long as
+  * its called with a location that's known to be already allocated in the WAL
+  * buffers. Calling it with the position of a record you've already inserted
+  * satisfies that condition. It can't get stuck, because an insertion to a
+  * WAL page that's already initialized in cache can always proceed without
+  * waiting on a lock. However, if the page has *just* been initialized, the
+  * insertion might still briefly acquire WALBufMappingLock to observe that
+  * fact.
+  *
   *----------
   */
  
***************
*** 346,356 **** typedef struct XLogwrtResult
   */
  typedef struct XLogCtlInsert
  {
! 	XLogwrtResult LogwrtResult; /* a recent value of LogwrtResult */
! 	XLogRecPtr	PrevRecord;		/* start of previously-inserted record */
! 	int			curridx;		/* current block index in cache */
! 	XLogPageHeader currpage;	/* points to header of block in cache */
! 	char	   *currpos;		/* current insertion point in cache */
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
--- 407,431 ----
   */
  typedef struct XLogCtlInsert
  {
! 	slock_t		insertpos_lck;	/* protects all the fields in this struct. */
! 
! 	/*
! 	 * CurrPos is the very tip of the reserved WAL space at the moment. The
! 	 * next record will be inserted there (or somewhere after it if there's
! 	 * not enough space on the current page). PrevRecord points to the
! 	 * beginning of the last record already reserved. It might not be fully
! 	 * copied into place yet, but we know its exact location.
! 	 */
! 	XLogRecPtr	CurrPos;
! 	XLogRecPtr	PrevRecord;
! 
! 	/*
! 	 * padding to push RedoRecPtr and forcePageWrites, which rarely change,
! 	 * to a different cache line than the rapidly-changing CurrPos and
! 	 * PrevRecord values.
! 	 */
! 	char		padding[128];
! 
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
***************
*** 381,389 **** typedef struct XLogCtlWrite
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by WALInsertLock: */
  	XLogCtlInsert Insert;
  
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
--- 456,466 ----
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by insertpos_lck: */
  	XLogCtlInsert Insert;
  
+ 	BackendXLogInsertSlot *BackendXLogInsertSlots;
+ 
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
***************
*** 397,405 **** typedef struct XLogCtlData
  	XLogCtlWrite Write;
  
  	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALInsertLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
--- 474,492 ----
  	XLogCtlWrite Write;
  
  	/*
+ 	 * To change curridx and the identity of a buffer, you need to hold
+ 	 * WALBufMappingLock. To change the identity of a buffer that's
+ 	 * still dirty, the old page needs to be written out first, and for that
+ 	 * you need WALWriteLock, and you need to ensure that there's no
+ 	 * in-progress insertions to the page by calling
+ 	 * WaitXLogInsertionsToFinish().
+ 	 */
+ 	int			curridx;		/* current (latest) block index in cache */
+ 
+ 	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALBufMappingLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
***************
*** 468,497 **** static XLogCtlData *XLogCtl = NULL;
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Macros for managing XLogInsert state.  In most cases, the calling routine
!  * has local copies of XLogCtl->Insert and/or XLogCtl->Insert->curridx,
!  * so these are passed as parameters instead of being fetched via XLogCtl.
   */
! 
! /* Free space remaining in the current xlog page buffer */
! #define INSERT_FREESPACE(Insert)  \
! 	(XLOG_BLCKSZ - ((Insert)->currpos - (char *) (Insert)->currpage))
! 
! /* Construct XLogRecPtr value for current insertion point */
! #define INSERT_RECPTR(recptr,Insert,curridx)  \
! 	( \
! 	  (recptr).xlogid = XLogCtl->xlblocks[curridx].xlogid, \
! 	  (recptr).xrecoff = \
! 		XLogCtl->xlblocks[curridx].xrecoff - INSERT_FREESPACE(Insert) \
! 	)
! 
! #define PrevBufIdx(idx)		\
! 		(((idx) == 0) ? XLogCtl->XLogCacheBlck : ((idx) - 1))
  
  #define NextBufIdx(idx)		\
  		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
   * See discussion above.
   */
--- 555,583 ----
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Calculate the amount of space left on the page after 'endptr'.
!  * Beware multiple evaluation!
   */
! #define INSERT_FREESPACE(endptr)	\
! 	(((endptr).xrecoff % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr).xrecoff % XLOG_BLCKSZ))
  
  #define NextBufIdx(idx)		\
  		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  /*
+  * XLogRecPtrToBufIdx returns the index of the WAL buffer that holds, or
+  * would hold if it was in cache, the page containing 'recptr'.
+  *
+  * XLogRecEndPtrToBufIdx is the same, but a pointer to the first byte of a
+  * page is taken to mean the previous page.
+  */
+ #define XLogRecPtrToBufIdx(recptr)	\
+ 	((((((uint64) (recptr).xlogid * (uint64) XLogSegsPerFile * XLogSegSize) + (recptr).xrecoff)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
+ 
+ #define XLogRecEndPtrToBufIdx(recptr)	\
+ 	((((((uint64) (recptr).xlogid * (uint64) XLogSegsPerFile * XLogSegSize) + (recptr).xrecoff - 1)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
+ 
+ /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
   * See discussion above.
   */
***************
*** 614,620 **** static void KeepLogSeg(XLogRecPtr recptr, uint32 *logId, uint32 *logSeg);
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static bool AdvanceXLInsertBuffer(bool new_segment);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
  static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
--- 700,706 ----
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static void AdvanceXLInsertBuffer(bool new_segment, XLogRecPtr upto, bool opportunistic);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
  static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
***************
*** 663,668 **** static bool read_backup_label(XLogRecPtr *checkPointLoc,
--- 749,766 ----
  static void rm_redo_error_callback(void *arg);
  static int	get_sync_bit(int method);
  
+ static XLogRecPtr PerformXLogInsert(int write_len, XLogRecord *rechdr,
+ 				  XLogRecData *rdata, pg_crc32 rdata_crc,
+ 				  bool forcePageWrites);
+ static bool ReserveXLogInsertLocation(int reqsize, bool forcePageWrites,
+ 						  XLogRecPtr *PrevRecord, XLogRecPtr *StartPos,
+ 						  XLogRecPtr *EndPos,
+ 						  volatile BackendXLogInsertSlot *myslot);
+ static XLogRecPtr WaitXLogInsertionsToFinish(XLogRecPtr upto,
+ 						   XLogRecPtr CurrPos);
+ static char *GetXLogBuffer(XLogRecPtr ptr);
+ static XLogRecPtr AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr);
+ 
  
  /*
   * Insert an XLOG record having the specified RMID and info bytes,
***************
*** 683,695 **** XLogRecPtr
  XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
- 	XLogRecord *record;
- 	XLogContRecord *contrecord;
  	XLogRecPtr	RecPtr;
- 	XLogRecPtr	WriteRqst;
- 	uint32		freespace;
- 	int			curridx;
  	XLogRecData *rdt;
  	Buffer		dtbuf[XLR_MAX_BKP_BLOCKS];
  	bool		dtbuf_bkp[XLR_MAX_BKP_BLOCKS];
  	BkpBlock	dtbuf_xlg[XLR_MAX_BKP_BLOCKS];
--- 781,789 ----
  XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	RecPtr;
  	XLogRecData *rdt;
+ 	XLogRecData *rdt_lastnormal;
  	Buffer		dtbuf[XLR_MAX_BKP_BLOCKS];
  	bool		dtbuf_bkp[XLR_MAX_BKP_BLOCKS];
  	BkpBlock	dtbuf_xlg[XLR_MAX_BKP_BLOCKS];
***************
*** 701,709 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  	uint32		len,
  				write_len;
  	unsigned	i;
- 	bool		updrqst;
  	bool		doPageWrites;
  	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
--- 795,805 ----
  	uint32		len,
  				write_len;
  	unsigned	i;
  	bool		doPageWrites;
+ 	bool		forcePageWrites;
  	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
+ 	uint8		info_final;
+ 	XLogRecord	rechdr;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
***************
*** 726,751 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  		return RecPtr;
  	}
  
  	/*
  	 * Here we scan the rdata chain, determine which buffers must be backed
! 	 * up, and compute the CRC values for the data.  Note that the record
! 	 * header isn't added into the CRC initially since we don't know the final
! 	 * length or info bits quite yet.  Thus, the CRC will represent the CRC of
! 	 * the whole record in the order "rdata, then backup blocks, then record
! 	 * header".
  	 *
  	 * We may have to loop back to here if a race condition is detected below.
  	 * We could prevent the race by doing all this work while holding the
  	 * insert lock, but it seems better to avoid doing CRC calculations while
! 	 * holding the lock.  This means we have to be careful about modifying the
! 	 * rdata chain until we know we aren't going to loop back again.  The only
! 	 * change we allow ourselves to make earlier is to set rdt->data = NULL in
! 	 * chain items we have decided we will have to back up the whole buffer
! 	 * for.  This is OK because we will certainly decide the same thing again
! 	 * for those items if we do it over; doing it here saves an extra pass
! 	 * over the chain later.
  	 */
  begin:;
  	for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
  	{
  		dtbuf[i] = InvalidBuffer;
--- 822,850 ----
  		return RecPtr;
  	}
  
+ 	/* TODO */
+ 	if (isLogSwitch)
+ 	{
+ 		elog(LOG, "log switch not implemented");
+ 		return InvalidXLogRecPtr;
+ 	}
+ 
  	/*
  	 * Here we scan the rdata chain, determine which buffers must be backed
! 	 * up.
  	 *
  	 * We may have to loop back to here if a race condition is detected below.
  	 * We could prevent the race by doing all this work while holding the
  	 * insert lock, but it seems better to avoid doing CRC calculations while
! 	 * holding the lock.
! 	 *
! 	 * To avoid modifying the original rdata chain, we copy it into
! 	 * rdata_final. Later we will also add entries for the backup blocks into
! 	 * rdata_final, so that they don't need any special treatment in the
! 	 * critical section where the chunks are copied into the WAL buffers.
  	 */
  begin:;
+ 	info_final = info;
  	for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
  	{
  		dtbuf[i] = InvalidBuffer;
***************
*** 758,766 **** begin:;
  	 * don't yet have the insert lock, forcePageWrites could change under us,
  	 * but we'll recheck it once we have the lock.
  	 */
! 	doPageWrites = fullPageWrites || Insert->forcePageWrites;
  
- 	INIT_CRC32(rdata_crc);
  	len = 0;
  	for (rdt = rdata;;)
  	{
--- 857,865 ----
  	 * don't yet have the insert lock, forcePageWrites could change under us,
  	 * but we'll recheck it once we have the lock.
  	 */
! 	forcePageWrites = Insert->forcePageWrites;
! 	doPageWrites = fullPageWrites || forcePageWrites;
  
  	len = 0;
  	for (rdt = rdata;;)
  	{
***************
*** 768,774 **** begin:;
  		{
  			/* Simple data, just include it */
  			len += rdt->len;
- 			COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  		}
  		else
  		{
--- 867,872 ----
***************
*** 779,790 **** begin:;
  				{
  					/* Buffer already referenced by earlier chain item */
  					if (dtbuf_bkp[i])
  						rdt->data = NULL;
  					else if (rdt->data)
- 					{
  						len += rdt->len;
- 						COMP_CRC32(rdata_crc, rdt->data, rdt->len);
- 					}
  					break;
  				}
  				if (dtbuf[i] == InvalidBuffer)
--- 877,888 ----
  				{
  					/* Buffer already referenced by earlier chain item */
  					if (dtbuf_bkp[i])
+ 					{
  						rdt->data = NULL;
+ 						rdt->len = 0;
+ 					}
  					else if (rdt->data)
  						len += rdt->len;
  					break;
  				}
  				if (dtbuf[i] == InvalidBuffer)
***************
*** 796,807 **** begin:;
  					{
  						dtbuf_bkp[i] = true;
  						rdt->data = NULL;
  					}
  					else if (rdt->data)
- 					{
  						len += rdt->len;
- 						COMP_CRC32(rdata_crc, rdt->data, rdt->len);
- 					}
  					break;
  				}
  			}
--- 894,903 ----
  					{
  						dtbuf_bkp[i] = true;
  						rdt->data = NULL;
+ 						rdt->len = 0;
  					}
  					else if (rdt->data)
  						len += rdt->len;
  					break;
  				}
  			}
***************
*** 814,852 **** begin:;
  			break;
  		rdt = rdt->next;
  	}
! 
! 	/*
! 	 * Now add the backup block headers and data into the CRC
! 	 */
! 	for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
! 	{
! 		if (dtbuf_bkp[i])
! 		{
! 			BkpBlock   *bkpb = &(dtbuf_xlg[i]);
! 			char	   *page;
! 
! 			COMP_CRC32(rdata_crc,
! 					   (char *) bkpb,
! 					   sizeof(BkpBlock));
! 			page = (char *) BufferGetBlock(dtbuf[i]);
! 			if (bkpb->hole_length == 0)
! 			{
! 				COMP_CRC32(rdata_crc,
! 						   page,
! 						   BLCKSZ);
! 			}
! 			else
! 			{
! 				/* must skip the hole */
! 				COMP_CRC32(rdata_crc,
! 						   page,
! 						   bkpb->hole_offset);
! 				COMP_CRC32(rdata_crc,
! 						   page + (bkpb->hole_offset + bkpb->hole_length),
! 						   BLCKSZ - (bkpb->hole_offset + bkpb->hole_length));
! 			}
! 		}
! 	}
  
  	/*
  	 * NOTE: We disallow len == 0 because it provides a useful bit of extra
--- 910,917 ----
  			break;
  		rdt = rdt->next;
  	}
! 	/* Remember that this was the last regular rdata entry */
! 	rdt_lastnormal = rdt;
  
  	/*
  	 * NOTE: We disallow len == 0 because it provides a useful bit of extra
***************
*** 858,922 **** begin:;
  	if (len == 0 && !isLogSwitch)
  		elog(PANIC, "invalid xlog record length %u", len);
  
- 	START_CRIT_SECTION();
- 
- 	/* Now wait to get insert lock */
- 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
- 
- 	/*
- 	 * Check to see if my RedoRecPtr is out of date.  If so, may have to go
- 	 * back and recompute everything.  This can only happen just after a
- 	 * checkpoint, so it's better to be slow in this case and fast otherwise.
- 	 *
- 	 * If we aren't doing full-page writes then RedoRecPtr doesn't actually
- 	 * affect the contents of the XLOG record, so we'll update our local copy
- 	 * but not force a recomputation.
- 	 */
- 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr))
- 	{
- 		Assert(XLByteLT(RedoRecPtr, Insert->RedoRecPtr));
- 		RedoRecPtr = Insert->RedoRecPtr;
- 
- 		if (doPageWrites)
- 		{
- 			for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
- 			{
- 				if (dtbuf[i] == InvalidBuffer)
- 					continue;
- 				if (dtbuf_bkp[i] == false &&
- 					XLByteLE(dtbuf_lsn[i], RedoRecPtr))
- 				{
- 					/*
- 					 * Oops, this buffer now needs to be backed up, but we
- 					 * didn't think so above.  Start over.
- 					 */
- 					LWLockRelease(WALInsertLock);
- 					END_CRIT_SECTION();
- 					goto begin;
- 				}
- 			}
- 		}
- 	}
- 
- 	/*
- 	 * Also check to see if forcePageWrites was just turned on; if we weren't
- 	 * already doing full-page writes then go back and recompute. (If it was
- 	 * just turned off, we could recompute the record without full pages, but
- 	 * we choose not to bother.)
- 	 */
- 	if (Insert->forcePageWrites && !doPageWrites)
- 	{
- 		/* Oops, must redo it with full-page data */
- 		LWLockRelease(WALInsertLock);
- 		END_CRIT_SECTION();
- 		goto begin;
- 	}
- 
  	/*
  	 * Make additional rdata chain entries for the backup blocks, so that we
! 	 * don't need to special-case them in the write loop.  Note that we have
! 	 * now irrevocably changed the input rdata chain.  At the exit of this
! 	 * loop, write_len includes the backup block data.
  	 *
  	 * Also set the appropriate info bits to show which buffers were backed
  	 * up. The i'th XLR_SET_BKP_BLOCK bit corresponds to the i'th distinct
--- 923,936 ----
  	if (len == 0 && !isLogSwitch)
  		elog(PANIC, "invalid xlog record length %u", len);
  
  	/*
  	 * Make additional rdata chain entries for the backup blocks, so that we
! 	 * don't need to special-case them in the write loop.  We have now
! 	 * modified the original rdata chain, but we remembered the last regular
! 	 * entry in rdt_lastnormal, so we can undo this if we have to loop back
! 	 * to the beginning.
! 	 *
! 	 * At the exit of this loop, write_len includes the backup block data.
  	 *
  	 * Also set the appropriate info bits to show which buffers were backed
  	 * up. The i'th XLR_SET_BKP_BLOCK bit corresponds to the i'th distinct
***************
*** 931,943 **** begin:;
  		if (!dtbuf_bkp[i])
  			continue;
  
! 		info |= XLR_SET_BKP_BLOCK(i);
  
  		bkpb = &(dtbuf_xlg[i]);
  		page = (char *) BufferGetBlock(dtbuf[i]);
  
  		rdt->next = &(dtbuf_rdt1[i]);
! 		rdt = rdt->next;
  
  		rdt->data = (char *) bkpb;
  		rdt->len = sizeof(BkpBlock);
--- 945,957 ----
  		if (!dtbuf_bkp[i])
  			continue;
  
! 		info_final |= XLR_SET_BKP_BLOCK(i);
  
  		bkpb = &(dtbuf_xlg[i]);
  		page = (char *) BufferGetBlock(dtbuf[i]);
  
  		rdt->next = &(dtbuf_rdt1[i]);
! 		rdt = &(dtbuf_rdt1[i]);
  
  		rdt->data = (char *) bkpb;
  		rdt->len = sizeof(BkpBlock);
***************
*** 971,1044 **** begin:;
  	}
  
  	/*
! 	 * If there isn't enough space on the current XLOG page for a record
! 	 * header, advance to the next page (leaving the unused space as zeroes).
  	 */
! 	updrqst = false;
! 	freespace = INSERT_FREESPACE(Insert);
! 	if (freespace < SizeOfXLogRecord)
! 	{
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		freespace = INSERT_FREESPACE(Insert);
! 	}
! 
! 	/* Compute record's XLOG location */
! 	curridx = Insert->curridx;
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
! 	 * segment, we need not insert it (and don't want to because we'd like
! 	 * consecutive switch requests to be no-ops).  Instead, make sure
! 	 * everything is written and flushed through the end of the prior segment,
! 	 * and return the prior segment's end address.
  	 */
! 	if (isLogSwitch &&
! 		(RecPtr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
! 	{
! 		/* We can release insert lock immediately */
! 		LWLockRelease(WALInsertLock);
! 
! 		RecPtr.xrecoff -= SizeOfXLogLongPHD;
! 		if (RecPtr.xrecoff == 0)
! 		{
! 			/* crossing a logid boundary */
! 			RecPtr.xlogid -= 1;
! 			RecPtr.xrecoff = XLogFileSize;
! 		}
! 
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 		LogwrtResult = XLogCtl->Write.LogwrtResult;
! 		if (!XLByteLE(RecPtr, LogwrtResult.Flush))
! 		{
! 			XLogwrtRqst FlushRqst;
! 
! 			FlushRqst.Write = RecPtr;
! 			FlushRqst.Flush = RecPtr;
! 			XLogWrite(FlushRqst, false, false);
! 		}
! 		LWLockRelease(WALWriteLock);
! 
! 		END_CRIT_SECTION();
! 
! 		return RecPtr;
! 	}
! 
! 	/* Insert record header */
! 
! 	record = (XLogRecord *) Insert->currpos;
! 	record->xl_prev = Insert->PrevRecord;
! 	record->xl_xid = GetCurrentTransactionIdIfAny();
! 	record->xl_tot_len = SizeOfXLogRecord + write_len;
! 	record->xl_len = len;		/* doesn't include backup blocks */
! 	record->xl_info = info;
! 	record->xl_rmid = rmid;
! 
! 	/* Now we can finish computing the record's CRC */
! 	COMP_CRC32(rdata_crc, (char *) record + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	record->xl_crc = rdata_crc;
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
--- 985,1013 ----
  	}
  
  	/*
! 	 * Calculate CRC of the data, including all the backup blocks
! 	 *
! 	 * Note that the record header isn't added into the CRC initially since
! 	 * we don't know the prev-link yet.  Thus, the CRC will represent the CRC
! 	 * of the whole record in the order "rdata, then backup blocks, then
! 	 * record header".
  	 */
! 	INIT_CRC32(rdata_crc);
! 	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
! 		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
  	/*
! 	 * Construct record header. We can't CRC it yet, because the prev-link
! 	 * needs to be covered by the CRC and we don't know that yet. We will
! 	 * finish computing the CRC when we do.
  	 */
! 	MemSet(&rechdr, 0, sizeof(rechdr));
! 	rechdr.xl_prev = InvalidXLogRecPtr; /* TO BE DETERMINED */
! 	rechdr.xl_xid = GetCurrentTransactionIdIfAny();
! 	rechdr.xl_tot_len = SizeOfXLogRecord + write_len;
! 	rechdr.xl_len = len;		/* doesn't include backup blocks */
! 	rechdr.xl_info = info;
! 	rechdr.xl_rmid = rmid;
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
***************
*** 1059,1231 **** begin:;
  	}
  #endif
  
! 	/* Record begin of record in appropriate places */
! 	ProcLastRecPtr = RecPtr;
! 	Insert->PrevRecord = RecPtr;
! 
! 	Insert->currpos += SizeOfXLogRecord;
! 	freespace -= SizeOfXLogRecord;
  
  	/*
! 	 * Append the data, including backup blocks if any
  	 */
! 	while (write_len)
! 	{
! 		while (rdata->data == NULL)
! 			rdata = rdata->next;
  
! 		if (freespace > 0)
! 		{
! 			if (rdata->len > freespace)
! 			{
! 				memcpy(Insert->currpos, rdata->data, freespace);
! 				rdata->data += freespace;
! 				rdata->len -= freespace;
! 				write_len -= freespace;
! 			}
! 			else
! 			{
! 				memcpy(Insert->currpos, rdata->data, rdata->len);
! 				freespace -= rdata->len;
! 				write_len -= rdata->len;
! 				Insert->currpos += rdata->len;
! 				rdata = rdata->next;
! 				continue;
! 			}
! 		}
  
! 		/* Use next buffer */
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		curridx = Insert->curridx;
! 		/* Insert cont-record header */
! 		Insert->currpage->xlp_info |= XLP_FIRST_IS_CONTRECORD;
! 		contrecord = (XLogContRecord *) Insert->currpos;
! 		contrecord->xl_rem_len = write_len;
! 		Insert->currpos += SizeOfXLogContRecord;
! 		freespace = INSERT_FREESPACE(Insert);
  	}
  
- 	/* Ensure next record will be properly aligned */
- 	Insert->currpos = (char *) Insert->currpage +
- 		MAXALIGN(Insert->currpos - (char *) Insert->currpage);
- 	freespace = INSERT_FREESPACE(Insert);
- 
  	/*
  	 * The recptr I return is the beginning of the *next* record. This will be
  	 * stored as LSN for changed data pages...
  	 */
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, we must now write and flush all the
! 	 * existing data, and then forcibly advance to the start of the next
! 	 * segment.  It's not good to do this I/O while holding the insert lock,
! 	 * but there seems too much risk of confusion if we try to release the
! 	 * lock sooner.  Fortunately xlog switch needn't be a high-performance
! 	 * operation anyway...
  	 */
! 	if (isLogSwitch)
  	{
! 		XLogCtlWrite *Write = &XLogCtl->Write;
! 		XLogwrtRqst FlushRqst;
! 		XLogRecPtr	OldSegEnd;
  
! 		TRACE_POSTGRESQL_XLOG_SWITCH();
  
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  
! 		/*
! 		 * Flush through the end of the page containing XLOG_SWITCH, and
! 		 * perform end-of-segment actions (eg, notifying archiver).
! 		 */
! 		WriteRqst = XLogCtl->xlblocks[curridx];
! 		FlushRqst.Write = WriteRqst;
! 		FlushRqst.Flush = WriteRqst;
! 		XLogWrite(FlushRqst, false, true);
! 
! 		/* Set up the next buffer as first page of next segment */
! 		/* Note: AdvanceXLInsertBuffer cannot need to do I/O here */
! 		(void) AdvanceXLInsertBuffer(true);
! 
! 		/* There should be no unwritten data */
! 		curridx = Insert->curridx;
! 		Assert(curridx == Write->curridx);
! 
! 		/* Compute end address of old segment */
! 		OldSegEnd = XLogCtl->xlblocks[curridx];
! 		OldSegEnd.xrecoff -= XLOG_BLCKSZ;
! 		if (OldSegEnd.xrecoff == 0)
! 		{
! 			/* crossing a logid boundary */
! 			OldSegEnd.xlogid -= 1;
! 			OldSegEnd.xrecoff = XLogFileSize;
! 		}
  
! 		/* Make it look like we've written and synced all of old segment */
! 		LogwrtResult.Write = OldSegEnd;
! 		LogwrtResult.Flush = OldSegEnd;
  
! 		/*
! 		 * Update shared-memory status --- this code should match XLogWrite
! 		 */
  		{
! 			/* use volatile pointer to prevent code rearrangement */
! 			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			SpinLockAcquire(&xlogctl->info_lck);
! 			xlogctl->LogwrtResult = LogwrtResult;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, LogwrtResult.Write))
! 				xlogctl->LogwrtRqst.Write = LogwrtResult.Write;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Flush, LogwrtResult.Flush))
! 				xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
! 			SpinLockRelease(&xlogctl->info_lck);
! 		}
  
! 		Write->LogwrtResult = LogwrtResult;
  
! 		LWLockRelease(WALWriteLock);
  
! 		updrqst = false;		/* done already */
! 	}
! 	else
! 	{
! 		/* normal case, ie not xlog switch */
  
! 		/* Need to update shared LogwrtRqst if some block was filled up */
! 		if (freespace < SizeOfXLogRecord)
! 		{
! 			/* curridx is filled and available for writing out */
! 			updrqst = true;
! 		}
! 		else
! 		{
! 			/* if updrqst already set, write through end of previous buf */
! 			curridx = PrevBufIdx(curridx);
  		}
! 		WriteRqst = XLogCtl->xlblocks[curridx];
  	}
  
! 	LWLockRelease(WALInsertLock);
  
! 	if (updrqst)
  	{
  		/* use volatile pointer to prevent code rearrangement */
  		volatile XLogCtlData *xlogctl = XLogCtl;
  
  		SpinLockAcquire(&xlogctl->info_lck);
  		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, WriteRqst))
! 			xlogctl->LogwrtRqst.Write = WriteRqst;
  		/* update local result copy while I have the chance */
  		LogwrtResult = xlogctl->LogwrtResult;
  		SpinLockRelease(&xlogctl->info_lck);
  	}
  
! 	XactLastRecEnd = RecPtr;
  
- 	END_CRIT_SECTION();
  
! 	return RecPtr;
  }
  
  /*
--- 1028,1505 ----
  	}
  #endif
  
! 	START_CRIT_SECTION();
  
  	/*
! 	 * Try to do the insertion.
  	 */
! 	RecPtr = PerformXLogInsert(write_len, &rechdr, rdata, rdata_crc,
! 							forcePageWrites);
! 	END_CRIT_SECTION();
  
! 	if (XLogRecPtrIsInvalid(RecPtr))
! 	{
! 		/*
! 		 * Oops, have to retry. Unlink the backup blocks from the chain,
! 		 * restoring it to its original state.
! 		 */
! 		rdt_lastnormal->next = NULL;
  
! 		goto begin;
  	}
  
  	/*
  	 * The recptr I return is the beginning of the *next* record. This will be
  	 * stored as LSN for changed data pages...
  	 */
! 	return RecPtr;
! }
! 
! /*
!  * Subroutine of XLogInsert. All the changes to shared state are done here,
!  * XLogInsert only prepares the record for insertion.
!  *
!  * On success, returns pointer to end of inserted record like XLogInsert().
!  * If RedoRecPtr or forcePageWrites had changed, returns InvalidRecPtr, and
!  * the caller must recalculate full-page-images and retry.
!  */
! static XLogRecPtr
! PerformXLogInsert(int write_len, XLogRecord *rechdr,
! 				  XLogRecData *rdata, pg_crc32 rdata_crc,
! 				  bool forcePageWrites)
! {
! 	volatile BackendXLogInsertSlot *myslot;
! 	char	   *currpos;
! 	XLogRecord *record;
! 	int			tot_len;
! 	int			freespace;
! 	int			tot_left;
! 	XLogRecPtr	PrevRecord;
! 	XLogRecPtr	StartPos;
! 	XLogRecPtr	EndPos;
! 	XLogRecPtr	CurrPos;
  
  	/*
! 	 * Our fast insertion method requires each process to have its own
! 	 * "slot", to tell others that it's still busy doing the insertion. Each
! 	 * regular backend has a dedicated slot, but auxiliary processes share
! 	 * one extra slot. Aux processes don't write a lot of WAL so they can
! 	 * well share. WALAuxSlotLock is used to coordinate access to the slot
! 	 * between aux processes.
  	 */
! 	if (MyBackendId == InvalidBackendId)
  	{
! 		LWLockAcquire(WALAuxSlotLock, LW_EXCLUSIVE);
! 		myslot = &XLogCtl->BackendXLogInsertSlots[MaxBackends];
! 	}
! 	else
! 		myslot = &XLogCtl->BackendXLogInsertSlots[MyBackendId];
  
! 	/* Get an insert location  */
! 	tot_len = SizeOfXLogRecord + write_len;
! 	if (!ReserveXLogInsertLocation(tot_len, forcePageWrites,
! 								   &PrevRecord, &StartPos, &EndPos, myslot))
! 	{
! 		if (MyBackendId == InvalidBackendId)
! 			LWLockRelease(WALAuxSlotLock);
! 		return InvalidXLogRecPtr;
! 	}
  
! 	/*
! 	 * Got an insertion location! Now that we know the prev-link, we can
! 	 * finish computing the record's CRC
! 	 */
! 	rechdr->xl_prev = PrevRecord;
! 	COMP_CRC32(rdata_crc, ((char *) rechdr) + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	rechdr->xl_crc = rdata_crc;
  
! 	/* Get the right WAL page to start inserting to */
! 	CurrPos = StartPos;
! 	currpos = GetXLogBuffer(CurrPos);
! 	freespace = XLOG_BLCKSZ - CurrPos.xrecoff % XLOG_BLCKSZ;
  
! 	/* Copy the record header and data */
! 	record = (XLogRecord *) currpos;
  
! 	memcpy(record, rechdr, sizeof(XLogRecord));
! 	currpos += SizeOfXLogRecord;
! 	CurrPos.xrecoff += SizeOfXLogRecord;
! 	freespace -= SizeOfXLogRecord;
! 
! 	tot_left = write_len;
! 	while (rdata != NULL)
! 	{
! 		while (rdata->len > freespace)
  		{
! 			/*
! 			 * Write what fits on this page, then write the continuation
! 			 * record, and continue.
! 			 */
! 			XLogContRecord *contrecord;
  
! 			memcpy(currpos, rdata->data, freespace);
! 			rdata->data += freespace;
! 			rdata->len -= freespace;
! 			tot_left -= freespace;
  
! 			CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
  
! 			/*
! 			 * Make sure the memcpy is visible to others before we claim
! 			 * it to be done. It's important to update CurrPos before calling
! 			 * GetXLogBuffer(), because GetXLogBuffer() might need to wait
! 			 * for some insertions to finish so that it can write out a
! 			 * buffer to make room for the new page. Updating CurrPos before
! 			 * waiting for a new buffer ensures that we don't deadlock with
! 			 * ourselves if we run out of clean buffers.
! 			 */
! 			pg_write_barrier();
! 			myslot->CurrPos = CurrPos;
  
! 			currpos = GetXLogBuffer(CurrPos);
  
! 			contrecord = (XLogContRecord *) currpos;
! 			contrecord->xl_rem_len = tot_len - tot_left;
! 
! 			currpos += SizeOfXLogContRecord;
! 			CurrPos.xrecoff += SizeOfXLogContRecord;
! 
! 			freespace = XLOG_BLCKSZ - CurrPos.xrecoff % XLOG_BLCKSZ;
  		}
! 
! 		memcpy(currpos, rdata->data, rdata->len);
! 		currpos += rdata->len;
! 		CurrPos.xrecoff += rdata->len;
! 		freespace -= rdata->len;
! 		tot_left -= rdata->len;
! 
! 		rdata = rdata->next;
  	}
+ 	Assert(tot_left == 0);
+ 
+ 	CurrPos.xrecoff = MAXALIGN(CurrPos.xrecoff);
+ 	Assert(XLByteEQ(CurrPos, EndPos));
+ 
+ 	/*
+ 	 * Done! Clear CurrPos in our slot to let others know that we're finished,
+ 	 * but first make sure the changes we made to the WAL pages are visible
+ 	 * to everyone.
+ 	 */
+ 	pg_write_barrier();
+ 	myslot->CurrPos = InvalidXLogRecPtr;
+ 	if (MyBackendId == InvalidBackendId)
+ 		LWLockRelease(WALAuxSlotLock);
  
! 	/* update our global variables */
! 	ProcLastRecPtr = StartPos;
! 	XactLastRecEnd = EndPos;
  
! 	/* update shared LogwrtRqst.Write, if we crossed page boundary */
! 	if (StartPos.xrecoff / XLOG_BLCKSZ != EndPos.xrecoff / XLOG_BLCKSZ)
  	{
  		/* use volatile pointer to prevent code rearrangement */
  		volatile XLogCtlData *xlogctl = XLogCtl;
  
  		SpinLockAcquire(&xlogctl->info_lck);
  		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, EndPos))
! 			xlogctl->LogwrtRqst.Write = EndPos;
  		/* update local result copy while I have the chance */
  		LogwrtResult = xlogctl->LogwrtResult;
  		SpinLockRelease(&xlogctl->info_lck);
  	}
  
! 	return EndPos;
! }
  
  
! /*
!  * Reserves the right amount of space for a record of the given size from
!  * the WAL. *StartPos_p is set to the beginning of the reserved section,
!  * *EndPos_p to its end, and *Prev_record_p points to the beginning of the
!  * previous record to set to the prev-link of the record header.
!  *
!  * While holding insertpos_lck, sets myslot->CurrPos to the starting position,
!  * to let others know that we're busy inserting to the reserved area. The
!  * caller must clear it when the insertion is finished.
!  *
!  * Returns true on success, or false if RedoRecPtr or forcePageWrites was
!  * changed. On failure, the shared state is not modified.
!  *
!  * This is the performance critical part of XLogInsert that must be
!  * serialized across backends. The rest can happen mostly in parallel.
!  *
!  * NB: The space calculation here must match the code in PerformXLogInsert,
!  * where we actually copy the record to the reserved space.
!  */
! static bool
! ReserveXLogInsertLocation(int size, bool forcePageWrites,
! 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
! 						  XLogRecPtr *EndPos_p,
! 						  volatile BackendXLogInsertSlot *myslot)
! {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			freespace;
! 	XLogRecPtr	ptr;
! 	XLogRecPtr	StartPos;
! 	int			sizeleft;
! 
! 	sizeleft = size;
! 
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 
! 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr) ||
! 		Insert->forcePageWrites != forcePageWrites)
! 	{
! 		/*
! 		 * Oops, forcePageWrites was just turned on, or a checkpoint
! 		 * just happened. Loop back to the beginning, because we might have
! 		 * to include more full-page images in the record
! 		 */
! 		RedoRecPtr = Insert->RedoRecPtr;
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		return false;
! 	}
! 
! 	/*
! 	 * Now reserve the right amount of space from the WAL for our record.
! 	 */
! 	ptr = Insert->CurrPos;
! 	*PrevRecord_p = Insert->PrevRecord;
! 
! 	/*
! 	 * If there isn't enough space on the current XLOG page for a record
! 	 * header, advance to the next page (leaving the unused space as zeroes).
! 	 */
! 	freespace = INSERT_FREESPACE(ptr);
! 	if (freespace < SizeOfXLogRecord)
! 	{
! 		ptr = AdvanceXLogRecPtrToNextPage(ptr);
! 		freespace = INSERT_FREESPACE(ptr);
! 	}
! 	StartPos = ptr;
! 
! 	/*
! 	 * Set our slot's CurrPos to the starting position, to let others know
! 	 * that we're busy inserting to this area.
! 	 */
! 	myslot->CurrPos = StartPos;
! 
! 	while (freespace < sizeleft)
! 	{
! 		/* fill this page, and continue on next page */
! 		sizeleft -= freespace;
! 		ptr = AdvanceXLogRecPtrToNextPage(ptr);
! 
! 		/* account for continuation record header */
! 		ptr.xrecoff += SizeOfXLogContRecord;
! 		freespace = INSERT_FREESPACE(ptr);
! 	}
! 	/* the rest fits on this page */
! 	ptr.xrecoff += sizeleft;
! 	sizeleft = 0;
! 
! 	/* Align the end position, so that the next record starts aligned */
! 	ptr.xrecoff = MAXALIGN(ptr.xrecoff);
! 
! 	/* Update the shared state, and our slot, before releasing the lock */
! 	Insert->CurrPos = ptr;
! 	Insert->PrevRecord = StartPos;
! 
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! #ifdef RESERVE_XLOGINSERT_LOCATION_DEBUG
! 	elog(DEBUG2, "reserved xlog: prev %X/%X, start %X/%X, end %X/%X (len %d)",
! 		 result->PrevRecord.xlogid, result->PrevRecord.xrecoff,
! 		 StartPos.xlogid, StartPos.xrecoff,
! 		 ptr.xlogid, ptr.xrecoff,
! 		 reqsize);
! #endif
! 
! 	*EndPos_p = ptr;
! 	*StartPos_p = StartPos;
! 
! 	return true;
! }
! 
! /*
!  * Get a pointer to the right location in the WAL buffer corresponding a
!  * given XLogRecPtr.
!  *
!  * If the page is not initialized yet, it is initialized. That might also
!  * require evicting an old diry buffer from the buffer cache, which means I/O.
!  *
!  * The caller must ensure that the page containing the requested location
!  * isn't evicted yet, and won't be evicted, by holding onto a
!  * BackendXLogInsertSlot with CurrPos set to 'ptr'. Setting it to some value
!  * less than 'ptr' would suffice for GetXLogBuffer(), but risks deadlock:
!  * if we have to evict a buffer, we might have to wait for someone else to
!  * finish a write. And that someone else might not be able to finish the write
!  * if our CurrPos points to a buffer that's still in the buffer cache.
!  */
! static char *
! GetXLogBuffer(XLogRecPtr ptr)
! {
! 	int			idx;
! 	XLogRecPtr	endptr;
! 
! 	/*
! 	 * The XLog buffer cache is organized so that we can easily calculate the
! 	 * buffer a given page must be loaded into from the XLogRecPtr alone.
! 	 * A page must always be loaded to a particular buffer.
! 	 */
! 	idx = XLogRecPtrToBufIdx(ptr);
! 
! 	/*
! 	 * See what page is loaded in the buffer at the moment. It could be the
! 	 * page we're looking for, or something older. It can't be anything
! 	 * newer - that would imply the page we're looking for has already
! 	 * been written out to disk, which shouldn't happen as long as the caller
! 	 * has set its slot's CurrPos correctly.
! 	 *
! 	 * However, we don't hold a lock while we read the value. If someone has
! 	 * just initialized the page, it's possible that we get a "torn read",
! 	 * and read a bogus value. That's ok, we'll grab the mapping lock (in
! 	 * AdvanceXLInsertBuffer) and retry if we see anything else than the page
! 	 * we're looking for. But it means that when we do this unlocked read, we
! 	 * might see a value that *is* ahead of the page we're looking for. So
! 	 * don't PANIC on that, until we've verified the value while holding the
! 	 * lock.
! 	 */
! 	endptr = XLogCtl->xlblocks[idx];
! 	if (ptr.xlogid != endptr.xlogid ||
! 		!(ptr.xrecoff < endptr.xrecoff &&
! 		  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
! 	{
! 		AdvanceXLInsertBuffer(false, ptr, false);
! 		endptr = XLogCtl->xlblocks[idx];
! 
! 		if (ptr.xlogid != endptr.xlogid ||
! 			!(ptr.xrecoff < endptr.xrecoff &&
! 			  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
! 		{
! 			elog(PANIC, "could not find WAL buffer for %X/%X", ptr.xlogid, ptr.xrecoff);
! 		}
! 	}
! 
! 	/*
! 	 * Found the buffer holding this page. Return a pointer to the right
! 	 * offset within the page.
! 	 */
! 	return (char *) XLogCtl->pages + idx * (Size) XLOG_BLCKSZ +
! 		ptr.xrecoff % XLOG_BLCKSZ;
! }
! 
! /*
!  * Advance an XLogRecPtr to the first valid insertion location on the next
!  * page, right after the page header. An XLogRecPtr pointing to a boundary,
!  * ie. the first byte of a page, is taken to belong to the previous page.
!  */
! static XLogRecPtr
! AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr)
! {
! 	int			freespace;
! 
! 	freespace = INSERT_FREESPACE(ptr);
! 	XLByteAdvance(ptr, freespace);
! 	if (ptr.xrecoff % XLogSegSize == 0)
! 		ptr.xrecoff += SizeOfXLogLongPHD;
! 	else
! 		ptr.xrecoff += SizeOfXLogShortPHD;
! 
! 	return ptr;
! }
! 
! /*
!  * Wait for any insertions < upto to finish.
!  *
!  * Returns a value >= upto, which indicates the oldest in-progress insertion
!  * that we saw in the array. All insertions upto that point are guaranteed to
!  * be finished. Note that it is just a conservative guess, there are race
!  * conditions where we return a bogus, too-low, value. If you care about the
!  * return value, you must get the current Insert->CurrPos value *before*
!  * calling this function, and pass that as the CurrPos argument.
!  */
! static XLogRecPtr
! WaitXLogInsertionsToFinish(XLogRecPtr upto, XLogRecPtr CurrPos)
! {
! 	int			i;
! 	int			nbusyslots = 0;
! 	/* FIXME: it's not safe to palloc here, would PANIC on OOM */
! 	int		   *busyslots = palloc0(sizeof(int) * NumXLogInsertSlots);
! 	int			cycles = 0;
! 
! 	/*
! 	 * Get a list of backend slots that are still inserting to a point earlier
! 	 * than 'upto'.
! 	 *
! 	 * This is a bit sloppy because we don't do any locking here. A slot's
! 	 * CurrPos that we read might get split if 8-byte loads are not atomic,
! 	 * but that's harmless. All slots with values <= upto, which we really do
! 	 * have to wait for, must be in the array before this function is called.
! 	 * That's because the 'upto' value must've been obtained by reading the
! 	 * current insert position, either directly or indirectly. It can never
! 	 * be > Insert->CurrPos. So we shouldn't miss anything that we genuinely
! 	 * need to wait for. OTOH, if someone is just storing an XLogRecPtr in a
! 	 * slot while we read it, we might incorrectly think that we have to wait
! 	 * for it. But that's OK, because in the loop that follows, we'll retry
! 	 * and see that it's actually > upto.
! 	 *
! 	 * XXX: that's bogus. You might see a too-new value if a slot's CurrPos is
! 	 * advanced at the same instant.
! 	 */
! 	for (i = 0; i < NumXLogInsertSlots; i++)
! 	{
! 		volatile BackendXLogInsertSlot *slot = &XLogCtl->BackendXLogInsertSlots[i];
! 		XLogRecPtr slotptr = slot->CurrPos;
! 
! 		if (XLogRecPtrIsInvalid(slotptr))
! 			continue;
! 
! 		if (XLByteLT(slotptr, upto))
! 			busyslots[nbusyslots++] = i;
! 		else if (XLByteLT(slotptr, CurrPos))
! 			CurrPos = slotptr;
! 	}
! 
! 	/*
! 	 * Busy-wait until the insertion is done.
! 	 *
! 	 * TODO: This needs to be replaced with something smarter. I don't think
! 	 * it's possible that we'd have to wait for I/O here, though. As the code
! 	 * stands, the caller never passes an 'upto' pointer that points to an
! 	 * uninitialized page. It always points to an already inserted record, in
! 	 * which case the page must already be initialized in the WAL buffer
! 	 * cache. Nevertheless, busy-waiting is not good.
! 	 */
! 	while (nbusyslots > 0)
! 	{
! 		pg_read_barrier();
! 		for (i = 0; i < nbusyslots; i++)
! 		{
! 			volatile BackendXLogInsertSlot *slot = &XLogCtl->BackendXLogInsertSlots[busyslots[i]];
! 			XLogRecPtr slotptr = slot->CurrPos;
! 
! 			if (XLogRecPtrIsInvalid(slot->CurrPos) || !XLByteLT(slotptr, upto))
! 			{
! 				if (nbusyslots > 1)
! 				{
! 					busyslots[i] = busyslots[nbusyslots - 1];
! 					i--;
! 				}
! 				nbusyslots--;
! 			}
! 		}
! 
! 		/* a debugging aid */
! 		if (++cycles == 1000000)
! 			elog(LOG, "stuck waiting upto %X/%X", upto.xlogid, upto.xrecoff);
! 	}
! 	pfree(busyslots);
! 
! 	return CurrPos;
  }
  
  /*
***************
*** 1458,1486 **** XLogArchiveCleanup(const char *xlog)
   * If new_segment is TRUE then we set up the next buffer page as the first
   * page of the next xlog segment file, possibly but not usually the next
   * consecutive file page.
-  *
-  * The global LogwrtRqst.Write pointer needs to be advanced to include the
-  * just-filled page.  If we can do this for free (without an extra lock),
-  * we do so here.  Otherwise the caller must do it.  We return TRUE if the
-  * request update still needs to be done, FALSE if we did it internally.
-  *
-  * Must be called with WALInsertLock held.
   */
! static bool
! AdvanceXLInsertBuffer(bool new_segment)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogCtlWrite *Write = &XLogCtl->Write;
! 	int			nextidx = NextBufIdx(Insert->curridx);
! 	bool		update_needed = true;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
  	XLogRecPtr	NewPageEndPtr;
  	XLogPageHeader NewPage;
  
! 	/* Use Insert->LogwrtResult copy if it's more fresh */
! 	if (XLByteLT(LogwrtResult.Write, Insert->LogwrtResult.Write))
! 		LogwrtResult = Insert->LogwrtResult;
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
--- 1732,1763 ----
   * If new_segment is TRUE then we set up the next buffer page as the first
   * page of the next xlog segment file, possibly but not usually the next
   * consecutive file page.
   */
! static void
! AdvanceXLInsertBuffer(bool new_segment, XLogRecPtr upto, bool opportunistic)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogCtlWrite *Write = &XLogCtl->Write;
! 	int			nextidx;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
  	XLogRecPtr	NewPageEndPtr;
  	XLogPageHeader NewPage;
+ 	bool		needflush;
+ 	int			npages = 0;
+ 	XLogRecPtr	EvictedPtr;
+ 
+ 	Assert(!new_segment); /* FIXME: not implemented */
+ 
+ 	LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
  
! 	/*
! 	 * Now that we have the lock, check if someone initialized the page
! 	 * already.
! 	 */
! while (!XLByteLT(upto, XLogCtl->xlblocks[XLogCtl->curridx]) || opportunistic)
! {
! 	nextidx = NextBufIdx(XLogCtl->curridx);
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
***************
*** 1488,1499 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
- 	if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
- 	{
- 		/* nope, got work to do... */
- 		XLogRecPtr	FinishedPageRqstPtr;
  
! 		FinishedPageRqstPtr = XLogCtl->xlblocks[Insert->curridx];
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
--- 1765,1781 ----
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
  
! 	needflush = !XLByteLE(OldPageRqstPtr, LogwrtResult.Write);
! 
! 	if (needflush)
! 	{
! 		/*
! 		 * Nope, got work to do. If we just want to pre-initialize as much as
! 		 * we can without flushing, give up now.
! 		 */
! 		if (opportunistic)
! 			break;
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
***************
*** 1501,1534 **** AdvanceXLInsertBuffer(bool new_segment)
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, FinishedPageRqstPtr))
! 				xlogctl->LogwrtRqst.Write = FinishedPageRqstPtr;
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		update_needed = false;	/* Did the shared-request update */
! 
! 		if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
! 		{
! 			/* OK, someone wrote it already */
! 			Insert->LogwrtResult = LogwrtResult;
! 		}
! 		else
  		{
! 			/* Must acquire write lock */
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  			LogwrtResult = Write->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding insert lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
--- 1783,1819 ----
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, OldPageRqstPtr))
! 			{
! 				Assert(XLByteLE(OldPageRqstPtr, xlogctl->Insert.CurrPos));
! 				xlogctl->LogwrtRqst.Write = OldPageRqstPtr;
! 			}
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/*
! 			 * Must acquire write lock. Release WALBufMappingLock first, to
! 			 * make sure that all insertions that we need to wait for can
! 			 * finish (up to this same position). Otherwise we risk deadlock.
! 			 */
! 			LWLockRelease(WALBufMappingLock);
! 
! 			WaitXLogInsertionsToFinish(OldPageRqstPtr, InvalidXLogRecPtr);
! 
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  			LogwrtResult = Write->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding mapping lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
***************
*** 1537,1560 **** AdvanceXLInsertBuffer(bool new_segment)
  				WriteRqst.Flush.xrecoff = 0;
  				XLogWrite(WriteRqst, false, false);
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
  		}
  	}
  
  	/*
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[Insert->curridx];
  
  	if (new_segment)
  	{
  		/* force it to a segment start point */
  		NewPageEndPtr.xrecoff += XLogSegSize - 1;
  		NewPageEndPtr.xrecoff -= NewPageEndPtr.xrecoff % XLogSegSize;
  	}
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
--- 1822,1851 ----
  				WriteRqst.Flush.xrecoff = 0;
  				XLogWrite(WriteRqst, false, false);
  				LWLockRelease(WALWriteLock);
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
+ 			/* Re-acquire WALBufMappingLock and retry */
+ 			LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
+ 			continue;
  		}
  	}
  
+ 	EvictedPtr = OldPageRqstPtr;
+ 
  	/*
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[XLogCtl->curridx];
  
+ #ifdef BROKEN
  	if (new_segment)
  	{
  		/* force it to a segment start point */
  		NewPageEndPtr.xrecoff += XLogSegSize - 1;
  		NewPageEndPtr.xrecoff -= NewPageEndPtr.xrecoff % XLogSegSize;
  	}
+ #endif
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
***************
*** 1564,1577 **** AdvanceXLInsertBuffer(bool new_segment)
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
  	XLogCtl->xlblocks[nextidx] = NewPageEndPtr;
  	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
- 	Insert->curridx = nextidx;
- 	Insert->currpage = NewPage;
- 
- 	Insert->currpos = ((char *) NewPage) +SizeOfXLogShortPHD;
- 
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
  	 * will look like zeroes and not valid XLOG records...
--- 1855,1866 ----
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
+ 	Assert(NewPageEndPtr.xrecoff % XLOG_BLCKSZ == 0);
+ 	Assert(XLogRecEndPtrToBufIdx(NewPageEndPtr) == nextidx);
+ 
  	XLogCtl->xlblocks[nextidx] = NewPageEndPtr;
  	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
  	 * will look like zeroes and not valid XLOG records...
***************
*** 1614,1624 **** AdvanceXLInsertBuffer(bool new_segment)
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
- 
- 		Insert->currpos = ((char *) NewPage) +SizeOfXLogLongPHD;
  	}
  
! 	return update_needed;
  }
  
  /*
--- 1903,1932 ----
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
  	}
  
! 	/*
! 	 * make sure the xlblocks update becomes visible to others before the
! 	 * curridx update.
! 	 */
! 	pg_write_barrier();
! 
! 	XLogCtl->curridx = nextidx;
! 
! 	npages++;
! }
! 
! 	Assert(opportunistic || XLByteLT(upto, XLogCtl->xlblocks[XLogCtl->curridx]));
! 	LWLockRelease(WALBufMappingLock);
! 
! #ifdef WAL_DEBUG
! 	if (npages > 0)
! 		elog(LOG, "initialized %d pages, upto %X/%X (evicted upto %X/%X) in slot %d (backend %d)",
! 			 npages,
! 			 NewPageEndPtr.xlogid, NewPageEndPtr.xrecoff,
! 			 EvictedPtr.xlogid, EvictedPtr.xrecoff,
! 			 nextidx, MyBackendId);
! #endif
  }
  
  /*
***************
*** 1669,1675 **** XLogCheckpointNeeded(uint32 logid, uint32 logseg)
   * only if caller specifies WriteRqst == page-end and flexible == false,
   * and there is some data to write.)
   *
!  * Must be called with WALWriteLock held.
   */
  static void
  XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
--- 1977,1985 ----
   * only if caller specifies WriteRqst == page-end and flexible == false,
   * and there is some data to write.)
   *
!  * Must be called with WALWriteLock held. And you must've called
!  * WaitXLogInsertionsToFinish(WriteRqst) to make sure the data is ready to
!  * write.
   */
  static void
  XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
***************
*** 1722,1731 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
  		if (!XLByteLT(LogwrtResult.Write, XLogCtl->xlblocks[curridx]))
! 			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  				 XLogCtl->xlblocks[curridx].xlogid,
! 				 XLogCtl->xlblocks[curridx].xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
  		LogwrtResult.Write = XLogCtl->xlblocks[curridx];
--- 2032,2041 ----
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
  		if (!XLByteLT(LogwrtResult.Write, XLogCtl->xlblocks[curridx]))
! 			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X (slot %d)",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  				 XLogCtl->xlblocks[curridx].xlogid,
! 				 XLogCtl->xlblocks[curridx].xrecoff, curridx);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
  		LogwrtResult.Write = XLogCtl->xlblocks[curridx];
***************
*** 2097,2129 **** XLogFlush(XLogRecPtr record)
  	/* done already? */
  	if (!XLByteLE(record, LogwrtResult.Flush))
  	{
  		/* now wait for the write lock */
  		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  		LogwrtResult = XLogCtl->Write.LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			/* try to write/flush later additions to XLOG as well */
! 			if (LWLockConditionalAcquire(WALInsertLock, LW_EXCLUSIVE))
! 			{
! 				XLogCtlInsert *Insert = &XLogCtl->Insert;
! 				uint32		freespace = INSERT_FREESPACE(Insert);
  
- 				if (freespace < SizeOfXLogRecord)		/* buffer is full */
- 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
- 				else
- 				{
- 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
- 					WriteRqstPtr.xrecoff -= freespace;
- 				}
- 				LWLockRelease(WALInsertLock);
- 				WriteRqst.Write = WriteRqstPtr;
- 				WriteRqst.Flush = WriteRqstPtr;
- 			}
- 			else
- 			{
- 				WriteRqst.Write = WriteRqstPtr;
- 				WriteRqst.Flush = record;
- 			}
  			XLogWrite(WriteRqst, false, false);
  		}
  		LWLockRelease(WALWriteLock);
--- 2407,2454 ----
  	/* done already? */
  	if (!XLByteLE(record, LogwrtResult.Flush))
  	{
+ 		/* try to write/flush later additions to XLOG as well */
+ 		volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 		uint32		freespace;
+ 		XLogRecPtr	insertpos;
+ 
+ 		/*
+ 		 * Get the current insert position.
+ 		 *
+ 		 * XXX: This used to use LWLockConditionalAcquire, and fall back
+ 		 * to writing just up to 'record' if we couldn't get the lock. I
+ 		 * wonder if it would be a good idea to have a
+ 		 * SpinLockConditionalAcquire function and use that? On one hand,
+ 		 * it would be good to not cause more contention on the lock if it's
+ 		 * busy, but on the other hand, this spinlock is much more lightweight
+ 		 * than the WALInsertLock was, so maybe it's better to just grab the
+ 		 * spinlock. Also note that if we stored the XLogRecPtr as one 64-bit
+ 		 * integer, we could just read it with no lock on platforms where
+ 		 * 64-bit integer accesses are atomic, which covers many common
+ 		 * platforms nowadays.
+ 		 */
+ 		SpinLockAcquire(&Insert->insertpos_lck);
+ 		insertpos = Insert->CurrPos;
+ 		SpinLockRelease(&Insert->insertpos_lck);
+ 
+ 		freespace = INSERT_FREESPACE(insertpos);
+ 		if (freespace < SizeOfXLogRecord)		/* buffer is full */
+ 			insertpos.xrecoff += freespace;
+ 
+ 		/*
+ 		 * Before actually performing the write, wait for all in-flight
+ 		 * insertions to the pages we're about to write to finish.
+ 		 */
+ 		insertpos = WaitXLogInsertionsToFinish(WriteRqstPtr, insertpos);
+ 
  		/* now wait for the write lock */
  		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  		LogwrtResult = XLogCtl->Write.LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			WriteRqst.Write = insertpos;
! 			WriteRqst.Flush = insertpos;
  
  			XLogWrite(WriteRqst, false, false);
  		}
  		LWLockRelease(WALWriteLock);
***************
*** 2234,2243 **** XLogBackgroundFlush(void)
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
- 
  	START_CRIT_SECTION();
  
  	/* now wait for the write lock */
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  	LogwrtResult = XLogCtl->Write.LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
--- 2559,2570 ----
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
  	START_CRIT_SECTION();
  
  	/* now wait for the write lock */
+ 
+ 	WaitXLogInsertionsToFinish(WriteRqstPtr, InvalidXLogRecPtr);
+ 
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  	LogwrtResult = XLogCtl->Write.LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
***************
*** 2248,2256 **** XLogBackgroundFlush(void)
  		WriteRqst.Flush = WriteRqstPtr;
  		XLogWrite(WriteRqst, flexible, false);
  	}
! 	LWLockRelease(WALWriteLock);
  
  	END_CRIT_SECTION();
  }
  
  /*
--- 2575,2594 ----
  		WriteRqst.Flush = WriteRqstPtr;
  		XLogWrite(WriteRqst, flexible, false);
  	}
! 	LogwrtResult = XLogCtl->Write.LogwrtResult;
  
  	END_CRIT_SECTION();
+ 
+ 	LWLockRelease(WALWriteLock);
+ 
+ 	/*
+ 	 * Great, done. To take some work off the critical path, try to initialize
+ 	 * as many of the no-longer-needed WAL buffers for future use as we can.
+ 	 *
+ 	 * Before we release the write lock, calculate the location of the last
+ 	 * fully written page.
+ 	 */
+ 	AdvanceXLInsertBuffer(false, InvalidXLogRecPtr, true);
  }
  
  /*
***************
*** 5044,5049 **** XLOGShmemSize(void)
--- 5382,5390 ----
  	/* and the buffers themselves */
  	size = add_size(size, mul_size(XLOG_BLCKSZ, XLOGbuffers));
  
+ 	/* XLog insertion slots */
+ 	size = add_size(size, mul_size(sizeof(BackendXLogInsertSlot), NumXLogInsertSlots));
+ 
  	/*
  	 * Note: we don't count ControlFileData, it comes out of the "slop factor"
  	 * added by CreateSharedMemoryAndSemaphores.  This lets us use this
***************
*** 5059,5064 **** XLOGShmemInit(void)
--- 5400,5406 ----
  	bool		foundCFile,
  				foundXLog;
  	char	   *allocptr;
+ 	int			i;
  
  	ControlFile = (ControlFileData *)
  		ShmemInitStruct("Control File", sizeof(ControlFileData), &foundCFile);
***************
*** 5084,5089 **** XLOGShmemInit(void)
--- 5426,5439 ----
  	memset(XLogCtl->xlblocks, 0, sizeof(XLogRecPtr) * XLOGbuffers);
  	allocptr += sizeof(XLogRecPtr) * XLOGbuffers;
  
+ 	/* Initialize per-backend buffers */
+ 	XLogCtl->BackendXLogInsertSlots = (BackendXLogInsertSlot *) allocptr;
+ 	for (i = 0; i < NumXLogInsertSlots; i++)
+ 	{
+ 		XLogCtl->BackendXLogInsertSlots[i].CurrPos = InvalidXLogRecPtr;
+ 	}
+ 	allocptr += sizeof(BackendXLogInsertSlot) * NumXLogInsertSlots;
+ 
  	/*
  	 * Align the start of the page buffers to an ALIGNOF_XLOG_BUFFER boundary.
  	 */
***************
*** 5098,5108 **** XLOGShmemInit(void)
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
- 	XLogCtl->Insert.currpage = (XLogPageHeader) (XLogCtl->pages);
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
--- 5448,5459 ----
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
+ 	SpinLockInit(&XLogCtl->Insert.insertpos_lck);
+ 
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
***************
*** 5942,5947 **** StartupXLOG(void)
--- 6293,6299 ----
  	uint32		freespace;
  	TransactionId oldestActiveXID;
  	bool		backupEndRequired = false;
+ 	int			firstIdx;
  
  	/*
  	 * Read control file and check XLOG status looks valid.
***************
*** 6697,6704 **** StartupXLOG(void)
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 	XLogCtl->xlblocks[0].xlogid = openLogId;
! 	XLogCtl->xlblocks[0].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
--- 7049,7060 ----
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 
! 	firstIdx = XLogRecPtrToBufIdx(EndOfLog);
! 	XLogCtl->curridx = firstIdx;
! 
! 	XLogCtl->xlblocks[firstIdx].xlogid = openLogId;
! 	XLogCtl->xlblocks[firstIdx].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
***************
*** 6706,6731 **** StartupXLOG(void)
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[0].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) Insert->currpage, readBuf, XLOG_BLCKSZ);
! 	Insert->currpos = (char *) Insert->currpage +
! 		(EndOfLog.xrecoff + XLOG_BLCKSZ - XLogCtl->xlblocks[0].xrecoff);
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
  	XLogCtl->Write.LogwrtResult = LogwrtResult;
- 	Insert->LogwrtResult = LogwrtResult;
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(Insert->currpos, 0, freespace);
! 		XLogCtl->Write.curridx = 0;
  	}
  	else
  	{
--- 7062,7085 ----
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[firstIdx].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) &XLogCtl->pages[firstIdx * XLOG_BLCKSZ], readBuf, XLOG_BLCKSZ);
! 	Insert->CurrPos = EndOfLog;
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
  	XLogCtl->Write.LogwrtResult = LogwrtResult;
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = XLOG_BLCKSZ - EndRecPtr.xrecoff % XLOG_BLCKSZ;
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(&XLogCtl->pages[firstIdx * XLOG_BLCKSZ] + EndRecPtr.xrecoff % XLOG_BLCKSZ, 0, freespace);
! 		XLogCtl->Write.curridx = firstIdx;
  	}
  	else
  	{
***************
*** 6737,6743 **** StartupXLOG(void)
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(0);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
--- 7091,7097 ----
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(firstIdx);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
***************
*** 7231,7239 **** GetRedoRecPtr(void)
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire WALInsertLock which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
  XLogRecPtr
  GetInsertRecPtr(void)
--- 7585,7597 ----
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire insertpos_lck which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
+  *
+  * XXX: now that there can be several insertions "in-flight", what should
+  * this return? The position a new insertion would got to? Or the the oldest
+  * still in-progress insertion, perhaps?
   */
  XLogRecPtr
  GetInsertRecPtr(void)
***************
*** 7507,7512 **** CreateCheckPoint(int flags)
--- 7865,7871 ----
  	uint32		insert_logSeg;
  	TransactionId *inCommitXids;
  	int			nInCommit;
+ 	XLogRecPtr	curInsert;
  
  	/*
  	 * An end-of-recovery checkpoint is really a shutdown checkpoint, just
***************
*** 7574,7584 **** CreateCheckPoint(int flags)
  	else
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * We must hold WALInsertLock while examining insert state to determine
! 	 * the checkpoint REDO pointer.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
--- 7933,7944 ----
  	else
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
+ 
  	/*
! 	 * Determine the checkpoint REDO pointer.
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	curInsert = Insert->CurrPos;
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
***************
*** 7590,7596 **** CreateCheckPoint(int flags)
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding the WALInsertLock we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
--- 7950,7956 ----
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding insertpos_lck we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
***************
*** 7599,7613 **** CreateCheckPoint(int flags)
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
- 		XLogRecPtr	curInsert;
- 
- 		INSERT_RECPTR(curInsert, Insert, Insert->curridx);
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			LWLockRelease(WALInsertLock);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
--- 7959,7970 ----
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
***************
*** 7633,7646 **** CreateCheckPoint(int flags)
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace < SizeOfXLogRecord)
! 	{
! 		(void) AdvanceXLInsertBuffer(false);
! 		/* OK to ignore update return flag, since we will do flush anyway */
! 		freespace = INSERT_FREESPACE(Insert);
! 	}
! 	INSERT_RECPTR(checkPoint.redo, Insert, Insert->curridx);
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
--- 7990,7999 ----
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = XLOG_BLCKSZ - curInsert.xrecoff % XLOG_BLCKSZ;
  	if (freespace < SizeOfXLogRecord)
! 		curInsert = AdvanceXLogRecPtrToNextPage(curInsert);
! 	checkPoint.redo = curInsert;
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
***************
*** 7666,7672 **** CreateCheckPoint(int flags)
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
--- 8019,8025 ----
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
***************
*** 7686,7692 **** CreateCheckPoint(int flags)
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released WALInsertLock, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
--- 8039,8045 ----
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released insertpos_lck, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
***************
*** 7798,7804 **** CreateCheckPoint(int flags)
  	 */
  	if (shutdown && !XLByteEQ(checkPoint.redo, ProcLastRecPtr))
  		ereport(PANIC,
! 				(errmsg("concurrent transaction log activity while database system is shutting down")));
  
  	/*
  	 * Select point at which we can truncate the log, which we base on the
--- 8151,8159 ----
  	 */
  	if (shutdown && !XLByteEQ(checkPoint.redo, ProcLastRecPtr))
  		ereport(PANIC,
! 				(errmsg("concurrent transaction log activity while database system is shutting down (redo %X/%X, ProcLastRecPtr %X/%X",
! 						checkPoint.redo.xlogid, checkPoint.redo.xrecoff,
! 						ProcLastRecPtr.xlogid, ProcLastRecPtr.xrecoff)));
  
  	/*
  	 * Select point at which we can truncate the log, which we base on the
***************
*** 8053,8067 **** CreateRestartPoint(int flags)
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * You need to hold WALInsertLock and info_lck to update it, although
! 	 * during recovery acquiring WALInsertLock is just pro forma, because
! 	 * there is no other processes updating Insert.RedoRecPtr.
  	 */
- 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
- 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * Prepare to accumulate statistics.
--- 8408,8419 ----
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * You need to hold info_lck to update it. There is no other processes
! 	 * updating Insert.RedoRecPtr, so we don't need a lock to protect that.
  	 */
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
  
  	/*
  	 * Prepare to accumulate statistics.
***************
*** 8816,8821 **** issue_xlog_fsync(int fd, uint32 log, uint32 seg)
--- 9168,9174 ----
  XLogRecPtr
  do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	XLogRecPtr	checkpointloc;
  	XLogRecPtr	startpoint;
***************
*** 8865,8890 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  	 * since we expect that any pages not modified during the backup interval
  	 * must have been correctly captured by the backup.)
  	 *
! 	 * We must hold WALInsertLock to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
! 		if (XLogCtl->Insert.exclusiveBackup)
  		{
! 			LWLockRelease(WALInsertLock);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		XLogCtl->Insert.exclusiveBackup = true;
  	}
  	else
! 		XLogCtl->Insert.nonExclusiveBackups++;
! 	XLogCtl->Insert.forcePageWrites = true;
! 	LWLockRelease(WALInsertLock);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
--- 9218,9243 ----
  	 * since we expect that any pages not modified during the backup interval
  	 * must have been correctly captured by the backup.)
  	 *
! 	 * We must hold insertpos_lck to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
! 		if (Insert->exclusiveBackup)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		Insert->exclusiveBackup = true;
  	}
  	else
! 		Insert->nonExclusiveBackups++;
! 	Insert->forcePageWrites = true;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
***************
*** 8946,8958 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			LWLockAcquire(WALInsertLock, LW_SHARED);
! 			if (XLByteLT(XLogCtl->Insert.lastBackupStart, startpoint))
  			{
! 				XLogCtl->Insert.lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			LWLockRelease(WALInsertLock);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
--- 9299,9311 ----
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			SpinLockAcquire(&Insert->insertpos_lck);
! 			if (XLByteLT(Insert->lastBackupStart, startpoint))
  			{
! 				Insert->lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			SpinLockRelease(&Insert->insertpos_lck);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
***************
*** 9034,9043 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
  		Assert(XLogCtl->Insert.exclusiveBackup);
--- 9387,9397 ----
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
  		Assert(XLogCtl->Insert.exclusiveBackup);
***************
*** 9054,9060 **** pg_start_backup_callback(int code, Datum arg)
  	{
  		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 9408,9414 ----
  	{
  		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9067,9072 **** pg_start_backup_callback(int code, Datum arg)
--- 9421,9427 ----
  XLogRecPtr
  do_pg_stop_backup(char *labelfile, bool waitforarchive)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	XLogRecPtr	startpoint;
  	XLogRecPtr	stoppoint;
***************
*** 9108,9116 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
! 		XLogCtl->Insert.exclusiveBackup = false;
  	else
  	{
  		/*
--- 9463,9471 ----
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
! 		Insert->exclusiveBackup = false;
  	else
  	{
  		/*
***************
*** 9119,9134 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 		XLogCtl->Insert.nonExclusiveBackups--;
  	}
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  
  	if (exclusive)
  	{
--- 9474,9489 ----
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(Insert->nonExclusiveBackups > 0);
! 		Insert->nonExclusiveBackups--;
  	}
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	if (exclusive)
  	{
***************
*** 9330,9345 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  void
  do_pg_abort_backup(void)
  {
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 	Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 	XLogCtl->Insert.nonExclusiveBackups--;
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 9685,9702 ----
  void
  do_pg_abort_backup(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	Assert(Insert->nonExclusiveBackups > 0);
! 	Insert->nonExclusiveBackups--;
! 
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9391,9406 **** GetStandbyFlushRecPtr(void)
   * Get latest WAL insert pointer
   */
  XLogRecPtr
! GetXLogInsertRecPtr(bool needlock)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	if (needlock)
! 		LWLockAcquire(WALInsertLock, LW_SHARED);
! 	INSERT_RECPTR(current_recptr, Insert, Insert->curridx);
! 	if (needlock)
! 		LWLockRelease(WALInsertLock);
  
  	return current_recptr;
  }
--- 9748,9761 ----
   * Get latest WAL insert pointer
   */
  XLogRecPtr
! GetXLogInsertRecPtr(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	current_recptr = Insert->CurrPos;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	return current_recptr;
  }
*** a/src/backend/access/transam/xlogfuncs.c
--- b/src/backend/access/transam/xlogfuncs.c
***************
*** 200,206 **** pg_current_xlog_insert_location(PG_FUNCTION_ARGS)
  				 errmsg("recovery is in progress"),
  				 errhint("WAL control functions cannot be executed during recovery.")));
  
! 	current_recptr = GetXLogInsertRecPtr(true);
  
  	snprintf(location, sizeof(location), "%X/%X",
  			 current_recptr.xlogid, current_recptr.xrecoff);
--- 200,206 ----
  				 errmsg("recovery is in progress"),
  				 errhint("WAL control functions cannot be executed during recovery.")));
  
! 	current_recptr = GetXLogInsertRecPtr();
  
  	snprintf(location, sizeof(location), "%X/%X",
  			 current_recptr.xlogid, current_recptr.xrecoff);
*** a/src/include/access/xlog.h
--- b/src/include/access/xlog.h
***************
*** 288,294 **** extern bool XLogInsertAllowed(void);
  extern void GetXLogReceiptTime(TimestampTz *rtime, bool *fromStream);
  extern XLogRecPtr GetXLogReplayRecPtr(XLogRecPtr *restoreLastRecPtr);
  extern XLogRecPtr GetStandbyFlushRecPtr(void);
! extern XLogRecPtr GetXLogInsertRecPtr(bool needlock);
  extern XLogRecPtr GetXLogWriteRecPtr(void);
  extern bool RecoveryIsPaused(void);
  extern void SetRecoveryPause(bool recoveryPause);
--- 288,294 ----
  extern void GetXLogReceiptTime(TimestampTz *rtime, bool *fromStream);
  extern XLogRecPtr GetXLogReplayRecPtr(XLogRecPtr *restoreLastRecPtr);
  extern XLogRecPtr GetStandbyFlushRecPtr(void);
! extern XLogRecPtr GetXLogInsertRecPtr(void);
  extern XLogRecPtr GetXLogWriteRecPtr(void);
  extern bool RecoveryIsPaused(void);
  extern void SetRecoveryPause(bool recoveryPause);
*** a/src/include/storage/lwlock.h
--- b/src/include/storage/lwlock.h
***************
*** 53,59 **** typedef enum LWLockId
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALInsertLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
--- 53,59 ----
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALBufMappingLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
***************
*** 79,84 **** typedef enum LWLockId
--- 79,85 ----
  	SerializablePredicateLockListLock,
  	OldSerXidLock,
  	SyncRepLock,
+ 	WALAuxSlotLock,
  	/* Individual lock IDs end here */
  	FirstBufMappingLock,
  	FirstLockMgrLock = FirstBufMappingLock + NUM_BUFFER_PARTITIONS,

*** a/src/backend/access/transam/xlog.c
--- b/src/backend/access/transam/xlog.c
***************
*** 42,47 ****
--- 42,48 ----
  #include "postmaster/startup.h"
  #include "replication/walreceiver.h"
  #include "replication/walsender.h"
+ #include "storage/barrier.h"
  #include "storage/bufmgr.h"
  #include "storage/fd.h"
  #include "storage/ipc.h"
***************
*** 282,307 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There are actually three shared-memory copies of
!  * LogwrtResult, plus one unshared copy in each backend.  Here's how it works:
!  *		XLogCtl->LogwrtResult is protected by info_lck
!  *		XLogCtl->Write.LogwrtResult is protected by WALWriteLock
!  *		XLogCtl->Insert.LogwrtResult is protected by WALInsertLock
!  * One must hold the associated lock to read or write any of these, but
!  * of course no lock is needed to read/write the unshared LogwrtResult.
!  *
!  * XLogCtl->LogwrtResult and XLogCtl->Write.LogwrtResult are both "always
!  * right", since both are updated by a write or flush operation before
!  * it releases WALWriteLock.  The point of keeping XLogCtl->Write.LogwrtResult
!  * is that it can be examined/modified by code that already holds WALWriteLock
!  * without needing to grab info_lck as well.
!  *
!  * XLogCtl->Insert.LogwrtResult may lag behind the reality of the other two,
!  * but is updated when convenient.	Again, it exists for the convenience of
!  * code that is already holding WALInsertLock but not the other locks.
!  *
!  * The unshared LogwrtResult may lag behind any or all of these, and again
!  * is updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
--- 283,293 ----
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There is one shared-memory copy of LogwrtResult,
!  * plus one unshared copy in each backend. To read the shared copy, you need
!  * to hold info_lck *or* WALWriteLock. To update it, you need to hold both
!  * locks. The unshared LogwrtResult may lag behind the shared copy, and is
!  * updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
***************
*** 311,320 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  The other locks are held longer (potentially
!  * over I/O operations), so we use LWLocks for them.  These locks are:
   *
!  * WALInsertLock: must be held to insert a record into the WAL buffers.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
--- 297,311 ----
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  insertpos_lck protects the current logical
!  * insert location, ie. the head of reserved WAL space.  The other locks are
!  * held longer (potentially over I/O operations), so we use LWLocks for them.
!  * These locks are:
   *
!  * WALBufMappingLock: must be held to replace a page in the WAL buffer cache.
!  * This is only held while initializing and changing the mapping. If the
!  * contents of the buffer being replaced haven't been written yet, the mapping
!  * lock is released while the write is done, and reacquired afterwards.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
***************
*** 326,331 **** static XLogRecPtr RedoStartLSN = {0, 0};
--- 317,393 ----
   * only one checkpointer at a time; currently, with all checkpoints done by
   * the checkpointer, this is just pro forma).
   *
+  *
+  * Inserting a new WAL record is a two-step process:
+  *
+  * 1. Reserve the right amount of space from the WAL, and the next insertion
+  *    slot to advertise that the insertion is in progress. The current head
+  *    of reserved space is kept in Insert->CurrPos, and is protected by
+  *    insertpos_lck. Try to keep this section as short as possible,
+  *    insertpos_lck can be heavily contended on a busy system
+  *
+  * 2. Copy the record to the reserved WAL space. This involves finding the
+  *    correct WAL buffer containing the reserved space, and copying the
+  *    record in place. This can be done concurrently in multiple processes.
+  *
+  * To allow as much parallelism as possible for step 2, we try hard to avoid
+  * lock contention in that code path. Each insertion is asssigned its own
+  * "XLog insertion slot", which is used to advertise the position the backend
+  * is writing to. The slot is marked as in-use in step 1, while holding
+  * insertpos_lck, by setting the position field in the slot. When the backend
+  * is finished with the insertion, it clears its slot. Each slot is protected
+  * by a separate spinlock, to keep contention minimal.
+  *
+  * The insertion slots also provide a mechanism to wait for an insertion to
+  * finish. This is important when an XLOG page is written out - any
+  * in-progress insertions must finish copying data to the page first, or the
+  * on-disk copy will be incomplete. Waiting is done by the
+  * WaitXLogInsertionsToFinish() function. It sets the 'waiter' field in the
+  * slot it needs to wait for, and when that insertion finishes (or proceeds
+  * to the next page, at least), the inserter wakes up the process waiting for
+  * it. There is only one waiter field in each slot, so
+  * WaitXLogInsertionsToFinish() uses a lwlock, WALInsertWaitLock, to ensure
+  * that only one process attempts to wait on any slot at a time.
+  *
+  * The insertion slots form a ring. Insert->nextslot points to the next free
+  * slot, and Insert->lastslot points to the last slot that's still in use.
+  * lastslot can lag behind reality by any number of slots, as long as nextslot
+  * doesn't catch up with it. lastslot is advanced by
+  * WaitXLogInsertionsToFinish(), and is protected by WALInsertWaitLock.
+  * nextslot is advanced in ReserveXLogInsertLocation() and is protected by
+  * insertpos_lck. Both slot variables are 32-bit integers, so that they can
+  * be read atomically without holding a lock.
+  *
+  * Whenever the ring fills up, ie. when nextslot wraps around and catches up
+  * with lastslot, ReserveXLogInsertLocation() has to wait for the oldest
+  * insertion to finish and advance lastslot, to make room for the new
+  * insertion. This is done by WaitForXLogInsertionSlotToBecomeFree() function,
+  * which is similar to WaitXLogInsertionsToFinish(), but instead of waiting
+  * for all insertions up to a given point to finish, it just waits for the
+  * inserter in the oldest slot to finish.
+  *
+  *
+  * Deadlock analysis
+  * -----------------
+  *
+  * It's important to call WaitXLogInsertionsToFinish() *before* acquiring
+  * WALWriteLock. Otherwise you might get stuck waiting for an insertion to
+  * finish (or at least advance to next uninitialized page), while you're
+  * holding WALWriteLock. That would be bad, because the backend you're waiting
+  * for might need to acquire WALWriteLock, too, to evict an old buffer, so
+  * you'd get deadlock.
+  *
+  * WaitXLogInsertionsToFinish() will not get stuck indefinitely, as long as
+  * it's called with a location that's known to be already allocated in the WAL
+  * buffers. Calling it with the position of a record you've already inserted
+  * satisfies that condition, so the common pattern:
+  *
+  *   recptr = XLogInsert(...)
+  *   XLogFlush(recptr)
+  *
+  * is safe. It can't get stuck, because an insertion to a WAL page that's
+  * already initialized in cache can always proceed without waiting on a lock.
+  *
   *----------
   */
  
***************
*** 346,356 **** typedef struct XLogwrtResult
   */
  typedef struct XLogCtlInsert
  {
! 	XLogwrtResult LogwrtResult; /* a recent value of LogwrtResult */
! 	XLogRecPtr	PrevRecord;		/* start of previously-inserted record */
! 	int			curridx;		/* current block index in cache */
! 	XLogPageHeader currpage;	/* points to header of block in cache */
! 	char	   *currpos;		/* current insertion point in cache */
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
--- 408,437 ----
   */
  typedef struct XLogCtlInsert
  {
! 	slock_t		insertpos_lck;	/* protects all the fields in this struct
! 								 * (except lastslot). */
! 
! 	int32		nextslot;		/* next insertion slot to use */
! 	int32		lastslot;		/* last in-use insertion slot (protected by
! 								 * WALInsertWaitLock) */
! 
! 	/*
! 	 * CurrPos is the very tip of the reserved WAL space at the moment. The
! 	 * next record will be inserted there (or somewhere after it if there's
! 	 * not enough space on the current page). PrevRecord points to the
! 	 * beginning of the last record already reserved. It might not be fully
! 	 * copied into place yet, but we know its exact location already.
! 	 */
! 	XLogRecPtr	CurrPos;
! 	XLogRecPtr	PrevRecord;
! 
! 	/*
! 	 * padding to push RedoRecPtr and forcePageWrites, which rarely change,
! 	 * to a different cache line than the rapidly-changing CurrPos and
! 	 * PrevRecord values. XXX: verify if this makes any difference
! 	 */
! 	char		padding[128];
! 
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
***************
*** 371,389 **** typedef struct XLogCtlInsert
   */
  typedef struct XLogCtlWrite
  {
- 	XLogwrtResult LogwrtResult; /* current value of LogwrtResult */
  	int			curridx;		/* cache index of next block to write */
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by WALInsertLock: */
  	XLogCtlInsert Insert;
  
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
--- 452,484 ----
   */
  typedef struct XLogCtlWrite
  {
  	int			curridx;		/* cache index of next block to write */
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
+ 
+ /*
+  * Slots for in-progress WAL insertions.
+  */
+ typedef struct
+ {
+ 	XLogRecPtr	CurrPos;	/* current position this process is inserting to */
+ 	PGPROC	   *waiter;
+ 	slock_t		lck;
+ } XLogInsertSlot;
+ 
+ #define NumXLogInsertSlots	1000
+ 
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by insertpos_lck: */
  	XLogCtlInsert Insert;
  
+ 	XLogInsertSlot *XLogInsertSlots;
+ 
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
***************
*** 397,405 **** typedef struct XLogCtlData
  	XLogCtlWrite Write;
  
  	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALInsertLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
--- 492,510 ----
  	XLogCtlWrite Write;
  
  	/*
+ 	 * To change curridx and the identity of a buffer, you need to hold
+ 	 * WALBufMappingLock. To change the identity of a buffer that's
+ 	 * still dirty, the old page needs to be written out first, and for that
+ 	 * you need WALWriteLock, and you need to ensure that there's no
+ 	 * in-progress insertions to the page by calling
+ 	 * WaitXLogInsertionsToFinish().
+ 	 */
+ 	int			curridx;		/* current (latest) block index in cache */
+ 
+ 	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALBufMappingLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
***************
*** 471,498 **** static XLogCtlData *XLogCtl = NULL;
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Macros for managing XLogInsert state.  In most cases, the calling routine
!  * has local copies of XLogCtl->Insert and/or XLogCtl->Insert->curridx,
!  * so these are passed as parameters instead of being fetched via XLogCtl.
   */
  
- /* Free space remaining in the current xlog page buffer */
- #define INSERT_FREESPACE(Insert)  \
- 	(XLOG_BLCKSZ - ((Insert)->currpos - (char *) (Insert)->currpage))
  
! /* Construct XLogRecPtr value for current insertion point */
! #define INSERT_RECPTR(recptr,Insert,curridx)  \
! 	( \
! 	  (recptr).xlogid = XLogCtl->xlblocks[curridx].xlogid, \
! 	  (recptr).xrecoff = \
! 		XLogCtl->xlblocks[curridx].xrecoff - INSERT_FREESPACE(Insert) \
! 	)
  
! #define PrevBufIdx(idx)		\
! 		(((idx) == 0) ? XLogCtl->XLogCacheBlck : ((idx) - 1))
  
! #define NextBufIdx(idx)		\
! 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
--- 576,606 ----
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Calculate the amount of space left on the page after 'endptr'.
!  * Beware multiple evaluation!
   */
+ #define INSERT_FREESPACE(endptr)	\
+ 	(((endptr).xrecoff % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr).xrecoff % XLOG_BLCKSZ))
+ 
+ #define NextBufIdx(idx)		\
+ 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  
! #define NextSlotNo(idx)		\
! 		(((idx) == NumXLogInsertSlots) ? 0 : ((idx) + 1))
  
! /*
!  * XLogRecPtrToBufIdx returns the index of the WAL buffer that holds, or
!  * would hold if it was in cache, the page containing 'recptr'.
!  *
!  * XLogRecEndPtrToBufIdx is the same, but a pointer to the first byte of a
!  * page is taken to mean the previous page.
!  */
! #define XLogRecPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogSegsPerFile * XLogSegSize) + (recptr).xrecoff)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
  
! #define XLogRecEndPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogSegsPerFile * XLogSegSize) + (recptr).xrecoff - 1)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
***************
*** 618,626 **** static void KeepLogSeg(XLogRecPtr recptr, uint32 *logId, uint32 *logSeg);
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static bool AdvanceXLInsertBuffer(bool new_segment);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
--- 726,734 ----
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static void AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
***************
*** 667,672 **** static bool read_backup_label(XLogRecPtr *checkPointLoc,
--- 775,798 ----
  static void rm_redo_error_callback(void *arg);
  static int	get_sync_bit(int method);
  
+ static XLogRecPtr PerformXLogInsert(int write_len,
+ 				  bool isLogSwitch,
+ 				  XLogRecord *rechdr,
+ 				  XLogRecData *rdata, pg_crc32 rdata_crc,
+ 				  bool forcePageWrites);
+ static bool ReserveXLogInsertLocation(int size, bool forcePageWrites,
+ 						  bool isLogSwitch,
+ 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
+ 						  XLogRecPtr *EndPos_p,
+ 						  XLogInsertSlot **myslot_p, bool *updrqst_p);
+ static void UpdateSlotCurrPos(volatile XLogInsertSlot *myslot,
+ 				  XLogRecPtr CurrPos);
+ static XLogRecPtr WaitXLogInsertionsToFinish(XLogRecPtr upto,
+ 						   XLogRecPtr CurrPos);
+ static void WaitForXLogInsertionSlotToBecomeFree(void);
+ static char *GetXLogBuffer(XLogRecPtr ptr);
+ static XLogRecPtr AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr);
+ 
  
  /*
   * Insert an XLOG record having the specified RMID and info bytes,
***************
*** 687,699 **** XLogRecPtr
  XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
- 	XLogRecord *record;
- 	XLogContRecord *contrecord;
  	XLogRecPtr	RecPtr;
- 	XLogRecPtr	WriteRqst;
- 	uint32		freespace;
- 	int			curridx;
  	XLogRecData *rdt;
  	Buffer		dtbuf[XLR_MAX_BKP_BLOCKS];
  	bool		dtbuf_bkp[XLR_MAX_BKP_BLOCKS];
  	BkpBlock	dtbuf_xlg[XLR_MAX_BKP_BLOCKS];
--- 813,821 ----
  XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	RecPtr;
  	XLogRecData *rdt;
+ 	XLogRecData *rdt_lastnormal;
  	Buffer		dtbuf[XLR_MAX_BKP_BLOCKS];
  	bool		dtbuf_bkp[XLR_MAX_BKP_BLOCKS];
  	BkpBlock	dtbuf_xlg[XLR_MAX_BKP_BLOCKS];
***************
*** 705,713 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  	uint32		len,
  				write_len;
  	unsigned	i;
- 	bool		updrqst;
  	bool		doPageWrites;
  	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
--- 827,837 ----
  	uint32		len,
  				write_len;
  	unsigned	i;
  	bool		doPageWrites;
+ 	bool		forcePageWrites;
  	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
+ 	uint8		info_orig = info;
+ 	XLogRecord	rechdr;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
***************
*** 731,753 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  	}
  
  	/*
! 	 * Here we scan the rdata chain, determine which buffers must be backed
! 	 * up, and compute the CRC values for the data.  Note that the record
! 	 * header isn't added into the CRC initially since we don't know the final
! 	 * length or info bits quite yet.  Thus, the CRC will represent the CRC of
! 	 * the whole record in the order "rdata, then backup blocks, then record
! 	 * header".
  	 *
  	 * We may have to loop back to here if a race condition is detected below.
! 	 * We could prevent the race by doing all this work while holding the
! 	 * insert lock, but it seems better to avoid doing CRC calculations while
! 	 * holding the lock.  This means we have to be careful about modifying the
! 	 * rdata chain until we know we aren't going to loop back again.  The only
! 	 * change we allow ourselves to make earlier is to set rdt->data = NULL in
! 	 * chain items we have decided we will have to back up the whole buffer
! 	 * for.  This is OK because we will certainly decide the same thing again
! 	 * for those items if we do it over; doing it here saves an extra pass
! 	 * over the chain later.
  	 */
  begin:;
  	for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
--- 855,872 ----
  	}
  
  	/*
! 	 * Here we scan the rdata chain, to determine which buffers must be backed
! 	 * up.
  	 *
  	 * We may have to loop back to here if a race condition is detected below.
! 	 * We could prevent the race by doing all this work while holding a lock
! 	 * while doing the CRC calculation, but the race condition is so rare that
! 	 * it's better to take an optimistic approach.
! 	 *
! 	 * We add entries for backup blocks to the chain, so that they don't
! 	 * need any special treatment in the critical section where the chunks
! 	 * are copied into the WAL buffers. But we are also prepared to undo those
! 	 * changes if we have to loop back here.
  	 */
  begin:;
  	for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
***************
*** 762,770 **** begin:;
  	 * don't yet have the insert lock, forcePageWrites could change under us,
  	 * but we'll recheck it once we have the lock.
  	 */
! 	doPageWrites = fullPageWrites || Insert->forcePageWrites;
  
- 	INIT_CRC32(rdata_crc);
  	len = 0;
  	for (rdt = rdata;;)
  	{
--- 881,889 ----
  	 * don't yet have the insert lock, forcePageWrites could change under us,
  	 * but we'll recheck it once we have the lock.
  	 */
! 	forcePageWrites = Insert->forcePageWrites;
! 	doPageWrites = fullPageWrites || forcePageWrites;
  
  	len = 0;
  	for (rdt = rdata;;)
  	{
***************
*** 772,778 **** begin:;
  		{
  			/* Simple data, just include it */
  			len += rdt->len;
- 			COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  		}
  		else
  		{
--- 891,896 ----
***************
*** 783,794 **** begin:;
  				{
  					/* Buffer already referenced by earlier chain item */
  					if (dtbuf_bkp[i])
  						rdt->data = NULL;
  					else if (rdt->data)
- 					{
  						len += rdt->len;
- 						COMP_CRC32(rdata_crc, rdt->data, rdt->len);
- 					}
  					break;
  				}
  				if (dtbuf[i] == InvalidBuffer)
--- 901,912 ----
  				{
  					/* Buffer already referenced by earlier chain item */
  					if (dtbuf_bkp[i])
+ 					{
  						rdt->data = NULL;
+ 						rdt->len = 0;
+ 					}
  					else if (rdt->data)
  						len += rdt->len;
  					break;
  				}
  				if (dtbuf[i] == InvalidBuffer)
***************
*** 800,811 **** begin:;
  					{
  						dtbuf_bkp[i] = true;
  						rdt->data = NULL;
  					}
  					else if (rdt->data)
- 					{
  						len += rdt->len;
- 						COMP_CRC32(rdata_crc, rdt->data, rdt->len);
- 					}
  					break;
  				}
  			}
--- 918,927 ----
  					{
  						dtbuf_bkp[i] = true;
  						rdt->data = NULL;
+ 						rdt->len = 0;
  					}
  					else if (rdt->data)
  						len += rdt->len;
  					break;
  				}
  			}
***************
*** 820,858 **** begin:;
  	}
  
  	/*
- 	 * Now add the backup block headers and data into the CRC
- 	 */
- 	for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
- 	{
- 		if (dtbuf_bkp[i])
- 		{
- 			BkpBlock   *bkpb = &(dtbuf_xlg[i]);
- 			char	   *page;
- 
- 			COMP_CRC32(rdata_crc,
- 					   (char *) bkpb,
- 					   sizeof(BkpBlock));
- 			page = (char *) BufferGetBlock(dtbuf[i]);
- 			if (bkpb->hole_length == 0)
- 			{
- 				COMP_CRC32(rdata_crc,
- 						   page,
- 						   BLCKSZ);
- 			}
- 			else
- 			{
- 				/* must skip the hole */
- 				COMP_CRC32(rdata_crc,
- 						   page,
- 						   bkpb->hole_offset);
- 				COMP_CRC32(rdata_crc,
- 						   page + (bkpb->hole_offset + bkpb->hole_length),
- 						   BLCKSZ - (bkpb->hole_offset + bkpb->hole_length));
- 			}
- 		}
- 	}
- 
- 	/*
  	 * NOTE: We disallow len == 0 because it provides a useful bit of extra
  	 * error checking in ReadRecord.  This means that all callers of
  	 * XLogInsert must supply at least some not-in-a-buffer data.  However, we
--- 936,941 ----
***************
*** 862,931 **** begin:;
  	if (len == 0 && !isLogSwitch)
  		elog(PANIC, "invalid xlog record length %u", len);
  
- 	START_CRIT_SECTION();
- 
- 	/* Now wait to get insert lock */
- 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
- 
- 	/*
- 	 * Check to see if my RedoRecPtr is out of date.  If so, may have to go
- 	 * back and recompute everything.  This can only happen just after a
- 	 * checkpoint, so it's better to be slow in this case and fast otherwise.
- 	 *
- 	 * If we aren't doing full-page writes then RedoRecPtr doesn't actually
- 	 * affect the contents of the XLOG record, so we'll update our local copy
- 	 * but not force a recomputation.
- 	 */
- 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr))
- 	{
- 		Assert(XLByteLT(RedoRecPtr, Insert->RedoRecPtr));
- 		RedoRecPtr = Insert->RedoRecPtr;
- 
- 		if (doPageWrites)
- 		{
- 			for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
- 			{
- 				if (dtbuf[i] == InvalidBuffer)
- 					continue;
- 				if (dtbuf_bkp[i] == false &&
- 					XLByteLE(dtbuf_lsn[i], RedoRecPtr))
- 				{
- 					/*
- 					 * Oops, this buffer now needs to be backed up, but we
- 					 * didn't think so above.  Start over.
- 					 */
- 					LWLockRelease(WALInsertLock);
- 					END_CRIT_SECTION();
- 					goto begin;
- 				}
- 			}
- 		}
- 	}
- 
- 	/*
- 	 * Also check to see if forcePageWrites was just turned on; if we weren't
- 	 * already doing full-page writes then go back and recompute. (If it was
- 	 * just turned off, we could recompute the record without full pages, but
- 	 * we choose not to bother.)
- 	 */
- 	if (Insert->forcePageWrites && !doPageWrites)
- 	{
- 		/* Oops, must redo it with full-page data */
- 		LWLockRelease(WALInsertLock);
- 		END_CRIT_SECTION();
- 		goto begin;
- 	}
- 
  	/*
  	 * Make additional rdata chain entries for the backup blocks, so that we
! 	 * don't need to special-case them in the write loop.  Note that we have
! 	 * now irrevocably changed the input rdata chain.  At the exit of this
! 	 * loop, write_len includes the backup block data.
  	 *
  	 * Also set the appropriate info bits to show which buffers were backed
  	 * up. The i'th XLR_SET_BKP_BLOCK bit corresponds to the i'th distinct
  	 * buffer value (ignoring InvalidBuffer) appearing in the rdata chain.
  	 */
  	write_len = len;
  	for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
  	{
--- 945,964 ----
  	if (len == 0 && !isLogSwitch)
  		elog(PANIC, "invalid xlog record length %u", len);
  
  	/*
  	 * Make additional rdata chain entries for the backup blocks, so that we
! 	 * don't need to special-case them in the write loop.  We have now
! 	 * modified the original rdata chain, but we remember the last regular
! 	 * entry in rdt_lastnormal, so we can undo this if we have to loop back
! 	 * to the beginning.
! 	 *
! 	 * At the exit of this loop, write_len includes the backup block data.
  	 *
  	 * Also set the appropriate info bits to show which buffers were backed
  	 * up. The i'th XLR_SET_BKP_BLOCK bit corresponds to the i'th distinct
  	 * buffer value (ignoring InvalidBuffer) appearing in the rdata chain.
  	 */
+ 	rdt_lastnormal = rdt;
  	write_len = len;
  	for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
  	{
***************
*** 941,947 **** begin:;
  		page = (char *) BufferGetBlock(dtbuf[i]);
  
  		rdt->next = &(dtbuf_rdt1[i]);
! 		rdt = rdt->next;
  
  		rdt->data = (char *) bkpb;
  		rdt->len = sizeof(BkpBlock);
--- 974,980 ----
  		page = (char *) BufferGetBlock(dtbuf[i]);
  
  		rdt->next = &(dtbuf_rdt1[i]);
! 		rdt = &(dtbuf_rdt1[i]);
  
  		rdt->data = (char *) bkpb;
  		rdt->len = sizeof(BkpBlock);
***************
*** 975,1048 **** begin:;
  	}
  
  	/*
! 	 * If there isn't enough space on the current XLOG page for a record
! 	 * header, advance to the next page (leaving the unused space as zeroes).
  	 */
! 	updrqst = false;
! 	freespace = INSERT_FREESPACE(Insert);
! 	if (freespace < SizeOfXLogRecord)
! 	{
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		freespace = INSERT_FREESPACE(Insert);
! 	}
! 
! 	/* Compute record's XLOG location */
! 	curridx = Insert->curridx;
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
! 	 * segment, we need not insert it (and don't want to because we'd like
! 	 * consecutive switch requests to be no-ops).  Instead, make sure
! 	 * everything is written and flushed through the end of the prior segment,
! 	 * and return the prior segment's end address.
  	 */
! 	if (isLogSwitch &&
! 		(RecPtr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
! 	{
! 		/* We can release insert lock immediately */
! 		LWLockRelease(WALInsertLock);
! 
! 		RecPtr.xrecoff -= SizeOfXLogLongPHD;
! 		if (RecPtr.xrecoff == 0)
! 		{
! 			/* crossing a logid boundary */
! 			RecPtr.xlogid -= 1;
! 			RecPtr.xrecoff = XLogFileSize;
! 		}
! 
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 		LogwrtResult = XLogCtl->Write.LogwrtResult;
! 		if (!XLByteLE(RecPtr, LogwrtResult.Flush))
! 		{
! 			XLogwrtRqst FlushRqst;
! 
! 			FlushRqst.Write = RecPtr;
! 			FlushRqst.Flush = RecPtr;
! 			XLogWrite(FlushRqst, false, false);
! 		}
! 		LWLockRelease(WALWriteLock);
! 
! 		END_CRIT_SECTION();
! 
! 		return RecPtr;
! 	}
! 
! 	/* Insert record header */
! 
! 	record = (XLogRecord *) Insert->currpos;
! 	record->xl_prev = Insert->PrevRecord;
! 	record->xl_xid = GetCurrentTransactionIdIfAny();
! 	record->xl_tot_len = SizeOfXLogRecord + write_len;
! 	record->xl_len = len;		/* doesn't include backup blocks */
! 	record->xl_info = info;
! 	record->xl_rmid = rmid;
! 
! 	/* Now we can finish computing the record's CRC */
! 	COMP_CRC32(rdata_crc, (char *) record + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	record->xl_crc = rdata_crc;
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
--- 1008,1036 ----
  	}
  
  	/*
! 	 * Calculate CRC of the data, including all the backup blocks
! 	 *
! 	 * Note that the record header isn't added into the CRC initially since
! 	 * we don't know the prev-link yet.  Thus, the CRC will represent the CRC
! 	 * of the whole record in the order: rdata, then backup blocks, then
! 	 * record header.
  	 */
! 	INIT_CRC32(rdata_crc);
! 	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
! 		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
  	/*
! 	 * Construct record header. We can't CRC it yet, because the prev-link
! 	 * needs to be covered by the CRC and we don't know that yet. We will
! 	 * finish computing the CRC when we do.
  	 */
! 	MemSet(&rechdr, 0, sizeof(rechdr));
! 	rechdr.xl_prev = InvalidXLogRecPtr; /* TO BE DETERMINED */
! 	rechdr.xl_xid = GetCurrentTransactionIdIfAny();
! 	rechdr.xl_tot_len = SizeOfXLogRecord + write_len;
! 	rechdr.xl_len = len;		/* doesn't include backup blocks */
! 	rechdr.xl_info = info;
! 	rechdr.xl_rmid = rmid;
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
***************
*** 1063,1235 **** begin:;
  	}
  #endif
  
! 	/* Record begin of record in appropriate places */
! 	ProcLastRecPtr = RecPtr;
! 	Insert->PrevRecord = RecPtr;
  
! 	Insert->currpos += SizeOfXLogRecord;
! 	freespace -= SizeOfXLogRecord;
  
  	/*
! 	 * Append the data, including backup blocks if any
  	 */
! 	while (write_len)
  	{
! 		while (rdata->data == NULL)
! 			rdata = rdata->next;
  
! 		if (freespace > 0)
  		{
! 			if (rdata->len > freespace)
  			{
! 				memcpy(Insert->currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				write_len -= freespace;
! 			}
! 			else
! 			{
! 				memcpy(Insert->currpos, rdata->data, rdata->len);
! 				freespace -= rdata->len;
! 				write_len -= rdata->len;
! 				Insert->currpos += rdata->len;
! 				rdata = rdata->next;
! 				continue;
  			}
  		}
  
! 		/* Use next buffer */
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		curridx = Insert->curridx;
! 		/* Insert cont-record header */
! 		Insert->currpage->xlp_info |= XLP_FIRST_IS_CONTRECORD;
! 		contrecord = (XLogContRecord *) Insert->currpos;
! 		contrecord->xl_rem_len = write_len;
! 		Insert->currpos += SizeOfXLogContRecord;
! 		freespace = INSERT_FREESPACE(Insert);
  	}
  
! 	/* Ensure next record will be properly aligned */
! 	Insert->currpos = (char *) Insert->currpage +
! 		MAXALIGN(Insert->currpos - (char *) Insert->currpage);
! 	freespace = INSERT_FREESPACE(Insert);
  
  	/*
! 	 * The recptr I return is the beginning of the *next* record. This will be
! 	 * stored as LSN for changed data pages...
  	 */
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, we must now write and flush all the
! 	 * existing data, and then forcibly advance to the start of the next
! 	 * segment.  It's not good to do this I/O while holding the insert lock,
! 	 * but there seems too much risk of confusion if we try to release the
! 	 * lock sooner.  Fortunately xlog switch needn't be a high-performance
! 	 * operation anyway...
  	 */
! 	if (isLogSwitch)
  	{
! 		XLogCtlWrite *Write = &XLogCtl->Write;
! 		XLogwrtRqst FlushRqst;
! 		XLogRecPtr	OldSegEnd;
  
! 		TRACE_POSTGRESQL_XLOG_SWITCH();
  
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  
  		/*
! 		 * Flush through the end of the page containing XLOG_SWITCH, and
! 		 * perform end-of-segment actions (eg, notifying archiver).
  		 */
! 		WriteRqst = XLogCtl->xlblocks[curridx];
! 		FlushRqst.Write = WriteRqst;
! 		FlushRqst.Flush = WriteRqst;
! 		XLogWrite(FlushRqst, false, true);
! 
! 		/* Set up the next buffer as first page of next segment */
! 		/* Note: AdvanceXLInsertBuffer cannot need to do I/O here */
! 		(void) AdvanceXLInsertBuffer(true);
! 
! 		/* There should be no unwritten data */
! 		curridx = Insert->curridx;
! 		Assert(curridx == Write->curridx);
! 
! 		/* Compute end address of old segment */
! 		OldSegEnd = XLogCtl->xlblocks[curridx];
! 		OldSegEnd.xrecoff -= XLOG_BLCKSZ;
! 		if (OldSegEnd.xrecoff == 0)
  		{
! 			/* crossing a logid boundary */
! 			OldSegEnd.xlogid -= 1;
! 			OldSegEnd.xrecoff = XLogFileSize;
! 		}
  
! 		/* Make it look like we've written and synced all of old segment */
! 		LogwrtResult.Write = OldSegEnd;
! 		LogwrtResult.Flush = OldSegEnd;
  
! 		/*
! 		 * Update shared-memory status --- this code should match XLogWrite
! 		 */
  		{
! 			/* use volatile pointer to prevent code rearrangement */
! 			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			SpinLockAcquire(&xlogctl->info_lck);
! 			xlogctl->LogwrtResult = LogwrtResult;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, LogwrtResult.Write))
! 				xlogctl->LogwrtRqst.Write = LogwrtResult.Write;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Flush, LogwrtResult.Flush))
! 				xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
! 			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		Write->LogwrtResult = LogwrtResult;
  
! 		LWLockRelease(WALWriteLock);
  
! 		updrqst = false;		/* done already */
  	}
  	else
  	{
! 		/* normal case, ie not xlog switch */
  
! 		/* Need to update shared LogwrtRqst if some block was filled up */
! 		if (freespace < SizeOfXLogRecord)
  		{
! 			/* curridx is filled and available for writing out */
! 			updrqst = true;
  		}
  		else
  		{
! 			/* if updrqst already set, write through end of previous buf */
! 			curridx = PrevBufIdx(curridx);
  		}
- 		WriteRqst = XLogCtl->xlblocks[curridx];
  	}
  
! 	LWLockRelease(WALInsertLock);
  
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
  
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, WriteRqst))
! 			xlogctl->LogwrtRqst.Write = WriteRqst;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
  	}
  
! 	XactLastRecEnd = RecPtr;
! 
! 	END_CRIT_SECTION();
  
! 	return RecPtr;
  }
  
  /*
--- 1051,1694 ----
  	}
  #endif
  
! 	START_CRIT_SECTION();
  
! 	/*
! 	 * Try to do the insertion.
! 	 */
! 	RecPtr = PerformXLogInsert(write_len, isLogSwitch, &rechdr,
! 							   rdata, rdata_crc, forcePageWrites);
! 	END_CRIT_SECTION();
! 
! 	if (XLogRecPtrIsInvalid(RecPtr))
! 	{
! 		/*
! 		 * Oops, have to retry. Unlink the backup blocks from the chain and
! 		 * reset info bitmask to undo the changes we've done.
! 		 */
! 		rdt_lastnormal->next = NULL;
! 		info = info_orig;
! 		goto begin;
! 	}
  
  	/*
! 	 * The recptr I return is the beginning of the *next* record. This will be
! 	 * stored as LSN for changed data pages...
  	 */
! 	return RecPtr;
! }
! 
! /*
!  * Subroutine of XLogInsert. All the changes to shared state are done here,
!  * XLogInsert only prepares the record for insertion.
!  *
!  * On success, returns pointer to end of inserted record like XLogInsert().
!  * If RedoRecPtr or forcePageWrites had changed, returns InvalidRecPtr, and
!  * the caller must recalculate full-page-images and retry.
!  */
! static XLogRecPtr
! PerformXLogInsert(int write_len, bool isLogSwitch, XLogRecord *rechdr,
! 				  XLogRecData *rdata, pg_crc32 rdata_crc,
! 				  bool forcePageWrites)
! {
! 	volatile XLogInsertSlot *myslot = NULL;
! 	char	   *currpos;
! 	XLogRecord *record;
! 	int			tot_len;
! 	int			freespace;
! 	int			written;
! 	XLogRecPtr	PrevRecord;
! 	XLogRecPtr	StartPos;
! 	XLogRecPtr	EndPos;
! 	XLogRecPtr	CurrPos;
! 	bool		updrqst;
! 
! 	/* Get an insert location  */
! 	tot_len = SizeOfXLogRecord + write_len;
! 	if (!ReserveXLogInsertLocation(tot_len, forcePageWrites, isLogSwitch,
! 								   &PrevRecord, &StartPos, &EndPos,
! 								   (XLogInsertSlot **) &myslot, &updrqst))
  	{
! 		return EndPos;
! 	}
! 
! 	/*
! 	 * Got it! Now that we know the prev-link, we can finish computing the
! 	 * record's CRC.
! 	 */
! 	rechdr->xl_prev = PrevRecord;
! 
! 	/* Get the right WAL page to start inserting to */
! 	CurrPos = StartPos;
! 	currpos = GetXLogBuffer(CurrPos);
! 
! 	/* Copy the record header in place */
! 	record = (XLogRecord *) currpos;
! 	memcpy(record, rechdr, sizeof(XLogRecord));
! 	COMP_CRC32(rdata_crc, currpos + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	record->xl_crc = rdata_crc;
  
! 	currpos += SizeOfXLogRecord;
! 	CurrPos.xrecoff += SizeOfXLogRecord;
! 
! 	if (!isLogSwitch)
! 	{
! 		/* Copy record data */
! 		written = 0;
! 		freespace = INSERT_FREESPACE(CurrPos);
! 		while (rdata != NULL)
  		{
! 			while (rdata->len > freespace)
  			{
! 				/*
! 				 * Write what fits on this page, then write the continuation
! 				 * record, and continue.
! 				 */
! 				XLogContRecord *contrecord;
! 
! 				memcpy(currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				written += freespace;
! 
! 				CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
! 
! 				/*
! 				 * Get the next page. It's important to update CurrPos before
! 				 * calling GetXLogBuffer(), because GetXLogBuffer() might need
! 				 * to wait for some insertions to finish so that it can write
! 				 * out a buffer to make room for the new page. Updating CurrPos
! 				 * before waiting for a new buffer ensures that we don't
! 				 * deadlock with ourselves if we run out of clean buffers.
! 				 */
! 				UpdateSlotCurrPos(myslot, CurrPos);
! 
! 				currpos = GetXLogBuffer(CurrPos);
! 
! 				contrecord = (XLogContRecord *) currpos;
! 				contrecord->xl_rem_len = write_len - written;
! 
! 				currpos += SizeOfXLogContRecord;
! 				CurrPos.xrecoff += SizeOfXLogContRecord;
! 
! 				freespace = INSERT_FREESPACE(CurrPos);
  			}
+ 
+ 			memcpy(currpos, rdata->data, rdata->len);
+ 			currpos += rdata->len;
+ 			CurrPos.xrecoff += rdata->len;
+ 			freespace -= rdata->len;
+ 			written += rdata->len;
+ 
+ 			rdata = rdata->next;
  		}
+ 		Assert(written == write_len);
+ 
+ 		CurrPos.xrecoff = MAXALIGN(CurrPos.xrecoff);
+ 		Assert(XLByteEQ(CurrPos, EndPos));
  
! 		/*
! 		 * Done! Clear CurrPos in our slot to let others know that we're
! 		 * finished.
! 		 */
! 		UpdateSlotCurrPos(myslot, InvalidXLogRecPtr);
  	}
+ 	else
+ 	{
+ 		/* An xlog-switch record doesn't contain any data besides the header */
+ 		Assert(write_len == 0);
  
! 		/*
! 		 * An xlog-switch record consumes all the remaining space on the
! 		 * WAL segment. We have already reserved it for us, but we still need
! 		 * to make sure it's been allocated and zeroed in the WAL buffers so
! 		 * that when the caller does XLogWrite(), it can really write out all
! 		 * the zeros.
! 		 *
! 		 * Before we do that, update our CurrPos to the end of segment. We
! 		 * don't write anything to the remaining wasted space here, the
! 		 * zeroing is done in AdvanceXLInsertBuffer().
! 		 */
! 		UpdateSlotCurrPos(myslot, InvalidXLogRecPtr);
! 		AdvanceXLInsertBuffer(EndPos, false);
! 
! 		/*
! 		 * Even though we reserved the rest of the segment for us, which
! 		 * is reflected in EndPos, we need to return a value that points just
! 		 * to the end of the xlog-switch record.
! 		 */
! 		EndPos.xlogid = StartPos.xlogid;
! 		EndPos.xrecoff = StartPos.xrecoff + SizeOfXLogRecord;
! 	}
  
  	/*
! 	 * Update shared LogwrtRqst.Write, if we crossed page boundary.
  	 */
! 	if (updrqst)
! 	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
! 
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, EndPos))
! 			xlogctl->LogwrtRqst.Write = EndPos;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
! 	}
! 
! 	/* update our global variables */
! 	ProcLastRecPtr = StartPos;
! 	XactLastRecEnd = EndPos;
! 
! 	return EndPos;
! }
! 
! /*
!  * Reserves the right amount of space for a record of the given size from
!  * the WAL. *StartPos_p is set to the beginning of the reserved section,
!  * *EndPos_p to its end, and *Prev_record_p points to the beginning of the
!  * previous record to set to the prev-link of the record header.
!  *
!  * A log-switch record is handled slightly differently. The rest of the
!  * segment will be reserved for this insertion, as indicated by the returned
!  * *EndPos_p value. However, if we are already at the beginning of the current
!  * segment, the *EndPos_p is set to the current location without reserving
!  * any space, and the function returns false.
!  *
!  * *updrqst_p is set to true, if this record ends on different page than
!  * the previous one - the caller should update the shared LogwrtRqst value
!  * after it's done inserting the record in that case, so that the WAL page
!  * that filled up gets written out at the next convenient moment.
!  *
!  * While holding insertpos_lck, sets myslot->CurrPos to the starting position,
!  * to let others know that we're busy inserting to the reserved area. The
!  * caller must clear it when the insertion is finished.
!  *
!  * Returns true on success, or false if RedoRecPtr or forcePageWrites was
!  * changed. On failure, the shared state is not modified.
!  *
!  * This is the performance critical part of XLogInsert that must be
!  * serialized across backends. The rest can happen mostly in parallel.
!  *
!  * NB: The space calculation here must match the code in PerformXLogInsert,
!  * where we actually copy the record to the reserved space.
!  */
! static bool
! ReserveXLogInsertLocation(int size, bool forcePageWrites,
! 						  bool isLogSwitch,
! 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
! 						  XLogRecPtr *EndPos_p,
! 						  XLogInsertSlot **myslot_p, bool *updrqst_p)
! {
! 	volatile XLogInsertSlot *myslot;
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			freespace;
! 	XLogRecPtr	ptr;
! 	XLogRecPtr	StartPos;
! 	int32		nextslot;
! 	int32		lastslot;
! 	bool		updrqst = false;
! 
! retry:
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 
! 	if (!isLogSwitch &&
! 		(!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr) ||
! 		 Insert->forcePageWrites != forcePageWrites))
! 	{
! 		/*
! 		 * Oops, forcePageWrites was just turned on, or a checkpoint
! 		 * just happened. Loop back to the beginning, because we might have
! 		 * to include more full-page images in the record.
! 		 */
! 		RedoRecPtr = Insert->RedoRecPtr;
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		*EndPos_p = InvalidXLogRecPtr;
! 		return false;
! 	}
  
  	/*
! 	 * Reserve the next insertion slot for us.
! 	 *
! 	 * First check that the slot is not still in use. Modifications to
! 	 * lastslot are protected by WALInsertWaitLock, but here we assume that
! 	 * reading an int32 is atomic. Another process might advance lastslot at
! 	 * the same time, but not past nextslot.
  	 */
! 	lastslot = Insert->lastslot;
! 	nextslot = Insert->nextslot;
! 	if (NextSlotNo(nextslot) == lastslot)
  	{
! 		/*
! 		 * Oops, we've "caught our tail" and the oldest slot is still in use.
! 		 * Have to wait for it to become vacant.
! 		 */
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		WaitForXLogInsertionSlotToBecomeFree();
! 		goto retry;
! 	}
! 	myslot = &XLogCtl->XLogInsertSlots[nextslot];
! 	nextslot = NextSlotNo(nextslot);
  
! 	/*
! 	 * Now reserve the right amount of space from the WAL for our record.
! 	 */
! 	ptr = Insert->CurrPos;
! 	*PrevRecord_p = Insert->PrevRecord;
  
! 	/*
! 	 * If there isn't enough space on the current XLOG page for a record
! 	 * header, advance to the next page (leaving the unused space as zeroes).
! 	 */
! 	freespace = INSERT_FREESPACE(ptr);
! 	if (freespace < SizeOfXLogRecord)
! 	{
! 		ptr = AdvanceXLogRecPtrToNextPage(ptr);
! 		freespace = INSERT_FREESPACE(ptr);
! 		updrqst = true;
! 	}
  
+ 	/*
+ 	 * We are now at the starting position of our record. Now figure out how
+ 	 * the data will be split across the WAL pages, to calculate where the
+ 	 * record ends.
+ 	 */
+ 	StartPos = ptr;
+ 
+ 	if (isLogSwitch)
+ 	{
  		/*
! 		 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
! 		 * segment, we need not insert it (and don't want to because we'd like
! 		 * consecutive switch requests to be no-ops). Otherwise the XLOG_SWITCH
! 		 * record should consume all the remaining space on the current segment.
  		 */
! 		Assert(size == SizeOfXLogRecord);
! 		if ((ptr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
  		{
! 			/* We can release insert lock immediately */
! 			SpinLockRelease(&Insert->insertpos_lck);
  
! 			ptr.xrecoff -= SizeOfXLogLongPHD;
! 			if (ptr.xrecoff == 0)
! 			{
! 				/* crossing a logid boundary */
! 				ptr.xlogid -= 1;
! 				ptr.xrecoff = XLogFileSize;
! 			}
  
! 			*EndPos_p = ptr;
! 			*StartPos_p = ptr;
! 			*myslot_p = NULL;
! 
! 			return false;
! 		}
! 		else
  		{
! 			if (ptr.xrecoff % XLOG_SEG_SIZE != 0)
! 			{
! 				int segleft = XLOG_SEG_SIZE - (ptr.xrecoff % XLOG_SEG_SIZE);
! 				XLByteAdvance(ptr, segleft);
! 			}
! 			updrqst = true;
! 		}
! 	}
! 	else
! 	{
! 		/* A normal record, ie. not xlog-switch */
! 		int sizeleft = size;
! 		while (freespace < sizeleft)
! 		{
! 			/* fill this page, and continue on next page */
! 			sizeleft -= freespace;
! 			ptr = AdvanceXLogRecPtrToNextPage(ptr);
  
! 			/* account for continuation record header */
! 			ptr.xrecoff += SizeOfXLogContRecord;
! 			freespace = INSERT_FREESPACE(ptr);
! 
! 			updrqst = true;
  		}
+ 		/* the rest fits on this page */
+ 		ptr.xrecoff += sizeleft;
  
! 		/* Align the end position, so that the next record starts aligned */
! 		ptr.xrecoff = MAXALIGN(ptr.xrecoff);
! 	}
  
! 	/* Update the shared state, and our slot, before releasing the lock */
! 	myslot->CurrPos = StartPos;
! 	Insert->CurrPos = ptr;
! 	Insert->PrevRecord = StartPos;
! 	Insert->nextslot = nextslot;
! 
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! #ifdef RESERVE_XLOGINSERT_LOCATION_DEBUG
! 	elog(LOG, "reserved xlog: prev %X/%X, start %X/%X, end %X/%X (len %d)",
! 		 PrevRecord_p->xlogid, PrevRecord_p->xrecoff,
! 		 StartPos.xlogid, StartPos.xrecoff,
! 		 ptr.xlogid, ptr.xrecoff,
! 		 size);
! #endif
! 
! 	*EndPos_p = ptr;
! 	*StartPos_p = StartPos;
! 	*myslot_p = (XLogInsertSlot *) myslot;
! 	*updrqst_p = updrqst;
! 
! 	return true;
! }
! 
! /*
!  * Update slot's CurrPos variable, and wake up anyone waiting on it.
!  */
! static void
! UpdateSlotCurrPos(volatile XLogInsertSlot *myslot, XLogRecPtr CurrPos)
! {
! 	PGPROC	   *waiter;
! 
! 	/*
! 	 * The write-barrier ensures that the changes we made to the WAL pages
! 	 * are visible to everyone before the update of CurrPos.
! 	 *
! 	 * XXX: I'm not sure if this is necessary. Does a function call act
! 	 * as an implicit barrier?
! 	 */
! 	pg_write_barrier();
! 
! 	SpinLockAcquire(&myslot->lck);
! 	myslot->CurrPos = CurrPos;
! 	waiter = myslot->waiter;
! 	myslot->waiter = NULL;
! 	SpinLockRelease(&myslot->lck);
! 	if (waiter != NULL)
! 		PGSemaphoreUnlock(&waiter->sem);
! }
! 
! /*
!  * Get a pointer to the right location in the WAL buffer corresponding a
!  * given XLogRecPtr.
!  *
!  * If the page is not initialized yet, it is initialized. That might also
!  * require evicting an old diry buffer from the buffer cache, which means I/O.
!  *
!  * The caller must ensure that the page containing the requested location
!  * isn't evicted yet, and won't be evicted, by holding onto an
!  * XLogInsertSlot with CurrPos set to 'ptr'. Setting it to some value
!  * less than 'ptr' would suffice for GetXLogBuffer(), but risks deadlock:
!  * if we have to evict a buffer, we might have to wait for someone else to
!  * finish a write. And that someone else might not be able to finish the write
!  * if our CurrPos points to a buffer that's still in the buffer cache.
!  */
! static char *
! GetXLogBuffer(XLogRecPtr ptr)
! {
! 	int			idx;
! 	XLogRecPtr	endptr;
  
! 	/*
! 	 * The XLog buffer cache is organized so that we can easily calculate the
! 	 * buffer a given page must be loaded into from the XLogRecPtr alone.
! 	 * A page must always be loaded to a particular buffer.
! 	 */
! 	idx = XLogRecPtrToBufIdx(ptr);
! 
! 	/*
! 	 * See what page is loaded in the buffer at the moment. It could be the
! 	 * page we're looking for, or something older. It can't be anything
! 	 * newer - that would imply the page we're looking for has already
! 	 * been written out to disk, which shouldn't happen as long as the caller
! 	 * has set its slot's CurrPos correctly.
! 	 *
! 	 * However, we don't hold a lock while we read the value. If someone has
! 	 * just initialized the page, it's possible that we get a "torn read",
! 	 * and read a bogus value. That's ok, we'll grab the mapping lock (in
! 	 * AdvanceXLInsertBuffer) and retry if we see anything else than the page
! 	 * we're looking for. But it means that when we do this unlocked read, we
! 	 * might see a value that *is* ahead of the page we're looking for. So
! 	 * don't PANIC on that, until we've verified the value while holding the
! 	 * lock.
! 	 */
! 	endptr = XLogCtl->xlblocks[idx];
! 	if (ptr.xlogid != endptr.xlogid ||
! 		!(ptr.xrecoff < endptr.xrecoff &&
! 		  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
! 	{
! 		AdvanceXLInsertBuffer(ptr, false);
! 		endptr = XLogCtl->xlblocks[idx];
! 
! 		if (ptr.xlogid != endptr.xlogid ||
! 			!(ptr.xrecoff < endptr.xrecoff &&
! 			  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
! 		{
! 			elog(PANIC, "could not find WAL buffer for %X/%X",
! 				 ptr.xlogid, ptr.xrecoff);
! 		}
  	}
+ 
+ 	/*
+ 	 * Found the buffer holding this page. Return a pointer to the right
+ 	 * offset within the page.
+ 	 */
+ 	return (char *) XLogCtl->pages + idx * (Size) XLOG_BLCKSZ +
+ 		ptr.xrecoff % XLOG_BLCKSZ;
+ }
+ 
+ /*
+  * Advance an XLogRecPtr to the first valid insertion location on the next
+  * page, right after the page header. An XLogRecPtr pointing to a boundary,
+  * ie. the first byte of a page, is taken to belong to the previous page.
+  */
+ static XLogRecPtr
+ AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr)
+ {
+ 	int			freespace;
+ 
+ 	freespace = INSERT_FREESPACE(ptr);
+ 	XLByteAdvance(ptr, freespace);
+ 	if (ptr.xrecoff % XLogSegSize == 0)
+ 		ptr.xrecoff += SizeOfXLogLongPHD;
  	else
+ 		ptr.xrecoff += SizeOfXLogShortPHD;
+ 
+ 	return ptr;
+ }
+ 
+ /*
+  * Wait for any insertions < upto to finish.
+  *
+  * Returns a value >= upto, which indicates the oldest in-progress insertion
+  * that we saw in the array, or CurrPos if there are no insertions in-progress
+  * at exit.
+  */
+ static XLogRecPtr
+ WaitXLogInsertionsToFinish(XLogRecPtr upto, XLogRecPtr CurrPos)
+ {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 	int			lastslot;
+ 	int			nextslot;
+ 	volatile XLogInsertSlot *slot;
+ 	XLogRecPtr	slotptr = InvalidXLogRecPtr;
+ 	XLogRecPtr	LastPos;
+ 
+ 	if (MyProc == NULL)
+ 		elog(PANIC, "cannot wait without a PGPROC structure");
+ 
+ 	LastPos = CurrPos;
+ 
+ 	LWLockAcquire(WALInsertWaitLock, LW_EXCLUSIVE);
+ 
+ 	lastslot = Insert->lastslot;
+ 	nextslot = Insert->nextslot;
+ 
+ 	/* Skip over slots that have finished already */
+ 	while (lastslot != nextslot)
  	{
! 		slot = &XLogCtl->XLogInsertSlots[lastslot];
! 		SpinLockAcquire(&slot->lck);
! 		slotptr = slot->CurrPos;
  
! 		if (XLogRecPtrIsInvalid(slotptr))
  		{
! 			lastslot = NextSlotNo(lastslot);
! 			SpinLockRelease(&slot->lck);
  		}
  		else
  		{
! 			/*
! 			 * This insertion is still in-progress. Wait for it to finish
! 			 * if it's <= upto, otherwise we're done.
! 			 */
! 			Insert->lastslot = lastslot;
! 
! 			if (XLogRecPtrIsInvalid(upto) || XLByteLE(upto, slotptr))
! 			{
! 				LastPos = slotptr;
! 				SpinLockRelease(&slot->lck);
! 				break;
! 			}
! 
! 			/* wait */
! 			slot->waiter = MyProc;
! 			SpinLockRelease(&slot->lck);
! 			ProcWaitForSignal();
  		}
  	}
  
! 	Insert->lastslot = lastslot;
! 	LWLockRelease(WALInsertWaitLock);
  
! 	return LastPos;
! }
! 
! /*
!  * Wait for the next insertion slot to become vacant.
!  */
! static void
! WaitForXLogInsertionSlotToBecomeFree(void)
! {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			lastslot;
! 	int			nextslot;
! 
! 	if (MyProc == NULL)
! 		elog(PANIC, "cannot wait without a PGPROC structure");
! 
! 	LWLockAcquire(WALInsertWaitLock, LW_EXCLUSIVE);
! 
! 	/*
! 	 * Re-read lastslot and nextslot, now that we have the wait-lock.
! 	 * We're reading nextslot without holding insertpos_lck. It could advance
! 	 * at the same time, but it can't advance beyond lastslot - 1.
! 	 */
! 	lastslot = Insert->lastslot;
! 	nextslot = Insert->nextslot;
! 
! 	/*
! 	 * If there are still no slots available, wait for the oldest slot to
! 	 * become vacant.
! 	 */
! 	if (NextSlotNo(nextslot) == lastslot)
  	{
! 		volatile XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[lastslot];
  
! 		SpinLockAcquire(&slot->lck);
! 		while(!XLogRecPtrIsInvalid(slot->CurrPos))
! 		{
! 			slot->waiter = MyProc;
! 			SpinLockRelease(&slot->lck);
! 			ProcWaitForSignal();
! 			SpinLockAcquire(&slot->lck);
! 		}
! 		SpinLockRelease(&slot->lck);
  	}
+ 	/*
+ 	 * Ok, there is at least one empty slot now. That's enouugh for our
+ 	 * insertion, but ẃhile we're at it, advance lastslot as much as we
+ 	 * can. That way we don't need to come back here on the next call
+ 	 * again.
+ 	 */
+ 	while (lastslot != nextslot)
+ 	{
+ 		volatile XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[lastslot];
+ 		/*
+ 		 * Don't need to grab the slot's spinlock here, because we're not
+ 		 * interested in the exact value of CurrPos, only whether it's
+ 		 * valid or not.
+ 		 */
+ 		if (!XLogRecPtrIsInvalid(slot->CurrPos))
+ 			break;
  
! 		lastslot = NextSlotNo(lastslot);
! 	}
! 	Insert->lastslot = lastslot;
  
! 	LWLockRelease(WALInsertWaitLock);
  }
  
  /*
***************
*** 1457,1490 **** XLogArchiveCleanup(const char *xlog)
  
  /*
   * Advance the Insert state to the next buffer page, writing out the next
!  * buffer if it still contains unwritten data.
!  *
!  * If new_segment is TRUE then we set up the next buffer page as the first
!  * page of the next xlog segment file, possibly but not usually the next
!  * consecutive file page.
!  *
!  * The global LogwrtRqst.Write pointer needs to be advanced to include the
!  * just-filled page.  If we can do this for free (without an extra lock),
!  * we do so here.  Otherwise the caller must do it.  We return TRUE if the
!  * request update still needs to be done, FALSE if we did it internally.
!  *
!  * Must be called with WALInsertLock held.
   */
! static bool
! AdvanceXLInsertBuffer(bool new_segment)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	XLogCtlWrite *Write = &XLogCtl->Write;
! 	int			nextidx = NextBufIdx(Insert->curridx);
! 	bool		update_needed = true;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
  	XLogRecPtr	NewPageEndPtr;
  	XLogPageHeader NewPage;
  
! 	/* Use Insert->LogwrtResult copy if it's more fresh */
! 	if (XLByteLT(LogwrtResult.Write, Insert->LogwrtResult.Write))
! 		LogwrtResult = Insert->LogwrtResult;
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
--- 1916,1946 ----
  
  /*
   * Advance the Insert state to the next buffer page, writing out the next
!  * buffer if it still contains unwritten data. Any new pages are initialized
!  * to zeros, with pages headers initialized properly.
   */
! static void
! AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			nextidx;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
  	XLogRecPtr	NewPageEndPtr;
  	XLogPageHeader NewPage;
+ 	bool		needflush;
+ 	int			npages = 0;
+ 	XLogRecPtr	EvictedPtr;
  
! 	LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
! 
! 	/*
! 	 * Now that we have the lock, check if someone initialized the page
! 	 * already.
! 	 */
! while (!XLByteLT(upto, XLogCtl->xlblocks[XLogCtl->curridx]) || opportunistic)
! {
! 	nextidx = NextBufIdx(XLogCtl->curridx);
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
***************
*** 1492,1503 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
- 	if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
- 	{
- 		/* nope, got work to do... */
- 		XLogRecPtr	FinishedPageRqstPtr;
  
! 		FinishedPageRqstPtr = XLogCtl->xlblocks[Insert->curridx];
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
--- 1948,1964 ----
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
  
! 	needflush = !XLByteLE(OldPageRqstPtr, LogwrtResult.Write);
! 
! 	if (needflush)
! 	{
! 		/*
! 		 * Nope, got work to do. If we just want to pre-initialize as much as
! 		 * we can without flushing, give up now.
! 		 */
! 		if (opportunistic)
! 			break;
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
***************
*** 1505,1564 **** AdvanceXLInsertBuffer(bool new_segment)
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, FinishedPageRqstPtr))
! 				xlogctl->LogwrtRqst.Write = FinishedPageRqstPtr;
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		update_needed = false;	/* Did the shared-request update */
! 
! 		if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/* OK, someone wrote it already */
! 			Insert->LogwrtResult = LogwrtResult;
! 		}
! 		else
! 		{
! 			/* Must acquire write lock */
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 			LogwrtResult = Write->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding insert lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false, false);
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
  		}
  	}
  
  	/*
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[Insert->curridx];
! 
! 	if (new_segment)
! 	{
! 		/* force it to a segment start point */
! 		NewPageEndPtr.xrecoff += XLogSegSize - 1;
! 		NewPageEndPtr.xrecoff -= NewPageEndPtr.xrecoff % XLogSegSize;
! 	}
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
--- 1966,2025 ----
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, OldPageRqstPtr))
! 			{
! 				Assert(XLByteLE(OldPageRqstPtr, xlogctl->Insert.CurrPos));
! 				xlogctl->LogwrtRqst.Write = OldPageRqstPtr;
! 			}
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/*
! 			 * Must acquire write lock. Release WALBufMappingLock first, to
! 			 * make sure that all insertions that we need to wait for can
! 			 * finish (up to this same position). Otherwise we risk deadlock.
! 			 */
! 			LWLockRelease(WALBufMappingLock);
! 
! 			WaitXLogInsertionsToFinish(OldPageRqstPtr, InvalidXLogRecPtr);
! 
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 			LogwrtResult = XLogCtl->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding mapping lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false);
  				LWLockRelease(WALWriteLock);
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
+ 			/* Re-acquire WALBufMappingLock and retry */
+ 			LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
+ 			continue;
  		}
  	}
  
+ 	EvictedPtr = OldPageRqstPtr;
+ 
  	/*
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[XLogCtl->curridx];
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
***************
*** 1568,1581 **** AdvanceXLInsertBuffer(bool new_segment)
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
  	XLogCtl->xlblocks[nextidx] = NewPageEndPtr;
  	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
- 	Insert->curridx = nextidx;
- 	Insert->currpage = NewPage;
- 
- 	Insert->currpos = ((char *) NewPage) +SizeOfXLogShortPHD;
- 
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
  	 * will look like zeroes and not valid XLOG records...
--- 2029,2040 ----
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
+ 	Assert(NewPageEndPtr.xrecoff % XLOG_BLCKSZ == 0);
+ 	Assert(XLogRecEndPtrToBufIdx(NewPageEndPtr) == nextidx);
+ 
  	XLogCtl->xlblocks[nextidx] = NewPageEndPtr;
  	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
  	 * will look like zeroes and not valid XLOG records...
***************
*** 1618,1628 **** AdvanceXLInsertBuffer(bool new_segment)
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
- 
- 		Insert->currpos = ((char *) NewPage) +SizeOfXLogLongPHD;
  	}
  
! 	return update_needed;
  }
  
  /*
--- 2077,2106 ----
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
  	}
  
! 	/*
! 	 * make sure the xlblocks update becomes visible to others before the
! 	 * curridx update.
! 	 */
! 	pg_write_barrier();
! 
! 	XLogCtl->curridx = nextidx;
! 
! 	npages++;
! }
! 
! 	Assert(opportunistic || XLByteLT(upto, XLogCtl->xlblocks[XLogCtl->curridx]));
! 	LWLockRelease(WALBufMappingLock);
! 
! #ifdef WAL_DEBUG
! 	if (npages > 0)
! 		elog(DEBUG1, "initialized %d pages, upto %X/%X (evicted upto %X/%X) in slot %d (backend %d)",
! 			 npages,
! 			 NewPageEndPtr.xlogid, NewPageEndPtr.xrecoff,
! 			 EvictedPtr.xlogid, EvictedPtr.xrecoff,
! 			 nextidx, MyBackendId);
! #endif
  }
  
  /*
***************
*** 1667,1682 **** XLogCheckpointNeeded(uint32 logid, uint32 logseg)
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * If xlog_switch == TRUE, we are intending an xlog segment switch, so
!  * perform end-of-segment actions after writing the last page, even if
!  * it's not physically the end of its segment.  (NB: this will work properly
!  * only if caller specifies WriteRqst == page-end and flexible == false,
!  * and there is some data to write.)
!  *
!  * Must be called with WALWriteLock held.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
--- 2145,2156 ----
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * Must be called with WALWriteLock held. And you must've called
!  * WaitXLogInsertionsToFinish(WriteRqst) before grabbing the lock to make sure
!  * the data is ready to write.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
***************
*** 1694,1700 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  	/*
  	 * Update local LogwrtResult (caller probably did this already, but...)
  	 */
! 	LogwrtResult = Write->LogwrtResult;
  
  	/*
  	 * Since successive pages in the xlog cache are consecutively allocated,
--- 2168,2174 ----
  	/*
  	 * Update local LogwrtResult (caller probably did this already, but...)
  	 */
! 	LogwrtResult = XLogCtl->LogwrtResult;
  
  	/*
  	 * Since successive pages in the xlog cache are consecutively allocated,
***************
*** 1726,1735 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
  		if (!XLByteLT(LogwrtResult.Write, XLogCtl->xlblocks[curridx]))
! 			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  				 XLogCtl->xlblocks[curridx].xlogid,
! 				 XLogCtl->xlblocks[curridx].xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
  		LogwrtResult.Write = XLogCtl->xlblocks[curridx];
--- 2200,2209 ----
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
  		if (!XLByteLT(LogwrtResult.Write, XLogCtl->xlblocks[curridx]))
! 			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X (slot %d)",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  				 XLogCtl->xlblocks[curridx].xlogid,
! 				 XLogCtl->xlblocks[curridx].xrecoff, curridx);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
  		LogwrtResult.Write = XLogCtl->xlblocks[curridx];
***************
*** 1829,1844 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
- 			 * We also do this if this is the last page written for an xlog
- 			 * switch.
- 			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg || (xlog_switch && last_iteration))
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
--- 2303,2315 ----
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg)
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
***************
*** 1928,1935 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  			xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
  		SpinLockRelease(&xlogctl->info_lck);
  	}
- 
- 	Write->LogwrtResult = LogwrtResult;
  }
  
  /*
--- 2399,2404 ----
***************
*** 2101,2134 **** XLogFlush(XLogRecPtr record)
  	/* done already? */
  	if (!XLByteLE(record, LogwrtResult.Flush))
  	{
  		/* now wait for the write lock */
  		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 		LogwrtResult = XLogCtl->Write.LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			/* try to write/flush later additions to XLOG as well */
! 			if (LWLockConditionalAcquire(WALInsertLock, LW_EXCLUSIVE))
! 			{
! 				XLogCtlInsert *Insert = &XLogCtl->Insert;
! 				uint32		freespace = INSERT_FREESPACE(Insert);
  
! 				if (freespace < SizeOfXLogRecord)		/* buffer is full */
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 				else
! 				{
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 					WriteRqstPtr.xrecoff -= freespace;
! 				}
! 				LWLockRelease(WALInsertLock);
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = WriteRqstPtr;
! 			}
! 			else
! 			{
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = record;
! 			}
! 			XLogWrite(WriteRqst, false, false);
  		}
  		LWLockRelease(WALWriteLock);
  	}
--- 2570,2618 ----
  	/* done already? */
  	if (!XLByteLE(record, LogwrtResult.Flush))
  	{
+ 		/* try to write/flush later additions to XLOG as well */
+ 		volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 		uint32		freespace;
+ 		XLogRecPtr	insertpos;
+ 
+ 		/*
+ 		 * Get the current insert position.
+ 		 *
+ 		 * XXX: This used to do LWLockConditionalAcquire(WALInsertLock), and
+ 		 * fall back to writing just up to 'record' if we couldn't get the
+ 		 * lock. I wonder if it would be a good idea to have a
+ 		 * SpinLockConditionalAcquire function and use that? On one hand,
+ 		 * it would be good to not cause more contention on the lock if it's
+ 		 * busy, but on the other hand, this spinlock is much more lightweight
+ 		 * than the WALInsertLock was, so maybe it's better to just grab the
+ 		 * spinlock. Also note that if we stored the XLogRecPtr as one 64-bit
+ 		 * integer, we could just read it with no lock on platforms where
+ 		 * 64-bit integer accesses are atomic, which covers many common
+ 		 * platforms nowadays.
+ 		 */
+ 		SpinLockAcquire(&Insert->insertpos_lck);
+ 		insertpos = Insert->CurrPos;
+ 		SpinLockRelease(&Insert->insertpos_lck);
+ 
+ 		freespace = INSERT_FREESPACE(insertpos);
+ 		if (freespace < SizeOfXLogRecord)		/* buffer is full */
+ 			insertpos.xrecoff += freespace;
+ 
+ 		/*
+ 		 * Before actually performing the write, wait for all in-flight
+ 		 * insertions to the pages we're about to write to finish.
+ 		 */
+ 		insertpos = WaitXLogInsertionsToFinish(WriteRqstPtr, insertpos);
+ 
  		/* now wait for the write lock */
  		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 		LogwrtResult = XLogCtl->LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			WriteRqst.Write = insertpos;
! 			WriteRqst.Flush = insertpos;
  
! 			XLogWrite(WriteRqst, false);
  		}
  		LWLockRelease(WALWriteLock);
  	}
***************
*** 2238,2260 **** XLogBackgroundFlush(void)
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
- 
  	START_CRIT_SECTION();
  
! 	/* now wait for the write lock */
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 	LogwrtResult = XLogCtl->Write.LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
  	{
  		XLogwrtRqst WriteRqst;
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible, false);
  	}
! 	LWLockRelease(WALWriteLock);
  
  	END_CRIT_SECTION();
  }
  
  /*
--- 2722,2752 ----
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
  	START_CRIT_SECTION();
  
! 	/* now wait for any in-progress insertions to finish and get write lock */
! 	WaitXLogInsertionsToFinish(WriteRqstPtr, InvalidXLogRecPtr);
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 	LogwrtResult = XLogCtl->LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
  	{
  		XLogwrtRqst WriteRqst;
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible);
  	}
! 	LogwrtResult = XLogCtl->LogwrtResult;
  
  	END_CRIT_SECTION();
+ 
+ 	LWLockRelease(WALWriteLock);
+ 
+ 	/*
+ 	 * Great, done. To take some work off the critical path, try to initialize
+ 	 * as many of the no-longer-needed WAL buffers for future use as we can.
+ 	 */
+ 	AdvanceXLInsertBuffer(InvalidXLogRecPtr, true);
  }
  
  /*
***************
*** 5048,5053 **** XLOGShmemSize(void)
--- 5540,5548 ----
  	/* and the buffers themselves */
  	size = add_size(size, mul_size(XLOG_BLCKSZ, XLOGbuffers));
  
+ 	/* XLog insertion slots */
+ 	size = add_size(size, mul_size(sizeof(XLogInsertSlot), NumXLogInsertSlots));
+ 
  	/*
  	 * Note: we don't count ControlFileData, it comes out of the "slop factor"
  	 * added by CreateSharedMemoryAndSemaphores.  This lets us use this
***************
*** 5063,5068 **** XLOGShmemInit(void)
--- 5558,5564 ----
  	bool		foundCFile,
  				foundXLog;
  	char	   *allocptr;
+ 	int			i;
  
  	ControlFile = (ControlFileData *)
  		ShmemInitStruct("Control File", sizeof(ControlFileData), &foundCFile);
***************
*** 5088,5093 **** XLOGShmemInit(void)
--- 5584,5601 ----
  	memset(XLogCtl->xlblocks, 0, sizeof(XLogRecPtr) * XLOGbuffers);
  	allocptr += sizeof(XLogRecPtr) * XLOGbuffers;
  
+ 	/* Initialize insertion slots */
+ 	XLogCtl->XLogInsertSlots = (XLogInsertSlot *) allocptr;
+ 	for (i = 0; i < NumXLogInsertSlots; i++)
+ 	{
+ 		XLogCtl->XLogInsertSlots[i].CurrPos = InvalidXLogRecPtr;
+ 		XLogCtl->XLogInsertSlots[i].waiter = NULL;
+ 		SpinLockInit(&XLogCtl->XLogInsertSlots[i].lck);
+ 	}
+ 	XLogCtl->Insert.nextslot = 1;
+ 	XLogCtl->Insert.lastslot = 0;
+ 	allocptr += sizeof(XLogInsertSlot) * NumXLogInsertSlots;
+ 
  	/*
  	 * Align the start of the page buffers to an ALIGNOF_XLOG_BUFFER boundary.
  	 */
***************
*** 5102,5112 **** XLOGShmemInit(void)
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
- 	XLogCtl->Insert.currpage = (XLogPageHeader) (XLogCtl->pages);
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
--- 5610,5621 ----
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
+ 	SpinLockInit(&XLogCtl->Insert.insertpos_lck);
+ 
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
***************
*** 5981,5986 **** StartupXLOG(void)
--- 6490,6496 ----
  	uint32		freespace;
  	TransactionId oldestActiveXID;
  	bool		backupEndRequired = false;
+ 	int			firstIdx;
  
  	/*
  	 * Read control file and check XLOG status looks valid.
***************
*** 6737,6744 **** StartupXLOG(void)
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 	XLogCtl->xlblocks[0].xlogid = openLogId;
! 	XLogCtl->xlblocks[0].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
--- 7247,7258 ----
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 
! 	firstIdx = XLogRecPtrToBufIdx(EndOfLog);
! 	XLogCtl->curridx = firstIdx;
! 
! 	XLogCtl->xlblocks[firstIdx].xlogid = openLogId;
! 	XLogCtl->xlblocks[firstIdx].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
***************
*** 6746,6771 **** StartupXLOG(void)
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[0].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) Insert->currpage, readBuf, XLOG_BLCKSZ);
! 	Insert->currpos = (char *) Insert->currpage +
! 		(EndOfLog.xrecoff + XLOG_BLCKSZ - XLogCtl->xlblocks[0].xrecoff);
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
- 	XLogCtl->Write.LogwrtResult = LogwrtResult;
- 	Insert->LogwrtResult = LogwrtResult;
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(Insert->currpos, 0, freespace);
! 		XLogCtl->Write.curridx = 0;
  	}
  	else
  	{
--- 7260,7282 ----
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[firstIdx].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) &XLogCtl->pages[firstIdx * XLOG_BLCKSZ], readBuf, XLOG_BLCKSZ);
! 	Insert->CurrPos = EndOfLog;
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = XLOG_BLCKSZ - EndRecPtr.xrecoff % XLOG_BLCKSZ;
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(&XLogCtl->pages[firstIdx * XLOG_BLCKSZ] + EndRecPtr.xrecoff % XLOG_BLCKSZ, 0, freespace);
! 		XLogCtl->Write.curridx = firstIdx;
  	}
  	else
  	{
***************
*** 6777,6783 **** StartupXLOG(void)
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(0);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
--- 7288,7294 ----
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(firstIdx);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
***************
*** 7271,7279 **** GetRedoRecPtr(void)
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire WALInsertLock which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
  XLogRecPtr
  GetInsertRecPtr(void)
--- 7782,7794 ----
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire insertpos_lck which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
+  *
+  * XXX: now that there can be several insertions "in-flight", what should
+  * this return? The position a new insertion would got to? Or the the oldest
+  * still in-progress insertion, perhaps?
   */
  XLogRecPtr
  GetInsertRecPtr(void)
***************
*** 7547,7552 **** CreateCheckPoint(int flags)
--- 8062,8068 ----
  	uint32		insert_logSeg;
  	TransactionId *inCommitXids;
  	int			nInCommit;
+ 	XLogRecPtr	curInsert;
  
  	/*
  	 * An end-of-recovery checkpoint is really a shutdown checkpoint, just
***************
*** 7615,7624 **** CreateCheckPoint(int flags)
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * We must hold WALInsertLock while examining insert state to determine
! 	 * the checkpoint REDO pointer.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
--- 8131,8140 ----
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * Determine the checkpoint REDO pointer.
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	curInsert = Insert->CurrPos;
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
***************
*** 7630,7636 **** CreateCheckPoint(int flags)
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding the WALInsertLock we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
--- 8146,8152 ----
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding insertpos_lck we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
***************
*** 7639,7653 **** CreateCheckPoint(int flags)
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
- 		XLogRecPtr	curInsert;
- 
- 		INSERT_RECPTR(curInsert, Insert, Insert->curridx);
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			LWLockRelease(WALInsertLock);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
--- 8155,8166 ----
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
***************
*** 7673,7686 **** CreateCheckPoint(int flags)
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace < SizeOfXLogRecord)
! 	{
! 		(void) AdvanceXLInsertBuffer(false);
! 		/* OK to ignore update return flag, since we will do flush anyway */
! 		freespace = INSERT_FREESPACE(Insert);
! 	}
! 	INSERT_RECPTR(checkPoint.redo, Insert, Insert->curridx);
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
--- 8186,8195 ----
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(curInsert);
  	if (freespace < SizeOfXLogRecord)
! 		curInsert = AdvanceXLogRecPtrToNextPage(curInsert);
! 	checkPoint.redo = curInsert;
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
***************
*** 7706,7712 **** CreateCheckPoint(int flags)
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
--- 8215,8221 ----
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
***************
*** 7726,7732 **** CreateCheckPoint(int flags)
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released WALInsertLock, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
--- 8235,8241 ----
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released insertpos_lck, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
***************
*** 8093,8107 **** CreateRestartPoint(int flags)
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * You need to hold WALInsertLock and info_lck to update it, although
! 	 * during recovery acquiring WALInsertLock is just pro forma, because
! 	 * there is no other processes updating Insert.RedoRecPtr.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * Prepare to accumulate statistics.
--- 8602,8616 ----
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * Like in CreateCheckPoint(), you need both insertpos_lck and info_lck
! 	 * to update it, although during recovery acquiring insertpos_lck is just
! 	 * pro forma, because no WAL insertions are happening.
  	 */
! 	SpinLockAcquire(&xlogctl->Insert.insertpos_lck);
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
! 	SpinLockRelease(&xlogctl->Insert.insertpos_lck);
  
  	/*
  	 * Prepare to accumulate statistics.
***************
*** 8294,8299 **** RequestXLogSwitch(void)
--- 8803,8809 ----
  {
  	XLogRecPtr	RecPtr;
  	XLogRecData rdata;
+ 	XLogwrtRqst FlushRqst;
  
  	/* XLOG SWITCH, alone among xlog record types, has no data */
  	rdata.buffer = InvalidBuffer;
***************
*** 8303,8308 **** RequestXLogSwitch(void)
--- 8813,8839 ----
  
  	RecPtr = XLogInsert(RM_XLOG_ID, XLOG_SWITCH, &rdata);
  
+ 	/* XXX: before this patch, TRACE_POSTGRESQL_XLOG_SWITCH was not called
+ 	 * if the xlog switch had no work to do, ie. if we were already at the
+ 	 * beginning of a new XLOG segment. You can check if RecPtr points to
+ 	 * beginning of a segment if you want to keep the distinction.
+ 	 */
+ 	TRACE_POSTGRESQL_XLOG_SWITCH();
+ 
+ 	/*
+ 	 * Flush through the end of the page containing XLOG_SWITCH, and
+ 	 * perform end-of-segment actions (eg, notifying archiver).
+ 	 */
+ 	WaitXLogInsertionsToFinish(RecPtr, InvalidXLogRecPtr);
+ 
+ 	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
+ 	FlushRqst.Write = RecPtr;
+ 	FlushRqst.Flush = RecPtr;
+ 	START_CRIT_SECTION();
+ 	XLogWrite(FlushRqst, false);
+ 	END_CRIT_SECTION();
+ 	LWLockRelease(WALWriteLock);
+ 
  	return RecPtr;
  }
  
***************
*** 8856,8861 **** issue_xlog_fsync(int fd, uint32 log, uint32 seg)
--- 9387,9393 ----
  XLogRecPtr
  do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	XLogRecPtr	checkpointloc;
  	XLogRecPtr	startpoint;
***************
*** 8905,8930 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  	 * since we expect that any pages not modified during the backup interval
  	 * must have been correctly captured by the backup.)
  	 *
! 	 * We must hold WALInsertLock to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
! 		if (XLogCtl->Insert.exclusiveBackup)
  		{
! 			LWLockRelease(WALInsertLock);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		XLogCtl->Insert.exclusiveBackup = true;
  	}
  	else
! 		XLogCtl->Insert.nonExclusiveBackups++;
! 	XLogCtl->Insert.forcePageWrites = true;
! 	LWLockRelease(WALInsertLock);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
--- 9437,9462 ----
  	 * since we expect that any pages not modified during the backup interval
  	 * must have been correctly captured by the backup.)
  	 *
! 	 * We must hold insertpos_lck to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
! 		if (Insert->exclusiveBackup)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		Insert->exclusiveBackup = true;
  	}
  	else
! 		Insert->nonExclusiveBackups++;
! 	Insert->forcePageWrites = true;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
***************
*** 8986,8998 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			LWLockAcquire(WALInsertLock, LW_SHARED);
! 			if (XLByteLT(XLogCtl->Insert.lastBackupStart, startpoint))
  			{
! 				XLogCtl->Insert.lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			LWLockRelease(WALInsertLock);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
--- 9518,9530 ----
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			SpinLockAcquire(&Insert->insertpos_lck);
! 			if (XLByteLT(Insert->lastBackupStart, startpoint))
  			{
! 				Insert->lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			SpinLockRelease(&Insert->insertpos_lck);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
***************
*** 9074,9083 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
  		Assert(XLogCtl->Insert.exclusiveBackup);
--- 9606,9616 ----
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
  		Assert(XLogCtl->Insert.exclusiveBackup);
***************
*** 9094,9100 **** pg_start_backup_callback(int code, Datum arg)
  	{
  		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 9627,9633 ----
  	{
  		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9107,9112 **** pg_start_backup_callback(int code, Datum arg)
--- 9640,9646 ----
  XLogRecPtr
  do_pg_stop_backup(char *labelfile, bool waitforarchive)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	XLogRecPtr	startpoint;
  	XLogRecPtr	stoppoint;
***************
*** 9148,9156 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
! 		XLogCtl->Insert.exclusiveBackup = false;
  	else
  	{
  		/*
--- 9682,9690 ----
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
! 		Insert->exclusiveBackup = false;
  	else
  	{
  		/*
***************
*** 9159,9174 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 		XLogCtl->Insert.nonExclusiveBackups--;
  	}
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  
  	if (exclusive)
  	{
--- 9693,9708 ----
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(Insert->nonExclusiveBackups > 0);
! 		Insert->nonExclusiveBackups--;
  	}
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	if (exclusive)
  	{
***************
*** 9370,9385 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  void
  do_pg_abort_backup(void)
  {
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 	Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 	XLogCtl->Insert.nonExclusiveBackups--;
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 9904,9921 ----
  void
  do_pg_abort_backup(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	Assert(Insert->nonExclusiveBackups > 0);
! 	Insert->nonExclusiveBackups--;
! 
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9431,9446 **** GetStandbyFlushRecPtr(void)
   * Get latest WAL insert pointer
   */
  XLogRecPtr
! GetXLogInsertRecPtr(bool needlock)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	if (needlock)
! 		LWLockAcquire(WALInsertLock, LW_SHARED);
! 	INSERT_RECPTR(current_recptr, Insert, Insert->curridx);
! 	if (needlock)
! 		LWLockRelease(WALInsertLock);
  
  	return current_recptr;
  }
--- 9967,9980 ----
   * Get latest WAL insert pointer
   */
  XLogRecPtr
! GetXLogInsertRecPtr(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	current_recptr = Insert->CurrPos;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	return current_recptr;
  }
*** a/src/backend/access/transam/xlogfuncs.c
--- b/src/backend/access/transam/xlogfuncs.c
***************
*** 200,206 **** pg_current_xlog_insert_location(PG_FUNCTION_ARGS)
  				 errmsg("recovery is in progress"),
  				 errhint("WAL control functions cannot be executed during recovery.")));
  
! 	current_recptr = GetXLogInsertRecPtr(true);
  
  	snprintf(location, sizeof(location), "%X/%X",
  			 current_recptr.xlogid, current_recptr.xrecoff);
--- 200,206 ----
  				 errmsg("recovery is in progress"),
  				 errhint("WAL control functions cannot be executed during recovery.")));
  
! 	current_recptr = GetXLogInsertRecPtr();
  
  	snprintf(location, sizeof(location), "%X/%X",
  			 current_recptr.xlogid, current_recptr.xrecoff);
*** a/src/backend/storage/lmgr/spin.c
--- b/src/backend/storage/lmgr/spin.c
***************
*** 56,61 **** SpinlockSemas(void)
--- 56,64 ----
  	 *
  	 * For now, though, we just need a few spinlocks (10 should be plenty)
  	 * plus one for each LWLock and one for each buffer header.
+ 	 *
+ 	 * XXX: remember to adjust this for the number of spinlocks needed by the
+ 	 * xlog.c changes before committing!
  	 */
  	return NumLWLocks() + NBuffers + 10;
  }
*** a/src/include/access/xlog.h
--- b/src/include/access/xlog.h
***************
*** 288,294 **** extern bool XLogInsertAllowed(void);
  extern void GetXLogReceiptTime(TimestampTz *rtime, bool *fromStream);
  extern XLogRecPtr GetXLogReplayRecPtr(XLogRecPtr *restoreLastRecPtr);
  extern XLogRecPtr GetStandbyFlushRecPtr(void);
! extern XLogRecPtr GetXLogInsertRecPtr(bool needlock);
  extern XLogRecPtr GetXLogWriteRecPtr(void);
  extern bool RecoveryIsPaused(void);
  extern void SetRecoveryPause(bool recoveryPause);
--- 288,294 ----
  extern void GetXLogReceiptTime(TimestampTz *rtime, bool *fromStream);
  extern XLogRecPtr GetXLogReplayRecPtr(XLogRecPtr *restoreLastRecPtr);
  extern XLogRecPtr GetStandbyFlushRecPtr(void);
! extern XLogRecPtr GetXLogInsertRecPtr(void);
  extern XLogRecPtr GetXLogWriteRecPtr(void);
  extern bool RecoveryIsPaused(void);
  extern void SetRecoveryPause(bool recoveryPause);
*** a/src/include/storage/lwlock.h
--- b/src/include/storage/lwlock.h
***************
*** 53,59 **** typedef enum LWLockId
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALInsertLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
--- 53,59 ----
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALBufMappingLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
***************
*** 79,84 **** typedef enum LWLockId
--- 79,85 ----
  	SerializablePredicateLockListLock,
  	OldSerXidLock,
  	SyncRepLock,
+ 	WALInsertWaitLock,
  	/* Individual lock IDs end here */
  	FirstBufMappingLock,
  	FirstLockMgrLock = FirstBufMappingLock + NUM_BUFFER_PARTITIONS,

*** a/src/backend/access/transam/xlog.c
--- b/src/backend/access/transam/xlog.c
***************
*** 42,47 ****
--- 42,48 ----
  #include "postmaster/startup.h"
  #include "replication/walreceiver.h"
  #include "replication/walsender.h"
+ #include "storage/barrier.h"
  #include "storage/bufmgr.h"
  #include "storage/fd.h"
  #include "storage/ipc.h"
***************
*** 282,307 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There are actually three shared-memory copies of
!  * LogwrtResult, plus one unshared copy in each backend.  Here's how it works:
!  *		XLogCtl->LogwrtResult is protected by info_lck
!  *		XLogCtl->Write.LogwrtResult is protected by WALWriteLock
!  *		XLogCtl->Insert.LogwrtResult is protected by WALInsertLock
!  * One must hold the associated lock to read or write any of these, but
!  * of course no lock is needed to read/write the unshared LogwrtResult.
!  *
!  * XLogCtl->LogwrtResult and XLogCtl->Write.LogwrtResult are both "always
!  * right", since both are updated by a write or flush operation before
!  * it releases WALWriteLock.  The point of keeping XLogCtl->Write.LogwrtResult
!  * is that it can be examined/modified by code that already holds WALWriteLock
!  * without needing to grab info_lck as well.
!  *
!  * XLogCtl->Insert.LogwrtResult may lag behind the reality of the other two,
!  * but is updated when convenient.	Again, it exists for the convenience of
!  * code that is already holding WALInsertLock but not the other locks.
!  *
!  * The unshared LogwrtResult may lag behind any or all of these, and again
!  * is updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
--- 283,293 ----
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There is one shared-memory copy of LogwrtResult,
!  * plus one unshared copy in each backend. To read the shared copy, you need
!  * to hold info_lck *or* WALWriteLock. To update it, you need to hold both
!  * locks. The unshared LogwrtResult may lag behind the shared copy, and is
!  * updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
***************
*** 311,320 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  The other locks are held longer (potentially
!  * over I/O operations), so we use LWLocks for them.  These locks are:
   *
!  * WALInsertLock: must be held to insert a record into the WAL buffers.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
--- 297,311 ----
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  insertpos_lck protects the current logical
!  * insert location, ie. the head of reserved WAL space.  The other locks are
!  * held longer (potentially over I/O operations), so we use LWLocks for them.
!  * These locks are:
   *
!  * WALBufMappingLock: must be held to replace a page in the WAL buffer cache.
!  * This is only held while initializing and changing the mapping. If the
!  * contents of the buffer being replaced haven't been written yet, the mapping
!  * lock is released while the write is done, and reacquired afterwards.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
***************
*** 326,331 **** static XLogRecPtr RedoStartLSN = {0, 0};
--- 317,391 ----
   * only one checkpointer at a time; currently, with all checkpoints done by
   * the checkpointer, this is just pro forma).
   *
+  *
+  * Inserting a new WAL record is a two-step process:
+  *
+  * 1. Reserve the right amount of space from the WAL, and the next insertion
+  *    slot to advertise that the insertion is in progress. The current head
+  *    of reserved space is kept in Insert->CurrPos, and is protected by
+  *    insertpos_lck. Try to keep this section as short as possible,
+  *    insertpos_lck can be heavily contended on a busy system
+  *
+  * 2. Copy the record to the reserved WAL space. This involves finding the
+  *    correct WAL buffer containing the reserved space, and copying the
+  *    record in place. This can be done concurrently in multiple processes.
+  *
+  * To allow as much parallelism as possible for step 2, we try hard to avoid
+  * lock contention in that code path. Each insertion is asssigned its own
+  * "XLog insertion slot", which is used to advertise the position the backend
+  * is writing to. The slot is marked as in-use in step 1, while holding
+  * insertpos_lck, by setting the position field in the slot. When the backend
+  * is finished with the insertion, it clears its slot. Each slot is protected
+  * by a separate spinlock, to keep contention minimal.
+  *
+  * The insertion slots also provide a mechanism to wait for an insertion to
+  * finish. This is important when an XLOG page is written out - any
+  * in-progress insertions must finish copying data to the page first, or the
+  * on-disk copy will be incomplete. Waiting is done by the
+  * WaitXLogInsertionsToFinish() function. It adds the current process to the
+  * waiting queue in the slot it needs to wait for, and when that insertion
+  * finishes (or proceeds to the next page, at least), the inserter wakes up
+  * the process.
+  *
+  * The insertion slots form a ring. Insert->nextslot points to the next free
+  * slot, and Insert->lastslot points to the last slot that's still in use.
+  * lastslot can lag behind reality by any number of slots, as long as nextslot
+  * doesn't catch up with it. lastslot is advanced by
+  * WaitXLogInsertionsToFinish(), and is protected by WALInsertTailLock.
+  * nextslot is advanced in ReserveXLogInsertLocation() and is protected by
+  * insertpos_lck. Both slot variables are 32-bit integers, so that they can
+  * be read atomically without holding a lock.
+  *
+  * Whenever the ring fills up, ie. when nextslot wraps around and catches up
+  * with lastslot, ReserveXLogInsertLocation() has to wait for the oldest
+  * insertion to finish and advance lastslot, to make room for the new
+  * insertion. This is done by WaitForXLogInsertionSlotToBecomeFree() function,
+  * which is similar to WaitXLogInsertionsToFinish(), but instead of waiting
+  * for all insertions up to a given point to finish, it just waits for the
+  * inserter in the oldest slot to finish.
+  *
+  *
+  * Deadlock analysis
+  * -----------------
+  *
+  * It's important to call WaitXLogInsertionsToFinish() *before* acquiring
+  * WALWriteLock. Otherwise you might get stuck waiting for an insertion to
+  * finish (or at least advance to next uninitialized page), while you're
+  * holding WALWriteLock. That would be bad, because the backend you're waiting
+  * for might need to acquire WALWriteLock, too, to evict an old buffer, so
+  * you'd get deadlock.
+  *
+  * WaitXLogInsertionsToFinish() will not get stuck indefinitely, as long as
+  * it's called with a location that's known to be already allocated in the WAL
+  * buffers. Calling it with the position of a record you've already inserted
+  * satisfies that condition, so the common pattern:
+  *
+  *   recptr = XLogInsert(...)
+  *   XLogFlush(recptr)
+  *
+  * is safe. It can't get stuck, because an insertion to a WAL page that's
+  * already initialized in cache can always proceed without waiting on a lock.
+  *
   *----------
   */
  
***************
*** 346,356 **** typedef struct XLogwrtResult
   */
  typedef struct XLogCtlInsert
  {
! 	XLogwrtResult LogwrtResult; /* a recent value of LogwrtResult */
! 	XLogRecPtr	PrevRecord;		/* start of previously-inserted record */
! 	int			curridx;		/* current block index in cache */
! 	XLogPageHeader currpage;	/* points to header of block in cache */
! 	char	   *currpos;		/* current insertion point in cache */
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
--- 406,435 ----
   */
  typedef struct XLogCtlInsert
  {
! 	slock_t		insertpos_lck;	/* protects all the fields in this struct
! 								 * (except lastslot). */
! 
! 	int32		nextslot;		/* next insertion slot to use */
! 	int32		lastslot;		/* last in-use insertion slot (protected by
! 								 * WALInsertTailLock) */
! 
! 	/*
! 	 * CurrPos is the very tip of the reserved WAL space at the moment. The
! 	 * next record will be inserted there (or somewhere after it if there's
! 	 * not enough space on the current page). PrevRecord points to the
! 	 * beginning of the last record already reserved. It might not be fully
! 	 * copied into place yet, but we know its exact location already.
! 	 */
! 	XLogRecPtr	CurrPos;
! 	XLogRecPtr	PrevRecord;
! 
! 	/*
! 	 * padding to push RedoRecPtr and forcePageWrites, which rarely change,
! 	 * to a different cache line than the rapidly-changing CurrPos and
! 	 * PrevRecord values. XXX: verify if this makes any difference
! 	 */
! 	char		padding[128];
! 
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
***************
*** 371,389 **** typedef struct XLogCtlInsert
   */
  typedef struct XLogCtlWrite
  {
- 	XLogwrtResult LogwrtResult; /* current value of LogwrtResult */
  	int			curridx;		/* cache index of next block to write */
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by WALInsertLock: */
  	XLogCtlInsert Insert;
  
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
--- 450,483 ----
   */
  typedef struct XLogCtlWrite
  {
  	int			curridx;		/* cache index of next block to write */
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
+ 
+ /*
+  * Slots for in-progress WAL insertions.
+  */
+ typedef struct
+ {
+ 	slock_t		lck;
+ 	XLogRecPtr	CurrPos;	/* current position this process is inserting to */
+ 	PGPROC	   *head;		/* head of list of waiting PGPROCs */
+ 	PGPROC	   *tail;		/* tail of list of waiting PGPROCs */
+ } XLogInsertSlot;
+ 
+ #define NumXLogInsertSlots	1000
+ 
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by insertpos_lck: */
  	XLogCtlInsert Insert;
  
+ 	XLogInsertSlot *XLogInsertSlots;
+ 
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
***************
*** 397,405 **** typedef struct XLogCtlData
  	XLogCtlWrite Write;
  
  	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALInsertLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
--- 491,509 ----
  	XLogCtlWrite Write;
  
  	/*
+ 	 * To change curridx and the identity of a buffer, you need to hold
+ 	 * WALBufMappingLock. To change the identity of a buffer that's
+ 	 * still dirty, the old page needs to be written out first, and for that
+ 	 * you need WALWriteLock, and you need to ensure that there's no
+ 	 * in-progress insertions to the page by calling
+ 	 * WaitXLogInsertionsToFinish().
+ 	 */
+ 	int			curridx;		/* current (latest) block index in cache */
+ 
+ 	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALBufMappingLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
***************
*** 471,498 **** static XLogCtlData *XLogCtl = NULL;
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Macros for managing XLogInsert state.  In most cases, the calling routine
!  * has local copies of XLogCtl->Insert and/or XLogCtl->Insert->curridx,
!  * so these are passed as parameters instead of being fetched via XLogCtl.
   */
  
- /* Free space remaining in the current xlog page buffer */
- #define INSERT_FREESPACE(Insert)  \
- 	(XLOG_BLCKSZ - ((Insert)->currpos - (char *) (Insert)->currpage))
  
! /* Construct XLogRecPtr value for current insertion point */
! #define INSERT_RECPTR(recptr,Insert,curridx)  \
! 	( \
! 	  (recptr).xlogid = XLogCtl->xlblocks[curridx].xlogid, \
! 	  (recptr).xrecoff = \
! 		XLogCtl->xlblocks[curridx].xrecoff - INSERT_FREESPACE(Insert) \
! 	)
  
! #define PrevBufIdx(idx)		\
! 		(((idx) == 0) ? XLogCtl->XLogCacheBlck : ((idx) - 1))
  
! #define NextBufIdx(idx)		\
! 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
--- 575,605 ----
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Calculate the amount of space left on the page after 'endptr'.
!  * Beware multiple evaluation!
   */
+ #define INSERT_FREESPACE(endptr)	\
+ 	(((endptr).xrecoff % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr).xrecoff % XLOG_BLCKSZ))
+ 
+ #define NextBufIdx(idx)		\
+ 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  
! #define NextSlotNo(idx)		\
! 		(((idx) == NumXLogInsertSlots) ? 0 : ((idx) + 1))
  
! /*
!  * XLogRecPtrToBufIdx returns the index of the WAL buffer that holds, or
!  * would hold if it was in cache, the page containing 'recptr'.
!  *
!  * XLogRecEndPtrToBufIdx is the same, but a pointer to the first byte of a
!  * page is taken to mean the previous page.
!  */
! #define XLogRecPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogSegsPerFile * XLogSegSize) + (recptr).xrecoff)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
  
! #define XLogRecEndPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogSegsPerFile * XLogSegSize) + (recptr).xrecoff - 1)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
***************
*** 618,626 **** static void KeepLogSeg(XLogRecPtr recptr, uint32 *logId, uint32 *logSeg);
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static bool AdvanceXLInsertBuffer(bool new_segment);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
--- 725,733 ----
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static void AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
***************
*** 667,672 **** static bool read_backup_label(XLogRecPtr *checkPointLoc,
--- 774,797 ----
  static void rm_redo_error_callback(void *arg);
  static int	get_sync_bit(int method);
  
+ static XLogRecPtr PerformXLogInsert(int write_len,
+ 				  bool isLogSwitch,
+ 				  XLogRecord *rechdr,
+ 				  XLogRecData *rdata, pg_crc32 rdata_crc,
+ 				  bool didPageWrites);
+ static bool ReserveXLogInsertLocation(int size, bool forcePageWrites,
+ 						  bool isLogSwitch,
+ 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
+ 						  XLogRecPtr *EndPos_p,
+ 						  XLogInsertSlot **myslot_p, bool *updrqst_p);
+ static void UpdateSlotCurrPos(volatile XLogInsertSlot *myslot,
+ 				  XLogRecPtr CurrPos);
+ static XLogRecPtr WaitXLogInsertionsToFinish(XLogRecPtr upto,
+ 						   XLogRecPtr CurrPos);
+ static void WaitForXLogInsertionSlotToBecomeFree(void);
+ static char *GetXLogBuffer(XLogRecPtr ptr);
+ static XLogRecPtr AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr);
+ 
  
  /*
   * Insert an XLOG record having the specified RMID and info bytes,
***************
*** 687,698 **** XLogRecPtr
  XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
- 	XLogRecord *record;
- 	XLogContRecord *contrecord;
  	XLogRecPtr	RecPtr;
- 	XLogRecPtr	WriteRqst;
- 	uint32		freespace;
- 	int			curridx;
  	XLogRecData *rdt;
  	XLogRecData *rdt_lastnormal;
  	Buffer		dtbuf[XLR_MAX_BKP_BLOCKS];
--- 812,818 ----
***************
*** 706,715 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  	uint32		len,
  				write_len;
  	unsigned	i;
- 	bool		updrqst;
  	bool		doPageWrites;
  	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
  	uint8		info_orig = info;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
--- 826,835 ----
  	uint32		len,
  				write_len;
  	unsigned	i;
  	bool		doPageWrites;
  	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
  	uint8		info_orig = info;
+ 	XLogRecord	rechdr;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
***************
*** 896,1029 **** begin:;
  	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
  		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
- 	START_CRIT_SECTION();
- 
- 	/* Now wait to get insert lock */
- 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
- 
  	/*
! 	 * Check to see if my RedoRecPtr is out of date.  If so, may have to go
! 	 * back and recompute everything.  This can only happen just after a
! 	 * checkpoint, so it's better to be slow in this case and fast otherwise.
! 	 *
! 	 * If we aren't doing full-page writes then RedoRecPtr doesn't actually
! 	 * affect the contents of the XLOG record, so we'll update our local copy
! 	 * but not force a recomputation.
  	 */
! 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr))
! 	{
! 		Assert(XLByteLT(RedoRecPtr, Insert->RedoRecPtr));
! 		RedoRecPtr = Insert->RedoRecPtr;
  
! 		if (doPageWrites)
! 		{
! 			for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
! 			{
! 				if (dtbuf[i] == InvalidBuffer)
! 					continue;
! 				if (dtbuf_bkp[i] == false &&
! 					XLByteLE(dtbuf_lsn[i], RedoRecPtr))
! 				{
! 					/*
! 					 * Oops, this buffer now needs to be backed up, but we
! 					 * didn't think so above.  Start over.
! 					 */
! 					LWLockRelease(WALInsertLock);
! 					END_CRIT_SECTION();
! 					rdt_lastnormal->next = NULL;
! 					info = info_orig;
! 					goto begin;
! 				}
! 			}
! 		}
! 	}
  
  	/*
! 	 * Also check to see if forcePageWrites was just turned on; if we weren't
! 	 * already doing full-page writes then go back and recompute. (If it was
! 	 * just turned off, we could recompute the record without full pages, but
! 	 * we choose not to bother.)
  	 */
! 	if (Insert->forcePageWrites && !doPageWrites)
  	{
! 		/* Oops, must redo it with full-page data. */
! 		LWLockRelease(WALInsertLock);
! 		END_CRIT_SECTION();
  		rdt_lastnormal->next = NULL;
  		info = info_orig;
  		goto begin;
  	}
  
- 	/*
- 	 * If there isn't enough space on the current XLOG page for a record
- 	 * header, advance to the next page (leaving the unused space as zeroes).
- 	 */
- 	updrqst = false;
- 	freespace = INSERT_FREESPACE(Insert);
- 	if (freespace < SizeOfXLogRecord)
- 	{
- 		updrqst = AdvanceXLInsertBuffer(false);
- 		freespace = INSERT_FREESPACE(Insert);
- 	}
- 
- 	/* Compute record's XLOG location */
- 	curridx = Insert->curridx;
- 	INSERT_RECPTR(RecPtr, Insert, curridx);
- 
- 	/*
- 	 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
- 	 * segment, we need not insert it (and don't want to because we'd like
- 	 * consecutive switch requests to be no-ops).  Instead, make sure
- 	 * everything is written and flushed through the end of the prior segment,
- 	 * and return the prior segment's end address.
- 	 */
- 	if (isLogSwitch &&
- 		(RecPtr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
- 	{
- 		/* We can release insert lock immediately */
- 		LWLockRelease(WALInsertLock);
- 
- 		RecPtr.xrecoff -= SizeOfXLogLongPHD;
- 		if (RecPtr.xrecoff == 0)
- 		{
- 			/* crossing a logid boundary */
- 			RecPtr.xlogid -= 1;
- 			RecPtr.xrecoff = XLogFileSize;
- 		}
- 
- 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
- 		LogwrtResult = XLogCtl->Write.LogwrtResult;
- 		if (!XLByteLE(RecPtr, LogwrtResult.Flush))
- 		{
- 			XLogwrtRqst FlushRqst;
- 
- 			FlushRqst.Write = RecPtr;
- 			FlushRqst.Flush = RecPtr;
- 			XLogWrite(FlushRqst, false, false);
- 		}
- 		LWLockRelease(WALWriteLock);
- 
- 		END_CRIT_SECTION();
- 
- 		return RecPtr;
- 	}
- 
- 	/* Insert record header */
- 
- 	record = (XLogRecord *) Insert->currpos;
- 	record->xl_prev = Insert->PrevRecord;
- 	record->xl_xid = GetCurrentTransactionIdIfAny();
- 	record->xl_tot_len = SizeOfXLogRecord + write_len;
- 	record->xl_len = len;		/* doesn't include backup blocks */
- 	record->xl_info = info;
- 	record->xl_rmid = rmid;
- 
- 	/* Now we can finish computing the record's CRC */
- 	COMP_CRC32(rdata_crc, (char *) record + sizeof(pg_crc32),
- 			   SizeOfXLogRecord - sizeof(pg_crc32));
- 	FIN_CRC32(rdata_crc);
- 	record->xl_crc = rdata_crc;
- 
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
  	{
--- 1016,1055 ----
  	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
  		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
  	/*
! 	 * Construct record header. We can't CRC it yet, because the prev-link
! 	 * needs to be covered by the CRC and we don't know that yet. We will
! 	 * finish computing the CRC when we do.
  	 */
! 	MemSet(&rechdr, 0, sizeof(rechdr));
! 	/* rechdr.xl_prev is set in PerformXLogInsert() */
! 	rechdr.xl_xid = GetCurrentTransactionIdIfAny();
! 	rechdr.xl_tot_len = SizeOfXLogRecord + write_len;
! 	rechdr.xl_len = len;		/* doesn't include backup blocks */
! 	rechdr.xl_info = info;
! 	rechdr.xl_rmid = rmid;
  
! 	START_CRIT_SECTION();
  
  	/*
! 	 * Try to do the insertion.
  	 */
! 	RecPtr = PerformXLogInsert(write_len, isLogSwitch, &rechdr,
! 							   rdata, rdata_crc, doPageWrites);
! 	END_CRIT_SECTION();
! 
! 	if (XLogRecPtrIsInvalid(RecPtr))
  	{
! 		/*
! 		 * Oops, must redo it with full-page data. Unlink the backup blocks
! 		 * from the chain and reset info bitmask to undo the changes we've
! 		 * done.
! 		 */
  		rdt_lastnormal->next = NULL;
  		info = info_orig;
  		goto begin;
  	}
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
  	{
***************
*** 1032,1215 **** begin:;
  		initStringInfo(&buf);
  		appendStringInfo(&buf, "INSERT @ %X/%X: ",
  						 RecPtr.xlogid, RecPtr.xrecoff);
! 		xlog_outrec(&buf, record);
  		if (rdata->data != NULL)
  		{
  			appendStringInfo(&buf, " - ");
! 			RmgrTable[record->xl_rmid].rm_desc(&buf, record->xl_info, rdata->data);
  		}
  		elog(LOG, "%s", buf.data);
  		pfree(buf.data);
  	}
  #endif
  
! 	/* Record begin of record in appropriate places */
! 	ProcLastRecPtr = RecPtr;
! 	Insert->PrevRecord = RecPtr;
  
! 	Insert->currpos += SizeOfXLogRecord;
! 	freespace -= SizeOfXLogRecord;
  
  	/*
! 	 * Append the data, including backup blocks if any
  	 */
! 	while (write_len)
! 	{
! 		while (rdata->data == NULL)
! 			rdata = rdata->next;
  
! 		if (freespace > 0)
  		{
! 			if (rdata->len > freespace)
  			{
! 				memcpy(Insert->currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				write_len -= freespace;
! 			}
! 			else
! 			{
! 				memcpy(Insert->currpos, rdata->data, rdata->len);
! 				freespace -= rdata->len;
! 				write_len -= rdata->len;
! 				Insert->currpos += rdata->len;
! 				rdata = rdata->next;
! 				continue;
  			}
  		}
  
! 		/* Use next buffer */
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		curridx = Insert->curridx;
! 		/* Insert cont-record header */
! 		Insert->currpage->xlp_info |= XLP_FIRST_IS_CONTRECORD;
! 		contrecord = (XLogContRecord *) Insert->currpos;
! 		contrecord->xl_rem_len = write_len;
! 		Insert->currpos += SizeOfXLogContRecord;
! 		freespace = INSERT_FREESPACE(Insert);
  	}
  
! 	/* Ensure next record will be properly aligned */
! 	Insert->currpos = (char *) Insert->currpage +
! 		MAXALIGN(Insert->currpos - (char *) Insert->currpage);
! 	freespace = INSERT_FREESPACE(Insert);
  
  	/*
! 	 * The recptr I return is the beginning of the *next* record. This will be
! 	 * stored as LSN for changed data pages...
  	 */
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, we must now write and flush all the
! 	 * existing data, and then forcibly advance to the start of the next
! 	 * segment.  It's not good to do this I/O while holding the insert lock,
! 	 * but there seems too much risk of confusion if we try to release the
! 	 * lock sooner.  Fortunately xlog switch needn't be a high-performance
! 	 * operation anyway...
  	 */
! 	if (isLogSwitch)
  	{
! 		XLogCtlWrite *Write = &XLogCtl->Write;
! 		XLogwrtRqst FlushRqst;
! 		XLogRecPtr	OldSegEnd;
  
! 		TRACE_POSTGRESQL_XLOG_SWITCH();
  
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  
  		/*
! 		 * Flush through the end of the page containing XLOG_SWITCH, and
! 		 * perform end-of-segment actions (eg, notifying archiver).
  		 */
! 		WriteRqst = XLogCtl->xlblocks[curridx];
! 		FlushRqst.Write = WriteRqst;
! 		FlushRqst.Flush = WriteRqst;
! 		XLogWrite(FlushRqst, false, true);
! 
! 		/* Set up the next buffer as first page of next segment */
! 		/* Note: AdvanceXLInsertBuffer cannot need to do I/O here */
! 		(void) AdvanceXLInsertBuffer(true);
! 
! 		/* There should be no unwritten data */
! 		curridx = Insert->curridx;
! 		Assert(curridx == Write->curridx);
! 
! 		/* Compute end address of old segment */
! 		OldSegEnd = XLogCtl->xlblocks[curridx];
! 		OldSegEnd.xrecoff -= XLOG_BLCKSZ;
! 		if (OldSegEnd.xrecoff == 0)
! 		{
! 			/* crossing a logid boundary */
! 			OldSegEnd.xlogid -= 1;
! 			OldSegEnd.xrecoff = XLogFileSize;
! 		}
  
! 		/* Make it look like we've written and synced all of old segment */
! 		LogwrtResult.Write = OldSegEnd;
! 		LogwrtResult.Flush = OldSegEnd;
  
  		/*
! 		 * Update shared-memory status --- this code should match XLogWrite
  		 */
  		{
! 			/* use volatile pointer to prevent code rearrangement */
! 			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			SpinLockAcquire(&xlogctl->info_lck);
! 			xlogctl->LogwrtResult = LogwrtResult;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, LogwrtResult.Write))
! 				xlogctl->LogwrtRqst.Write = LogwrtResult.Write;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Flush, LogwrtResult.Flush))
! 				xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
! 			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		Write->LogwrtResult = LogwrtResult;
  
! 		LWLockRelease(WALWriteLock);
  
! 		updrqst = false;		/* done already */
  	}
  	else
  	{
! 		/* normal case, ie not xlog switch */
  
! 		/* Need to update shared LogwrtRqst if some block was filled up */
! 		if (freespace < SizeOfXLogRecord)
  		{
! 			/* curridx is filled and available for writing out */
! 			updrqst = true;
  		}
  		else
  		{
! 			/* if updrqst already set, write through end of previous buf */
! 			curridx = PrevBufIdx(curridx);
  		}
- 		WriteRqst = XLogCtl->xlblocks[curridx];
  	}
  
! 	LWLockRelease(WALInsertLock);
  
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
  
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, WriteRqst))
! 			xlogctl->LogwrtRqst.Write = WriteRqst;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
  	}
  
! 	XactLastRecEnd = RecPtr;
  
! 	END_CRIT_SECTION();
  
! 	return RecPtr;
  }
  
  /*
--- 1058,1762 ----
  		initStringInfo(&buf);
  		appendStringInfo(&buf, "INSERT @ %X/%X: ",
  						 RecPtr.xlogid, RecPtr.xrecoff);
! 		xlog_outrec(&buf, &rechdr);
  		if (rdata->data != NULL)
  		{
  			appendStringInfo(&buf, " - ");
! 			RmgrTable[rmid].rm_desc(&buf, rechdr.xl_info, rdata->data);
  		}
  		elog(LOG, "%s", buf.data);
  		pfree(buf.data);
  	}
  #endif
  
! 	/*
! 	 * The recptr I return is the beginning of the *next* record. This will be
! 	 * stored as LSN for changed data pages...
! 	 */
! 	return RecPtr;
! }
  
! /*
!  * Subroutine of XLogInsert. All the changes to shared state are done here,
!  * XLogInsert only prepares the record for insertion.
!  *
!  * On success, returns pointer to end of inserted record like XLogInsert().
!  * If RedoRecPtr or forcePageWrites had changed, returns InvalidRecPtr, and
!  * the caller must recalculate full-page-images and retry.
!  */
! static XLogRecPtr
! PerformXLogInsert(int write_len, bool isLogSwitch, XLogRecord *rechdr,
! 				  XLogRecData *rdata, pg_crc32 rdata_crc,
! 				  bool didPageWrites)
! {
! 	volatile XLogInsertSlot *myslot = NULL;
! 	char	   *currpos;
! 	XLogRecord *record;
! 	int			tot_len;
! 	int			freespace;
! 	int			written;
! 	XLogRecPtr	PrevRecord;
! 	XLogRecPtr	StartPos;
! 	XLogRecPtr	EndPos;
! 	XLogRecPtr	CurrPos;
! 	bool		updrqst;
! 
! 	/* Get an insert location  */
! 	tot_len = SizeOfXLogRecord + write_len;
! 	if (!ReserveXLogInsertLocation(tot_len, didPageWrites, isLogSwitch,
! 								   &PrevRecord, &StartPos, &EndPos,
! 								   (XLogInsertSlot **) &myslot, &updrqst))
! 	{
! 		return EndPos;
! 	}
  
  	/*
! 	 * Got it! Now that we know the prev-link, we can finish computing the
! 	 * record's CRC.
  	 */
! 	rechdr->xl_prev = PrevRecord;
! 
! 	/* Get the right WAL page to start inserting to */
! 	CurrPos = StartPos;
! 	currpos = GetXLogBuffer(CurrPos);
  
! 	/* Copy the record header in place */
! 	record = (XLogRecord *) currpos;
! 	memcpy(record, rechdr, sizeof(XLogRecord));
! 	COMP_CRC32(rdata_crc, currpos + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	record->xl_crc = rdata_crc;
! 
! 	currpos += SizeOfXLogRecord;
! 	CurrPos.xrecoff += SizeOfXLogRecord;
! 
! 	if (!isLogSwitch)
! 	{
! 		/* Copy record data */
! 		written = 0;
! 		freespace = INSERT_FREESPACE(CurrPos);
! 		while (rdata != NULL)
  		{
! 			while (rdata->len > freespace)
  			{
! 				/*
! 				 * Write what fits on this page, then write the continuation
! 				 * record, and continue.
! 				 */
! 				XLogContRecord *contrecord;
! 
! 				memcpy(currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				written += freespace;
! 				CurrPos.xrecoff += freespace;
! 
! 				/*
! 				 * CurrPos now points to the page boundary, ie. the first byte
! 				 * of the next page. Update CurrPos with that before
! 				 * calling GetXLogBuffer(), because GetXLogBuffer() might need
! 				 * to wait for some insertions to finish so that it can write
! 				 * out a buffer to make room for the new page. Updating CurrPos
! 				 * before waiting for a new buffer ensures that we don't
! 				 * deadlock with ourselves if we run out of clean buffers.
! 				 *
! 				 * However, we must not advance CurrPos past the page header
! 				 * yet, otherwise someone might try to flush up to that point,
! 				 * which would fail if the next page was not initialized yet.
! 				 */
! 				UpdateSlotCurrPos(myslot, CurrPos);
! 
! 				/* Now skip page header */
! 				CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
! 
! 				currpos = GetXLogBuffer(CurrPos);
! 
! 				contrecord = (XLogContRecord *) currpos;
! 				contrecord->xl_rem_len = write_len - written;
! 
! 				currpos += SizeOfXLogContRecord;
! 				CurrPos.xrecoff += SizeOfXLogContRecord;
! 
! 				freespace = INSERT_FREESPACE(CurrPos);
  			}
+ 
+ 			memcpy(currpos, rdata->data, rdata->len);
+ 			currpos += rdata->len;
+ 			CurrPos.xrecoff += rdata->len;
+ 			freespace -= rdata->len;
+ 			written += rdata->len;
+ 
+ 			rdata = rdata->next;
  		}
+ 		Assert(written == write_len);
  
! 		CurrPos.xrecoff = MAXALIGN(CurrPos.xrecoff);
! 		Assert(XLByteEQ(CurrPos, EndPos));
  	}
+ 	else
+ 	{
+ 		/* An xlog-switch record doesn't contain any data besides the header */
+ 		Assert(write_len == 0);
+ 
+ 		/*
+ 		 * An xlog-switch record consumes all the remaining space on the
+ 		 * WAL segment. We have already reserved it for us, but we still need
+ 		 * to make sure it's been allocated and zeroed in the WAL buffers so
+ 		 * that when the caller (or someone else) does XLogWrite(), it can
+ 		 * really write out all the zeros.
+ 		 *
+ 		 * We do this one page at a time, to make sure we don't deadlock
+ 		 * against ourselves if wal_buffers < XLOG_SEG_SIZE.
+ 		 */
+ 		while (XLByteLT(CurrPos, EndPos))
+ 		{
+ 			/* use up all the remaining space in this page */
+ 			freespace = INSERT_FREESPACE(CurrPos);
+ 			XLByteAdvance(CurrPos, freespace);
+ 			/*
+ 			 * like in the non-xlog-switch codepath, let others know that
+ 			 * we're done writing up to the end of this page
+ 			 */
+ 			UpdateSlotCurrPos(myslot, CurrPos);
+ 			/*
+ 			 * let GetXLogBuffer initialize next page if necessary.
+ 			 */
+ 			CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
+ 			(void) GetXLogBuffer(CurrPos);
+ 		}
  
! 		/*
! 		 * Even though we reserved the rest of the segment for us, which
! 		 * is reflected in EndPos, we need to return a value that points just
! 		 * to the end of the xlog-switch record.
! 		 */
! 		EndPos.xlogid = StartPos.xlogid;
! 		EndPos.xrecoff = StartPos.xrecoff + SizeOfXLogRecord;
! 	}
  
  	/*
! 	 * Done! Clear CurrPos in our slot to let others know that we're
! 	 * finished.
  	 */
! 	UpdateSlotCurrPos(myslot, InvalidXLogRecPtr);
  
  	/*
! 	 * Update shared LogwrtRqst.Write, if we crossed page boundary.
  	 */
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
! 
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, EndPos))
! 			xlogctl->LogwrtRqst.Write = EndPos;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
! 	}
  
! 	/* update our global variables */
! 	ProcLastRecPtr = StartPos;
! 	XactLastRecEnd = EndPos;
  
! 	return EndPos;
! }
  
+ /*
+  * Reserves the right amount of space for a record of given size from the WAL.
+  * *StartPos_p is set to the beginning of the reserved section, *EndPos_p to
+  * its end, and *Prev_record_p points to the beginning of the previous record
+  * to set to the prev-link of the record header.
+  *
+  * A log-switch record is handled slightly differently. The rest of the
+  * segment will be reserved for this insertion, as indicated by the returned
+  * *EndPos_p value. However, if we are already at the beginning of the current
+  * segment, the *EndPos_p is set to the current location without reserving
+  * any space, and the function returns false.
+  *
+  * *updrqst_p is set to true, if this record ends on different page than
+  * the previous one - the caller should update the shared LogwrtRqst value
+  * after it's done inserting the record in that case, so that the WAL page
+  * that filled up gets written out at the next convenient moment.
+  *
+  * While holding insertpos_lck, sets myslot->CurrPos to the starting position,
+  * (or the end of previous record, to be exact) to let others know that we're
+  * busy inserting to the reserved area. The caller must clear it when the
+  * insertion is finished.
+  *
+  * Returns true on success, or false if RedoRecPtr or forcePageWrites was
+  * changed. On failure, the shared state is not modified.
+  *
+  * This is the performance critical part of XLogInsert that must be
+  * serialized across backends. The rest can happen mostly in parallel.
+  *
+  * NB: The space calculation here must match the code in PerformXLogInsert,
+  * where we actually copy the record to the reserved space.
+  */
+ static bool
+ ReserveXLogInsertLocation(int size, bool didPageWrites,
+ 						  bool isLogSwitch,
+ 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
+ 						  XLogRecPtr *EndPos_p,
+ 						  XLogInsertSlot **myslot_p, bool *updrqst_p)
+ {
+ 	volatile XLogInsertSlot *myslot;
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 	int			freespace;
+ 	XLogRecPtr	ptr;
+ 	XLogRecPtr	StartPos;
+ 	XLogRecPtr	LastEndPos;
+ 	int32		nextslot;
+ 	int32		lastslot;
+ 	bool		updrqst = false;
+ 
+ retry:
+ 	SpinLockAcquire(&Insert->insertpos_lck);
+ 
+ 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr) ||
+ 		(!didPageWrites && Insert->forcePageWrites))
+ 	{
  		/*
! 		 * Oops, a checkpoint just happened, or forcePageWrites was just
! 		 * turned on. Start XLogInsert() all over, because we might have to
! 		 * include more full-page images in the record.
  		 */
! 		RedoRecPtr = Insert->RedoRecPtr;
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		*EndPos_p = InvalidXLogRecPtr;
! 		return false;
! 	}
! 
! 	/*
! 	 * Reserve the next insertion slot for us.
! 	 *
! 	 * First check that the slot is not still in use. Modifications to
! 	 * lastslot are protected by WALInsertTailLock, but here we assume that
! 	 * reading an int32 is atomic. Another process might advance lastslot at
! 	 * the same time, but not past nextslot.
! 	 */
! 	lastslot = Insert->lastslot;
! 	nextslot = Insert->nextslot;
! 	if (NextSlotNo(nextslot) == lastslot)
! 	{
! 		/*
! 		 * Oops, we've "caught our tail" and the oldest slot is still in use.
! 		 * Have to wait for it to become vacant.
! 		 */
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		WaitForXLogInsertionSlotToBecomeFree();
! 		goto retry;
! 	}
! 	myslot = &XLogCtl->XLogInsertSlots[nextslot];
! 	nextslot = NextSlotNo(nextslot);
  
! 	/*
! 	 * Got the slot, now reserve the right amount of space from the WAL for
! 	 * our record.
! 	 */
! 	LastEndPos = ptr = Insert->CurrPos;
! 	*PrevRecord_p = Insert->PrevRecord;
  
+ 	/*
+ 	 * If there isn't enough space on the current XLOG page for a record
+ 	 * header, advance to the next page (leaving the unused space as zeroes).
+ 	 */
+ 	freespace = INSERT_FREESPACE(ptr);
+ 	if (freespace < SizeOfXLogRecord)
+ 	{
+ 		ptr = AdvanceXLogRecPtrToNextPage(ptr);
+ 		freespace = INSERT_FREESPACE(ptr);
+ 		updrqst = true;
+ 	}
+ 
+ 	/*
+ 	 * We are now at the starting position of our record. Now figure out how
+ 	 * the data will be split across the WAL pages, to calculate where the
+ 	 * record ends.
+ 	 */
+ 	StartPos = ptr;
+ 
+ 	if (isLogSwitch)
+ 	{
  		/*
! 		 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
! 		 * segment, we need not insert it (and don't want to because we'd like
! 		 * consecutive switch requests to be no-ops). Otherwise the XLOG_SWITCH
! 		 * record should consume all the remaining space on the current segment.
  		 */
+ 		Assert(size == SizeOfXLogRecord);
+ 		if ((ptr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
  		{
! 			/* We can release insert lock immediately */
! 			SpinLockRelease(&Insert->insertpos_lck);
  
! 			ptr.xrecoff -= SizeOfXLogLongPHD;
! 			if (ptr.xrecoff == 0)
! 			{
! 				/* crossing a logid boundary */
! 				ptr.xlogid -= 1;
! 				ptr.xrecoff = XLogFileSize;
! 			}
! 
! 			*EndPos_p = ptr;
! 			*StartPos_p = ptr;
! 			*myslot_p = NULL;
! 
! 			return false;
  		}
+ 		else
+ 		{
+ 			if (ptr.xrecoff % XLOG_SEG_SIZE != 0)
+ 			{
+ 				int segleft = XLOG_SEG_SIZE - (ptr.xrecoff % XLOG_SEG_SIZE);
+ 				XLByteAdvance(ptr, segleft);
+ 			}
+ 			updrqst = true;
+ 		}
+ 	}
+ 	else
+ 	{
+ 		/* A normal record, ie. not xlog-switch */
+ 		int sizeleft = size;
+ 		while (freespace < sizeleft)
+ 		{
+ 			/* fill this page, and continue on next page */
+ 			sizeleft -= freespace;
+ 			ptr = AdvanceXLogRecPtrToNextPage(ptr);
  
! 			/* account for continuation record header */
! 			ptr.xrecoff += SizeOfXLogContRecord;
! 			freespace = INSERT_FREESPACE(ptr);
  
! 			updrqst = true;
! 		}
! 		/* the rest fits on this page */
! 		ptr.xrecoff += sizeleft;
! 
! 		/* Align the end position, so that the next record starts aligned */
! 		ptr.xrecoff = MAXALIGN(ptr.xrecoff);
! 	}
! 
! 	/* Update the shared state, and our slot, before releasing the lock */
! 	myslot->CurrPos = LastEndPos;
! 	Insert->CurrPos = ptr;
! 	Insert->PrevRecord = StartPos;
! 	Insert->nextslot = nextslot;
! 
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! #ifdef RESERVE_XLOGINSERT_LOCATION_DEBUG
! 	elog(LOG, "reserved xlog: prev %X/%X, start %X/%X, end %X/%X (len %d)",
! 		 PrevRecord_p->xlogid, PrevRecord_p->xrecoff,
! 		 StartPos.xlogid, StartPos.xrecoff,
! 		 ptr.xlogid, ptr.xrecoff,
! 		 size);
! #endif
! 
! 	*EndPos_p = ptr;
! 	*StartPos_p = StartPos;
! 	*myslot_p = (XLogInsertSlot *) myslot;
! 	*updrqst_p = updrqst;
! 
! 	return true;
! }
! 
! /*
!  * Update slot's CurrPos variable, and wake up anyone waiting on it.
!  */
! static void
! UpdateSlotCurrPos(volatile XLogInsertSlot *myslot, XLogRecPtr CurrPos)
! {
! 	PGPROC	   *head;
! 
! 	/*
! 	 * The write-barrier ensures that the changes we made to the WAL pages
! 	 * are visible to everyone before the update of CurrPos.
! 	 *
! 	 * XXX: I'm not sure if this is necessary. Does a function call act
! 	 * as an implicit barrier?
! 	 */
! 	pg_write_barrier();
! 
! 	SpinLockAcquire(&myslot->lck);
! 	myslot->CurrPos = CurrPos;
! 	head = myslot->head;
! 	myslot->head = myslot->tail = NULL;
! 	SpinLockRelease(&myslot->lck);
! 	while (head != NULL)
! 	{
! 		PGPROC *proc = head;
! 		head = proc->lwWaitLink;
! 		proc->lwWaitLink = NULL;
! 		proc->lwWaiting = false;
! 		PGSemaphoreUnlock(&proc->sem);
! 	}
! }
! 
! /*
!  * Get a pointer to the right location in the WAL buffer containing the
!  * given XLogRecPtr.
!  *
!  * If the page is not initialized yet, it is initialized. That might require
!  * evicting an old dirty buffer from the buffer cache, which means I/O.
!  *
!  * The caller must ensure that the page containing the requested location
!  * isn't evicted yet, and won't be evicted, by holding onto an
!  * XLogInsertSlot with CurrPos set to 'ptr'. Setting it to some value
!  * less than 'ptr' would suffice for GetXLogBuffer(), but risks deadlock:
!  * if we have to evict a buffer, we might have to wait for someone else to
!  * finish a write. And that someone else might not be able to finish the write
!  * if our CurrPos points to a buffer that's still in the buffer cache.
!  */
! static char *
! GetXLogBuffer(XLogRecPtr ptr)
! {
! 	int			idx;
! 	XLogRecPtr	endptr;
! 
! 	/*
! 	 * The XLog buffer cache is organized so that we can easily calculate the
! 	 * buffer a given page must be loaded into from the XLogRecPtr alone.
! 	 * A page must always be loaded to a particular buffer.
! 	 */
! 	idx = XLogRecPtrToBufIdx(ptr);
! 
! 	/*
! 	 * See what page is loaded in the buffer at the moment. It could be the
! 	 * page we're looking for, or something older. It can't be anything
! 	 * newer - that would imply the page we're looking for has already
! 	 * been written out to disk, which shouldn't happen as long as the caller
! 	 * has set its slot's CurrPos correctly.
! 	 *
! 	 * However, we don't hold a lock while we read the value. If someone has
! 	 * just initialized the page, it's possible that we get a "torn read",
! 	 * and read a bogus value. That's ok, we'll grab the mapping lock (in
! 	 * AdvanceXLInsertBuffer) and retry if we see anything else than the page
! 	 * we're looking for. But it means that when we do this unlocked read, we
! 	 * might see a value that appears to be ahead of the page we're looking
! 	 * for. So don't PANIC on that, until we've verified the value while
! 	 * holding the lock.
! 	 */
! 	endptr = XLogCtl->xlblocks[idx];
! 	if (ptr.xlogid != endptr.xlogid ||
! 		!(ptr.xrecoff < endptr.xrecoff &&
! 		  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
! 	{
! 		AdvanceXLInsertBuffer(ptr, false);
! 		endptr = XLogCtl->xlblocks[idx];
  
! 		if (ptr.xlogid != endptr.xlogid ||
! 			!(ptr.xrecoff < endptr.xrecoff &&
! 			  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
! 		{
! 			elog(PANIC, "could not find WAL buffer for %X/%X",
! 				 ptr.xlogid, ptr.xrecoff);
! 		}
  	}
+ 
+ 	/*
+ 	 * Found the buffer holding this page. Return a pointer to the right
+ 	 * offset within the page.
+ 	 */
+ 	return (char *) XLogCtl->pages + idx * (Size) XLOG_BLCKSZ +
+ 		ptr.xrecoff % XLOG_BLCKSZ;
+ }
+ 
+ /*
+  * Advance an XLogRecPtr to the first valid insertion location on the next
+  * page, right after the page header. An XLogRecPtr pointing to a boundary,
+  * ie. the first byte of a page, is taken to belong to the previous page.
+  */
+ static XLogRecPtr
+ AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr)
+ {
+ 	int			freespace;
+ 
+ 	freespace = INSERT_FREESPACE(ptr);
+ 	XLByteAdvance(ptr, freespace);
+ 	if (ptr.xrecoff % XLogSegSize == 0)
+ 		ptr.xrecoff += SizeOfXLogLongPHD;
  	else
+ 		ptr.xrecoff += SizeOfXLogShortPHD;
+ 
+ 	return ptr;
+ }
+ 
+ /*
+  * Wait for any insertions < upto to finish.
+  *
+  * Returns a value >= upto, which indicates the oldest in-progress insertion
+  * that we saw in the array, or CurrPos if there are no insertions in-progress
+  * at exit.
+  */
+ static XLogRecPtr
+ WaitXLogInsertionsToFinish(XLogRecPtr upto, XLogRecPtr CurrPos)
+ {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 	int			lastslot;
+ 	int			nextslot;
+ 	volatile XLogInsertSlot *slot;
+ 	XLogRecPtr	slotptr = InvalidXLogRecPtr;
+ 	XLogRecPtr	LastPos;
+ 	int			extraWaits = 0;
+ 
+ 	if (MyProc == NULL)
+ 		elog(PANIC, "cannot wait without a PGPROC structure");
+ 
+ 	LastPos = CurrPos;
+ 
+ 	LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
+ 
+ 	lastslot = Insert->lastslot;
+ 	nextslot = Insert->nextslot;
+ 
+ 	/* Skip over slots that have finished already */
+ 	while (lastslot != nextslot)
  	{
! 		slot = &XLogCtl->XLogInsertSlots[lastslot];
! 		SpinLockAcquire(&slot->lck);
! 		slotptr = slot->CurrPos;
  
! 		if (XLogRecPtrIsInvalid(slotptr))
  		{
! 			lastslot = NextSlotNo(lastslot);
! 			SpinLockRelease(&slot->lck);
  		}
  		else
  		{
! 			/*
! 			 * This insertion is still in-progress. Wait for it to finish
! 			 * if it's <= upto, otherwise we're done.
! 			 */
! 			Insert->lastslot = lastslot;
! 
! 			if (XLogRecPtrIsInvalid(upto) || XLByteLE(upto, slotptr))
! 			{
! 				LastPos = slotptr;
! 				SpinLockRelease(&slot->lck);
! 				break;
! 			}
! 
! 			/* wait */
! 			MyProc->lwWaiting = true;
! 			MyProc->lwExclusive = false;
! 			MyProc->lwWaitLink = NULL;
! 			if (slot->head == NULL)
! 				slot->head = MyProc;
! 			else
! 				slot->tail->lwWaitLink = MyProc;
! 			slot->tail = MyProc;
! 			SpinLockRelease(&slot->lck);
! 			LWLockRelease(WALInsertTailLock);
! 			for (;;)
! 			{
! 				PGSemaphoreLock(&MyProc->sem, false);
! 				if (!MyProc->lwWaiting)
! 					break;
! 				extraWaits++;
! 			}
! 			LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
! 			lastslot = Insert->lastslot;
! 			nextslot = Insert->nextslot;
  		}
  	}
  
! 	Insert->lastslot = lastslot;
! 	LWLockRelease(WALInsertTailLock);
  
! 	while (extraWaits-- > 0)
! 		PGSemaphoreUnlock(&MyProc->sem);
! 
! 	return LastPos;
! }
! 
! /*
!  * Wait for the next insertion slot to become vacant.
!  */
! static void
! WaitForXLogInsertionSlotToBecomeFree(void)
! {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			lastslot;
! 	int			nextslot;
! 	int			extraWaits = 0;
! 
! 	if (MyProc == NULL)
! 		elog(PANIC, "cannot wait without a PGPROC structure");
! 
! 	LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
! 
! 	/*
! 	 * Re-read lastslot and nextslot, now that we have the wait-lock.
! 	 * We're reading nextslot without holding insertpos_lck. It could advance
! 	 * at the same time, but it can't advance beyond lastslot - 1.
! 	 */
! 	lastslot = Insert->lastslot;
! 	nextslot = Insert->nextslot;
! 
! 	/*
! 	 * If there are still no slots available, wait for the oldest slot to
! 	 * become vacant.
! 	 */
! 	while (NextSlotNo(nextslot) == lastslot)
  	{
! 		volatile XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[lastslot];
  
! 		SpinLockAcquire(&slot->lck);
! 		if (XLogRecPtrIsInvalid(slot->CurrPos))
! 		{
! 			SpinLockRelease(&slot->lck);
! 			break;
! 		}
! 
! 		/* wait */
! 		MyProc->lwWaiting = true;
! 		MyProc->lwExclusive = false;
! 		MyProc->lwWaitLink = NULL;
! 		if (slot->head == NULL)
! 			slot->head = MyProc;
! 		else
! 			slot->tail->lwWaitLink = MyProc;
! 		slot->tail = MyProc;
! 		SpinLockRelease(&slot->lck);
! 		LWLockRelease(WALInsertTailLock);
! 		for (;;)
! 		{
! 			PGSemaphoreLock(&MyProc->sem, false);
! 			if (!MyProc->lwWaiting)
! 				break;
! 			extraWaits++;
! 		}
! 		LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
! 		lastslot = Insert->lastslot;
! 		nextslot = Insert->nextslot;
  	}
  
! 	/*
! 	 * Ok, there is at least one empty slot now. That's enouugh for our
! 	 * insertion, but ẃhile we're at it, advance lastslot as much as we
! 	 * can. That way we don't need to come back here on the next call
! 	 * again.
! 	 */
! 	while (lastslot != nextslot)
! 	{
! 		volatile XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[lastslot];
! 		/*
! 		 * Don't need to grab the slot's spinlock here, because we're not
! 		 * interested in the exact value of CurrPos, only whether it's
! 		 * valid or not.
! 		 */
! 		if (!XLogRecPtrIsInvalid(slot->CurrPos))
! 			break;
  
! 		lastslot = NextSlotNo(lastslot);
! 	}
! 	Insert->lastslot = lastslot;
  
! 	LWLockRelease(WALInsertTailLock);
  }
  
  /*
***************
*** 1436,1470 **** XLogArchiveCleanup(const char *xlog)
  }
  
  /*
!  * Advance the Insert state to the next buffer page, writing out the next
!  * buffer if it still contains unwritten data.
!  *
!  * If new_segment is TRUE then we set up the next buffer page as the first
!  * page of the next xlog segment file, possibly but not usually the next
!  * consecutive file page.
!  *
!  * The global LogwrtRqst.Write pointer needs to be advanced to include the
!  * just-filled page.  If we can do this for free (without an extra lock),
!  * we do so here.  Otherwise the caller must do it.  We return TRUE if the
!  * request update still needs to be done, FALSE if we did it internally.
!  *
!  * Must be called with WALInsertLock held.
   */
! static bool
! AdvanceXLInsertBuffer(bool new_segment)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	XLogCtlWrite *Write = &XLogCtl->Write;
! 	int			nextidx = NextBufIdx(Insert->curridx);
! 	bool		update_needed = true;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
! 	XLogRecPtr	NewPageEndPtr;
  	XLogPageHeader NewPage;
  
! 	/* Use Insert->LogwrtResult copy if it's more fresh */
! 	if (XLByteLT(LogwrtResult.Write, Insert->LogwrtResult.Write))
! 		LogwrtResult = Insert->LogwrtResult;
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
--- 1983,2016 ----
  }
  
  /*
!  * Initialize XLOG buffers, writing out old buffers if they still contain
!  * unwritten data, upto the page containing 'upto'. Or if 'opportunistic' is
!  * true, initialize as many pages as we can without having to write out
!  * unwritten data. Any new pages are initialized to zeros, with pages headers
!  * initialized properly.
   */
! static void
! AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			nextidx;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
! 	XLogRecPtr	NewPageEndPtr = InvalidXLogRecPtr;
  	XLogPageHeader NewPage;
+ 	bool		needflush;
+ 	int			npages = 0;
  
! 	LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
! 
! 	/*
! 	 * Now that we have the lock, check if someone initialized the page
! 	 * already.
! 	 */
! /* XXX: fix indentation before commit */
! while (!XLByteLT(upto, XLogCtl->xlblocks[XLogCtl->curridx]) || opportunistic)
! {
! 	nextidx = NextBufIdx(XLogCtl->curridx);
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
***************
*** 1472,1483 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
- 	if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
- 	{
- 		/* nope, got work to do... */
- 		XLogRecPtr	FinishedPageRqstPtr;
  
! 		FinishedPageRqstPtr = XLogCtl->xlblocks[Insert->curridx];
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
--- 2018,2034 ----
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
  
! 	needflush = !XLByteLE(OldPageRqstPtr, LogwrtResult.Write);
! 
! 	if (needflush)
! 	{
! 		/*
! 		 * Nope, got work to do. If we just want to pre-initialize as much as
! 		 * we can without flushing, give up now.
! 		 */
! 		if (opportunistic)
! 			break;
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
***************
*** 1485,1529 **** AdvanceXLInsertBuffer(bool new_segment)
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, FinishedPageRqstPtr))
! 				xlogctl->LogwrtRqst.Write = FinishedPageRqstPtr;
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		update_needed = false;	/* Did the shared-request update */
! 
! 		if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/* OK, someone wrote it already */
! 			Insert->LogwrtResult = LogwrtResult;
! 		}
! 		else
! 		{
! 			/* Must acquire write lock */
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 			LogwrtResult = Write->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding insert lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false, false);
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
  		}
  	}
  
--- 2036,2085 ----
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, OldPageRqstPtr))
! 			{
! 				Assert(XLByteLE(OldPageRqstPtr, xlogctl->Insert.CurrPos));
! 				xlogctl->LogwrtRqst.Write = OldPageRqstPtr;
! 			}
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/*
! 			 * Must acquire write lock. Release WALBufMappingLock first, to
! 			 * make sure that all insertions that we need to wait for can
! 			 * finish (up to this same position). Otherwise we risk deadlock.
! 			 */
! 			LWLockRelease(WALBufMappingLock);
! 
! 			WaitXLogInsertionsToFinish(OldPageRqstPtr, InvalidXLogRecPtr);
! 
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 			LogwrtResult = XLogCtl->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding mapping lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false);
  				LWLockRelease(WALWriteLock);
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
+ 			/* Re-acquire WALBufMappingLock and retry */
+ 			LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
+ 			continue;
  		}
  	}
  
***************
*** 1531,1544 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[Insert->curridx];
! 
! 	if (new_segment)
! 	{
! 		/* force it to a segment start point */
! 		NewPageEndPtr.xrecoff += XLogSegSize - 1;
! 		NewPageEndPtr.xrecoff -= NewPageEndPtr.xrecoff % XLogSegSize;
! 	}
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
--- 2087,2093 ----
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[XLogCtl->curridx];
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
***************
*** 1548,1560 **** AdvanceXLInsertBuffer(bool new_segment)
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
! 	XLogCtl->xlblocks[nextidx] = NewPageEndPtr;
! 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
! 	Insert->curridx = nextidx;
! 	Insert->currpage = NewPage;
! 
! 	Insert->currpos = ((char *) NewPage) +SizeOfXLogShortPHD;
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
--- 2097,2106 ----
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
! 	Assert(NewPageEndPtr.xrecoff % XLOG_BLCKSZ == 0);
! 	Assert(XLogRecEndPtrToBufIdx(NewPageEndPtr) == nextidx);
  
! 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
***************
*** 1598,1608 **** AdvanceXLInsertBuffer(bool new_segment)
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
- 
- 		Insert->currpos = ((char *) NewPage) +SizeOfXLogLongPHD;
  	}
  
! 	return update_needed;
  }
  
  /*
--- 2144,2171 ----
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
  	}
  
! 	/*
! 	 * Make sure the initialization of the page becomes visible to others
! 	 * before the xlblocks update. GetXLogBuffer() reads xlblocks without
! 	 * holding a lock.
! 	 */
! 	pg_write_barrier();
! 
! 	*((volatile XLogRecPtr *) &XLogCtl->xlblocks[nextidx]) = NewPageEndPtr;
! 
! 	XLogCtl->curridx = nextidx;
! 
! 	npages++;
! }
! 	LWLockRelease(WALBufMappingLock);
! 
! #ifdef WAL_DEBUG
! 	if (npages > 0)
! 		elog(DEBUG1, "initialized %d pages, upto %X/%X",
! 			 npages, NewPageEndPtr.xlogid, NewPageEndPtr.xrecoff);
! #endif
  }
  
  /*
***************
*** 1647,1662 **** XLogCheckpointNeeded(uint32 logid, uint32 logseg)
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * If xlog_switch == TRUE, we are intending an xlog segment switch, so
!  * perform end-of-segment actions after writing the last page, even if
!  * it's not physically the end of its segment.  (NB: this will work properly
!  * only if caller specifies WriteRqst == page-end and flexible == false,
!  * and there is some data to write.)
!  *
!  * Must be called with WALWriteLock held.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
--- 2210,2221 ----
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * Must be called with WALWriteLock held. And you must've called
!  * WaitXLogInsertionsToFinish(WriteRqst) before grabbing the lock to make sure
!  * the data is ready to write.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
***************
*** 1674,1680 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  	/*
  	 * Update local LogwrtResult (caller probably did this already, but...)
  	 */
! 	LogwrtResult = Write->LogwrtResult;
  
  	/*
  	 * Since successive pages in the xlog cache are consecutively allocated,
--- 2233,2239 ----
  	/*
  	 * Update local LogwrtResult (caller probably did this already, but...)
  	 */
! 	LogwrtResult = XLogCtl->LogwrtResult;
  
  	/*
  	 * Since successive pages in the xlog cache are consecutively allocated,
***************
*** 1705,1718 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  		 * if we're passed a bogus WriteRqst.Write that is past the end of the
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
! 		if (!XLByteLT(LogwrtResult.Write, XLogCtl->xlblocks[curridx]))
  			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
! 				 XLogCtl->xlblocks[curridx].xlogid,
! 				 XLogCtl->xlblocks[curridx].xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
! 		LogwrtResult.Write = XLogCtl->xlblocks[curridx];
  		ispartialpage = XLByteLT(WriteRqst.Write, LogwrtResult.Write);
  
  		if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
--- 2264,2277 ----
  		 * if we're passed a bogus WriteRqst.Write that is past the end of the
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
! 		XLogRecPtr EndPtr = XLogCtl->xlblocks[curridx];
! 		if (!XLByteLT(LogwrtResult.Write, EndPtr))
  			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
! 				 EndPtr.xlogid, EndPtr.xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
! 		LogwrtResult.Write = EndPtr;
  		ispartialpage = XLByteLT(WriteRqst.Write, LogwrtResult.Write);
  
  		if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
***************
*** 1809,1824 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
- 			 * We also do this if this is the last page written for an xlog
- 			 * switch.
- 			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg || (xlog_switch && last_iteration))
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
--- 2368,2380 ----
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg)
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
***************
*** 1908,1915 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  			xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
  		SpinLockRelease(&xlogctl->info_lck);
  	}
- 
- 	Write->LogwrtResult = LogwrtResult;
  }
  
  /*
--- 2464,2469 ----
***************
*** 2081,2114 **** XLogFlush(XLogRecPtr record)
  	/* done already? */
  	if (!XLByteLE(record, LogwrtResult.Flush))
  	{
  		/* now wait for the write lock */
  		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 		LogwrtResult = XLogCtl->Write.LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			/* try to write/flush later additions to XLOG as well */
! 			if (LWLockConditionalAcquire(WALInsertLock, LW_EXCLUSIVE))
! 			{
! 				XLogCtlInsert *Insert = &XLogCtl->Insert;
! 				uint32		freespace = INSERT_FREESPACE(Insert);
  
! 				if (freespace < SizeOfXLogRecord)		/* buffer is full */
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 				else
! 				{
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 					WriteRqstPtr.xrecoff -= freespace;
! 				}
! 				LWLockRelease(WALInsertLock);
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = WriteRqstPtr;
! 			}
! 			else
! 			{
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = record;
! 			}
! 			XLogWrite(WriteRqst, false, false);
  		}
  		LWLockRelease(WALWriteLock);
  	}
--- 2635,2683 ----
  	/* done already? */
  	if (!XLByteLE(record, LogwrtResult.Flush))
  	{
+ 		/* try to write/flush later additions to XLOG as well */
+ 		volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 		uint32		freespace;
+ 		XLogRecPtr	insertpos;
+ 
+ 		/*
+ 		 * Get the current insert position.
+ 		 *
+ 		 * XXX: This used to do LWLockConditionalAcquire(WALInsertLock), and
+ 		 * fall back to writing just up to 'record' if we couldn't get the
+ 		 * lock. I wonder if it would be a good idea to have a
+ 		 * SpinLockConditionalAcquire function and use that? On one hand,
+ 		 * it would be good to not cause more contention on the lock if it's
+ 		 * busy, but on the other hand, this spinlock is much more lightweight
+ 		 * than the WALInsertLock was, so maybe it's better to just grab the
+ 		 * spinlock. Also note that if we stored the XLogRecPtr as one 64-bit
+ 		 * integer, we could just read it with no lock on platforms where
+ 		 * 64-bit integer accesses are atomic, which covers many common
+ 		 * platforms nowadays.
+ 		 */
+ 		SpinLockAcquire(&Insert->insertpos_lck);
+ 		insertpos = Insert->CurrPos;
+ 		SpinLockRelease(&Insert->insertpos_lck);
+ 
+ 		freespace = INSERT_FREESPACE(insertpos);
+ 		if (freespace < SizeOfXLogRecord)		/* buffer is full */
+ 			insertpos.xrecoff += freespace;
+ 
+ 		/*
+ 		 * Before actually performing the write, wait for all in-flight
+ 		 * insertions to the pages we're about to write to finish.
+ 		 */
+ 		insertpos = WaitXLogInsertionsToFinish(WriteRqstPtr, insertpos);
+ 
  		/* now wait for the write lock */
  		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 		LogwrtResult = XLogCtl->LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			WriteRqst.Write = insertpos;
! 			WriteRqst.Flush = insertpos;
  
! 			XLogWrite(WriteRqst, false);
  		}
  		LWLockRelease(WALWriteLock);
  	}
***************
*** 2218,2240 **** XLogBackgroundFlush(void)
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
- 
  	START_CRIT_SECTION();
  
! 	/* now wait for the write lock */
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 	LogwrtResult = XLogCtl->Write.LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
  	{
  		XLogwrtRqst WriteRqst;
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible, false);
  	}
! 	LWLockRelease(WALWriteLock);
  
  	END_CRIT_SECTION();
  }
  
  /*
--- 2787,2817 ----
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
  	START_CRIT_SECTION();
  
! 	/* now wait for any in-progress insertions to finish and get write lock */
! 	WaitXLogInsertionsToFinish(WriteRqstPtr, InvalidXLogRecPtr);
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 	LogwrtResult = XLogCtl->LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
  	{
  		XLogwrtRqst WriteRqst;
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible);
  	}
! 	LogwrtResult = XLogCtl->LogwrtResult;
  
  	END_CRIT_SECTION();
+ 
+ 	LWLockRelease(WALWriteLock);
+ 
+ 	/*
+ 	 * Great, done. To take some work off the critical path, try to initialize
+ 	 * as many of the no-longer-needed WAL buffers for future use as we can.
+ 	 */
+ 	AdvanceXLInsertBuffer(InvalidXLogRecPtr, true);
  }
  
  /*
***************
*** 5028,5033 **** XLOGShmemSize(void)
--- 5605,5613 ----
  	/* and the buffers themselves */
  	size = add_size(size, mul_size(XLOG_BLCKSZ, XLOGbuffers));
  
+ 	/* XLog insertion slots */
+ 	size = add_size(size, mul_size(sizeof(XLogInsertSlot), NumXLogInsertSlots));
+ 
  	/*
  	 * Note: we don't count ControlFileData, it comes out of the "slop factor"
  	 * added by CreateSharedMemoryAndSemaphores.  This lets us use this
***************
*** 5043,5048 **** XLOGShmemInit(void)
--- 5623,5629 ----
  	bool		foundCFile,
  				foundXLog;
  	char	   *allocptr;
+ 	int			i;
  
  	ControlFile = (ControlFileData *)
  		ShmemInitStruct("Control File", sizeof(ControlFileData), &foundCFile);
***************
*** 5068,5073 **** XLOGShmemInit(void)
--- 5649,5667 ----
  	memset(XLogCtl->xlblocks, 0, sizeof(XLogRecPtr) * XLOGbuffers);
  	allocptr += sizeof(XLogRecPtr) * XLOGbuffers;
  
+ 	/* Initialize insertion slots */
+ 	XLogCtl->XLogInsertSlots = (XLogInsertSlot *) allocptr;
+ 	for (i = 0; i < NumXLogInsertSlots; i++)
+ 	{
+ 		XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[i];
+ 		slot->CurrPos = InvalidXLogRecPtr;
+ 		slot->head = slot->tail = NULL;
+ 		SpinLockInit(&slot->lck);
+ 	}
+ 	XLogCtl->Insert.nextslot = 1;
+ 	XLogCtl->Insert.lastslot = 0;
+ 	allocptr += sizeof(XLogInsertSlot) * NumXLogInsertSlots;
+ 
  	/*
  	 * Align the start of the page buffers to an ALIGNOF_XLOG_BUFFER boundary.
  	 */
***************
*** 5082,5092 **** XLOGShmemInit(void)
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
- 	XLogCtl->Insert.currpage = (XLogPageHeader) (XLogCtl->pages);
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
--- 5676,5687 ----
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
+ 	SpinLockInit(&XLogCtl->Insert.insertpos_lck);
+ 
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
***************
*** 5961,5966 **** StartupXLOG(void)
--- 6556,6562 ----
  	uint32		freespace;
  	TransactionId oldestActiveXID;
  	bool		backupEndRequired = false;
+ 	int			firstIdx;
  
  	/*
  	 * Read control file and check XLOG status looks valid.
***************
*** 6717,6724 **** StartupXLOG(void)
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 	XLogCtl->xlblocks[0].xlogid = openLogId;
! 	XLogCtl->xlblocks[0].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
--- 7313,7324 ----
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 
! 	firstIdx = XLogRecPtrToBufIdx(EndOfLog);
! 	XLogCtl->curridx = firstIdx;
! 
! 	XLogCtl->xlblocks[firstIdx].xlogid = openLogId;
! 	XLogCtl->xlblocks[firstIdx].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
***************
*** 6726,6751 **** StartupXLOG(void)
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[0].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) Insert->currpage, readBuf, XLOG_BLCKSZ);
! 	Insert->currpos = (char *) Insert->currpage +
! 		(EndOfLog.xrecoff + XLOG_BLCKSZ - XLogCtl->xlblocks[0].xrecoff);
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
- 	XLogCtl->Write.LogwrtResult = LogwrtResult;
- 	Insert->LogwrtResult = LogwrtResult;
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(Insert->currpos, 0, freespace);
! 		XLogCtl->Write.curridx = 0;
  	}
  	else
  	{
--- 7326,7348 ----
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[firstIdx].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) &XLogCtl->pages[firstIdx * XLOG_BLCKSZ], readBuf, XLOG_BLCKSZ);
! 	Insert->CurrPos = EndOfLog;
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = XLOG_BLCKSZ - EndRecPtr.xrecoff % XLOG_BLCKSZ;
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(&XLogCtl->pages[firstIdx * XLOG_BLCKSZ] + EndRecPtr.xrecoff % XLOG_BLCKSZ, 0, freespace);
! 		XLogCtl->Write.curridx = firstIdx;
  	}
  	else
  	{
***************
*** 6757,6763 **** StartupXLOG(void)
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(0);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
--- 7354,7360 ----
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(firstIdx);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
***************
*** 7251,7257 **** GetRedoRecPtr(void)
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire WALInsertLock which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
--- 7848,7854 ----
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire insertpos_lck which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
***************
*** 7527,7532 **** CreateCheckPoint(int flags)
--- 8124,8130 ----
  	uint32		insert_logSeg;
  	TransactionId *inCommitXids;
  	int			nInCommit;
+ 	XLogRecPtr	curInsert;
  
  	/*
  	 * An end-of-recovery checkpoint is really a shutdown checkpoint, just
***************
*** 7595,7604 **** CreateCheckPoint(int flags)
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * We must hold WALInsertLock while examining insert state to determine
! 	 * the checkpoint REDO pointer.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
--- 8193,8202 ----
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * Determine the checkpoint REDO pointer.
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	curInsert = Insert->CurrPos;
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
***************
*** 7610,7616 **** CreateCheckPoint(int flags)
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding the WALInsertLock we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
--- 8208,8214 ----
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding insertpos_lck we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
***************
*** 7619,7633 **** CreateCheckPoint(int flags)
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
- 		XLogRecPtr	curInsert;
- 
- 		INSERT_RECPTR(curInsert, Insert, Insert->curridx);
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			LWLockRelease(WALInsertLock);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
--- 8217,8228 ----
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
***************
*** 7653,7666 **** CreateCheckPoint(int flags)
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace < SizeOfXLogRecord)
! 	{
! 		(void) AdvanceXLInsertBuffer(false);
! 		/* OK to ignore update return flag, since we will do flush anyway */
! 		freespace = INSERT_FREESPACE(Insert);
! 	}
! 	INSERT_RECPTR(checkPoint.redo, Insert, Insert->curridx);
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
--- 8248,8257 ----
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(curInsert);
  	if (freespace < SizeOfXLogRecord)
! 		curInsert = AdvanceXLogRecPtrToNextPage(curInsert);
! 	checkPoint.redo = curInsert;
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
***************
*** 7686,7692 **** CreateCheckPoint(int flags)
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
--- 8277,8283 ----
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
***************
*** 7706,7712 **** CreateCheckPoint(int flags)
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released WALInsertLock, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
--- 8297,8303 ----
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released insertpos_lck, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
***************
*** 8073,8087 **** CreateRestartPoint(int flags)
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * You need to hold WALInsertLock and info_lck to update it, although
! 	 * during recovery acquiring WALInsertLock is just pro forma, because
! 	 * there is no other processes updating Insert.RedoRecPtr.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * Prepare to accumulate statistics.
--- 8664,8678 ----
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * Like in CreateCheckPoint(), you need both insertpos_lck and info_lck
! 	 * to update it, although during recovery acquiring insertpos_lck is just
! 	 * pro forma, because no WAL insertions are happening.
  	 */
! 	SpinLockAcquire(&xlogctl->Insert.insertpos_lck);
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
! 	SpinLockRelease(&xlogctl->Insert.insertpos_lck);
  
  	/*
  	 * Prepare to accumulate statistics.
***************
*** 8274,8279 **** RequestXLogSwitch(void)
--- 8865,8871 ----
  {
  	XLogRecPtr	RecPtr;
  	XLogRecData rdata;
+ 	XLogwrtRqst FlushRqst;
  
  	/* XLOG SWITCH, alone among xlog record types, has no data */
  	rdata.buffer = InvalidBuffer;
***************
*** 8283,8288 **** RequestXLogSwitch(void)
--- 8875,8901 ----
  
  	RecPtr = XLogInsert(RM_XLOG_ID, XLOG_SWITCH, &rdata);
  
+ 	/* XXX: before this patch, TRACE_POSTGRESQL_XLOG_SWITCH was not called
+ 	 * if the xlog switch had no work to do, ie. if we were already at the
+ 	 * beginning of a new XLOG segment. You can check if RecPtr points to
+ 	 * beginning of a segment if you want to keep the distinction.
+ 	 */
+ 	TRACE_POSTGRESQL_XLOG_SWITCH();
+ 
+ 	/*
+ 	 * Flush through the end of the page containing XLOG_SWITCH, and
+ 	 * perform end-of-segment actions (eg, notifying archiver).
+ 	 */
+ 	WaitXLogInsertionsToFinish(RecPtr, InvalidXLogRecPtr);
+ 
+ 	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
+ 	FlushRqst.Write = RecPtr;
+ 	FlushRqst.Flush = RecPtr;
+ 	START_CRIT_SECTION();
+ 	XLogWrite(FlushRqst, false);
+ 	END_CRIT_SECTION();
+ 	LWLockRelease(WALWriteLock);
+ 
  	return RecPtr;
  }
  
***************
*** 8836,8841 **** issue_xlog_fsync(int fd, uint32 log, uint32 seg)
--- 9449,9455 ----
  XLogRecPtr
  do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	XLogRecPtr	checkpointloc;
  	XLogRecPtr	startpoint;
***************
*** 8885,8910 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  	 * since we expect that any pages not modified during the backup interval
  	 * must have been correctly captured by the backup.)
  	 *
! 	 * We must hold WALInsertLock to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
! 		if (XLogCtl->Insert.exclusiveBackup)
  		{
! 			LWLockRelease(WALInsertLock);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		XLogCtl->Insert.exclusiveBackup = true;
  	}
  	else
! 		XLogCtl->Insert.nonExclusiveBackups++;
! 	XLogCtl->Insert.forcePageWrites = true;
! 	LWLockRelease(WALInsertLock);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
--- 9499,9524 ----
  	 * since we expect that any pages not modified during the backup interval
  	 * must have been correctly captured by the backup.)
  	 *
! 	 * We must hold insertpos_lck to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
! 		if (Insert->exclusiveBackup)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		Insert->exclusiveBackup = true;
  	}
  	else
! 		Insert->nonExclusiveBackups++;
! 	Insert->forcePageWrites = true;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
***************
*** 8966,8978 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			LWLockAcquire(WALInsertLock, LW_SHARED);
! 			if (XLByteLT(XLogCtl->Insert.lastBackupStart, startpoint))
  			{
! 				XLogCtl->Insert.lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			LWLockRelease(WALInsertLock);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
--- 9580,9592 ----
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			SpinLockAcquire(&Insert->insertpos_lck);
! 			if (XLByteLT(Insert->lastBackupStart, startpoint))
  			{
! 				Insert->lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			SpinLockRelease(&Insert->insertpos_lck);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
***************
*** 9054,9063 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
  		Assert(XLogCtl->Insert.exclusiveBackup);
--- 9668,9678 ----
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
  		Assert(XLogCtl->Insert.exclusiveBackup);
***************
*** 9074,9080 **** pg_start_backup_callback(int code, Datum arg)
  	{
  		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 9689,9695 ----
  	{
  		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9087,9092 **** pg_start_backup_callback(int code, Datum arg)
--- 9702,9708 ----
  XLogRecPtr
  do_pg_stop_backup(char *labelfile, bool waitforarchive)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	XLogRecPtr	startpoint;
  	XLogRecPtr	stoppoint;
***************
*** 9128,9136 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
! 		XLogCtl->Insert.exclusiveBackup = false;
  	else
  	{
  		/*
--- 9744,9752 ----
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
! 		Insert->exclusiveBackup = false;
  	else
  	{
  		/*
***************
*** 9139,9154 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 		XLogCtl->Insert.nonExclusiveBackups--;
  	}
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  
  	if (exclusive)
  	{
--- 9755,9770 ----
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(Insert->nonExclusiveBackups > 0);
! 		Insert->nonExclusiveBackups--;
  	}
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	if (exclusive)
  	{
***************
*** 9350,9365 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  void
  do_pg_abort_backup(void)
  {
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 	Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 	XLogCtl->Insert.nonExclusiveBackups--;
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 9966,9983 ----
  void
  do_pg_abort_backup(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	Assert(Insert->nonExclusiveBackups > 0);
! 	Insert->nonExclusiveBackups--;
! 
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9413,9424 **** GetStandbyFlushRecPtr(void)
  XLogRecPtr
  GetXLogInsertRecPtr(void)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	LWLockAcquire(WALInsertLock, LW_SHARED);
! 	INSERT_RECPTR(current_recptr, Insert, Insert->curridx);
! 	LWLockRelease(WALInsertLock);
  
  	return current_recptr;
  }
--- 10031,10042 ----
  XLogRecPtr
  GetXLogInsertRecPtr(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	current_recptr = Insert->CurrPos;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	return current_recptr;
  }
*** a/src/backend/storage/lmgr/spin.c
--- b/src/backend/storage/lmgr/spin.c
***************
*** 56,61 **** SpinlockSemas(void)
--- 56,64 ----
  	 *
  	 * For now, though, we just need a few spinlocks (10 should be plenty)
  	 * plus one for each LWLock and one for each buffer header.
+ 	 *
+ 	 * XXX: remember to adjust this for the number of spinlocks needed by the
+ 	 * xlog.c changes before committing!
  	 */
  	return NumLWLocks() + NBuffers + 10;
  }
*** a/src/include/storage/lwlock.h
--- b/src/include/storage/lwlock.h
***************
*** 53,59 **** typedef enum LWLockId
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALInsertLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
--- 53,59 ----
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALBufMappingLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
***************
*** 79,84 **** typedef enum LWLockId
--- 79,85 ----
  	SerializablePredicateLockListLock,
  	OldSerXidLock,
  	SyncRepLock,
+ 	WALInsertTailLock,
  	/* Individual lock IDs end here */
  	FirstBufMappingLock,
  	FirstLockMgrLock = FirstBufMappingLock + NUM_BUFFER_PARTITIONS,

*** a/src/backend/access/transam/xlog.c
--- b/src/backend/access/transam/xlog.c
***************
*** 42,47 ****
--- 42,48 ----
  #include "postmaster/startup.h"
  #include "replication/walreceiver.h"
  #include "replication/walsender.h"
+ #include "storage/barrier.h"
  #include "storage/bufmgr.h"
  #include "storage/fd.h"
  #include "storage/ipc.h"
***************
*** 282,307 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There are actually three shared-memory copies of
!  * LogwrtResult, plus one unshared copy in each backend.  Here's how it works:
!  *		XLogCtl->LogwrtResult is protected by info_lck
!  *		XLogCtl->Write.LogwrtResult is protected by WALWriteLock
!  *		XLogCtl->Insert.LogwrtResult is protected by WALInsertLock
!  * One must hold the associated lock to read or write any of these, but
!  * of course no lock is needed to read/write the unshared LogwrtResult.
!  *
!  * XLogCtl->LogwrtResult and XLogCtl->Write.LogwrtResult are both "always
!  * right", since both are updated by a write or flush operation before
!  * it releases WALWriteLock.  The point of keeping XLogCtl->Write.LogwrtResult
!  * is that it can be examined/modified by code that already holds WALWriteLock
!  * without needing to grab info_lck as well.
!  *
!  * XLogCtl->Insert.LogwrtResult may lag behind the reality of the other two,
!  * but is updated when convenient.	Again, it exists for the convenience of
!  * code that is already holding WALInsertLock but not the other locks.
!  *
!  * The unshared LogwrtResult may lag behind any or all of these, and again
!  * is updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
--- 283,293 ----
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There is one shared-memory copy of LogwrtResult,
!  * plus one unshared copy in each backend. To read the shared copy, you need
!  * to hold info_lck *or* WALWriteLock. To update it, you need to hold both
!  * locks. The unshared LogwrtResult may lag behind the shared copy, and is
!  * updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
***************
*** 311,320 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  The other locks are held longer (potentially
!  * over I/O operations), so we use LWLocks for them.  These locks are:
   *
!  * WALInsertLock: must be held to insert a record into the WAL buffers.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
--- 297,311 ----
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  insertpos_lck protects the current logical
!  * insert location, ie. the head of reserved WAL space.  The other locks are
!  * held longer (potentially over I/O operations), so we use LWLocks for them.
!  * These locks are:
   *
!  * WALBufMappingLock: must be held to replace a page in the WAL buffer cache.
!  * This is only held while initializing and changing the mapping. If the
!  * contents of the buffer being replaced haven't been written yet, the mapping
!  * lock is released while the write is done, and reacquired afterwards.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
***************
*** 326,331 **** static XLogRecPtr RedoStartLSN = {0, 0};
--- 317,391 ----
   * only one checkpointer at a time; currently, with all checkpoints done by
   * the checkpointer, this is just pro forma).
   *
+  *
+  * Inserting a new WAL record is a two-step process:
+  *
+  * 1. Reserve the right amount of space from the WAL, and the next insertion
+  *    slot to advertise that the insertion is in progress. The current head
+  *    of reserved space is kept in Insert->CurrPos, and is protected by
+  *    insertpos_lck. Try to keep this section as short as possible,
+  *    insertpos_lck can be heavily contended on a busy system
+  *
+  * 2. Copy the record to the reserved WAL space. This involves finding the
+  *    correct WAL buffer containing the reserved space, and copying the
+  *    record in place. This can be done concurrently in multiple processes.
+  *
+  * To allow as much parallelism as possible for step 2, we try hard to avoid
+  * lock contention in that code path. Each insertion is asssigned its own
+  * "XLog insertion slot", which is used to advertise the position the backend
+  * is writing to. The slot is marked as in-use in step 1, while holding
+  * insertpos_lck, by setting the position field in the slot. When the backend
+  * is finished with the insertion, it clears its slot. Each slot is protected
+  * by a separate spinlock, to keep contention minimal.
+  *
+  * The insertion slots also provide a mechanism to wait for an insertion to
+  * finish. This is important when an XLOG page is written out - any
+  * in-progress insertions must finish copying data to the page first, or the
+  * on-disk copy will be incomplete. Waiting is done by the
+  * WaitXLogInsertionsToFinish() function. It adds the current process to the
+  * waiting queue in the slot it needs to wait for, and when that insertion
+  * finishes (or proceeds to the next page, at least), the inserter wakes up
+  * the process.
+  *
+  * The insertion slots form a ring. Insert->nextslot points to the next free
+  * slot, and Insert->lastslot points to the last slot that's still in use.
+  * lastslot can lag behind reality by any number of slots, as long as nextslot
+  * doesn't catch up with it. lastslot is advanced by
+  * WaitXLogInsertionsToFinish(), and is protected by WALInsertTailLock.
+  * nextslot is advanced in ReserveXLogInsertLocation() and is protected by
+  * insertpos_lck. Both slot variables are 32-bit integers, so that they can
+  * be read atomically without holding a lock.
+  *
+  * Whenever the ring fills up, ie. when nextslot wraps around and catches up
+  * with lastslot, ReserveXLogInsertLocation() has to wait for the oldest
+  * insertion to finish and advance lastslot, to make room for the new
+  * insertion. This is done by WaitForXLogInsertionSlotToBecomeFree() function,
+  * which is similar to WaitXLogInsertionsToFinish(), but instead of waiting
+  * for all insertions up to a given point to finish, it just waits for the
+  * inserter in the oldest slot to finish.
+  *
+  *
+  * Deadlock analysis
+  * -----------------
+  *
+  * It's important to call WaitXLogInsertionsToFinish() *before* acquiring
+  * WALWriteLock. Otherwise you might get stuck waiting for an insertion to
+  * finish (or at least advance to next uninitialized page), while you're
+  * holding WALWriteLock. That would be bad, because the backend you're waiting
+  * for might need to acquire WALWriteLock, too, to evict an old buffer, so
+  * you'd get deadlock.
+  *
+  * WaitXLogInsertionsToFinish() will not get stuck indefinitely, as long as
+  * it's called with a location that's known to be already allocated in the WAL
+  * buffers. Calling it with the position of a record you've already inserted
+  * satisfies that condition, so the common pattern:
+  *
+  *   recptr = XLogInsert(...)
+  *   XLogFlush(recptr)
+  *
+  * is safe. It can't get stuck, because an insertion to a WAL page that's
+  * already initialized in cache can always proceed without waiting on a lock.
+  *
   *----------
   */
  
***************
*** 346,356 **** typedef struct XLogwrtResult
   */
  typedef struct XLogCtlInsert
  {
! 	XLogwrtResult LogwrtResult; /* a recent value of LogwrtResult */
! 	XLogRecPtr	PrevRecord;		/* start of previously-inserted record */
! 	int			curridx;		/* current block index in cache */
! 	XLogPageHeader currpage;	/* points to header of block in cache */
! 	char	   *currpos;		/* current insertion point in cache */
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
--- 406,435 ----
   */
  typedef struct XLogCtlInsert
  {
! 	slock_t		insertpos_lck;	/* protects all the fields in this struct
! 								 * (except lastslot). */
! 
! 	int32		nextslot;		/* next insertion slot to use */
! 	int32		lastslot;		/* last in-use insertion slot (protected by
! 								 * WALInsertTailLock) */
! 
! 	/*
! 	 * CurrPos is the very tip of the reserved WAL space at the moment. The
! 	 * next record will be inserted there (or somewhere after it if there's
! 	 * not enough space on the current page). PrevRecord points to the
! 	 * beginning of the last record already reserved. It might not be fully
! 	 * copied into place yet, but we know its exact location already.
! 	 */
! 	XLogRecPtr	CurrPos;
! 	XLogRecPtr	PrevRecord;
! 
! 	/*
! 	 * padding to push RedoRecPtr and forcePageWrites, which rarely change,
! 	 * to a different cache line than the rapidly-changing CurrPos and
! 	 * PrevRecord values. XXX: verify if this makes any difference
! 	 */
! 	char		padding[128];
! 
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
***************
*** 371,389 **** typedef struct XLogCtlInsert
   */
  typedef struct XLogCtlWrite
  {
- 	XLogwrtResult LogwrtResult; /* current value of LogwrtResult */
  	int			curridx;		/* cache index of next block to write */
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by WALInsertLock: */
  	XLogCtlInsert Insert;
  
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
--- 450,483 ----
   */
  typedef struct XLogCtlWrite
  {
  	int			curridx;		/* cache index of next block to write */
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
+ 
+ /*
+  * Slots for in-progress WAL insertions.
+  */
+ typedef struct
+ {
+ 	slock_t		lck;
+ 	XLogRecPtr	CurrPos;	/* current position this process is inserting to */
+ 	PGPROC	   *head;		/* head of list of waiting PGPROCs */
+ 	PGPROC	   *tail;		/* tail of list of waiting PGPROCs */
+ } XLogInsertSlot;
+ 
+ #define NumXLogInsertSlots	1000
+ 
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by insertpos_lck: */
  	XLogCtlInsert Insert;
  
+ 	XLogInsertSlot *XLogInsertSlots;
+ 
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
***************
*** 397,405 **** typedef struct XLogCtlData
  	XLogCtlWrite Write;
  
  	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALInsertLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
--- 491,509 ----
  	XLogCtlWrite Write;
  
  	/*
+ 	 * To change curridx and the identity of a buffer, you need to hold
+ 	 * WALBufMappingLock. To change the identity of a buffer that's
+ 	 * still dirty, the old page needs to be written out first, and for that
+ 	 * you need WALWriteLock, and you need to ensure that there's no
+ 	 * in-progress insertions to the page by calling
+ 	 * WaitXLogInsertionsToFinish().
+ 	 */
+ 	int			curridx;		/* current (latest) block index in cache */
+ 
+ 	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALBufMappingLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
***************
*** 471,498 **** static XLogCtlData *XLogCtl = NULL;
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Macros for managing XLogInsert state.  In most cases, the calling routine
!  * has local copies of XLogCtl->Insert and/or XLogCtl->Insert->curridx,
!  * so these are passed as parameters instead of being fetched via XLogCtl.
   */
  
- /* Free space remaining in the current xlog page buffer */
- #define INSERT_FREESPACE(Insert)  \
- 	(XLOG_BLCKSZ - ((Insert)->currpos - (char *) (Insert)->currpage))
  
! /* Construct XLogRecPtr value for current insertion point */
! #define INSERT_RECPTR(recptr,Insert,curridx)  \
! 	( \
! 	  (recptr).xlogid = XLogCtl->xlblocks[curridx].xlogid, \
! 	  (recptr).xrecoff = \
! 		XLogCtl->xlblocks[curridx].xrecoff - INSERT_FREESPACE(Insert) \
! 	)
  
! #define PrevBufIdx(idx)		\
! 		(((idx) == 0) ? XLogCtl->XLogCacheBlck : ((idx) - 1))
  
! #define NextBufIdx(idx)		\
! 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
--- 575,605 ----
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Calculate the amount of space left on the page after 'endptr'.
!  * Beware multiple evaluation!
   */
+ #define INSERT_FREESPACE(endptr)	\
+ 	(((endptr).xrecoff % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr).xrecoff % XLOG_BLCKSZ))
+ 
+ #define NextBufIdx(idx)		\
+ 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  
! #define NextSlotNo(idx)		\
! 		(((idx) == NumXLogInsertSlots) ? 0 : ((idx) + 1))
  
! /*
!  * XLogRecPtrToBufIdx returns the index of the WAL buffer that holds, or
!  * would hold if it was in cache, the page containing 'recptr'.
!  *
!  * XLogRecEndPtrToBufIdx is the same, but a pointer to the first byte of a
!  * page is taken to mean the previous page.
!  */
! #define XLogRecPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogSegsPerFile * XLogSegSize) + (recptr).xrecoff)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
  
! #define XLogRecEndPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogSegsPerFile * XLogSegSize) + (recptr).xrecoff - 1)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
***************
*** 618,626 **** static void KeepLogSeg(XLogRecPtr recptr, uint32 *logId, uint32 *logSeg);
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static bool AdvanceXLInsertBuffer(bool new_segment);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
--- 725,733 ----
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static void AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
***************
*** 667,672 **** static bool read_backup_label(XLogRecPtr *checkPointLoc,
--- 774,797 ----
  static void rm_redo_error_callback(void *arg);
  static int	get_sync_bit(int method);
  
+ static XLogRecPtr PerformXLogInsert(int write_len,
+ 				  bool isLogSwitch,
+ 				  XLogRecord *rechdr,
+ 				  XLogRecData *rdata, pg_crc32 rdata_crc,
+ 				  bool didPageWrites);
+ static bool ReserveXLogInsertLocation(int size, bool forcePageWrites,
+ 						  bool isLogSwitch,
+ 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
+ 						  XLogRecPtr *EndPos_p,
+ 						  XLogInsertSlot **myslot_p, bool *updrqst_p);
+ static void UpdateSlotCurrPos(volatile XLogInsertSlot *myslot,
+ 				  XLogRecPtr CurrPos);
+ static XLogRecPtr WaitXLogInsertionsToFinish(XLogRecPtr upto,
+ 						   XLogRecPtr CurrPos);
+ static void WaitForXLogInsertionSlotToBecomeFree(void);
+ static char *GetXLogBuffer(XLogRecPtr ptr);
+ static XLogRecPtr AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr);
+ 
  
  /*
   * Insert an XLOG record having the specified RMID and info bytes,
***************
*** 687,698 **** XLogRecPtr
  XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
- 	XLogRecord *record;
- 	XLogContRecord *contrecord;
  	XLogRecPtr	RecPtr;
- 	XLogRecPtr	WriteRqst;
- 	uint32		freespace;
- 	int			curridx;
  	XLogRecData *rdt;
  	XLogRecData *rdt_lastnormal;
  	Buffer		dtbuf[XLR_MAX_BKP_BLOCKS];
--- 812,818 ----
***************
*** 706,715 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  	uint32		len,
  				write_len;
  	unsigned	i;
- 	bool		updrqst;
  	bool		doPageWrites;
  	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
  	uint8		info_orig = info;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
--- 826,835 ----
  	uint32		len,
  				write_len;
  	unsigned	i;
  	bool		doPageWrites;
  	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
  	uint8		info_orig = info;
+ 	XLogRecord	rechdr;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
***************
*** 896,1029 **** begin:;
  	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
  		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
- 	START_CRIT_SECTION();
- 
- 	/* Now wait to get insert lock */
- 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
- 
  	/*
! 	 * Check to see if my RedoRecPtr is out of date.  If so, may have to go
! 	 * back and recompute everything.  This can only happen just after a
! 	 * checkpoint, so it's better to be slow in this case and fast otherwise.
! 	 *
! 	 * If we aren't doing full-page writes then RedoRecPtr doesn't actually
! 	 * affect the contents of the XLOG record, so we'll update our local copy
! 	 * but not force a recomputation.
  	 */
! 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr))
! 	{
! 		Assert(XLByteLT(RedoRecPtr, Insert->RedoRecPtr));
! 		RedoRecPtr = Insert->RedoRecPtr;
  
! 		if (doPageWrites)
! 		{
! 			for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
! 			{
! 				if (dtbuf[i] == InvalidBuffer)
! 					continue;
! 				if (dtbuf_bkp[i] == false &&
! 					XLByteLE(dtbuf_lsn[i], RedoRecPtr))
! 				{
! 					/*
! 					 * Oops, this buffer now needs to be backed up, but we
! 					 * didn't think so above.  Start over.
! 					 */
! 					LWLockRelease(WALInsertLock);
! 					END_CRIT_SECTION();
! 					rdt_lastnormal->next = NULL;
! 					info = info_orig;
! 					goto begin;
! 				}
! 			}
! 		}
! 	}
  
  	/*
! 	 * Also check to see if forcePageWrites was just turned on; if we weren't
! 	 * already doing full-page writes then go back and recompute. (If it was
! 	 * just turned off, we could recompute the record without full pages, but
! 	 * we choose not to bother.)
  	 */
! 	if (Insert->forcePageWrites && !doPageWrites)
  	{
! 		/* Oops, must redo it with full-page data. */
! 		LWLockRelease(WALInsertLock);
! 		END_CRIT_SECTION();
  		rdt_lastnormal->next = NULL;
  		info = info_orig;
  		goto begin;
  	}
  
- 	/*
- 	 * If there isn't enough space on the current XLOG page for a record
- 	 * header, advance to the next page (leaving the unused space as zeroes).
- 	 */
- 	updrqst = false;
- 	freespace = INSERT_FREESPACE(Insert);
- 	if (freespace < SizeOfXLogRecord)
- 	{
- 		updrqst = AdvanceXLInsertBuffer(false);
- 		freespace = INSERT_FREESPACE(Insert);
- 	}
- 
- 	/* Compute record's XLOG location */
- 	curridx = Insert->curridx;
- 	INSERT_RECPTR(RecPtr, Insert, curridx);
- 
- 	/*
- 	 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
- 	 * segment, we need not insert it (and don't want to because we'd like
- 	 * consecutive switch requests to be no-ops).  Instead, make sure
- 	 * everything is written and flushed through the end of the prior segment,
- 	 * and return the prior segment's end address.
- 	 */
- 	if (isLogSwitch &&
- 		(RecPtr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
- 	{
- 		/* We can release insert lock immediately */
- 		LWLockRelease(WALInsertLock);
- 
- 		RecPtr.xrecoff -= SizeOfXLogLongPHD;
- 		if (RecPtr.xrecoff == 0)
- 		{
- 			/* crossing a logid boundary */
- 			RecPtr.xlogid -= 1;
- 			RecPtr.xrecoff = XLogFileSize;
- 		}
- 
- 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
- 		LogwrtResult = XLogCtl->Write.LogwrtResult;
- 		if (!XLByteLE(RecPtr, LogwrtResult.Flush))
- 		{
- 			XLogwrtRqst FlushRqst;
- 
- 			FlushRqst.Write = RecPtr;
- 			FlushRqst.Flush = RecPtr;
- 			XLogWrite(FlushRqst, false, false);
- 		}
- 		LWLockRelease(WALWriteLock);
- 
- 		END_CRIT_SECTION();
- 
- 		return RecPtr;
- 	}
- 
- 	/* Insert record header */
- 
- 	record = (XLogRecord *) Insert->currpos;
- 	record->xl_prev = Insert->PrevRecord;
- 	record->xl_xid = GetCurrentTransactionIdIfAny();
- 	record->xl_tot_len = SizeOfXLogRecord + write_len;
- 	record->xl_len = len;		/* doesn't include backup blocks */
- 	record->xl_info = info;
- 	record->xl_rmid = rmid;
- 
- 	/* Now we can finish computing the record's CRC */
- 	COMP_CRC32(rdata_crc, (char *) record + sizeof(pg_crc32),
- 			   SizeOfXLogRecord - sizeof(pg_crc32));
- 	FIN_CRC32(rdata_crc);
- 	record->xl_crc = rdata_crc;
- 
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
  	{
--- 1016,1055 ----
  	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
  		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
  	/*
! 	 * Construct record header. We can't CRC it yet, because the prev-link
! 	 * needs to be covered by the CRC and we don't know that yet. We will
! 	 * finish computing the CRC when we do.
  	 */
! 	MemSet(&rechdr, 0, sizeof(rechdr));
! 	/* rechdr.xl_prev is set in PerformXLogInsert() */
! 	rechdr.xl_xid = GetCurrentTransactionIdIfAny();
! 	rechdr.xl_tot_len = SizeOfXLogRecord + write_len;
! 	rechdr.xl_len = len;		/* doesn't include backup blocks */
! 	rechdr.xl_info = info;
! 	rechdr.xl_rmid = rmid;
  
! 	START_CRIT_SECTION();
  
  	/*
! 	 * Try to do the insertion.
  	 */
! 	RecPtr = PerformXLogInsert(write_len, isLogSwitch, &rechdr,
! 							   rdata, rdata_crc, doPageWrites);
! 	END_CRIT_SECTION();
! 
! 	if (XLogRecPtrIsInvalid(RecPtr))
  	{
! 		/*
! 		 * Oops, must redo it with full-page data. Unlink the backup blocks
! 		 * from the chain and reset info bitmask to undo the changes we've
! 		 * done.
! 		 */
  		rdt_lastnormal->next = NULL;
  		info = info_orig;
  		goto begin;
  	}
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
  	{
***************
*** 1032,1215 **** begin:;
  		initStringInfo(&buf);
  		appendStringInfo(&buf, "INSERT @ %X/%X: ",
  						 RecPtr.xlogid, RecPtr.xrecoff);
! 		xlog_outrec(&buf, record);
  		if (rdata->data != NULL)
  		{
  			appendStringInfo(&buf, " - ");
! 			RmgrTable[record->xl_rmid].rm_desc(&buf, record->xl_info, rdata->data);
  		}
  		elog(LOG, "%s", buf.data);
  		pfree(buf.data);
  	}
  #endif
  
! 	/* Record begin of record in appropriate places */
! 	ProcLastRecPtr = RecPtr;
! 	Insert->PrevRecord = RecPtr;
  
! 	Insert->currpos += SizeOfXLogRecord;
! 	freespace -= SizeOfXLogRecord;
  
  	/*
! 	 * Append the data, including backup blocks if any
  	 */
! 	while (write_len)
! 	{
! 		while (rdata->data == NULL)
! 			rdata = rdata->next;
  
! 		if (freespace > 0)
  		{
! 			if (rdata->len > freespace)
  			{
! 				memcpy(Insert->currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				write_len -= freespace;
! 			}
! 			else
! 			{
! 				memcpy(Insert->currpos, rdata->data, rdata->len);
! 				freespace -= rdata->len;
! 				write_len -= rdata->len;
! 				Insert->currpos += rdata->len;
! 				rdata = rdata->next;
! 				continue;
  			}
  		}
  
! 		/* Use next buffer */
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		curridx = Insert->curridx;
! 		/* Insert cont-record header */
! 		Insert->currpage->xlp_info |= XLP_FIRST_IS_CONTRECORD;
! 		contrecord = (XLogContRecord *) Insert->currpos;
! 		contrecord->xl_rem_len = write_len;
! 		Insert->currpos += SizeOfXLogContRecord;
! 		freespace = INSERT_FREESPACE(Insert);
  	}
  
! 	/* Ensure next record will be properly aligned */
! 	Insert->currpos = (char *) Insert->currpage +
! 		MAXALIGN(Insert->currpos - (char *) Insert->currpage);
! 	freespace = INSERT_FREESPACE(Insert);
  
  	/*
! 	 * The recptr I return is the beginning of the *next* record. This will be
! 	 * stored as LSN for changed data pages...
  	 */
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, we must now write and flush all the
! 	 * existing data, and then forcibly advance to the start of the next
! 	 * segment.  It's not good to do this I/O while holding the insert lock,
! 	 * but there seems too much risk of confusion if we try to release the
! 	 * lock sooner.  Fortunately xlog switch needn't be a high-performance
! 	 * operation anyway...
  	 */
! 	if (isLogSwitch)
  	{
! 		XLogCtlWrite *Write = &XLogCtl->Write;
! 		XLogwrtRqst FlushRqst;
! 		XLogRecPtr	OldSegEnd;
  
! 		TRACE_POSTGRESQL_XLOG_SWITCH();
  
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  
  		/*
! 		 * Flush through the end of the page containing XLOG_SWITCH, and
! 		 * perform end-of-segment actions (eg, notifying archiver).
  		 */
! 		WriteRqst = XLogCtl->xlblocks[curridx];
! 		FlushRqst.Write = WriteRqst;
! 		FlushRqst.Flush = WriteRqst;
! 		XLogWrite(FlushRqst, false, true);
! 
! 		/* Set up the next buffer as first page of next segment */
! 		/* Note: AdvanceXLInsertBuffer cannot need to do I/O here */
! 		(void) AdvanceXLInsertBuffer(true);
! 
! 		/* There should be no unwritten data */
! 		curridx = Insert->curridx;
! 		Assert(curridx == Write->curridx);
! 
! 		/* Compute end address of old segment */
! 		OldSegEnd = XLogCtl->xlblocks[curridx];
! 		OldSegEnd.xrecoff -= XLOG_BLCKSZ;
! 		if (OldSegEnd.xrecoff == 0)
! 		{
! 			/* crossing a logid boundary */
! 			OldSegEnd.xlogid -= 1;
! 			OldSegEnd.xrecoff = XLogFileSize;
! 		}
  
! 		/* Make it look like we've written and synced all of old segment */
! 		LogwrtResult.Write = OldSegEnd;
! 		LogwrtResult.Flush = OldSegEnd;
  
  		/*
! 		 * Update shared-memory status --- this code should match XLogWrite
  		 */
  		{
! 			/* use volatile pointer to prevent code rearrangement */
! 			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			SpinLockAcquire(&xlogctl->info_lck);
! 			xlogctl->LogwrtResult = LogwrtResult;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, LogwrtResult.Write))
! 				xlogctl->LogwrtRqst.Write = LogwrtResult.Write;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Flush, LogwrtResult.Flush))
! 				xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
! 			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		Write->LogwrtResult = LogwrtResult;
  
! 		LWLockRelease(WALWriteLock);
  
! 		updrqst = false;		/* done already */
  	}
  	else
  	{
! 		/* normal case, ie not xlog switch */
  
! 		/* Need to update shared LogwrtRqst if some block was filled up */
! 		if (freespace < SizeOfXLogRecord)
  		{
! 			/* curridx is filled and available for writing out */
! 			updrqst = true;
  		}
  		else
  		{
! 			/* if updrqst already set, write through end of previous buf */
! 			curridx = PrevBufIdx(curridx);
  		}
- 		WriteRqst = XLogCtl->xlblocks[curridx];
  	}
  
! 	LWLockRelease(WALInsertLock);
  
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
  
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, WriteRqst))
! 			xlogctl->LogwrtRqst.Write = WriteRqst;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
  	}
  
! 	XactLastRecEnd = RecPtr;
  
! 	END_CRIT_SECTION();
  
! 	return RecPtr;
  }
  
  /*
--- 1058,1762 ----
  		initStringInfo(&buf);
  		appendStringInfo(&buf, "INSERT @ %X/%X: ",
  						 RecPtr.xlogid, RecPtr.xrecoff);
! 		xlog_outrec(&buf, &rechdr);
  		if (rdata->data != NULL)
  		{
  			appendStringInfo(&buf, " - ");
! 			RmgrTable[rmid].rm_desc(&buf, rechdr.xl_info, rdata->data);
  		}
  		elog(LOG, "%s", buf.data);
  		pfree(buf.data);
  	}
  #endif
  
! 	/*
! 	 * The recptr I return is the beginning of the *next* record. This will be
! 	 * stored as LSN for changed data pages...
! 	 */
! 	return RecPtr;
! }
  
! /*
!  * Subroutine of XLogInsert. All the changes to shared state are done here,
!  * XLogInsert only prepares the record for insertion.
!  *
!  * On success, returns pointer to end of inserted record like XLogInsert().
!  * If RedoRecPtr or forcePageWrites had changed, returns InvalidRecPtr, and
!  * the caller must recalculate full-page-images and retry.
!  */
! static XLogRecPtr
! PerformXLogInsert(int write_len, bool isLogSwitch, XLogRecord *rechdr,
! 				  XLogRecData *rdata, pg_crc32 rdata_crc,
! 				  bool didPageWrites)
! {
! 	volatile XLogInsertSlot *myslot = NULL;
! 	char	   *currpos;
! 	XLogRecord *record;
! 	int			tot_len;
! 	int			freespace;
! 	int			written;
! 	XLogRecPtr	PrevRecord;
! 	XLogRecPtr	StartPos;
! 	XLogRecPtr	EndPos;
! 	XLogRecPtr	CurrPos;
! 	bool		updrqst;
! 
! 	/* Get an insert location  */
! 	tot_len = SizeOfXLogRecord + write_len;
! 	if (!ReserveXLogInsertLocation(tot_len, didPageWrites, isLogSwitch,
! 								   &PrevRecord, &StartPos, &EndPos,
! 								   (XLogInsertSlot **) &myslot, &updrqst))
! 	{
! 		return EndPos;
! 	}
  
  	/*
! 	 * Got it! Now that we know the prev-link, we can finish computing the
! 	 * record's CRC.
  	 */
! 	rechdr->xl_prev = PrevRecord;
! 
! 	/* Get the right WAL page to start inserting to */
! 	CurrPos = StartPos;
! 	currpos = GetXLogBuffer(CurrPos);
  
! 	/* Copy the record header in place */
! 	record = (XLogRecord *) currpos;
! 	memcpy(record, rechdr, sizeof(XLogRecord));
! 	COMP_CRC32(rdata_crc, currpos + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	record->xl_crc = rdata_crc;
! 
! 	currpos += SizeOfXLogRecord;
! 	CurrPos.xrecoff += SizeOfXLogRecord;
! 
! 	if (!isLogSwitch)
! 	{
! 		/* Copy record data */
! 		written = 0;
! 		freespace = INSERT_FREESPACE(CurrPos);
! 		while (rdata != NULL)
  		{
! 			while (rdata->len > freespace)
  			{
! 				/*
! 				 * Write what fits on this page, then write the continuation
! 				 * record, and continue.
! 				 */
! 				XLogContRecord *contrecord;
! 
! 				memcpy(currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				written += freespace;
! 				CurrPos.xrecoff += freespace;
! 
! 				/*
! 				 * CurrPos now points to the page boundary, ie. the first byte
! 				 * of the next page. Update CurrPos with that before
! 				 * calling GetXLogBuffer(), because GetXLogBuffer() might need
! 				 * to wait for some insertions to finish so that it can write
! 				 * out a buffer to make room for the new page. Updating CurrPos
! 				 * before waiting for a new buffer ensures that we don't
! 				 * deadlock with ourselves if we run out of clean buffers.
! 				 *
! 				 * However, we must not advance CurrPos past the page header
! 				 * yet, otherwise someone might try to flush up to that point,
! 				 * which would fail if the next page was not initialized yet.
! 				 */
! 				UpdateSlotCurrPos(myslot, CurrPos);
! 
! 				/* Now skip page header */
! 				CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
! 
! 				currpos = GetXLogBuffer(CurrPos);
! 
! 				contrecord = (XLogContRecord *) currpos;
! 				contrecord->xl_rem_len = write_len - written;
! 
! 				currpos += SizeOfXLogContRecord;
! 				CurrPos.xrecoff += SizeOfXLogContRecord;
! 
! 				freespace = INSERT_FREESPACE(CurrPos);
  			}
+ 
+ 			memcpy(currpos, rdata->data, rdata->len);
+ 			currpos += rdata->len;
+ 			CurrPos.xrecoff += rdata->len;
+ 			freespace -= rdata->len;
+ 			written += rdata->len;
+ 
+ 			rdata = rdata->next;
  		}
+ 		Assert(written == write_len);
  
! 		CurrPos.xrecoff = MAXALIGN(CurrPos.xrecoff);
! 		Assert(XLByteEQ(CurrPos, EndPos));
  	}
+ 	else
+ 	{
+ 		/* An xlog-switch record doesn't contain any data besides the header */
+ 		Assert(write_len == 0);
+ 
+ 		/*
+ 		 * An xlog-switch record consumes all the remaining space on the
+ 		 * WAL segment. We have already reserved it for us, but we still need
+ 		 * to make sure it's been allocated and zeroed in the WAL buffers so
+ 		 * that when the caller (or someone else) does XLogWrite(), it can
+ 		 * really write out all the zeros.
+ 		 *
+ 		 * We do this one page at a time, to make sure we don't deadlock
+ 		 * against ourselves if wal_buffers < XLOG_SEG_SIZE.
+ 		 */
+ 		while (XLByteLT(CurrPos, EndPos))
+ 		{
+ 			/* use up all the remaining space in this page */
+ 			freespace = INSERT_FREESPACE(CurrPos);
+ 			XLByteAdvance(CurrPos, freespace);
+ 			/*
+ 			 * like in the non-xlog-switch codepath, let others know that
+ 			 * we're done writing up to the end of this page
+ 			 */
+ 			UpdateSlotCurrPos(myslot, CurrPos);
+ 			/*
+ 			 * let GetXLogBuffer initialize next page if necessary.
+ 			 */
+ 			CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
+ 			(void) GetXLogBuffer(CurrPos);
+ 		}
  
! 		/*
! 		 * Even though we reserved the rest of the segment for us, which
! 		 * is reflected in EndPos, we need to return a value that points just
! 		 * to the end of the xlog-switch record.
! 		 */
! 		EndPos.xlogid = StartPos.xlogid;
! 		EndPos.xrecoff = StartPos.xrecoff + SizeOfXLogRecord;
! 	}
  
  	/*
! 	 * Done! Clear CurrPos in our slot to let others know that we're
! 	 * finished.
  	 */
! 	UpdateSlotCurrPos(myslot, InvalidXLogRecPtr);
  
  	/*
! 	 * Update shared LogwrtRqst.Write, if we crossed page boundary.
  	 */
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
! 
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, EndPos))
! 			xlogctl->LogwrtRqst.Write = EndPos;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
! 	}
  
! 	/* update our global variables */
! 	ProcLastRecPtr = StartPos;
! 	XactLastRecEnd = EndPos;
  
! 	return EndPos;
! }
  
+ /*
+  * Reserves the right amount of space for a record of given size from the WAL.
+  * *StartPos_p is set to the beginning of the reserved section, *EndPos_p to
+  * its end, and *Prev_record_p points to the beginning of the previous record
+  * to set to the prev-link of the record header.
+  *
+  * A log-switch record is handled slightly differently. The rest of the
+  * segment will be reserved for this insertion, as indicated by the returned
+  * *EndPos_p value. However, if we are already at the beginning of the current
+  * segment, the *EndPos_p is set to the current location without reserving
+  * any space, and the function returns false.
+  *
+  * *updrqst_p is set to true, if this record ends on different page than
+  * the previous one - the caller should update the shared LogwrtRqst value
+  * after it's done inserting the record in that case, so that the WAL page
+  * that filled up gets written out at the next convenient moment.
+  *
+  * While holding insertpos_lck, sets myslot->CurrPos to the starting position,
+  * (or the end of previous record, to be exact) to let others know that we're
+  * busy inserting to the reserved area. The caller must clear it when the
+  * insertion is finished.
+  *
+  * Returns true on success, or false if RedoRecPtr or forcePageWrites was
+  * changed. On failure, the shared state is not modified.
+  *
+  * This is the performance critical part of XLogInsert that must be
+  * serialized across backends. The rest can happen mostly in parallel.
+  *
+  * NB: The space calculation here must match the code in PerformXLogInsert,
+  * where we actually copy the record to the reserved space.
+  */
+ static bool
+ ReserveXLogInsertLocation(int size, bool didPageWrites,
+ 						  bool isLogSwitch,
+ 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
+ 						  XLogRecPtr *EndPos_p,
+ 						  XLogInsertSlot **myslot_p, bool *updrqst_p)
+ {
+ 	volatile XLogInsertSlot *myslot;
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 	int			freespace;
+ 	XLogRecPtr	ptr;
+ 	XLogRecPtr	StartPos;
+ 	XLogRecPtr	LastEndPos;
+ 	int32		nextslot;
+ 	int32		lastslot;
+ 	bool		updrqst = false;
+ 
+ retry:
+ 	SpinLockAcquire(&Insert->insertpos_lck);
+ 
+ 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr) ||
+ 		(!didPageWrites && Insert->forcePageWrites))
+ 	{
  		/*
! 		 * Oops, a checkpoint just happened, or forcePageWrites was just
! 		 * turned on. Start XLogInsert() all over, because we might have to
! 		 * include more full-page images in the record.
  		 */
! 		RedoRecPtr = Insert->RedoRecPtr;
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		*EndPos_p = InvalidXLogRecPtr;
! 		return false;
! 	}
! 
! 	/*
! 	 * Reserve the next insertion slot for us.
! 	 *
! 	 * First check that the slot is not still in use. Modifications to
! 	 * lastslot are protected by WALInsertTailLock, but here we assume that
! 	 * reading an int32 is atomic. Another process might advance lastslot at
! 	 * the same time, but not past nextslot.
! 	 */
! 	lastslot = Insert->lastslot;
! 	nextslot = Insert->nextslot;
! 	if (NextSlotNo(nextslot) == lastslot)
! 	{
! 		/*
! 		 * Oops, we've "caught our tail" and the oldest slot is still in use.
! 		 * Have to wait for it to become vacant.
! 		 */
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		WaitForXLogInsertionSlotToBecomeFree();
! 		goto retry;
! 	}
! 	myslot = &XLogCtl->XLogInsertSlots[nextslot];
! 	nextslot = NextSlotNo(nextslot);
  
! 	/*
! 	 * Got the slot, now reserve the right amount of space from the WAL for
! 	 * our record.
! 	 */
! 	LastEndPos = ptr = Insert->CurrPos;
! 	*PrevRecord_p = Insert->PrevRecord;
  
+ 	/*
+ 	 * If there isn't enough space on the current XLOG page for a record
+ 	 * header, advance to the next page (leaving the unused space as zeroes).
+ 	 */
+ 	freespace = INSERT_FREESPACE(ptr);
+ 	if (freespace < SizeOfXLogRecord)
+ 	{
+ 		ptr = AdvanceXLogRecPtrToNextPage(ptr);
+ 		freespace = INSERT_FREESPACE(ptr);
+ 		updrqst = true;
+ 	}
+ 
+ 	/*
+ 	 * We are now at the starting position of our record. Now figure out how
+ 	 * the data will be split across the WAL pages, to calculate where the
+ 	 * record ends.
+ 	 */
+ 	StartPos = ptr;
+ 
+ 	if (isLogSwitch)
+ 	{
  		/*
! 		 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
! 		 * segment, we need not insert it (and don't want to because we'd like
! 		 * consecutive switch requests to be no-ops). Otherwise the XLOG_SWITCH
! 		 * record should consume all the remaining space on the current segment.
  		 */
+ 		Assert(size == SizeOfXLogRecord);
+ 		if ((ptr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
  		{
! 			/* We can release insert lock immediately */
! 			SpinLockRelease(&Insert->insertpos_lck);
  
! 			ptr.xrecoff -= SizeOfXLogLongPHD;
! 			if (ptr.xrecoff == 0)
! 			{
! 				/* crossing a logid boundary */
! 				ptr.xlogid -= 1;
! 				ptr.xrecoff = XLogFileSize;
! 			}
! 
! 			*EndPos_p = ptr;
! 			*StartPos_p = ptr;
! 			*myslot_p = NULL;
! 
! 			return false;
  		}
+ 		else
+ 		{
+ 			if (ptr.xrecoff % XLOG_SEG_SIZE != 0)
+ 			{
+ 				int segleft = XLOG_SEG_SIZE - (ptr.xrecoff % XLOG_SEG_SIZE);
+ 				XLByteAdvance(ptr, segleft);
+ 			}
+ 			updrqst = true;
+ 		}
+ 	}
+ 	else
+ 	{
+ 		/* A normal record, ie. not xlog-switch */
+ 		int sizeleft = size;
+ 		while (freespace < sizeleft)
+ 		{
+ 			/* fill this page, and continue on next page */
+ 			sizeleft -= freespace;
+ 			ptr = AdvanceXLogRecPtrToNextPage(ptr);
  
! 			/* account for continuation record header */
! 			ptr.xrecoff += SizeOfXLogContRecord;
! 			freespace = INSERT_FREESPACE(ptr);
  
! 			updrqst = true;
! 		}
! 		/* the rest fits on this page */
! 		ptr.xrecoff += sizeleft;
! 
! 		/* Align the end position, so that the next record starts aligned */
! 		ptr.xrecoff = MAXALIGN(ptr.xrecoff);
! 	}
! 
! 	/* Update the shared state, and our slot, before releasing the lock */
! 	myslot->CurrPos = LastEndPos;
! 	Insert->CurrPos = ptr;
! 	Insert->PrevRecord = StartPos;
! 	Insert->nextslot = nextslot;
! 
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! #ifdef RESERVE_XLOGINSERT_LOCATION_DEBUG
! 	elog(LOG, "reserved xlog: prev %X/%X, start %X/%X, end %X/%X (len %d)",
! 		 PrevRecord_p->xlogid, PrevRecord_p->xrecoff,
! 		 StartPos.xlogid, StartPos.xrecoff,
! 		 ptr.xlogid, ptr.xrecoff,
! 		 size);
! #endif
! 
! 	*EndPos_p = ptr;
! 	*StartPos_p = StartPos;
! 	*myslot_p = (XLogInsertSlot *) myslot;
! 	*updrqst_p = updrqst;
! 
! 	return true;
! }
! 
! /*
!  * Update slot's CurrPos variable, and wake up anyone waiting on it.
!  */
! static void
! UpdateSlotCurrPos(volatile XLogInsertSlot *myslot, XLogRecPtr CurrPos)
! {
! 	PGPROC	   *head;
! 
! 	/*
! 	 * The write-barrier ensures that the changes we made to the WAL pages
! 	 * are visible to everyone before the update of CurrPos.
! 	 *
! 	 * XXX: I'm not sure if this is necessary. Does a function call act
! 	 * as an implicit barrier?
! 	 */
! 	pg_write_barrier();
! 
! 	SpinLockAcquire(&myslot->lck);
! 	myslot->CurrPos = CurrPos;
! 	head = myslot->head;
! 	myslot->head = myslot->tail = NULL;
! 	SpinLockRelease(&myslot->lck);
! 	while (head != NULL)
! 	{
! 		PGPROC *proc = head;
! 		head = proc->lwWaitLink;
! 		proc->lwWaitLink = NULL;
! 		proc->lwWaiting = false;
! 		PGSemaphoreUnlock(&proc->sem);
! 	}
! }
! 
! /*
!  * Get a pointer to the right location in the WAL buffer containing the
!  * given XLogRecPtr.
!  *
!  * If the page is not initialized yet, it is initialized. That might require
!  * evicting an old dirty buffer from the buffer cache, which means I/O.
!  *
!  * The caller must ensure that the page containing the requested location
!  * isn't evicted yet, and won't be evicted, by holding onto an
!  * XLogInsertSlot with CurrPos set to 'ptr'. Setting it to some value
!  * less than 'ptr' would suffice for GetXLogBuffer(), but risks deadlock:
!  * if we have to evict a buffer, we might have to wait for someone else to
!  * finish a write. And that someone else might not be able to finish the write
!  * if our CurrPos points to a buffer that's still in the buffer cache.
!  */
! static char *
! GetXLogBuffer(XLogRecPtr ptr)
! {
! 	int			idx;
! 	XLogRecPtr	endptr;
! 
! 	/*
! 	 * The XLog buffer cache is organized so that we can easily calculate the
! 	 * buffer a given page must be loaded into from the XLogRecPtr alone.
! 	 * A page must always be loaded to a particular buffer.
! 	 */
! 	idx = XLogRecPtrToBufIdx(ptr);
! 
! 	/*
! 	 * See what page is loaded in the buffer at the moment. It could be the
! 	 * page we're looking for, or something older. It can't be anything
! 	 * newer - that would imply the page we're looking for has already
! 	 * been written out to disk, which shouldn't happen as long as the caller
! 	 * has set its slot's CurrPos correctly.
! 	 *
! 	 * However, we don't hold a lock while we read the value. If someone has
! 	 * just initialized the page, it's possible that we get a "torn read",
! 	 * and read a bogus value. That's ok, we'll grab the mapping lock (in
! 	 * AdvanceXLInsertBuffer) and retry if we see anything else than the page
! 	 * we're looking for. But it means that when we do this unlocked read, we
! 	 * might see a value that appears to be ahead of the page we're looking
! 	 * for. So don't PANIC on that, until we've verified the value while
! 	 * holding the lock.
! 	 */
! 	endptr = XLogCtl->xlblocks[idx];
! 	if (ptr.xlogid != endptr.xlogid ||
! 		!(ptr.xrecoff < endptr.xrecoff &&
! 		  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
! 	{
! 		AdvanceXLInsertBuffer(ptr, false);
! 		endptr = XLogCtl->xlblocks[idx];
  
! 		if (ptr.xlogid != endptr.xlogid ||
! 			!(ptr.xrecoff < endptr.xrecoff &&
! 			  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
! 		{
! 			elog(PANIC, "could not find WAL buffer for %X/%X",
! 				 ptr.xlogid, ptr.xrecoff);
! 		}
  	}
+ 
+ 	/*
+ 	 * Found the buffer holding this page. Return a pointer to the right
+ 	 * offset within the page.
+ 	 */
+ 	return (char *) XLogCtl->pages + idx * (Size) XLOG_BLCKSZ +
+ 		ptr.xrecoff % XLOG_BLCKSZ;
+ }
+ 
+ /*
+  * Advance an XLogRecPtr to the first valid insertion location on the next
+  * page, right after the page header. An XLogRecPtr pointing to a boundary,
+  * ie. the first byte of a page, is taken to belong to the previous page.
+  */
+ static XLogRecPtr
+ AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr)
+ {
+ 	int			freespace;
+ 
+ 	freespace = INSERT_FREESPACE(ptr);
+ 	XLByteAdvance(ptr, freespace);
+ 	if (ptr.xrecoff % XLogSegSize == 0)
+ 		ptr.xrecoff += SizeOfXLogLongPHD;
  	else
+ 		ptr.xrecoff += SizeOfXLogShortPHD;
+ 
+ 	return ptr;
+ }
+ 
+ /*
+  * Wait for any insertions < upto to finish.
+  *
+  * Returns a value >= upto, which indicates the oldest in-progress insertion
+  * that we saw in the array, or CurrPos if there are no insertions in-progress
+  * at exit.
+  */
+ static XLogRecPtr
+ WaitXLogInsertionsToFinish(XLogRecPtr upto, XLogRecPtr CurrPos)
+ {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 	int			lastslot;
+ 	int			nextslot;
+ 	volatile XLogInsertSlot *slot;
+ 	XLogRecPtr	slotptr = InvalidXLogRecPtr;
+ 	XLogRecPtr	LastPos;
+ 	int			extraWaits = 0;
+ 
+ 	if (MyProc == NULL)
+ 		elog(PANIC, "cannot wait without a PGPROC structure");
+ 
+ 	LastPos = CurrPos;
+ 
+ 	LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
+ 
+ 	lastslot = Insert->lastslot;
+ 	nextslot = Insert->nextslot;
+ 
+ 	/* Skip over slots that have finished already */
+ 	while (lastslot != nextslot)
  	{
! 		slot = &XLogCtl->XLogInsertSlots[lastslot];
! 		SpinLockAcquire(&slot->lck);
! 		slotptr = slot->CurrPos;
  
! 		if (XLogRecPtrIsInvalid(slotptr))
  		{
! 			lastslot = NextSlotNo(lastslot);
! 			SpinLockRelease(&slot->lck);
  		}
  		else
  		{
! 			/*
! 			 * This insertion is still in-progress. Wait for it to finish
! 			 * if it's <= upto, otherwise we're done.
! 			 */
! 			Insert->lastslot = lastslot;
! 
! 			if (XLogRecPtrIsInvalid(upto) || XLByteLE(upto, slotptr))
! 			{
! 				LastPos = slotptr;
! 				SpinLockRelease(&slot->lck);
! 				break;
! 			}
! 
! 			/* wait */
! 			MyProc->lwWaiting = true;
! 			MyProc->lwExclusive = false;
! 			MyProc->lwWaitLink = NULL;
! 			if (slot->head == NULL)
! 				slot->head = MyProc;
! 			else
! 				slot->tail->lwWaitLink = MyProc;
! 			slot->tail = MyProc;
! 			SpinLockRelease(&slot->lck);
! 			LWLockRelease(WALInsertTailLock);
! 			for (;;)
! 			{
! 				PGSemaphoreLock(&MyProc->sem, false);
! 				if (!MyProc->lwWaiting)
! 					break;
! 				extraWaits++;
! 			}
! 			LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
! 			lastslot = Insert->lastslot;
! 			nextslot = Insert->nextslot;
  		}
  	}
  
! 	Insert->lastslot = lastslot;
! 	LWLockRelease(WALInsertTailLock);
  
! 	while (extraWaits-- > 0)
! 		PGSemaphoreUnlock(&MyProc->sem);
! 
! 	return LastPos;
! }
! 
! /*
!  * Wait for the next insertion slot to become vacant.
!  */
! static void
! WaitForXLogInsertionSlotToBecomeFree(void)
! {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			lastslot;
! 	int			nextslot;
! 	int			extraWaits = 0;
! 
! 	if (MyProc == NULL)
! 		elog(PANIC, "cannot wait without a PGPROC structure");
! 
! 	LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
! 
! 	/*
! 	 * Re-read lastslot and nextslot, now that we have the wait-lock.
! 	 * We're reading nextslot without holding insertpos_lck. It could advance
! 	 * at the same time, but it can't advance beyond lastslot - 1.
! 	 */
! 	lastslot = Insert->lastslot;
! 	nextslot = Insert->nextslot;
! 
! 	/*
! 	 * If there are still no slots available, wait for the oldest slot to
! 	 * become vacant.
! 	 */
! 	while (NextSlotNo(nextslot) == lastslot)
  	{
! 		volatile XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[lastslot];
  
! 		SpinLockAcquire(&slot->lck);
! 		if (XLogRecPtrIsInvalid(slot->CurrPos))
! 		{
! 			SpinLockRelease(&slot->lck);
! 			break;
! 		}
! 
! 		/* wait */
! 		MyProc->lwWaiting = true;
! 		MyProc->lwExclusive = false;
! 		MyProc->lwWaitLink = NULL;
! 		if (slot->head == NULL)
! 			slot->head = MyProc;
! 		else
! 			slot->tail->lwWaitLink = MyProc;
! 		slot->tail = MyProc;
! 		SpinLockRelease(&slot->lck);
! 		LWLockRelease(WALInsertTailLock);
! 		for (;;)
! 		{
! 			PGSemaphoreLock(&MyProc->sem, false);
! 			if (!MyProc->lwWaiting)
! 				break;
! 			extraWaits++;
! 		}
! 		LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
! 		lastslot = Insert->lastslot;
! 		nextslot = Insert->nextslot;
  	}
  
! 	/*
! 	 * Ok, there is at least one empty slot now. That's enouugh for our
! 	 * insertion, but ẃhile we're at it, advance lastslot as much as we
! 	 * can. That way we don't need to come back here on the next call
! 	 * again.
! 	 */
! 	while (lastslot != nextslot)
! 	{
! 		volatile XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[lastslot];
! 		/*
! 		 * Don't need to grab the slot's spinlock here, because we're not
! 		 * interested in the exact value of CurrPos, only whether it's
! 		 * valid or not.
! 		 */
! 		if (!XLogRecPtrIsInvalid(slot->CurrPos))
! 			break;
  
! 		lastslot = NextSlotNo(lastslot);
! 	}
! 	Insert->lastslot = lastslot;
  
! 	LWLockRelease(WALInsertTailLock);
  }
  
  /*
***************
*** 1436,1470 **** XLogArchiveCleanup(const char *xlog)
  }
  
  /*
!  * Advance the Insert state to the next buffer page, writing out the next
!  * buffer if it still contains unwritten data.
!  *
!  * If new_segment is TRUE then we set up the next buffer page as the first
!  * page of the next xlog segment file, possibly but not usually the next
!  * consecutive file page.
!  *
!  * The global LogwrtRqst.Write pointer needs to be advanced to include the
!  * just-filled page.  If we can do this for free (without an extra lock),
!  * we do so here.  Otherwise the caller must do it.  We return TRUE if the
!  * request update still needs to be done, FALSE if we did it internally.
!  *
!  * Must be called with WALInsertLock held.
   */
! static bool
! AdvanceXLInsertBuffer(bool new_segment)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	XLogCtlWrite *Write = &XLogCtl->Write;
! 	int			nextidx = NextBufIdx(Insert->curridx);
! 	bool		update_needed = true;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
! 	XLogRecPtr	NewPageEndPtr;
  	XLogPageHeader NewPage;
  
! 	/* Use Insert->LogwrtResult copy if it's more fresh */
! 	if (XLByteLT(LogwrtResult.Write, Insert->LogwrtResult.Write))
! 		LogwrtResult = Insert->LogwrtResult;
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
--- 1983,2016 ----
  }
  
  /*
!  * Initialize XLOG buffers, writing out old buffers if they still contain
!  * unwritten data, upto the page containing 'upto'. Or if 'opportunistic' is
!  * true, initialize as many pages as we can without having to write out
!  * unwritten data. Any new pages are initialized to zeros, with pages headers
!  * initialized properly.
   */
! static void
! AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			nextidx;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
! 	XLogRecPtr	NewPageEndPtr = InvalidXLogRecPtr;
  	XLogPageHeader NewPage;
+ 	bool		needflush;
+ 	int			npages = 0;
  
! 	LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
! 
! 	/*
! 	 * Now that we have the lock, check if someone initialized the page
! 	 * already.
! 	 */
! /* XXX: fix indentation before commit */
! while (!XLByteLT(upto, XLogCtl->xlblocks[XLogCtl->curridx]) || opportunistic)
! {
! 	nextidx = NextBufIdx(XLogCtl->curridx);
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
***************
*** 1472,1483 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
- 	if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
- 	{
- 		/* nope, got work to do... */
- 		XLogRecPtr	FinishedPageRqstPtr;
  
! 		FinishedPageRqstPtr = XLogCtl->xlblocks[Insert->curridx];
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
--- 2018,2034 ----
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
  
! 	needflush = !XLByteLE(OldPageRqstPtr, LogwrtResult.Write);
! 
! 	if (needflush)
! 	{
! 		/*
! 		 * Nope, got work to do. If we just want to pre-initialize as much as
! 		 * we can without flushing, give up now.
! 		 */
! 		if (opportunistic)
! 			break;
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
***************
*** 1485,1529 **** AdvanceXLInsertBuffer(bool new_segment)
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, FinishedPageRqstPtr))
! 				xlogctl->LogwrtRqst.Write = FinishedPageRqstPtr;
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		update_needed = false;	/* Did the shared-request update */
! 
! 		if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/* OK, someone wrote it already */
! 			Insert->LogwrtResult = LogwrtResult;
! 		}
! 		else
! 		{
! 			/* Must acquire write lock */
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 			LogwrtResult = Write->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding insert lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false, false);
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
  		}
  	}
  
--- 2036,2085 ----
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, OldPageRqstPtr))
! 			{
! 				Assert(XLByteLE(OldPageRqstPtr, xlogctl->Insert.CurrPos));
! 				xlogctl->LogwrtRqst.Write = OldPageRqstPtr;
! 			}
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/*
! 			 * Must acquire write lock. Release WALBufMappingLock first, to
! 			 * make sure that all insertions that we need to wait for can
! 			 * finish (up to this same position). Otherwise we risk deadlock.
! 			 */
! 			LWLockRelease(WALBufMappingLock);
! 
! 			WaitXLogInsertionsToFinish(OldPageRqstPtr, InvalidXLogRecPtr);
! 
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 			LogwrtResult = XLogCtl->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding mapping lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false);
  				LWLockRelease(WALWriteLock);
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
+ 			/* Re-acquire WALBufMappingLock and retry */
+ 			LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
+ 			continue;
  		}
  	}
  
***************
*** 1531,1544 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[Insert->curridx];
! 
! 	if (new_segment)
! 	{
! 		/* force it to a segment start point */
! 		NewPageEndPtr.xrecoff += XLogSegSize - 1;
! 		NewPageEndPtr.xrecoff -= NewPageEndPtr.xrecoff % XLogSegSize;
! 	}
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
--- 2087,2093 ----
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[XLogCtl->curridx];
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
***************
*** 1548,1560 **** AdvanceXLInsertBuffer(bool new_segment)
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
! 	XLogCtl->xlblocks[nextidx] = NewPageEndPtr;
! 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
! 	Insert->curridx = nextidx;
! 	Insert->currpage = NewPage;
! 
! 	Insert->currpos = ((char *) NewPage) +SizeOfXLogShortPHD;
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
--- 2097,2106 ----
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
! 	Assert(NewPageEndPtr.xrecoff % XLOG_BLCKSZ == 0);
! 	Assert(XLogRecEndPtrToBufIdx(NewPageEndPtr) == nextidx);
  
! 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
***************
*** 1598,1608 **** AdvanceXLInsertBuffer(bool new_segment)
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
- 
- 		Insert->currpos = ((char *) NewPage) +SizeOfXLogLongPHD;
  	}
  
! 	return update_needed;
  }
  
  /*
--- 2144,2171 ----
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
  	}
  
! 	/*
! 	 * Make sure the initialization of the page becomes visible to others
! 	 * before the xlblocks update. GetXLogBuffer() reads xlblocks without
! 	 * holding a lock.
! 	 */
! 	pg_write_barrier();
! 
! 	*((volatile XLogRecPtr *) &XLogCtl->xlblocks[nextidx]) = NewPageEndPtr;
! 
! 	XLogCtl->curridx = nextidx;
! 
! 	npages++;
! }
! 	LWLockRelease(WALBufMappingLock);
! 
! #ifdef WAL_DEBUG
! 	if (npages > 0)
! 		elog(DEBUG1, "initialized %d pages, upto %X/%X",
! 			 npages, NewPageEndPtr.xlogid, NewPageEndPtr.xrecoff);
! #endif
  }
  
  /*
***************
*** 1647,1662 **** XLogCheckpointNeeded(uint32 logid, uint32 logseg)
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * If xlog_switch == TRUE, we are intending an xlog segment switch, so
!  * perform end-of-segment actions after writing the last page, even if
!  * it's not physically the end of its segment.  (NB: this will work properly
!  * only if caller specifies WriteRqst == page-end and flexible == false,
!  * and there is some data to write.)
!  *
!  * Must be called with WALWriteLock held.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
--- 2210,2221 ----
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * Must be called with WALWriteLock held. And you must've called
!  * WaitXLogInsertionsToFinish(WriteRqst) before grabbing the lock to make sure
!  * the data is ready to write.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
***************
*** 1674,1680 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  	/*
  	 * Update local LogwrtResult (caller probably did this already, but...)
  	 */
! 	LogwrtResult = Write->LogwrtResult;
  
  	/*
  	 * Since successive pages in the xlog cache are consecutively allocated,
--- 2233,2239 ----
  	/*
  	 * Update local LogwrtResult (caller probably did this already, but...)
  	 */
! 	LogwrtResult = XLogCtl->LogwrtResult;
  
  	/*
  	 * Since successive pages in the xlog cache are consecutively allocated,
***************
*** 1705,1718 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  		 * if we're passed a bogus WriteRqst.Write that is past the end of the
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
! 		if (!XLByteLT(LogwrtResult.Write, XLogCtl->xlblocks[curridx]))
  			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
! 				 XLogCtl->xlblocks[curridx].xlogid,
! 				 XLogCtl->xlblocks[curridx].xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
! 		LogwrtResult.Write = XLogCtl->xlblocks[curridx];
  		ispartialpage = XLByteLT(WriteRqst.Write, LogwrtResult.Write);
  
  		if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
--- 2264,2277 ----
  		 * if we're passed a bogus WriteRqst.Write that is past the end of the
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
! 		XLogRecPtr EndPtr = XLogCtl->xlblocks[curridx];
! 		if (!XLByteLT(LogwrtResult.Write, EndPtr))
  			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
! 				 EndPtr.xlogid, EndPtr.xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
! 		LogwrtResult.Write = EndPtr;
  		ispartialpage = XLByteLT(WriteRqst.Write, LogwrtResult.Write);
  
  		if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
***************
*** 1809,1824 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
- 			 * We also do this if this is the last page written for an xlog
- 			 * switch.
- 			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg || (xlog_switch && last_iteration))
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
--- 2368,2380 ----
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg)
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
***************
*** 1908,1915 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  			xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
  		SpinLockRelease(&xlogctl->info_lck);
  	}
- 
- 	Write->LogwrtResult = LogwrtResult;
  }
  
  /*
--- 2464,2469 ----
***************
*** 2081,2114 **** XLogFlush(XLogRecPtr record)
  	/* done already? */
  	if (!XLByteLE(record, LogwrtResult.Flush))
  	{
  		/* now wait for the write lock */
  		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 		LogwrtResult = XLogCtl->Write.LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			/* try to write/flush later additions to XLOG as well */
! 			if (LWLockConditionalAcquire(WALInsertLock, LW_EXCLUSIVE))
! 			{
! 				XLogCtlInsert *Insert = &XLogCtl->Insert;
! 				uint32		freespace = INSERT_FREESPACE(Insert);
  
! 				if (freespace < SizeOfXLogRecord)		/* buffer is full */
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 				else
! 				{
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 					WriteRqstPtr.xrecoff -= freespace;
! 				}
! 				LWLockRelease(WALInsertLock);
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = WriteRqstPtr;
! 			}
! 			else
! 			{
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = record;
! 			}
! 			XLogWrite(WriteRqst, false, false);
  		}
  		LWLockRelease(WALWriteLock);
  	}
--- 2635,2683 ----
  	/* done already? */
  	if (!XLByteLE(record, LogwrtResult.Flush))
  	{
+ 		/* try to write/flush later additions to XLOG as well */
+ 		volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 		uint32		freespace;
+ 		XLogRecPtr	insertpos;
+ 
+ 		/*
+ 		 * Get the current insert position.
+ 		 *
+ 		 * XXX: This used to do LWLockConditionalAcquire(WALInsertLock), and
+ 		 * fall back to writing just up to 'record' if we couldn't get the
+ 		 * lock. I wonder if it would be a good idea to have a
+ 		 * SpinLockConditionalAcquire function and use that? On one hand,
+ 		 * it would be good to not cause more contention on the lock if it's
+ 		 * busy, but on the other hand, this spinlock is much more lightweight
+ 		 * than the WALInsertLock was, so maybe it's better to just grab the
+ 		 * spinlock. Also note that if we stored the XLogRecPtr as one 64-bit
+ 		 * integer, we could just read it with no lock on platforms where
+ 		 * 64-bit integer accesses are atomic, which covers many common
+ 		 * platforms nowadays.
+ 		 */
+ 		SpinLockAcquire(&Insert->insertpos_lck);
+ 		insertpos = Insert->CurrPos;
+ 		SpinLockRelease(&Insert->insertpos_lck);
+ 
+ 		freespace = INSERT_FREESPACE(insertpos);
+ 		if (freespace < SizeOfXLogRecord)		/* buffer is full */
+ 			insertpos.xrecoff += freespace;
+ 
+ 		/*
+ 		 * Before actually performing the write, wait for all in-flight
+ 		 * insertions to the pages we're about to write to finish.
+ 		 */
+ 		insertpos = WaitXLogInsertionsToFinish(WriteRqstPtr, insertpos);
+ 
  		/* now wait for the write lock */
  		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 		LogwrtResult = XLogCtl->LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			WriteRqst.Write = insertpos;
! 			WriteRqst.Flush = insertpos;
  
! 			XLogWrite(WriteRqst, false);
  		}
  		LWLockRelease(WALWriteLock);
  	}
***************
*** 2218,2240 **** XLogBackgroundFlush(void)
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
- 
  	START_CRIT_SECTION();
  
! 	/* now wait for the write lock */
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 	LogwrtResult = XLogCtl->Write.LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
  	{
  		XLogwrtRqst WriteRqst;
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible, false);
  	}
! 	LWLockRelease(WALWriteLock);
  
  	END_CRIT_SECTION();
  }
  
  /*
--- 2787,2817 ----
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
  	START_CRIT_SECTION();
  
! 	/* now wait for any in-progress insertions to finish and get write lock */
! 	WaitXLogInsertionsToFinish(WriteRqstPtr, InvalidXLogRecPtr);
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 	LogwrtResult = XLogCtl->LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
  	{
  		XLogwrtRqst WriteRqst;
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible);
  	}
! 	LogwrtResult = XLogCtl->LogwrtResult;
  
  	END_CRIT_SECTION();
+ 
+ 	LWLockRelease(WALWriteLock);
+ 
+ 	/*
+ 	 * Great, done. To take some work off the critical path, try to initialize
+ 	 * as many of the no-longer-needed WAL buffers for future use as we can.
+ 	 */
+ 	AdvanceXLInsertBuffer(InvalidXLogRecPtr, true);
  }
  
  /*
***************
*** 5028,5033 **** XLOGShmemSize(void)
--- 5605,5613 ----
  	/* and the buffers themselves */
  	size = add_size(size, mul_size(XLOG_BLCKSZ, XLOGbuffers));
  
+ 	/* XLog insertion slots */
+ 	size = add_size(size, mul_size(sizeof(XLogInsertSlot), NumXLogInsertSlots));
+ 
  	/*
  	 * Note: we don't count ControlFileData, it comes out of the "slop factor"
  	 * added by CreateSharedMemoryAndSemaphores.  This lets us use this
***************
*** 5043,5048 **** XLOGShmemInit(void)
--- 5623,5629 ----
  	bool		foundCFile,
  				foundXLog;
  	char	   *allocptr;
+ 	int			i;
  
  	ControlFile = (ControlFileData *)
  		ShmemInitStruct("Control File", sizeof(ControlFileData), &foundCFile);
***************
*** 5068,5073 **** XLOGShmemInit(void)
--- 5649,5667 ----
  	memset(XLogCtl->xlblocks, 0, sizeof(XLogRecPtr) * XLOGbuffers);
  	allocptr += sizeof(XLogRecPtr) * XLOGbuffers;
  
+ 	/* Initialize insertion slots */
+ 	XLogCtl->XLogInsertSlots = (XLogInsertSlot *) allocptr;
+ 	for (i = 0; i < NumXLogInsertSlots; i++)
+ 	{
+ 		XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[i];
+ 		slot->CurrPos = InvalidXLogRecPtr;
+ 		slot->head = slot->tail = NULL;
+ 		SpinLockInit(&slot->lck);
+ 	}
+ 	XLogCtl->Insert.nextslot = 1;
+ 	XLogCtl->Insert.lastslot = 0;
+ 	allocptr += sizeof(XLogInsertSlot) * NumXLogInsertSlots;
+ 
  	/*
  	 * Align the start of the page buffers to an ALIGNOF_XLOG_BUFFER boundary.
  	 */
***************
*** 5082,5092 **** XLOGShmemInit(void)
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
- 	XLogCtl->Insert.currpage = (XLogPageHeader) (XLogCtl->pages);
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
--- 5676,5687 ----
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
+ 	SpinLockInit(&XLogCtl->Insert.insertpos_lck);
+ 
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
***************
*** 5961,5966 **** StartupXLOG(void)
--- 6556,6562 ----
  	uint32		freespace;
  	TransactionId oldestActiveXID;
  	bool		backupEndRequired = false;
+ 	int			firstIdx;
  
  	/*
  	 * Read control file and check XLOG status looks valid.
***************
*** 6717,6724 **** StartupXLOG(void)
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 	XLogCtl->xlblocks[0].xlogid = openLogId;
! 	XLogCtl->xlblocks[0].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
--- 7313,7324 ----
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 
! 	firstIdx = XLogRecPtrToBufIdx(EndOfLog);
! 	XLogCtl->curridx = firstIdx;
! 
! 	XLogCtl->xlblocks[firstIdx].xlogid = openLogId;
! 	XLogCtl->xlblocks[firstIdx].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
***************
*** 6726,6751 **** StartupXLOG(void)
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[0].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) Insert->currpage, readBuf, XLOG_BLCKSZ);
! 	Insert->currpos = (char *) Insert->currpage +
! 		(EndOfLog.xrecoff + XLOG_BLCKSZ - XLogCtl->xlblocks[0].xrecoff);
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
- 	XLogCtl->Write.LogwrtResult = LogwrtResult;
- 	Insert->LogwrtResult = LogwrtResult;
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(Insert->currpos, 0, freespace);
! 		XLogCtl->Write.curridx = 0;
  	}
  	else
  	{
--- 7326,7348 ----
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[firstIdx].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) &XLogCtl->pages[firstIdx * XLOG_BLCKSZ], readBuf, XLOG_BLCKSZ);
! 	Insert->CurrPos = EndOfLog;
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = XLOG_BLCKSZ - EndRecPtr.xrecoff % XLOG_BLCKSZ;
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(&XLogCtl->pages[firstIdx * XLOG_BLCKSZ] + EndRecPtr.xrecoff % XLOG_BLCKSZ, 0, freespace);
! 		XLogCtl->Write.curridx = firstIdx;
  	}
  	else
  	{
***************
*** 6757,6763 **** StartupXLOG(void)
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(0);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
--- 7354,7360 ----
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(firstIdx);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
***************
*** 7251,7257 **** GetRedoRecPtr(void)
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire WALInsertLock which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
--- 7848,7854 ----
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire insertpos_lck which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
***************
*** 7527,7532 **** CreateCheckPoint(int flags)
--- 8124,8130 ----
  	uint32		insert_logSeg;
  	TransactionId *inCommitXids;
  	int			nInCommit;
+ 	XLogRecPtr	curInsert;
  
  	/*
  	 * An end-of-recovery checkpoint is really a shutdown checkpoint, just
***************
*** 7595,7604 **** CreateCheckPoint(int flags)
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * We must hold WALInsertLock while examining insert state to determine
! 	 * the checkpoint REDO pointer.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
--- 8193,8202 ----
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * Determine the checkpoint REDO pointer.
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	curInsert = Insert->CurrPos;
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
***************
*** 7610,7616 **** CreateCheckPoint(int flags)
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding the WALInsertLock we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
--- 8208,8214 ----
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding insertpos_lck we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
***************
*** 7619,7633 **** CreateCheckPoint(int flags)
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
- 		XLogRecPtr	curInsert;
- 
- 		INSERT_RECPTR(curInsert, Insert, Insert->curridx);
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			LWLockRelease(WALInsertLock);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
--- 8217,8228 ----
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
***************
*** 7653,7666 **** CreateCheckPoint(int flags)
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace < SizeOfXLogRecord)
! 	{
! 		(void) AdvanceXLInsertBuffer(false);
! 		/* OK to ignore update return flag, since we will do flush anyway */
! 		freespace = INSERT_FREESPACE(Insert);
! 	}
! 	INSERT_RECPTR(checkPoint.redo, Insert, Insert->curridx);
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
--- 8248,8257 ----
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(curInsert);
  	if (freespace < SizeOfXLogRecord)
! 		curInsert = AdvanceXLogRecPtrToNextPage(curInsert);
! 	checkPoint.redo = curInsert;
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
***************
*** 7686,7692 **** CreateCheckPoint(int flags)
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
--- 8277,8283 ----
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
***************
*** 7706,7712 **** CreateCheckPoint(int flags)
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released WALInsertLock, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
--- 8297,8303 ----
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released insertpos_lck, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
***************
*** 8073,8087 **** CreateRestartPoint(int flags)
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * You need to hold WALInsertLock and info_lck to update it, although
! 	 * during recovery acquiring WALInsertLock is just pro forma, because
! 	 * there is no other processes updating Insert.RedoRecPtr.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * Prepare to accumulate statistics.
--- 8664,8678 ----
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * Like in CreateCheckPoint(), you need both insertpos_lck and info_lck
! 	 * to update it, although during recovery acquiring insertpos_lck is just
! 	 * pro forma, because no WAL insertions are happening.
  	 */
! 	SpinLockAcquire(&xlogctl->Insert.insertpos_lck);
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
! 	SpinLockRelease(&xlogctl->Insert.insertpos_lck);
  
  	/*
  	 * Prepare to accumulate statistics.
***************
*** 8274,8279 **** RequestXLogSwitch(void)
--- 8865,8871 ----
  {
  	XLogRecPtr	RecPtr;
  	XLogRecData rdata;
+ 	XLogwrtRqst FlushRqst;
  
  	/* XLOG SWITCH, alone among xlog record types, has no data */
  	rdata.buffer = InvalidBuffer;
***************
*** 8283,8288 **** RequestXLogSwitch(void)
--- 8875,8901 ----
  
  	RecPtr = XLogInsert(RM_XLOG_ID, XLOG_SWITCH, &rdata);
  
+ 	/* XXX: before this patch, TRACE_POSTGRESQL_XLOG_SWITCH was not called
+ 	 * if the xlog switch had no work to do, ie. if we were already at the
+ 	 * beginning of a new XLOG segment. You can check if RecPtr points to
+ 	 * beginning of a segment if you want to keep the distinction.
+ 	 */
+ 	TRACE_POSTGRESQL_XLOG_SWITCH();
+ 
+ 	/*
+ 	 * Flush through the end of the page containing XLOG_SWITCH, and
+ 	 * perform end-of-segment actions (eg, notifying archiver).
+ 	 */
+ 	WaitXLogInsertionsToFinish(RecPtr, InvalidXLogRecPtr);
+ 
+ 	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
+ 	FlushRqst.Write = RecPtr;
+ 	FlushRqst.Flush = RecPtr;
+ 	START_CRIT_SECTION();
+ 	XLogWrite(FlushRqst, false);
+ 	END_CRIT_SECTION();
+ 	LWLockRelease(WALWriteLock);
+ 
  	return RecPtr;
  }
  
***************
*** 8836,8841 **** issue_xlog_fsync(int fd, uint32 log, uint32 seg)
--- 9449,9455 ----
  XLogRecPtr
  do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	XLogRecPtr	checkpointloc;
  	XLogRecPtr	startpoint;
***************
*** 8885,8910 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  	 * since we expect that any pages not modified during the backup interval
  	 * must have been correctly captured by the backup.)
  	 *
! 	 * We must hold WALInsertLock to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
! 		if (XLogCtl->Insert.exclusiveBackup)
  		{
! 			LWLockRelease(WALInsertLock);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		XLogCtl->Insert.exclusiveBackup = true;
  	}
  	else
! 		XLogCtl->Insert.nonExclusiveBackups++;
! 	XLogCtl->Insert.forcePageWrites = true;
! 	LWLockRelease(WALInsertLock);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
--- 9499,9524 ----
  	 * since we expect that any pages not modified during the backup interval
  	 * must have been correctly captured by the backup.)
  	 *
! 	 * We must hold insertpos_lck to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
! 		if (Insert->exclusiveBackup)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		Insert->exclusiveBackup = true;
  	}
  	else
! 		Insert->nonExclusiveBackups++;
! 	Insert->forcePageWrites = true;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
***************
*** 8966,8978 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			LWLockAcquire(WALInsertLock, LW_SHARED);
! 			if (XLByteLT(XLogCtl->Insert.lastBackupStart, startpoint))
  			{
! 				XLogCtl->Insert.lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			LWLockRelease(WALInsertLock);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
--- 9580,9592 ----
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			SpinLockAcquire(&Insert->insertpos_lck);
! 			if (XLByteLT(Insert->lastBackupStart, startpoint))
  			{
! 				Insert->lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			SpinLockRelease(&Insert->insertpos_lck);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
***************
*** 9054,9063 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
  		Assert(XLogCtl->Insert.exclusiveBackup);
--- 9668,9678 ----
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
  		Assert(XLogCtl->Insert.exclusiveBackup);
***************
*** 9074,9080 **** pg_start_backup_callback(int code, Datum arg)
  	{
  		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 9689,9695 ----
  	{
  		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9087,9092 **** pg_start_backup_callback(int code, Datum arg)
--- 9702,9708 ----
  XLogRecPtr
  do_pg_stop_backup(char *labelfile, bool waitforarchive)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	XLogRecPtr	startpoint;
  	XLogRecPtr	stoppoint;
***************
*** 9128,9136 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
! 		XLogCtl->Insert.exclusiveBackup = false;
  	else
  	{
  		/*
--- 9744,9752 ----
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
! 		Insert->exclusiveBackup = false;
  	else
  	{
  		/*
***************
*** 9139,9154 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 		XLogCtl->Insert.nonExclusiveBackups--;
  	}
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  
  	if (exclusive)
  	{
--- 9755,9770 ----
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(Insert->nonExclusiveBackups > 0);
! 		Insert->nonExclusiveBackups--;
  	}
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	if (exclusive)
  	{
***************
*** 9350,9365 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  void
  do_pg_abort_backup(void)
  {
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 	Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 	XLogCtl->Insert.nonExclusiveBackups--;
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 9966,9983 ----
  void
  do_pg_abort_backup(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	Assert(Insert->nonExclusiveBackups > 0);
! 	Insert->nonExclusiveBackups--;
! 
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9413,9424 **** GetStandbyFlushRecPtr(void)
  XLogRecPtr
  GetXLogInsertRecPtr(void)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	LWLockAcquire(WALInsertLock, LW_SHARED);
! 	INSERT_RECPTR(current_recptr, Insert, Insert->curridx);
! 	LWLockRelease(WALInsertLock);
  
  	return current_recptr;
  }
--- 10031,10042 ----
  XLogRecPtr
  GetXLogInsertRecPtr(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	current_recptr = Insert->CurrPos;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	return current_recptr;
  }
*** a/src/backend/storage/lmgr/spin.c
--- b/src/backend/storage/lmgr/spin.c
***************
*** 56,61 **** SpinlockSemas(void)
--- 56,64 ----
  	 *
  	 * For now, though, we just need a few spinlocks (10 should be plenty)
  	 * plus one for each LWLock and one for each buffer header.
+ 	 *
+ 	 * XXX: remember to adjust this for the number of spinlocks needed by the
+ 	 * xlog.c changes before committing!
  	 */
  	return NumLWLocks() + NBuffers + 10;
  }
*** a/src/include/storage/lwlock.h
--- b/src/include/storage/lwlock.h
***************
*** 53,59 **** typedef enum LWLockId
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALInsertLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
--- 53,59 ----
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALBufMappingLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
***************
*** 79,84 **** typedef enum LWLockId
--- 79,85 ----
  	SerializablePredicateLockListLock,
  	OldSerXidLock,
  	SyncRepLock,
+ 	WALInsertTailLock,
  	/* Individual lock IDs end here */
  	FirstBufMappingLock,
  	FirstLockMgrLock = FirstBufMappingLock + NUM_BUFFER_PARTITIONS,

*** a/src/backend/access/transam/xlog.c
--- b/src/backend/access/transam/xlog.c
***************
*** 42,47 ****
--- 42,48 ----
  #include "postmaster/startup.h"
  #include "replication/walreceiver.h"
  #include "replication/walsender.h"
+ #include "storage/barrier.h"
  #include "storage/bufmgr.h"
  #include "storage/fd.h"
  #include "storage/ipc.h"
***************
*** 290,315 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There are actually three shared-memory copies of
!  * LogwrtResult, plus one unshared copy in each backend.  Here's how it works:
!  *		XLogCtl->LogwrtResult is protected by info_lck
!  *		XLogCtl->Write.LogwrtResult is protected by WALWriteLock
!  *		XLogCtl->Insert.LogwrtResult is protected by WALInsertLock
!  * One must hold the associated lock to read or write any of these, but
!  * of course no lock is needed to read/write the unshared LogwrtResult.
!  *
!  * XLogCtl->LogwrtResult and XLogCtl->Write.LogwrtResult are both "always
!  * right", since both are updated by a write or flush operation before
!  * it releases WALWriteLock.  The point of keeping XLogCtl->Write.LogwrtResult
!  * is that it can be examined/modified by code that already holds WALWriteLock
!  * without needing to grab info_lck as well.
!  *
!  * XLogCtl->Insert.LogwrtResult may lag behind the reality of the other two,
!  * but is updated when convenient.	Again, it exists for the convenience of
!  * code that is already holding WALInsertLock but not the other locks.
!  *
!  * The unshared LogwrtResult may lag behind any or all of these, and again
!  * is updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
--- 291,301 ----
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There is one shared-memory copy of LogwrtResult,
!  * plus one unshared copy in each backend. To read the shared copy, you need
!  * to hold info_lck *or* WALWriteLock. To update it, you need to hold both
!  * locks. The unshared LogwrtResult may lag behind the shared copy, and is
!  * updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
***************
*** 319,328 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  The other locks are held longer (potentially
!  * over I/O operations), so we use LWLocks for them.  These locks are:
   *
!  * WALInsertLock: must be held to insert a record into the WAL buffers.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
--- 305,319 ----
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  insertpos_lck protects the current logical
!  * insert location, ie. the head of reserved WAL space.  The other locks are
!  * held longer (potentially over I/O operations), so we use LWLocks for them.
!  * These locks are:
   *
!  * WALBufMappingLock: must be held to replace a page in the WAL buffer cache.
!  * This is only held while initializing and changing the mapping. If the
!  * contents of the buffer being replaced haven't been written yet, the mapping
!  * lock is released while the write is done, and reacquired afterwards.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
***************
*** 334,339 **** static XLogRecPtr RedoStartLSN = {0, 0};
--- 325,399 ----
   * only one checkpointer at a time; currently, with all checkpoints done by
   * the checkpointer, this is just pro forma).
   *
+  *
+  * Inserting a new WAL record is a two-step process:
+  *
+  * 1. Reserve the right amount of space from the WAL, and the next insertion
+  *    slot to advertise that the insertion is in progress. The current head
+  *    of reserved space is kept in Insert->CurrPos, and is protected by
+  *    insertpos_lck. Try to keep this section as short as possible,
+  *    insertpos_lck can be heavily contended on a busy system
+  *
+  * 2. Copy the record to the reserved WAL space. This involves finding the
+  *    correct WAL buffer containing the reserved space, and copying the
+  *    record in place. This can be done concurrently in multiple processes.
+  *
+  * To allow as much parallelism as possible for step 2, we try hard to avoid
+  * lock contention in that code path. Each insertion is asssigned its own
+  * "XLog insertion slot", which is used to advertise the position the backend
+  * is writing to. The slot is marked as in-use in step 1, while holding
+  * insertpos_lck, by setting the position field in the slot. When the backend
+  * is finished with the insertion, it clears its slot. Each slot is protected
+  * by a separate spinlock, to keep contention minimal.
+  *
+  * The insertion slots also provide a mechanism to wait for an insertion to
+  * finish. This is important when an XLOG page is written out - any
+  * in-progress insertions must finish copying data to the page first, or the
+  * on-disk copy will be incomplete. Waiting is done by the
+  * WaitXLogInsertionsToFinish() function. It adds the current process to the
+  * waiting queue in the slot it needs to wait for, and when that insertion
+  * finishes (or proceeds to the next page, at least), the inserter wakes up
+  * the process.
+  *
+  * The insertion slots form a ring. Insert->nextslot points to the next free
+  * slot, and Insert->lastslot points to the last slot that's still in use.
+  * lastslot can lag behind reality by any number of slots, as long as nextslot
+  * doesn't catch up with it. lastslot is advanced by
+  * WaitXLogInsertionsToFinish(), and is protected by WALInsertTailLock.
+  * nextslot is advanced in ReserveXLogInsertLocation() and is protected by
+  * insertpos_lck. Both slot variables are 32-bit integers, so that they can
+  * be read atomically without holding a lock.
+  *
+  * Whenever the ring fills up, ie. when nextslot wraps around and catches up
+  * with lastslot, ReserveXLogInsertLocation() has to wait for the oldest
+  * insertion to finish and advance lastslot, to make room for the new
+  * insertion. This is done by WaitForXLogInsertionSlotToBecomeFree() function,
+  * which is similar to WaitXLogInsertionsToFinish(), but instead of waiting
+  * for all insertions up to a given point to finish, it just waits for the
+  * inserter in the oldest slot to finish.
+  *
+  *
+  * Deadlock analysis
+  * -----------------
+  *
+  * It's important to call WaitXLogInsertionsToFinish() *before* acquiring
+  * WALWriteLock. Otherwise you might get stuck waiting for an insertion to
+  * finish (or at least advance to next uninitialized page), while you're
+  * holding WALWriteLock. That would be bad, because the backend you're waiting
+  * for might need to acquire WALWriteLock, too, to evict an old buffer, so
+  * you'd get deadlock.
+  *
+  * WaitXLogInsertionsToFinish() will not get stuck indefinitely, as long as
+  * it's called with a location that's known to be already allocated in the WAL
+  * buffers. Calling it with the position of a record you've already inserted
+  * satisfies that condition, so the common pattern:
+  *
+  *   recptr = XLogInsert(...)
+  *   XLogFlush(recptr)
+  *
+  * is safe. It can't get stuck, because an insertion to a WAL page that's
+  * already initialized in cache can always proceed without waiting on a lock.
+  *
   *----------
   */
  
***************
*** 354,364 **** typedef struct XLogwrtResult
   */
  typedef struct XLogCtlInsert
  {
! 	XLogwrtResult LogwrtResult; /* a recent value of LogwrtResult */
! 	XLogRecPtr	PrevRecord;		/* start of previously-inserted record */
! 	int			curridx;		/* current block index in cache */
! 	XLogPageHeader currpage;	/* points to header of block in cache */
! 	char	   *currpos;		/* current insertion point in cache */
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
--- 414,443 ----
   */
  typedef struct XLogCtlInsert
  {
! 	slock_t		insertpos_lck;	/* protects all the fields in this struct
! 								 * (except lastslot). */
! 
! 	int32		nextslot;		/* next insertion slot to use */
! 	int32		lastslot;		/* last in-use insertion slot (protected by
! 								 * WALInsertTailLock) */
! 
! 	/*
! 	 * CurrPos is the very tip of the reserved WAL space at the moment. The
! 	 * next record will be inserted there (or somewhere after it if there's
! 	 * not enough space on the current page). PrevRecord points to the
! 	 * beginning of the last record already reserved. It might not be fully
! 	 * copied into place yet, but we know its exact location already.
! 	 */
! 	XLogRecPtr	CurrPos;
! 	XLogRecPtr	PrevRecord;
! 
! 	/*
! 	 * padding to push RedoRecPtr and forcePageWrites, which rarely change,
! 	 * to a different cache line than the rapidly-changing CurrPos and
! 	 * PrevRecord values. XXX: verify if this makes any difference
! 	 */
! 	char		padding[128];
! 
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
***************
*** 388,406 **** typedef struct XLogCtlInsert
   */
  typedef struct XLogCtlWrite
  {
- 	XLogwrtResult LogwrtResult; /* current value of LogwrtResult */
  	int			curridx;		/* cache index of next block to write */
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by WALInsertLock: */
  	XLogCtlInsert Insert;
  
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
--- 467,500 ----
   */
  typedef struct XLogCtlWrite
  {
  	int			curridx;		/* cache index of next block to write */
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
+ 
+ /*
+  * Slots for in-progress WAL insertions.
+  */
+ typedef struct
+ {
+ 	slock_t		lck;
+ 	XLogRecPtr	CurrPos;	/* current position this process is inserting to */
+ 	PGPROC	   *head;		/* head of list of waiting PGPROCs */
+ 	PGPROC	   *tail;		/* tail of list of waiting PGPROCs */
+ } XLogInsertSlot;
+ 
+ #define NumXLogInsertSlots	1000
+ 
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by insertpos_lck: */
  	XLogCtlInsert Insert;
  
+ 	XLogInsertSlot *XLogInsertSlots;
+ 
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
***************
*** 414,422 **** typedef struct XLogCtlData
  	XLogCtlWrite Write;
  
  	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALInsertLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
--- 508,526 ----
  	XLogCtlWrite Write;
  
  	/*
+ 	 * To change curridx and the identity of a buffer, you need to hold
+ 	 * WALBufMappingLock. To change the identity of a buffer that's
+ 	 * still dirty, the old page needs to be written out first, and for that
+ 	 * you need WALWriteLock, and you need to ensure that there's no
+ 	 * in-progress insertions to the page by calling
+ 	 * WaitXLogInsertionsToFinish().
+ 	 */
+ 	int			curridx;		/* current (latest) block index in cache */
+ 
+ 	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALBufMappingLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
***************
*** 494,521 **** static XLogCtlData *XLogCtl = NULL;
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Macros for managing XLogInsert state.  In most cases, the calling routine
!  * has local copies of XLogCtl->Insert and/or XLogCtl->Insert->curridx,
!  * so these are passed as parameters instead of being fetched via XLogCtl.
   */
  
- /* Free space remaining in the current xlog page buffer */
- #define INSERT_FREESPACE(Insert)  \
- 	(XLOG_BLCKSZ - ((Insert)->currpos - (char *) (Insert)->currpage))
  
! /* Construct XLogRecPtr value for current insertion point */
! #define INSERT_RECPTR(recptr,Insert,curridx)  \
! 	( \
! 	  (recptr).xlogid = XLogCtl->xlblocks[curridx].xlogid, \
! 	  (recptr).xrecoff = \
! 		XLogCtl->xlblocks[curridx].xrecoff - INSERT_FREESPACE(Insert) \
! 	)
  
! #define PrevBufIdx(idx)		\
! 		(((idx) == 0) ? XLogCtl->XLogCacheBlck : ((idx) - 1))
  
! #define NextBufIdx(idx)		\
! 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
--- 598,628 ----
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Calculate the amount of space left on the page after 'endptr'.
!  * Beware multiple evaluation!
   */
+ #define INSERT_FREESPACE(endptr)	\
+ 	(((endptr).xrecoff % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr).xrecoff % XLOG_BLCKSZ))
+ 
+ #define NextBufIdx(idx)		\
+ 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  
! #define NextSlotNo(idx)		\
! 		(((idx) == NumXLogInsertSlots) ? 0 : ((idx) + 1))
  
! /*
!  * XLogRecPtrToBufIdx returns the index of the WAL buffer that holds, or
!  * would hold if it was in cache, the page containing 'recptr'.
!  *
!  * XLogRecEndPtrToBufIdx is the same, but a pointer to the first byte of a
!  * page is taken to mean the previous page.
!  */
! #define XLogRecPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogSegsPerFile * XLogSegSize) + (recptr).xrecoff)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
  
! #define XLogRecEndPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogSegsPerFile * XLogSegSize) + (recptr).xrecoff - 1)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
***************
*** 641,649 **** static void KeepLogSeg(XLogRecPtr recptr, uint32 *logId, uint32 *logSeg);
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static bool AdvanceXLInsertBuffer(bool new_segment);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
--- 748,756 ----
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static void AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
***************
*** 690,695 **** static bool read_backup_label(XLogRecPtr *checkPointLoc,
--- 797,820 ----
  static void rm_redo_error_callback(void *arg);
  static int	get_sync_bit(int method);
  
+ static XLogRecPtr PerformXLogInsert(int write_len,
+ 				  bool isLogSwitch,
+ 				  XLogRecord *rechdr,
+ 				  XLogRecData *rdata, pg_crc32 rdata_crc,
+ 				  bool didPageWrites);
+ static bool ReserveXLogInsertLocation(int size, bool forcePageWrites,
+ 						  bool isLogSwitch,
+ 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
+ 						  XLogRecPtr *EndPos_p,
+ 						  XLogInsertSlot **myslot_p, bool *updrqst_p);
+ static void UpdateSlotCurrPos(volatile XLogInsertSlot *myslot,
+ 				  XLogRecPtr CurrPos);
+ static XLogRecPtr WaitXLogInsertionsToFinish(XLogRecPtr upto,
+ 						   XLogRecPtr CurrPos);
+ static void WaitForXLogInsertionSlotToBecomeFree(void);
+ static char *GetXLogBuffer(XLogRecPtr ptr);
+ static XLogRecPtr AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr);
+ 
  
  /*
   * Insert an XLOG record having the specified RMID and info bytes,
***************
*** 710,721 **** XLogRecPtr
  XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
- 	XLogRecord *record;
- 	XLogContRecord *contrecord;
  	XLogRecPtr	RecPtr;
- 	XLogRecPtr	WriteRqst;
- 	uint32		freespace;
- 	int			curridx;
  	XLogRecData *rdt;
  	XLogRecData *rdt_lastnormal;
  	Buffer		dtbuf[XLR_MAX_BKP_BLOCKS];
--- 835,841 ----
***************
*** 729,739 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  	uint32		len,
  				write_len;
  	unsigned	i;
- 	bool		updrqst;
  	bool		doPageWrites;
! 	bool		isLogSwitch = false;
! 	bool		fpwChange = false;
  	uint8		info_orig = info;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
--- 849,858 ----
  	uint32		len,
  				write_len;
  	unsigned	i;
  	bool		doPageWrites;
! 	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
  	uint8		info_orig = info;
+ 	XLogRecord	rechdr;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
***************
*** 746,775 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  	TRACE_POSTGRESQL_XLOG_INSERT(rmid, info);
  
  	/*
! 	 * Handle special cases/records.
  	 */
! 	if (rmid == RM_XLOG_ID)
  	{
- 		switch (info)
- 		{
- 			case XLOG_SWITCH:
- 				isLogSwitch = true;
- 				break;
- 
- 			case XLOG_FPW_CHANGE:
- 				fpwChange = true;
- 				break;
- 
- 			default:
- 				break;
- 		}
- 	}
- 	else if (IsBootstrapProcessingMode())
- 	{
- 		/*
- 		 * In bootstrap mode, we don't actually log anything but XLOG resources;
- 		 * return a phony record pointer.
- 		 */
  		RecPtr.xlogid = 0;
  		RecPtr.xrecoff = SizeOfXLogLongPHD;		/* start of 1st chkpt record */
  		return RecPtr;
--- 865,875 ----
  	TRACE_POSTGRESQL_XLOG_INSERT(rmid, info);
  
  	/*
! 	 * In bootstrap mode, we don't actually log anything but XLOG resources;
! 	 * return a phony record pointer.
  	 */
! 	if (IsBootstrapProcessingMode() && rmid != RM_XLOG_ID)
  	{
  		RecPtr.xlogid = 0;
  		RecPtr.xrecoff = SizeOfXLogLongPHD;		/* start of 1st chkpt record */
  		return RecPtr;
***************
*** 939,1072 **** begin:;
  	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
  		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
- 	START_CRIT_SECTION();
- 
- 	/* Now wait to get insert lock */
- 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
- 
  	/*
! 	 * Check to see if my RedoRecPtr is out of date.  If so, may have to go
! 	 * back and recompute everything.  This can only happen just after a
! 	 * checkpoint, so it's better to be slow in this case and fast otherwise.
! 	 *
! 	 * If we aren't doing full-page writes then RedoRecPtr doesn't actually
! 	 * affect the contents of the XLOG record, so we'll update our local copy
! 	 * but not force a recomputation.
  	 */
! 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr))
! 	{
! 		Assert(XLByteLT(RedoRecPtr, Insert->RedoRecPtr));
! 		RedoRecPtr = Insert->RedoRecPtr;
  
! 		if (doPageWrites)
! 		{
! 			for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
! 			{
! 				if (dtbuf[i] == InvalidBuffer)
! 					continue;
! 				if (dtbuf_bkp[i] == false &&
! 					XLByteLE(dtbuf_lsn[i], RedoRecPtr))
! 				{
! 					/*
! 					 * Oops, this buffer now needs to be backed up, but we
! 					 * didn't think so above.  Start over.
! 					 */
! 					LWLockRelease(WALInsertLock);
! 					END_CRIT_SECTION();
! 					rdt_lastnormal->next = NULL;
! 					info = info_orig;
! 					goto begin;
! 				}
! 			}
! 		}
! 	}
  
  	/*
! 	 * Also check to see if fullPageWrites or forcePageWrites was just turned on;
! 	 * if we weren't already doing full-page writes then go back and recompute.
! 	 * (If it was just turned off, we could recompute the record without full pages,
! 	 * but we choose not to bother.)
  	 */
! 	if ((Insert->fullPageWrites || Insert->forcePageWrites) && !doPageWrites)
  	{
! 		/* Oops, must redo it with full-page data. */
! 		LWLockRelease(WALInsertLock);
! 		END_CRIT_SECTION();
  		rdt_lastnormal->next = NULL;
  		info = info_orig;
  		goto begin;
  	}
  
- 	/*
- 	 * If there isn't enough space on the current XLOG page for a record
- 	 * header, advance to the next page (leaving the unused space as zeroes).
- 	 */
- 	updrqst = false;
- 	freespace = INSERT_FREESPACE(Insert);
- 	if (freespace < SizeOfXLogRecord)
- 	{
- 		updrqst = AdvanceXLInsertBuffer(false);
- 		freespace = INSERT_FREESPACE(Insert);
- 	}
- 
- 	/* Compute record's XLOG location */
- 	curridx = Insert->curridx;
- 	INSERT_RECPTR(RecPtr, Insert, curridx);
- 
- 	/*
- 	 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
- 	 * segment, we need not insert it (and don't want to because we'd like
- 	 * consecutive switch requests to be no-ops).  Instead, make sure
- 	 * everything is written and flushed through the end of the prior segment,
- 	 * and return the prior segment's end address.
- 	 */
- 	if (isLogSwitch &&
- 		(RecPtr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
- 	{
- 		/* We can release insert lock immediately */
- 		LWLockRelease(WALInsertLock);
- 
- 		RecPtr.xrecoff -= SizeOfXLogLongPHD;
- 		if (RecPtr.xrecoff == 0)
- 		{
- 			/* crossing a logid boundary */
- 			RecPtr.xlogid -= 1;
- 			RecPtr.xrecoff = XLogFileSize;
- 		}
- 
- 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
- 		LogwrtResult = XLogCtl->Write.LogwrtResult;
- 		if (!XLByteLE(RecPtr, LogwrtResult.Flush))
- 		{
- 			XLogwrtRqst FlushRqst;
- 
- 			FlushRqst.Write = RecPtr;
- 			FlushRqst.Flush = RecPtr;
- 			XLogWrite(FlushRqst, false, false);
- 		}
- 		LWLockRelease(WALWriteLock);
- 
- 		END_CRIT_SECTION();
- 
- 		return RecPtr;
- 	}
- 
- 	/* Insert record header */
- 
- 	record = (XLogRecord *) Insert->currpos;
- 	record->xl_prev = Insert->PrevRecord;
- 	record->xl_xid = GetCurrentTransactionIdIfAny();
- 	record->xl_tot_len = SizeOfXLogRecord + write_len;
- 	record->xl_len = len;		/* doesn't include backup blocks */
- 	record->xl_info = info;
- 	record->xl_rmid = rmid;
- 
- 	/* Now we can finish computing the record's CRC */
- 	COMP_CRC32(rdata_crc, (char *) record + sizeof(pg_crc32),
- 			   SizeOfXLogRecord - sizeof(pg_crc32));
- 	FIN_CRC32(rdata_crc);
- 	record->xl_crc = rdata_crc;
- 
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
  	{
--- 1039,1078 ----
  	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
  		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
  	/*
! 	 * Construct record header. We can't CRC it yet, because the prev-link
! 	 * needs to be covered by the CRC and we don't know that yet. We will
! 	 * finish computing the CRC when we do.
  	 */
! 	MemSet(&rechdr, 0, sizeof(rechdr));
! 	/* rechdr.xl_prev is set in PerformXLogInsert() */
! 	rechdr.xl_xid = GetCurrentTransactionIdIfAny();
! 	rechdr.xl_tot_len = SizeOfXLogRecord + write_len;
! 	rechdr.xl_len = len;		/* doesn't include backup blocks */
! 	rechdr.xl_info = info;
! 	rechdr.xl_rmid = rmid;
  
! 	START_CRIT_SECTION();
  
  	/*
! 	 * Try to do the insertion.
  	 */
! 	RecPtr = PerformXLogInsert(write_len, isLogSwitch, &rechdr,
! 							   rdata, rdata_crc, doPageWrites);
! 	END_CRIT_SECTION();
! 
! 	if (XLogRecPtrIsInvalid(RecPtr))
  	{
! 		/*
! 		 * Oops, must redo it with full-page data. Unlink the backup blocks
! 		 * from the chain and reset info bitmask to undo the changes we've
! 		 * done.
! 		 */
  		rdt_lastnormal->next = NULL;
  		info = info_orig;
  		goto begin;
  	}
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
  	{
***************
*** 1075,1267 **** begin:;
  		initStringInfo(&buf);
  		appendStringInfo(&buf, "INSERT @ %X/%X: ",
  						 RecPtr.xlogid, RecPtr.xrecoff);
! 		xlog_outrec(&buf, record);
  		if (rdata->data != NULL)
  		{
  			appendStringInfo(&buf, " - ");
! 			RmgrTable[record->xl_rmid].rm_desc(&buf, record->xl_info, rdata->data);
  		}
  		elog(LOG, "%s", buf.data);
  		pfree(buf.data);
  	}
  #endif
  
! 	/* Record begin of record in appropriate places */
! 	ProcLastRecPtr = RecPtr;
! 	Insert->PrevRecord = RecPtr;
  
! 	Insert->currpos += SizeOfXLogRecord;
! 	freespace -= SizeOfXLogRecord;
  
  	/*
! 	 * Append the data, including backup blocks if any
  	 */
! 	while (write_len)
! 	{
! 		while (rdata->data == NULL)
! 			rdata = rdata->next;
  
! 		if (freespace > 0)
  		{
! 			if (rdata->len > freespace)
  			{
! 				memcpy(Insert->currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				write_len -= freespace;
! 			}
! 			else
! 			{
! 				memcpy(Insert->currpos, rdata->data, rdata->len);
! 				freespace -= rdata->len;
! 				write_len -= rdata->len;
! 				Insert->currpos += rdata->len;
! 				rdata = rdata->next;
! 				continue;
  			}
  		}
  
! 		/* Use next buffer */
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		curridx = Insert->curridx;
! 		/* Insert cont-record header */
! 		Insert->currpage->xlp_info |= XLP_FIRST_IS_CONTRECORD;
! 		contrecord = (XLogContRecord *) Insert->currpos;
! 		contrecord->xl_rem_len = write_len;
! 		Insert->currpos += SizeOfXLogContRecord;
! 		freespace = INSERT_FREESPACE(Insert);
  	}
  
! 	/* Ensure next record will be properly aligned */
! 	Insert->currpos = (char *) Insert->currpage +
! 		MAXALIGN(Insert->currpos - (char *) Insert->currpage);
! 	freespace = INSERT_FREESPACE(Insert);
  
  	/*
! 	 * The recptr I return is the beginning of the *next* record. This will be
! 	 * stored as LSN for changed data pages...
  	 */
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, we must now write and flush all the
! 	 * existing data, and then forcibly advance to the start of the next
! 	 * segment.  It's not good to do this I/O while holding the insert lock,
! 	 * but there seems too much risk of confusion if we try to release the
! 	 * lock sooner.  Fortunately xlog switch needn't be a high-performance
! 	 * operation anyway...
  	 */
! 	if (isLogSwitch)
  	{
! 		XLogCtlWrite *Write = &XLogCtl->Write;
! 		XLogwrtRqst FlushRqst;
! 		XLogRecPtr	OldSegEnd;
  
! 		TRACE_POSTGRESQL_XLOG_SWITCH();
  
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  
  		/*
! 		 * Flush through the end of the page containing XLOG_SWITCH, and
! 		 * perform end-of-segment actions (eg, notifying archiver).
  		 */
! 		WriteRqst = XLogCtl->xlblocks[curridx];
! 		FlushRqst.Write = WriteRqst;
! 		FlushRqst.Flush = WriteRqst;
! 		XLogWrite(FlushRqst, false, true);
! 
! 		/* Set up the next buffer as first page of next segment */
! 		/* Note: AdvanceXLInsertBuffer cannot need to do I/O here */
! 		(void) AdvanceXLInsertBuffer(true);
! 
! 		/* There should be no unwritten data */
! 		curridx = Insert->curridx;
! 		Assert(curridx == Write->curridx);
! 
! 		/* Compute end address of old segment */
! 		OldSegEnd = XLogCtl->xlblocks[curridx];
! 		OldSegEnd.xrecoff -= XLOG_BLCKSZ;
! 		if (OldSegEnd.xrecoff == 0)
! 		{
! 			/* crossing a logid boundary */
! 			OldSegEnd.xlogid -= 1;
! 			OldSegEnd.xrecoff = XLogFileSize;
! 		}
  
! 		/* Make it look like we've written and synced all of old segment */
! 		LogwrtResult.Write = OldSegEnd;
! 		LogwrtResult.Flush = OldSegEnd;
  
  		/*
! 		 * Update shared-memory status --- this code should match XLogWrite
  		 */
  		{
! 			/* use volatile pointer to prevent code rearrangement */
! 			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			SpinLockAcquire(&xlogctl->info_lck);
! 			xlogctl->LogwrtResult = LogwrtResult;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, LogwrtResult.Write))
! 				xlogctl->LogwrtRqst.Write = LogwrtResult.Write;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Flush, LogwrtResult.Flush))
! 				xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
! 			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		Write->LogwrtResult = LogwrtResult;
  
! 		LWLockRelease(WALWriteLock);
  
! 		updrqst = false;		/* done already */
  	}
  	else
  	{
! 		/* normal case, ie not xlog switch */
  
! 		/* Need to update shared LogwrtRqst if some block was filled up */
! 		if (freespace < SizeOfXLogRecord)
  		{
! 			/* curridx is filled and available for writing out */
! 			updrqst = true;
  		}
  		else
  		{
! 			/* if updrqst already set, write through end of previous buf */
! 			curridx = PrevBufIdx(curridx);
  		}
- 		WriteRqst = XLogCtl->xlblocks[curridx];
  	}
  
  	/*
! 	 * If the record is an XLOG_FPW_CHANGE, we update full_page_writes
! 	 * in shared memory before releasing WALInsertLock. This ensures that
! 	 * an XLOG_FPW_CHANGE record precedes any WAL record affected
! 	 * by this change of full_page_writes.
  	 */
! 	if (fpwChange)
! 		Insert->fullPageWrites = fullPageWrites;
! 
! 	LWLockRelease(WALInsertLock);
  
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
  
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, WriteRqst))
! 			xlogctl->LogwrtRqst.Write = WriteRqst;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
  	}
  
! 	XactLastRecEnd = RecPtr;
  
! 	END_CRIT_SECTION();
  
! 	return RecPtr;
  }
  
  /*
--- 1081,1785 ----
  		initStringInfo(&buf);
  		appendStringInfo(&buf, "INSERT @ %X/%X: ",
  						 RecPtr.xlogid, RecPtr.xrecoff);
! 		xlog_outrec(&buf, &rechdr);
  		if (rdata->data != NULL)
  		{
  			appendStringInfo(&buf, " - ");
! 			RmgrTable[rmid].rm_desc(&buf, rechdr.xl_info, rdata->data);
  		}
  		elog(LOG, "%s", buf.data);
  		pfree(buf.data);
  	}
  #endif
  
! 	/*
! 	 * The recptr I return is the beginning of the *next* record. This will be
! 	 * stored as LSN for changed data pages...
! 	 */
! 	return RecPtr;
! }
! 
! /*
!  * Subroutine of XLogInsert. All the changes to shared state are done here,
!  * XLogInsert only prepares the record for insertion.
!  *
!  * On success, returns pointer to end of inserted record like XLogInsert().
!  * If RedoRecPtr or forcePageWrites had changed, returns InvalidRecPtr, and
!  * the caller must recalculate full-page-images and retry.
!  */
! static XLogRecPtr
! PerformXLogInsert(int write_len, bool isLogSwitch, XLogRecord *rechdr,
! 				  XLogRecData *rdata, pg_crc32 rdata_crc,
! 				  bool didPageWrites)
! {
! 	volatile XLogInsertSlot *myslot = NULL;
! 	char	   *currpos;
! 	XLogRecord *record;
! 	int			tot_len;
! 	int			freespace;
! 	int			written;
! 	XLogRecPtr	PrevRecord;
! 	XLogRecPtr	StartPos;
! 	XLogRecPtr	EndPos;
! 	XLogRecPtr	CurrPos;
! 	bool		updrqst;
  
! 	/* Get an insert location  */
! 	tot_len = SizeOfXLogRecord + write_len;
! 	if (!ReserveXLogInsertLocation(tot_len, didPageWrites, isLogSwitch,
! 								   &PrevRecord, &StartPos, &EndPos,
! 								   (XLogInsertSlot **) &myslot, &updrqst))
! 	{
! 		return EndPos;
! 	}
  
  	/*
! 	 * Got it! Now that we know the prev-link, we can finish computing the
! 	 * record's CRC.
  	 */
! 	rechdr->xl_prev = PrevRecord;
! 
! 	/* Get the right WAL page to start inserting to */
! 	CurrPos = StartPos;
! 	currpos = GetXLogBuffer(CurrPos);
  
! 	/* Copy the record header in place */
! 	record = (XLogRecord *) currpos;
! 	memcpy(record, rechdr, sizeof(XLogRecord));
! 	COMP_CRC32(rdata_crc, currpos + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	record->xl_crc = rdata_crc;
! 
! 	currpos += SizeOfXLogRecord;
! 	CurrPos.xrecoff += SizeOfXLogRecord;
! 
! 	if (!isLogSwitch)
! 	{
! 		/* Copy record data */
! 		written = 0;
! 		freespace = INSERT_FREESPACE(CurrPos);
! 		while (rdata != NULL)
  		{
! 			while (rdata->len > freespace)
  			{
! 				/*
! 				 * Write what fits on this page, then write the continuation
! 				 * record, and continue.
! 				 */
! 				XLogContRecord *contrecord;
! 
! 				memcpy(currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				written += freespace;
! 				CurrPos.xrecoff += freespace;
! 
! 				/*
! 				 * CurrPos now points to the page boundary, ie. the first byte
! 				 * of the next page. Update CurrPos with that before
! 				 * calling GetXLogBuffer(), because GetXLogBuffer() might need
! 				 * to wait for some insertions to finish so that it can write
! 				 * out a buffer to make room for the new page. Updating CurrPos
! 				 * before waiting for a new buffer ensures that we don't
! 				 * deadlock with ourselves if we run out of clean buffers.
! 				 *
! 				 * However, we must not advance CurrPos past the page header
! 				 * yet, otherwise someone might try to flush up to that point,
! 				 * which would fail if the next page was not initialized yet.
! 				 */
! 				UpdateSlotCurrPos(myslot, CurrPos);
! 
! 				/* Now skip page header */
! 				CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
! 
! 				currpos = GetXLogBuffer(CurrPos);
! 
! 				contrecord = (XLogContRecord *) currpos;
! 				contrecord->xl_rem_len = write_len - written;
! 
! 				currpos += SizeOfXLogContRecord;
! 				CurrPos.xrecoff += SizeOfXLogContRecord;
! 
! 				freespace = INSERT_FREESPACE(CurrPos);
  			}
+ 
+ 			memcpy(currpos, rdata->data, rdata->len);
+ 			currpos += rdata->len;
+ 			CurrPos.xrecoff += rdata->len;
+ 			freespace -= rdata->len;
+ 			written += rdata->len;
+ 
+ 			rdata = rdata->next;
  		}
+ 		Assert(written == write_len);
  
! 		CurrPos.xrecoff = MAXALIGN(CurrPos.xrecoff);
! 		Assert(XLByteEQ(CurrPos, EndPos));
  	}
+ 	else
+ 	{
+ 		/* An xlog-switch record doesn't contain any data besides the header */
+ 		Assert(write_len == 0);
+ 
+ 		/*
+ 		 * An xlog-switch record consumes all the remaining space on the
+ 		 * WAL segment. We have already reserved it for us, but we still need
+ 		 * to make sure it's been allocated and zeroed in the WAL buffers so
+ 		 * that when the caller (or someone else) does XLogWrite(), it can
+ 		 * really write out all the zeros.
+ 		 *
+ 		 * We do this one page at a time, to make sure we don't deadlock
+ 		 * against ourselves if wal_buffers < XLOG_SEG_SIZE.
+ 		 */
+ 		while (XLByteLT(CurrPos, EndPos))
+ 		{
+ 			/* use up all the remaining space in this page */
+ 			freespace = INSERT_FREESPACE(CurrPos);
+ 			XLByteAdvance(CurrPos, freespace);
+ 			/*
+ 			 * like in the non-xlog-switch codepath, let others know that
+ 			 * we're done writing up to the end of this page
+ 			 */
+ 			UpdateSlotCurrPos(myslot, CurrPos);
+ 			/*
+ 			 * let GetXLogBuffer initialize next page if necessary.
+ 			 */
+ 			CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
+ 			(void) GetXLogBuffer(CurrPos);
+ 		}
  
! 		/*
! 		 * Even though we reserved the rest of the segment for us, which
! 		 * is reflected in EndPos, we need to return a value that points just
! 		 * to the end of the xlog-switch record.
! 		 */
! 		EndPos.xlogid = StartPos.xlogid;
! 		EndPos.xrecoff = StartPos.xrecoff + SizeOfXLogRecord;
! 	}
  
  	/*
! 	 * Done! Clear CurrPos in our slot to let others know that we're
! 	 * finished.
  	 */
! 	UpdateSlotCurrPos(myslot, InvalidXLogRecPtr);
  
  	/*
! 	 * Update shared LogwrtRqst.Write, if we crossed page boundary.
  	 */
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
! 
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, EndPos))
! 			xlogctl->LogwrtRqst.Write = EndPos;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
! 	}
! 
! 	/* update our global variables */
! 	ProcLastRecPtr = StartPos;
! 	XactLastRecEnd = EndPos;
! 
! 	return EndPos;
! }
! 
! /*
!  * Reserves the right amount of space for a record of given size from the WAL.
!  * *StartPos_p is set to the beginning of the reserved section, *EndPos_p to
!  * its end, and *Prev_record_p points to the beginning of the previous record
!  * to set to the prev-link of the record header.
!  *
!  * A log-switch record is handled slightly differently. The rest of the
!  * segment will be reserved for this insertion, as indicated by the returned
!  * *EndPos_p value. However, if we are already at the beginning of the current
!  * segment, the *EndPos_p is set to the current location without reserving
!  * any space, and the function returns false.
!  *
!  * *updrqst_p is set to true, if this record ends on different page than
!  * the previous one - the caller should update the shared LogwrtRqst value
!  * after it's done inserting the record in that case, so that the WAL page
!  * that filled up gets written out at the next convenient moment.
!  *
!  * While holding insertpos_lck, sets myslot->CurrPos to the starting position,
!  * (or the end of previous record, to be exact) to let others know that we're
!  * busy inserting to the reserved area. The caller must clear it when the
!  * insertion is finished.
!  *
!  * Returns true on success, or false if RedoRecPtr or forcePageWrites was
!  * changed. On failure, the shared state is not modified.
!  *
!  * This is the performance critical part of XLogInsert that must be
!  * serialized across backends. The rest can happen mostly in parallel.
!  *
!  * NB: The space calculation here must match the code in PerformXLogInsert,
!  * where we actually copy the record to the reserved space.
!  */
! static bool
! ReserveXLogInsertLocation(int size, bool didPageWrites,
! 						  bool isLogSwitch,
! 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
! 						  XLogRecPtr *EndPos_p,
! 						  XLogInsertSlot **myslot_p, bool *updrqst_p)
! {
! 	volatile XLogInsertSlot *myslot;
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			freespace;
! 	XLogRecPtr	ptr;
! 	XLogRecPtr	StartPos;
! 	XLogRecPtr	LastEndPos;
! 	int32		nextslot;
! 	int32		lastslot;
! 	bool		updrqst = false;
  
! retry:
! 	SpinLockAcquire(&Insert->insertpos_lck);
  
! 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr) ||
! 		(!didPageWrites && (Insert->forcePageWrites || Insert->fullPageWrites)))
! 	{
! 		/*
! 		 * Oops, a checkpoint just happened, or forcePageWrites was just
! 		 * turned on. Start XLogInsert() all over, because we might have to
! 		 * include more full-page images in the record.
! 		 */
! 		RedoRecPtr = Insert->RedoRecPtr;
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		*EndPos_p = InvalidXLogRecPtr;
! 		return false;
! 	}
  
+ 	/*
+ 	 * Reserve the next insertion slot for us.
+ 	 *
+ 	 * First check that the slot is not still in use. Modifications to
+ 	 * lastslot are protected by WALInsertTailLock, but here we assume that
+ 	 * reading an int32 is atomic. Another process might advance lastslot at
+ 	 * the same time, but not past nextslot.
+ 	 */
+ 	lastslot = Insert->lastslot;
+ 	nextslot = Insert->nextslot;
+ 	if (NextSlotNo(nextslot) == lastslot)
+ 	{
  		/*
! 		 * Oops, we've "caught our tail" and the oldest slot is still in use.
! 		 * Have to wait for it to become vacant.
  		 */
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		WaitForXLogInsertionSlotToBecomeFree();
! 		goto retry;
! 	}
! 	myslot = &XLogCtl->XLogInsertSlots[nextslot];
! 	nextslot = NextSlotNo(nextslot);
! 
! 	/*
! 	 * Got the slot, now reserve the right amount of space from the WAL for
! 	 * our record.
! 	 */
! 	LastEndPos = ptr = Insert->CurrPos;
! 	*PrevRecord_p = Insert->PrevRecord;
! 
! 	/*
! 	 * If there isn't enough space on the current XLOG page for a record
! 	 * header, advance to the next page (leaving the unused space as zeroes).
! 	 */
! 	freespace = INSERT_FREESPACE(ptr);
! 	if (freespace < SizeOfXLogRecord)
! 	{
! 		ptr = AdvanceXLogRecPtrToNextPage(ptr);
! 		freespace = INSERT_FREESPACE(ptr);
! 		updrqst = true;
! 	}
  
! 	/*
! 	 * We are now at the starting position of our record. Now figure out how
! 	 * the data will be split across the WAL pages, to calculate where the
! 	 * record ends.
! 	 */
! 	StartPos = ptr;
  
+ 	if (isLogSwitch)
+ 	{
  		/*
! 		 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
! 		 * segment, we need not insert it (and don't want to because we'd like
! 		 * consecutive switch requests to be no-ops). Otherwise the XLOG_SWITCH
! 		 * record should consume all the remaining space on the current segment.
  		 */
+ 		Assert(size == SizeOfXLogRecord);
+ 		if ((ptr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
  		{
! 			/* We can release insert lock immediately */
! 			SpinLockRelease(&Insert->insertpos_lck);
  
! 			ptr.xrecoff -= SizeOfXLogLongPHD;
! 			if (ptr.xrecoff == 0)
! 			{
! 				/* crossing a logid boundary */
! 				ptr.xlogid -= 1;
! 				ptr.xrecoff = XLogFileSize;
! 			}
! 
! 			*EndPos_p = ptr;
! 			*StartPos_p = ptr;
! 			*myslot_p = NULL;
! 
! 			return false;
! 		}
! 		else
! 		{
! 			if (ptr.xrecoff % XLOG_SEG_SIZE != 0)
! 			{
! 				int segleft = XLOG_SEG_SIZE - (ptr.xrecoff % XLOG_SEG_SIZE);
! 				XLByteAdvance(ptr, segleft);
! 			}
! 			updrqst = true;
  		}
+ 	}
+ 	else
+ 	{
+ 		/* A normal record, ie. not xlog-switch */
+ 		int sizeleft = size;
+ 		while (freespace < sizeleft)
+ 		{
+ 			/* fill this page, and continue on next page */
+ 			sizeleft -= freespace;
+ 			ptr = AdvanceXLogRecPtrToNextPage(ptr);
  
! 			/* account for continuation record header */
! 			ptr.xrecoff += SizeOfXLogContRecord;
! 			freespace = INSERT_FREESPACE(ptr);
  
! 			updrqst = true;
! 		}
! 		/* the rest fits on this page */
! 		ptr.xrecoff += sizeleft;
! 
! 		/* Align the end position, so that the next record starts aligned */
! 		ptr.xrecoff = MAXALIGN(ptr.xrecoff);
! 	}
! 
! 	/* Update the shared state, and our slot, before releasing the lock */
! 	myslot->CurrPos = LastEndPos;
! 	Insert->CurrPos = ptr;
! 	Insert->PrevRecord = StartPos;
! 	Insert->nextslot = nextslot;
! 
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! #ifdef RESERVE_XLOGINSERT_LOCATION_DEBUG
! 	elog(LOG, "reserved xlog: prev %X/%X, start %X/%X, end %X/%X (len %d)",
! 		 PrevRecord_p->xlogid, PrevRecord_p->xrecoff,
! 		 StartPos.xlogid, StartPos.xrecoff,
! 		 ptr.xlogid, ptr.xrecoff,
! 		 size);
! #endif
! 
! 	*EndPos_p = ptr;
! 	*StartPos_p = StartPos;
! 	*myslot_p = (XLogInsertSlot *) myslot;
! 	*updrqst_p = updrqst;
! 
! 	return true;
! }
! 
! /*
!  * Update slot's CurrPos variable, and wake up anyone waiting on it.
!  */
! static void
! UpdateSlotCurrPos(volatile XLogInsertSlot *myslot, XLogRecPtr CurrPos)
! {
! 	PGPROC	   *head;
! 
! 	/*
! 	 * The write-barrier ensures that the changes we made to the WAL pages
! 	 * are visible to everyone before the update of CurrPos.
! 	 *
! 	 * XXX: I'm not sure if this is necessary. Does a function call act
! 	 * as an implicit barrier?
! 	 */
! 	pg_write_barrier();
! 
! 	SpinLockAcquire(&myslot->lck);
! 	myslot->CurrPos = CurrPos;
! 	head = myslot->head;
! 	myslot->head = myslot->tail = NULL;
! 	SpinLockRelease(&myslot->lck);
! 	while (head != NULL)
! 	{
! 		PGPROC *proc = head;
! 		head = proc->lwWaitLink;
! 		proc->lwWaitLink = NULL;
! 		proc->lwWaiting = false;
! 		PGSemaphoreUnlock(&proc->sem);
! 	}
! }
! 
! /*
!  * Get a pointer to the right location in the WAL buffer containing the
!  * given XLogRecPtr.
!  *
!  * If the page is not initialized yet, it is initialized. That might require
!  * evicting an old dirty buffer from the buffer cache, which means I/O.
!  *
!  * The caller must ensure that the page containing the requested location
!  * isn't evicted yet, and won't be evicted, by holding onto an
!  * XLogInsertSlot with CurrPos set to 'ptr'. Setting it to some value
!  * less than 'ptr' would suffice for GetXLogBuffer(), but risks deadlock:
!  * if we have to evict a buffer, we might have to wait for someone else to
!  * finish a write. And that someone else might not be able to finish the write
!  * if our CurrPos points to a buffer that's still in the buffer cache.
!  */
! static char *
! GetXLogBuffer(XLogRecPtr ptr)
! {
! 	int			idx;
! 	XLogRecPtr	endptr;
! 
! 	/*
! 	 * The XLog buffer cache is organized so that we can easily calculate the
! 	 * buffer a given page must be loaded into from the XLogRecPtr alone.
! 	 * A page must always be loaded to a particular buffer.
! 	 */
! 	idx = XLogRecPtrToBufIdx(ptr);
  
! 	/*
! 	 * See what page is loaded in the buffer at the moment. It could be the
! 	 * page we're looking for, or something older. It can't be anything
! 	 * newer - that would imply the page we're looking for has already
! 	 * been written out to disk, which shouldn't happen as long as the caller
! 	 * has set its slot's CurrPos correctly.
! 	 *
! 	 * However, we don't hold a lock while we read the value. If someone has
! 	 * just initialized the page, it's possible that we get a "torn read",
! 	 * and read a bogus value. That's ok, we'll grab the mapping lock (in
! 	 * AdvanceXLInsertBuffer) and retry if we see anything else than the page
! 	 * we're looking for. But it means that when we do this unlocked read, we
! 	 * might see a value that appears to be ahead of the page we're looking
! 	 * for. So don't PANIC on that, until we've verified the value while
! 	 * holding the lock.
! 	 */
! 	endptr = XLogCtl->xlblocks[idx];
! 	if (ptr.xlogid != endptr.xlogid ||
! 		!(ptr.xrecoff < endptr.xrecoff &&
! 		  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
! 	{
! 		AdvanceXLInsertBuffer(ptr, false);
! 		endptr = XLogCtl->xlblocks[idx];
! 
! 		if (ptr.xlogid != endptr.xlogid ||
! 			!(ptr.xrecoff < endptr.xrecoff &&
! 			  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
! 		{
! 			elog(PANIC, "could not find WAL buffer for %X/%X",
! 				 ptr.xlogid, ptr.xrecoff);
! 		}
  	}
+ 
+ 	/*
+ 	 * Found the buffer holding this page. Return a pointer to the right
+ 	 * offset within the page.
+ 	 */
+ 	return (char *) XLogCtl->pages + idx * (Size) XLOG_BLCKSZ +
+ 		ptr.xrecoff % XLOG_BLCKSZ;
+ }
+ 
+ /*
+  * Advance an XLogRecPtr to the first valid insertion location on the next
+  * page, right after the page header. An XLogRecPtr pointing to a boundary,
+  * ie. the first byte of a page, is taken to belong to the previous page.
+  */
+ static XLogRecPtr
+ AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr)
+ {
+ 	int			freespace;
+ 
+ 	freespace = INSERT_FREESPACE(ptr);
+ 	XLByteAdvance(ptr, freespace);
+ 	if (ptr.xrecoff % XLogSegSize == 0)
+ 		ptr.xrecoff += SizeOfXLogLongPHD;
  	else
+ 		ptr.xrecoff += SizeOfXLogShortPHD;
+ 
+ 	return ptr;
+ }
+ 
+ /*
+  * Wait for any insertions < upto to finish.
+  *
+  * Returns a value >= upto, which indicates the oldest in-progress insertion
+  * that we saw in the array, or CurrPos if there are no insertions in-progress
+  * at exit.
+  */
+ static XLogRecPtr
+ WaitXLogInsertionsToFinish(XLogRecPtr upto, XLogRecPtr CurrPos)
+ {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 	int			lastslot;
+ 	int			nextslot;
+ 	volatile XLogInsertSlot *slot;
+ 	XLogRecPtr	slotptr = InvalidXLogRecPtr;
+ 	XLogRecPtr	LastPos;
+ 	int			extraWaits = 0;
+ 
+ 	if (MyProc == NULL)
+ 		elog(PANIC, "cannot wait without a PGPROC structure");
+ 
+ 	LastPos = CurrPos;
+ 
+ 	LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
+ 
+ 	lastslot = Insert->lastslot;
+ 	nextslot = Insert->nextslot;
+ 
+ 	/* Skip over slots that have finished already */
+ 	while (lastslot != nextslot)
  	{
! 		slot = &XLogCtl->XLogInsertSlots[lastslot];
! 		SpinLockAcquire(&slot->lck);
! 		slotptr = slot->CurrPos;
  
! 		if (XLogRecPtrIsInvalid(slotptr))
  		{
! 			lastslot = NextSlotNo(lastslot);
! 			SpinLockRelease(&slot->lck);
  		}
  		else
  		{
! 			/*
! 			 * This insertion is still in-progress. Wait for it to finish
! 			 * if it's <= upto, otherwise we're done.
! 			 */
! 			Insert->lastslot = lastslot;
! 
! 			if (XLogRecPtrIsInvalid(upto) || XLByteLE(upto, slotptr))
! 			{
! 				LastPos = slotptr;
! 				SpinLockRelease(&slot->lck);
! 				break;
! 			}
! 
! 			/* wait */
! 			MyProc->lwWaiting = true;
! 			MyProc->lwWaitMode = 0; /* doesn't matter */
! 			MyProc->lwWaitLink = NULL;
! 			if (slot->head == NULL)
! 				slot->head = MyProc;
! 			else
! 				slot->tail->lwWaitLink = MyProc;
! 			slot->tail = MyProc;
! 			SpinLockRelease(&slot->lck);
! 			LWLockRelease(WALInsertTailLock);
! 			for (;;)
! 			{
! 				PGSemaphoreLock(&MyProc->sem, false);
! 				if (!MyProc->lwWaiting)
! 					break;
! 				extraWaits++;
! 			}
! 			LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
! 			lastslot = Insert->lastslot;
! 			nextslot = Insert->nextslot;
  		}
  	}
  
+ 	Insert->lastslot = lastslot;
+ 	LWLockRelease(WALInsertTailLock);
+ 
+ 	while (extraWaits-- > 0)
+ 		PGSemaphoreUnlock(&MyProc->sem);
+ 
+ 	return LastPos;
+ }
+ 
+ /*
+  * Wait for the next insertion slot to become vacant.
+  */
+ static void
+ WaitForXLogInsertionSlotToBecomeFree(void)
+ {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 	int			lastslot;
+ 	int			nextslot;
+ 	int			extraWaits = 0;
+ 
+ 	if (MyProc == NULL)
+ 		elog(PANIC, "cannot wait without a PGPROC structure");
+ 
+ 	LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
+ 
  	/*
! 	 * Re-read lastslot and nextslot, now that we have the wait-lock.
! 	 * We're reading nextslot without holding insertpos_lck. It could advance
! 	 * at the same time, but it can't advance beyond lastslot - 1.
  	 */
! 	lastslot = Insert->lastslot;
! 	nextslot = Insert->nextslot;
  
! 	/*
! 	 * If there are still no slots available, wait for the oldest slot to
! 	 * become vacant.
! 	 */
! 	while (NextSlotNo(nextslot) == lastslot)
  	{
! 		volatile XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[lastslot];
  
! 		SpinLockAcquire(&slot->lck);
! 		if (XLogRecPtrIsInvalid(slot->CurrPos))
! 		{
! 			SpinLockRelease(&slot->lck);
! 			break;
! 		}
! 
! 		/* wait */
! 		MyProc->lwWaiting = true;
! 		MyProc->lwWaitMode = 0; /* doesn't matter */
! 		MyProc->lwWaitLink = NULL;
! 		if (slot->head == NULL)
! 			slot->head = MyProc;
! 		else
! 			slot->tail->lwWaitLink = MyProc;
! 		slot->tail = MyProc;
! 		SpinLockRelease(&slot->lck);
! 		LWLockRelease(WALInsertTailLock);
! 		for (;;)
! 		{
! 			PGSemaphoreLock(&MyProc->sem, false);
! 			if (!MyProc->lwWaiting)
! 				break;
! 			extraWaits++;
! 		}
! 		LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
! 		lastslot = Insert->lastslot;
! 		nextslot = Insert->nextslot;
  	}
  
! 	/*
! 	 * Ok, there is at least one empty slot now. That's enouugh for our
! 	 * insertion, but ẃhile we're at it, advance lastslot as much as we
! 	 * can. That way we don't need to come back here on the next call
! 	 * again.
! 	 */
! 	while (lastslot != nextslot)
! 	{
! 		volatile XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[lastslot];
! 		/*
! 		 * Don't need to grab the slot's spinlock here, because we're not
! 		 * interested in the exact value of CurrPos, only whether it's
! 		 * valid or not.
! 		 */
! 		if (!XLogRecPtrIsInvalid(slot->CurrPos))
! 			break;
  
! 		lastslot = NextSlotNo(lastslot);
! 	}
! 	Insert->lastslot = lastslot;
  
! 	LWLockRelease(WALInsertTailLock);
  }
  
  /*
***************
*** 1488,1522 **** XLogArchiveCleanup(const char *xlog)
  }
  
  /*
!  * Advance the Insert state to the next buffer page, writing out the next
!  * buffer if it still contains unwritten data.
!  *
!  * If new_segment is TRUE then we set up the next buffer page as the first
!  * page of the next xlog segment file, possibly but not usually the next
!  * consecutive file page.
!  *
!  * The global LogwrtRqst.Write pointer needs to be advanced to include the
!  * just-filled page.  If we can do this for free (without an extra lock),
!  * we do so here.  Otherwise the caller must do it.  We return TRUE if the
!  * request update still needs to be done, FALSE if we did it internally.
!  *
!  * Must be called with WALInsertLock held.
   */
! static bool
! AdvanceXLInsertBuffer(bool new_segment)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	XLogCtlWrite *Write = &XLogCtl->Write;
! 	int			nextidx = NextBufIdx(Insert->curridx);
! 	bool		update_needed = true;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
! 	XLogRecPtr	NewPageEndPtr;
  	XLogPageHeader NewPage;
  
! 	/* Use Insert->LogwrtResult copy if it's more fresh */
! 	if (XLByteLT(LogwrtResult.Write, Insert->LogwrtResult.Write))
! 		LogwrtResult = Insert->LogwrtResult;
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
--- 2006,2039 ----
  }
  
  /*
!  * Initialize XLOG buffers, writing out old buffers if they still contain
!  * unwritten data, upto the page containing 'upto'. Or if 'opportunistic' is
!  * true, initialize as many pages as we can without having to write out
!  * unwritten data. Any new pages are initialized to zeros, with pages headers
!  * initialized properly.
   */
! static void
! AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			nextidx;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
! 	XLogRecPtr	NewPageEndPtr = InvalidXLogRecPtr;
  	XLogPageHeader NewPage;
+ 	bool		needflush;
+ 	int			npages = 0;
  
! 	LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
! 
! 	/*
! 	 * Now that we have the lock, check if someone initialized the page
! 	 * already.
! 	 */
! /* XXX: fix indentation before commit */
! while (!XLByteLT(upto, XLogCtl->xlblocks[XLogCtl->curridx]) || opportunistic)
! {
! 	nextidx = NextBufIdx(XLogCtl->curridx);
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
***************
*** 1524,1535 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
- 	if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
- 	{
- 		/* nope, got work to do... */
- 		XLogRecPtr	FinishedPageRqstPtr;
  
! 		FinishedPageRqstPtr = XLogCtl->xlblocks[Insert->curridx];
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
--- 2041,2057 ----
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
  
! 	needflush = !XLByteLE(OldPageRqstPtr, LogwrtResult.Write);
! 
! 	if (needflush)
! 	{
! 		/*
! 		 * Nope, got work to do. If we just want to pre-initialize as much as
! 		 * we can without flushing, give up now.
! 		 */
! 		if (opportunistic)
! 			break;
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
***************
*** 1537,1581 **** AdvanceXLInsertBuffer(bool new_segment)
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, FinishedPageRqstPtr))
! 				xlogctl->LogwrtRqst.Write = FinishedPageRqstPtr;
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		update_needed = false;	/* Did the shared-request update */
! 
! 		if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
! 		{
! 			/* OK, someone wrote it already */
! 			Insert->LogwrtResult = LogwrtResult;
! 		}
! 		else
  		{
! 			/* Must acquire write lock */
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 			LogwrtResult = Write->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding insert lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false, false);
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
  		}
  	}
  
--- 2059,2108 ----
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, OldPageRqstPtr))
! 			{
! 				Assert(XLByteLE(OldPageRqstPtr, xlogctl->Insert.CurrPos));
! 				xlogctl->LogwrtRqst.Write = OldPageRqstPtr;
! 			}
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/*
! 			 * Must acquire write lock. Release WALBufMappingLock first, to
! 			 * make sure that all insertions that we need to wait for can
! 			 * finish (up to this same position). Otherwise we risk deadlock.
! 			 */
! 			LWLockRelease(WALBufMappingLock);
! 
! 			WaitXLogInsertionsToFinish(OldPageRqstPtr, InvalidXLogRecPtr);
! 
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 			LogwrtResult = XLogCtl->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding mapping lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false);
  				LWLockRelease(WALWriteLock);
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
+ 			/* Re-acquire WALBufMappingLock and retry */
+ 			LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
+ 			continue;
  		}
  	}
  
***************
*** 1583,1596 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[Insert->curridx];
! 
! 	if (new_segment)
! 	{
! 		/* force it to a segment start point */
! 		NewPageEndPtr.xrecoff += XLogSegSize - 1;
! 		NewPageEndPtr.xrecoff -= NewPageEndPtr.xrecoff % XLogSegSize;
! 	}
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
--- 2110,2116 ----
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[XLogCtl->curridx];
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
***************
*** 1600,1612 **** AdvanceXLInsertBuffer(bool new_segment)
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
! 	XLogCtl->xlblocks[nextidx] = NewPageEndPtr;
! 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
! 
! 	Insert->curridx = nextidx;
! 	Insert->currpage = NewPage;
  
! 	Insert->currpos = ((char *) NewPage) +SizeOfXLogShortPHD;
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
--- 2120,2129 ----
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
! 	Assert(NewPageEndPtr.xrecoff % XLOG_BLCKSZ == 0);
! 	Assert(XLogRecEndPtrToBufIdx(NewPageEndPtr) == nextidx);
  
! 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
***************
*** 1650,1660 **** AdvanceXLInsertBuffer(bool new_segment)
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
- 
- 		Insert->currpos = ((char *) NewPage) +SizeOfXLogLongPHD;
  	}
  
! 	return update_needed;
  }
  
  /*
--- 2167,2194 ----
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
  	}
  
! 	/*
! 	 * Make sure the initialization of the page becomes visible to others
! 	 * before the xlblocks update. GetXLogBuffer() reads xlblocks without
! 	 * holding a lock.
! 	 */
! 	pg_write_barrier();
! 
! 	*((volatile XLogRecPtr *) &XLogCtl->xlblocks[nextidx]) = NewPageEndPtr;
! 
! 	XLogCtl->curridx = nextidx;
! 
! 	npages++;
! }
! 	LWLockRelease(WALBufMappingLock);
! 
! #ifdef WAL_DEBUG
! 	if (npages > 0)
! 		elog(DEBUG1, "initialized %d pages, upto %X/%X",
! 			 npages, NewPageEndPtr.xlogid, NewPageEndPtr.xrecoff);
! #endif
  }
  
  /*
***************
*** 1699,1714 **** XLogCheckpointNeeded(uint32 logid, uint32 logseg)
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * If xlog_switch == TRUE, we are intending an xlog segment switch, so
!  * perform end-of-segment actions after writing the last page, even if
!  * it's not physically the end of its segment.  (NB: this will work properly
!  * only if caller specifies WriteRqst == page-end and flexible == false,
!  * and there is some data to write.)
!  *
!  * Must be called with WALWriteLock held.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
--- 2233,2244 ----
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * Must be called with WALWriteLock held. And you must've called
!  * WaitXLogInsertionsToFinish(WriteRqst) before grabbing the lock to make sure
!  * the data is ready to write.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
***************
*** 1726,1732 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  	/*
  	 * Update local LogwrtResult (caller probably did this already, but...)
  	 */
! 	LogwrtResult = Write->LogwrtResult;
  
  	/*
  	 * Since successive pages in the xlog cache are consecutively allocated,
--- 2256,2262 ----
  	/*
  	 * Update local LogwrtResult (caller probably did this already, but...)
  	 */
! 	LogwrtResult = XLogCtl->LogwrtResult;
  
  	/*
  	 * Since successive pages in the xlog cache are consecutively allocated,
***************
*** 1757,1770 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  		 * if we're passed a bogus WriteRqst.Write that is past the end of the
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
! 		if (!XLByteLT(LogwrtResult.Write, XLogCtl->xlblocks[curridx]))
  			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
! 				 XLogCtl->xlblocks[curridx].xlogid,
! 				 XLogCtl->xlblocks[curridx].xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
! 		LogwrtResult.Write = XLogCtl->xlblocks[curridx];
  		ispartialpage = XLByteLT(WriteRqst.Write, LogwrtResult.Write);
  
  		if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
--- 2287,2300 ----
  		 * if we're passed a bogus WriteRqst.Write that is past the end of the
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
! 		XLogRecPtr EndPtr = XLogCtl->xlblocks[curridx];
! 		if (!XLByteLT(LogwrtResult.Write, EndPtr))
  			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
! 				 EndPtr.xlogid, EndPtr.xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
! 		LogwrtResult.Write = EndPtr;
  		ispartialpage = XLByteLT(WriteRqst.Write, LogwrtResult.Write);
  
  		if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
***************
*** 1861,1876 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
- 			 * We also do this if this is the last page written for an xlog
- 			 * switch.
- 			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg || (xlog_switch && last_iteration))
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
--- 2391,2403 ----
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg)
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
***************
*** 1960,1967 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  			xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
  		SpinLockRelease(&xlogctl->info_lck);
  	}
- 
- 	Write->LogwrtResult = LogwrtResult;
  }
  
  /*
--- 2487,2492 ----
***************
*** 2124,2131 **** XLogFlush(XLogRecPtr record)
  	 */
  	for (;;)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
  		volatile XLogCtlData *xlogctl = XLogCtl;
  
  		/* read LogwrtResult and update local state */
  		SpinLockAcquire(&xlogctl->info_lck);
--- 2649,2659 ----
  	 */
  	for (;;)
  	{
! 		/* use volatile pointers to prevent code rearrangement */
  		volatile XLogCtlData *xlogctl = XLogCtl;
+ 		volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 		uint32		freespace;
+ 		XLogRecPtr	insertpos;
  
  		/* read LogwrtResult and update local state */
  		SpinLockAcquire(&xlogctl->info_lck);
***************
*** 2139,2144 **** XLogFlush(XLogRecPtr record)
--- 2667,2701 ----
  			break;
  
  		/*
+ 		 * Get the current insert position.
+ 		 *
+ 		 * XXX: This used to do LWLockConditionalAcquire(WALInsertLock),
+ 		 * fall back to writing just up to 'record' if we couldn't get t
+ 		 * lock. I wonder if it would be a good idea to have a
+ 		 * SpinLockConditionalAcquire function and use that? On one hand
+ 		 * it would be good to not cause more contention on the lock if
+ 		 * busy, but on the other hand, this spinlock is much more light
+ 		 * than the WALInsertLock was, so maybe it's better to just grab
+ 		 * spinlock. Also note that if we stored the XLogRecPtr as one 6
+ 		 * integer, we could just read it with no lock on platforms wher
+ 		 * 64-bit integer accesses are atomic, which covers many common
+ 		 * platforms nowadays.
+ 		 */
+ 		SpinLockAcquire(&Insert->insertpos_lck);
+ 		insertpos = Insert->CurrPos;
+ 		SpinLockRelease(&Insert->insertpos_lck);
+ 
+ 		freespace = INSERT_FREESPACE(insertpos);
+ 		if (freespace < SizeOfXLogRecord)               /* buffer is full */
+ 			insertpos.xrecoff += freespace;
+ 
+ 		/*
+ 		 * Before actually performing the write, wait for all in-flight
+ 		 * insertions to the pages we're about to write to finish.
+ 		 */
+ 		insertpos = WaitXLogInsertionsToFinish(WriteRqstPtr, insertpos);
+ 
+ 		/*
  		 * Try to get the write lock. If we can't get it immediately, wait
  		 * until it's released, and recheck if we still need to do the flush
  		 * or if the backend that held the lock did it for us already. This
***************
*** 2155,2186 **** XLogFlush(XLogRecPtr record)
  			continue;
  		}
  		/* Got the lock */
! 		LogwrtResult = XLogCtl->Write.LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			/* try to write/flush later additions to XLOG as well */
! 			if (LWLockConditionalAcquire(WALInsertLock, LW_EXCLUSIVE))
! 			{
! 				XLogCtlInsert *Insert = &XLogCtl->Insert;
! 				uint32		freespace = INSERT_FREESPACE(Insert);
  
! 				if (freespace < SizeOfXLogRecord)		/* buffer is full */
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 				else
! 				{
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 					WriteRqstPtr.xrecoff -= freespace;
! 				}
! 				LWLockRelease(WALInsertLock);
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = WriteRqstPtr;
! 			}
! 			else
! 			{
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = record;
! 			}
! 			XLogWrite(WriteRqst, false, false);
  		}
  		LWLockRelease(WALWriteLock);
  		/* done */
--- 2712,2724 ----
  			continue;
  		}
  		/* Got the lock */
! 		LogwrtResult = XLogCtl->LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			WriteRqst.Write = insertpos;
! 			WriteRqst.Flush = insertpos;
  
! 			XLogWrite(WriteRqst, false);
  		}
  		LWLockRelease(WALWriteLock);
  		/* done */
***************
*** 2292,2314 **** XLogBackgroundFlush(void)
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
- 
  	START_CRIT_SECTION();
  
! 	/* now wait for the write lock */
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 	LogwrtResult = XLogCtl->Write.LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
  	{
  		XLogwrtRqst WriteRqst;
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible, false);
  	}
! 	LWLockRelease(WALWriteLock);
  
  	END_CRIT_SECTION();
  }
  
  /*
--- 2830,2860 ----
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
  	START_CRIT_SECTION();
  
! 	/* now wait for any in-progress insertions to finish and get write lock */
! 	WaitXLogInsertionsToFinish(WriteRqstPtr, InvalidXLogRecPtr);
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 	LogwrtResult = XLogCtl->LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
  	{
  		XLogwrtRqst WriteRqst;
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible);
  	}
! 	LogwrtResult = XLogCtl->LogwrtResult;
  
  	END_CRIT_SECTION();
+ 
+ 	LWLockRelease(WALWriteLock);
+ 
+ 	/*
+ 	 * Great, done. To take some work off the critical path, try to initialize
+ 	 * as many of the no-longer-needed WAL buffers for future use as we can.
+ 	 */
+ 	AdvanceXLInsertBuffer(InvalidXLogRecPtr, true);
  }
  
  /*
***************
*** 5102,5107 **** XLOGShmemSize(void)
--- 5648,5656 ----
  	/* and the buffers themselves */
  	size = add_size(size, mul_size(XLOG_BLCKSZ, XLOGbuffers));
  
+ 	/* XLog insertion slots */
+ 	size = add_size(size, mul_size(sizeof(XLogInsertSlot), NumXLogInsertSlots));
+ 
  	/*
  	 * Note: we don't count ControlFileData, it comes out of the "slop factor"
  	 * added by CreateSharedMemoryAndSemaphores.  This lets us use this
***************
*** 5117,5122 **** XLOGShmemInit(void)
--- 5666,5672 ----
  	bool		foundCFile,
  				foundXLog;
  	char	   *allocptr;
+ 	int			i;
  
  	ControlFile = (ControlFileData *)
  		ShmemInitStruct("Control File", sizeof(ControlFileData), &foundCFile);
***************
*** 5142,5147 **** XLOGShmemInit(void)
--- 5692,5710 ----
  	memset(XLogCtl->xlblocks, 0, sizeof(XLogRecPtr) * XLOGbuffers);
  	allocptr += sizeof(XLogRecPtr) * XLOGbuffers;
  
+ 	/* Initialize insertion slots */
+ 	XLogCtl->XLogInsertSlots = (XLogInsertSlot *) allocptr;
+ 	for (i = 0; i < NumXLogInsertSlots; i++)
+ 	{
+ 		XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[i];
+ 		slot->CurrPos = InvalidXLogRecPtr;
+ 		slot->head = slot->tail = NULL;
+ 		SpinLockInit(&slot->lck);
+ 	}
+ 	XLogCtl->Insert.nextslot = 1;
+ 	XLogCtl->Insert.lastslot = 0;
+ 	allocptr += sizeof(XLogInsertSlot) * NumXLogInsertSlots;
+ 
  	/*
  	 * Align the start of the page buffers to an ALIGNOF_XLOG_BUFFER boundary.
  	 */
***************
*** 5156,5166 **** XLOGShmemInit(void)
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
- 	XLogCtl->Insert.currpage = (XLogPageHeader) (XLogCtl->pages);
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
--- 5719,5730 ----
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
+ 	SpinLockInit(&XLogCtl->Insert.insertpos_lck);
+ 
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
***************
*** 6038,6043 **** StartupXLOG(void)
--- 6602,6608 ----
  	bool		backupEndRequired = false;
  	bool		backupFromStandby = false;
  	DBState		dbstate_at_startup;
+ 	int			firstIdx;
  
  	/*
  	 * Read control file and check XLOG status looks valid.
***************
*** 6835,6842 **** StartupXLOG(void)
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 	XLogCtl->xlblocks[0].xlogid = openLogId;
! 	XLogCtl->xlblocks[0].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
--- 7400,7411 ----
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 
! 	firstIdx = XLogRecPtrToBufIdx(EndOfLog);
! 	XLogCtl->curridx = firstIdx;
! 
! 	XLogCtl->xlblocks[firstIdx].xlogid = openLogId;
! 	XLogCtl->xlblocks[firstIdx].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
***************
*** 6844,6869 **** StartupXLOG(void)
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[0].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) Insert->currpage, readBuf, XLOG_BLCKSZ);
! 	Insert->currpos = (char *) Insert->currpage +
! 		(EndOfLog.xrecoff + XLOG_BLCKSZ - XLogCtl->xlblocks[0].xrecoff);
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
- 	XLogCtl->Write.LogwrtResult = LogwrtResult;
- 	Insert->LogwrtResult = LogwrtResult;
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(Insert->currpos, 0, freespace);
! 		XLogCtl->Write.curridx = 0;
  	}
  	else
  	{
--- 7413,7435 ----
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[firstIdx].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) &XLogCtl->pages[firstIdx * XLOG_BLCKSZ], readBuf, XLOG_BLCKSZ);
! 	Insert->CurrPos = EndOfLog;
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = XLOG_BLCKSZ - EndRecPtr.xrecoff % XLOG_BLCKSZ;
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(&XLogCtl->pages[firstIdx * XLOG_BLCKSZ] + EndRecPtr.xrecoff % XLOG_BLCKSZ, 0, freespace);
! 		XLogCtl->Write.curridx = firstIdx;
  	}
  	else
  	{
***************
*** 6875,6881 **** StartupXLOG(void)
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(0);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
--- 7441,7447 ----
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(firstIdx);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
***************
*** 7379,7385 **** GetRedoRecPtr(void)
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire WALInsertLock which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
--- 7945,7951 ----
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire insertpos_lck which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
***************
*** 7655,7660 **** CreateCheckPoint(int flags)
--- 8221,8227 ----
  	uint32		insert_logSeg;
  	TransactionId *inCommitXids;
  	int			nInCommit;
+ 	XLogRecPtr	curInsert;
  
  	/*
  	 * An end-of-recovery checkpoint is really a shutdown checkpoint, just
***************
*** 7723,7732 **** CreateCheckPoint(int flags)
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * We must hold WALInsertLock while examining insert state to determine
! 	 * the checkpoint REDO pointer.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
--- 8290,8299 ----
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * Determine the checkpoint REDO pointer.
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	curInsert = Insert->CurrPos;
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
***************
*** 7738,7744 **** CreateCheckPoint(int flags)
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding the WALInsertLock we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
--- 8305,8311 ----
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding insertpos_lck we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
***************
*** 7747,7761 **** CreateCheckPoint(int flags)
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
- 		XLogRecPtr	curInsert;
- 
- 		INSERT_RECPTR(curInsert, Insert, Insert->curridx);
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			LWLockRelease(WALInsertLock);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
--- 8314,8325 ----
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
***************
*** 7782,7795 **** CreateCheckPoint(int flags)
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace < SizeOfXLogRecord)
! 	{
! 		(void) AdvanceXLInsertBuffer(false);
! 		/* OK to ignore update return flag, since we will do flush anyway */
! 		freespace = INSERT_FREESPACE(Insert);
! 	}
! 	INSERT_RECPTR(checkPoint.redo, Insert, Insert->curridx);
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
--- 8346,8355 ----
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(curInsert);
  	if (freespace < SizeOfXLogRecord)
! 		curInsert = AdvanceXLogRecPtrToNextPage(curInsert);
! 	checkPoint.redo = curInsert;
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
***************
*** 7815,7821 **** CreateCheckPoint(int flags)
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
--- 8375,8381 ----
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
***************
*** 7835,7841 **** CreateCheckPoint(int flags)
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released WALInsertLock, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
--- 8395,8401 ----
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released insertpos_lck, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
***************
*** 8202,8216 **** CreateRestartPoint(int flags)
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * You need to hold WALInsertLock and info_lck to update it, although
! 	 * during recovery acquiring WALInsertLock is just pro forma, because
! 	 * there is no other processes updating Insert.RedoRecPtr.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * Prepare to accumulate statistics.
--- 8762,8776 ----
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * Like in CreateCheckPoint(), you need both insertpos_lck and info_lck
! 	 * to update it, although during recovery acquiring insertpos_lck is just
! 	 * pro forma, because no WAL insertions are happening.
  	 */
! 	SpinLockAcquire(&xlogctl->Insert.insertpos_lck);
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
! 	SpinLockRelease(&xlogctl->Insert.insertpos_lck);
  
  	/*
  	 * Prepare to accumulate statistics.
***************
*** 8403,8408 **** RequestXLogSwitch(void)
--- 8963,8969 ----
  {
  	XLogRecPtr	RecPtr;
  	XLogRecData rdata;
+ 	XLogwrtRqst FlushRqst;
  
  	/* XLOG SWITCH, alone among xlog record types, has no data */
  	rdata.buffer = InvalidBuffer;
***************
*** 8412,8417 **** RequestXLogSwitch(void)
--- 8973,8999 ----
  
  	RecPtr = XLogInsert(RM_XLOG_ID, XLOG_SWITCH, &rdata);
  
+ 	/* XXX: before this patch, TRACE_POSTGRESQL_XLOG_SWITCH was not called
+ 	 * if the xlog switch had no work to do, ie. if we were already at the
+ 	 * beginning of a new XLOG segment. You can check if RecPtr points to
+ 	 * beginning of a segment if you want to keep the distinction.
+ 	 */
+ 	TRACE_POSTGRESQL_XLOG_SWITCH();
+ 
+ 	/*
+ 	 * Flush through the end of the page containing XLOG_SWITCH, and
+ 	 * perform end-of-segment actions (eg, notifying archiver).
+ 	 */
+ 	WaitXLogInsertionsToFinish(RecPtr, InvalidXLogRecPtr);
+ 
+ 	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
+ 	FlushRqst.Write = RecPtr;
+ 	FlushRqst.Flush = RecPtr;
+ 	START_CRIT_SECTION();
+ 	XLogWrite(FlushRqst, false);
+ 	END_CRIT_SECTION();
+ 	LWLockRelease(WALWriteLock);
+ 
  	return RecPtr;
  }
  
***************
*** 8490,8511 **** XLogReportParameters(void)
  /*
   * Update full_page_writes in shared memory, and write an
   * XLOG_FPW_CHANGE record if necessary.
   */
  void
  UpdateFullPageWrites(void)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  
  	/*
  	 * Do nothing if full_page_writes has not been changed.
  	 *
  	 * It's safe to check the shared full_page_writes without the lock,
! 	 * because we can guarantee that there is no concurrently running
! 	 * process which can update it.
  	 */
  	if (fullPageWrites == Insert->fullPageWrites)
  		return;
  
  	/*
  	 * Write an XLOG_FPW_CHANGE record. This allows us to keep
  	 * track of full_page_writes during archive recovery, if required.
--- 9072,9112 ----
  /*
   * Update full_page_writes in shared memory, and write an
   * XLOG_FPW_CHANGE record if necessary.
+  *
+  * Note: this function assumes there is no other process running
+  * concurrently that could update it.
   */
  void
  UpdateFullPageWrites(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  
  	/*
  	 * Do nothing if full_page_writes has not been changed.
  	 *
  	 * It's safe to check the shared full_page_writes without the lock,
! 	 * because we assume that there is no concurrently running process
! 	 * which can update it.
  	 */
  	if (fullPageWrites == Insert->fullPageWrites)
  		return;
  
+ 	START_CRIT_SECTION();
+ 
+ 	/*
+ 	 * It's always safe to take full page images, even when not strictly
+ 	 * required, but not the other round. So if we're setting full_page_writes
+ 	 * to true, first set it true and then write the WAL record. If we're
+ 	 * setting it to false, first write the WAL record and then set the
+ 	 * global flag.
+ 	 */
+ 	if (fullPageWrites)
+ 	{
+ 		SpinLockAcquire(&Insert->insertpos_lck);
+ 		Insert->fullPageWrites = true;
+ 		SpinLockRelease(&Insert->insertpos_lck);
+ 	}
+ 
  	/*
  	 * Write an XLOG_FPW_CHANGE record. This allows us to keep
  	 * track of full_page_writes during archive recovery, if required.
***************
*** 8521,8532 **** UpdateFullPageWrites(void)
  
  		XLogInsert(RM_XLOG_ID, XLOG_FPW_CHANGE, &rdata);
  	}
! 	else
  	{
! 		LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 		Insert->fullPageWrites = fullPageWrites;
! 		LWLockRelease(WALInsertLock);
  	}
  }
  
  /*
--- 9122,9135 ----
  
  		XLogInsert(RM_XLOG_ID, XLOG_FPW_CHANGE, &rdata);
  	}
! 
! 	if (!fullPageWrites)
  	{
! 		SpinLockAcquire(&Insert->insertpos_lck);
! 		Insert->fullPageWrites = false;
! 		SpinLockRelease(&Insert->insertpos_lck);
  	}
+ 	END_CRIT_SECTION();
  }
  
  /*
***************
*** 9040,9045 **** issue_xlog_fsync(int fd, uint32 log, uint32 seg)
--- 9643,9649 ----
  XLogRecPtr
  do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	bool		backup_started_in_recovery = false;
  	XLogRecPtr	checkpointloc;
***************
*** 9102,9127 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  	 * Note that forcePageWrites has no effect during an online backup from
  	 * the standby.
  	 *
! 	 * We must hold WALInsertLock to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
! 		if (XLogCtl->Insert.exclusiveBackup)
  		{
! 			LWLockRelease(WALInsertLock);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		XLogCtl->Insert.exclusiveBackup = true;
  	}
  	else
! 		XLogCtl->Insert.nonExclusiveBackups++;
! 	XLogCtl->Insert.forcePageWrites = true;
! 	LWLockRelease(WALInsertLock);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
--- 9706,9731 ----
  	 * Note that forcePageWrites has no effect during an online backup from
  	 * the standby.
  	 *
! 	 * We must hold insertpos_lck to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
! 		if (Insert->exclusiveBackup)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		Insert->exclusiveBackup = true;
  	}
  	else
! 		Insert->nonExclusiveBackups++;
! 	Insert->forcePageWrites = true;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
***************
*** 9234,9246 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			LWLockAcquire(WALInsertLock, LW_SHARED);
! 			if (XLByteLT(XLogCtl->Insert.lastBackupStart, startpoint))
  			{
! 				XLogCtl->Insert.lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			LWLockRelease(WALInsertLock);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
--- 9838,9850 ----
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			SpinLockAcquire(&Insert->insertpos_lck);
! 			if (XLByteLT(Insert->lastBackupStart, startpoint))
  			{
! 				Insert->lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			SpinLockRelease(&Insert->insertpos_lck);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
***************
*** 9324,9333 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
  		Assert(XLogCtl->Insert.exclusiveBackup);
--- 9928,9938 ----
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
  		Assert(XLogCtl->Insert.exclusiveBackup);
***************
*** 9344,9350 **** pg_start_backup_callback(int code, Datum arg)
  	{
  		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 9949,9955 ----
  	{
  		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9357,9362 **** pg_start_backup_callback(int code, Datum arg)
--- 9962,9968 ----
  XLogRecPtr
  do_pg_stop_backup(char *labelfile, bool waitforarchive)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	bool		backup_started_in_recovery = false;
  	XLogRecPtr	startpoint;
***************
*** 9410,9418 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
! 		XLogCtl->Insert.exclusiveBackup = false;
  	else
  	{
  		/*
--- 10016,10024 ----
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
! 		Insert->exclusiveBackup = false;
  	else
  	{
  		/*
***************
*** 9421,9436 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 		XLogCtl->Insert.nonExclusiveBackups--;
  	}
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  
  	if (exclusive)
  	{
--- 10027,10042 ----
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(Insert->nonExclusiveBackups > 0);
! 		Insert->nonExclusiveBackups--;
  	}
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	if (exclusive)
  	{
***************
*** 9708,9723 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  void
  do_pg_abort_backup(void)
  {
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 	Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 	XLogCtl->Insert.nonExclusiveBackups--;
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 10314,10331 ----
  void
  do_pg_abort_backup(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	Assert(Insert->nonExclusiveBackups > 0);
! 	Insert->nonExclusiveBackups--;
! 
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9771,9782 **** GetStandbyFlushRecPtr(void)
  XLogRecPtr
  GetXLogInsertRecPtr(void)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	LWLockAcquire(WALInsertLock, LW_SHARED);
! 	INSERT_RECPTR(current_recptr, Insert, Insert->curridx);
! 	LWLockRelease(WALInsertLock);
  
  	return current_recptr;
  }
--- 10379,10390 ----
  XLogRecPtr
  GetXLogInsertRecPtr(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	current_recptr = Insert->CurrPos;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	return current_recptr;
  }
*** a/src/backend/storage/lmgr/spin.c
--- b/src/backend/storage/lmgr/spin.c
***************
*** 56,61 **** SpinlockSemas(void)
--- 56,64 ----
  	 *
  	 * For now, though, we just need a few spinlocks (10 should be plenty)
  	 * plus one for each LWLock and one for each buffer header.
+ 	 *
+ 	 * XXX: remember to adjust this for the number of spinlocks needed by the
+ 	 * xlog.c changes before committing!
  	 */
  	return NumLWLocks() + NBuffers + 10;
  }
*** a/src/include/storage/lwlock.h
--- b/src/include/storage/lwlock.h
***************
*** 53,59 **** typedef enum LWLockId
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALInsertLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
--- 53,59 ----
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALBufMappingLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
***************
*** 79,84 **** typedef enum LWLockId
--- 79,85 ----
  	SerializablePredicateLockListLock,
  	OldSerXidLock,
  	SyncRepLock,
+ 	WALInsertTailLock,
  	/* Individual lock IDs end here */
  	FirstBufMappingLock,
  	FirstLockMgrLock = FirstBufMappingLock + NUM_BUFFER_PARTITIONS,

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index ba83123..a950518 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -1168,6 +1168,7 @@ PerformXLogInsert(int write_len, bool isLogSwitch, XLogRecord *rechdr,
 				 * record, and continue.
 				 */
 				XLogContRecord *contrecord;
+				int			freespace2;
 
 				memcpy(currpos, rdata->data, freespace);
 				rdata->data += freespace;
@@ -1191,7 +1192,18 @@ PerformXLogInsert(int write_len, bool isLogSwitch, XLogRecord *rechdr,
 				UpdateSlotCurrPos(myslot, CurrPos);
 
 				/* Now skip page header */
-				CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
+//				CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
+
+				freespace2 = INSERT_FREESPACE(CurrPos);
+				XLByteAdvance(CurrPos, freespace2);
+
+				currpos = GetXLogBuffer(CurrPos);
+                                ((XLogPageHeader)currpos)->xlp_info |= XLP_FIRST_IS_CONTRECORD;
+
+				if (CurrPos.xrecoff % XLogSegSize == 0)
+					CurrPos.xrecoff += SizeOfXLogLongPHD;
+				else
+					CurrPos.xrecoff += SizeOfXLogShortPHD;
 
 				currpos = GetXLogBuffer(CurrPos);
 

*** a/src/backend/access/transam/xlog.c
--- b/src/backend/access/transam/xlog.c
***************
*** 42,47 ****
--- 42,48 ----
  #include "postmaster/startup.h"
  #include "replication/walreceiver.h"
  #include "replication/walsender.h"
+ #include "storage/barrier.h"
  #include "storage/bufmgr.h"
  #include "storage/fd.h"
  #include "storage/ipc.h"
***************
*** 290,315 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There are actually three shared-memory copies of
!  * LogwrtResult, plus one unshared copy in each backend.  Here's how it works:
!  *		XLogCtl->LogwrtResult is protected by info_lck
!  *		XLogCtl->Write.LogwrtResult is protected by WALWriteLock
!  *		XLogCtl->Insert.LogwrtResult is protected by WALInsertLock
!  * One must hold the associated lock to read or write any of these, but
!  * of course no lock is needed to read/write the unshared LogwrtResult.
!  *
!  * XLogCtl->LogwrtResult and XLogCtl->Write.LogwrtResult are both "always
!  * right", since both are updated by a write or flush operation before
!  * it releases WALWriteLock.  The point of keeping XLogCtl->Write.LogwrtResult
!  * is that it can be examined/modified by code that already holds WALWriteLock
!  * without needing to grab info_lck as well.
!  *
!  * XLogCtl->Insert.LogwrtResult may lag behind the reality of the other two,
!  * but is updated when convenient.	Again, it exists for the convenience of
!  * code that is already holding WALInsertLock but not the other locks.
!  *
!  * The unshared LogwrtResult may lag behind any or all of these, and again
!  * is updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
--- 291,301 ----
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There is one shared-memory copy of LogwrtResult,
!  * plus one unshared copy in each backend. To read the shared copy, you need
!  * to hold info_lck *or* WALWriteLock. To update it, you need to hold both
!  * locks. The unshared LogwrtResult may lag behind the shared copy, and is
!  * updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
***************
*** 319,328 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  The other locks are held longer (potentially
!  * over I/O operations), so we use LWLocks for them.  These locks are:
   *
!  * WALInsertLock: must be held to insert a record into the WAL buffers.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
--- 305,319 ----
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  insertpos_lck protects the current logical
!  * insert location, ie. the head of reserved WAL space.  The other locks are
!  * held longer (potentially over I/O operations), so we use LWLocks for them.
!  * These locks are:
   *
!  * WALBufMappingLock: must be held to replace a page in the WAL buffer cache.
!  * This is only held while initializing and changing the mapping. If the
!  * contents of the buffer being replaced haven't been written yet, the mapping
!  * lock is released while the write is done, and reacquired afterwards.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
***************
*** 334,339 **** static XLogRecPtr RedoStartLSN = {0, 0};
--- 325,399 ----
   * only one checkpointer at a time; currently, with all checkpoints done by
   * the checkpointer, this is just pro forma).
   *
+  *
+  * Inserting a new WAL record is a two-step process:
+  *
+  * 1. Reserve the right amount of space from the WAL, and the next insertion
+  *    slot to advertise that the insertion is in progress. The current head
+  *    of reserved space is kept in Insert->CurrPos, and is protected by
+  *    insertpos_lck. Try to keep this section as short as possible,
+  *    insertpos_lck can be heavily contended on a busy system
+  *
+  * 2. Copy the record to the reserved WAL space. This involves finding the
+  *    correct WAL buffer containing the reserved space, and copying the
+  *    record in place. This can be done concurrently in multiple processes.
+  *
+  * To allow as much parallelism as possible for step 2, we try hard to avoid
+  * lock contention in that code path. Each insertion is asssigned its own
+  * "XLog insertion slot", which is used to advertise the position the backend
+  * is writing to. The slot is marked as in-use in step 1, while holding
+  * insertpos_lck, by setting the position field in the slot. When the backend
+  * is finished with the insertion, it clears its slot. Each slot is protected
+  * by a separate spinlock, to keep contention minimal.
+  *
+  * The insertion slots also provide a mechanism to wait for an insertion to
+  * finish. This is important when an XLOG page is written out - any
+  * in-progress insertions must finish copying data to the page first, or the
+  * on-disk copy will be incomplete. Waiting is done by the
+  * WaitXLogInsertionsToFinish() function. It adds the current process to the
+  * waiting queue in the slot it needs to wait for, and when that insertion
+  * finishes (or proceeds to the next page, at least), the inserter wakes up
+  * the process.
+  *
+  * The insertion slots form a ring. Insert->nextslot points to the next free
+  * slot, and Insert->lastslot points to the last slot that's still in use.
+  * lastslot can lag behind reality by any number of slots, as long as nextslot
+  * doesn't catch up with it. lastslot is advanced by
+  * WaitXLogInsertionsToFinish(), and is protected by WALInsertTailLock.
+  * nextslot is advanced in ReserveXLogInsertLocation() and is protected by
+  * insertpos_lck. Both slot variables are 32-bit integers, so that they can
+  * be read atomically without holding a lock.
+  *
+  * Whenever the ring fills up, ie. when nextslot wraps around and catches up
+  * with lastslot, ReserveXLogInsertLocation() has to wait for the oldest
+  * insertion to finish and advance lastslot, to make room for the new
+  * insertion. This is done by WaitForXLogInsertionSlotToBecomeFree() function,
+  * which is similar to WaitXLogInsertionsToFinish(), but instead of waiting
+  * for all insertions up to a given point to finish, it just waits for the
+  * inserter in the oldest slot to finish.
+  *
+  *
+  * Deadlock analysis
+  * -----------------
+  *
+  * It's important to call WaitXLogInsertionsToFinish() *before* acquiring
+  * WALWriteLock. Otherwise you might get stuck waiting for an insertion to
+  * finish (or at least advance to next uninitialized page), while you're
+  * holding WALWriteLock. That would be bad, because the backend you're waiting
+  * for might need to acquire WALWriteLock, too, to evict an old buffer, so
+  * you'd get deadlock.
+  *
+  * WaitXLogInsertionsToFinish() will not get stuck indefinitely, as long as
+  * it's called with a location that's known to be already allocated in the WAL
+  * buffers. Calling it with the position of a record you've already inserted
+  * satisfies that condition, so the common pattern:
+  *
+  *   recptr = XLogInsert(...)
+  *   XLogFlush(recptr)
+  *
+  * is safe. It can't get stuck, because an insertion to a WAL page that's
+  * already initialized in cache can always proceed without waiting on a lock.
+  *
   *----------
   */
  
***************
*** 354,364 **** typedef struct XLogwrtResult
   */
  typedef struct XLogCtlInsert
  {
! 	XLogwrtResult LogwrtResult; /* a recent value of LogwrtResult */
! 	XLogRecPtr	PrevRecord;		/* start of previously-inserted record */
! 	int			curridx;		/* current block index in cache */
! 	XLogPageHeader currpage;	/* points to header of block in cache */
! 	char	   *currpos;		/* current insertion point in cache */
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
--- 414,443 ----
   */
  typedef struct XLogCtlInsert
  {
! 	slock_t		insertpos_lck;	/* protects all the fields in this struct
! 								 * (except lastslot). */
! 
! 	int32		nextslot;		/* next insertion slot to use */
! 	int32		lastslot;		/* last in-use insertion slot (protected by
! 								 * WALInsertTailLock) */
! 
! 	/*
! 	 * CurrPos is the very tip of the reserved WAL space at the moment. The
! 	 * next record will be inserted there (or somewhere after it if there's
! 	 * not enough space on the current page). PrevRecord points to the
! 	 * beginning of the last record already reserved. It might not be fully
! 	 * copied into place yet, but we know its exact location already.
! 	 */
! 	XLogRecPtr	CurrPos;
! 	XLogRecPtr	PrevRecord;
! 
! 	/*
! 	 * padding to push RedoRecPtr and forcePageWrites, which rarely change,
! 	 * to a different cache line than the rapidly-changing CurrPos and
! 	 * PrevRecord values. XXX: verify if this makes any difference
! 	 */
! 	char		padding[128];
! 
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
***************
*** 388,406 **** typedef struct XLogCtlInsert
   */
  typedef struct XLogCtlWrite
  {
- 	XLogwrtResult LogwrtResult; /* current value of LogwrtResult */
  	int			curridx;		/* cache index of next block to write */
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by WALInsertLock: */
  	XLogCtlInsert Insert;
  
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
--- 467,500 ----
   */
  typedef struct XLogCtlWrite
  {
  	int			curridx;		/* cache index of next block to write */
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
+ 
+ /*
+  * Slots for in-progress WAL insertions.
+  */
+ typedef struct
+ {
+ 	slock_t		lck;
+ 	XLogRecPtr	CurrPos;	/* current position this process is inserting to */
+ 	PGPROC	   *head;		/* head of list of waiting PGPROCs */
+ 	PGPROC	   *tail;		/* tail of list of waiting PGPROCs */
+ } XLogInsertSlot;
+ 
+ #define NumXLogInsertSlots	1000
+ 
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by insertpos_lck: */
  	XLogCtlInsert Insert;
  
+ 	XLogInsertSlot *XLogInsertSlots;
+ 
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
***************
*** 414,422 **** typedef struct XLogCtlData
  	XLogCtlWrite Write;
  
  	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALInsertLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
--- 508,526 ----
  	XLogCtlWrite Write;
  
  	/*
+ 	 * To change curridx and the identity of a buffer, you need to hold
+ 	 * WALBufMappingLock. To change the identity of a buffer that's
+ 	 * still dirty, the old page needs to be written out first, and for that
+ 	 * you need WALWriteLock, and you need to ensure that there's no
+ 	 * in-progress insertions to the page by calling
+ 	 * WaitXLogInsertionsToFinish().
+ 	 */
+ 	int			curridx;		/* current (latest) block index in cache */
+ 
+ 	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALBufMappingLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
***************
*** 494,521 **** static XLogCtlData *XLogCtl = NULL;
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Macros for managing XLogInsert state.  In most cases, the calling routine
!  * has local copies of XLogCtl->Insert and/or XLogCtl->Insert->curridx,
!  * so these are passed as parameters instead of being fetched via XLogCtl.
   */
  
! /* Free space remaining in the current xlog page buffer */
! #define INSERT_FREESPACE(Insert)  \
! 	(XLOG_BLCKSZ - ((Insert)->currpos - (char *) (Insert)->currpage))
  
- /* Construct XLogRecPtr value for current insertion point */
- #define INSERT_RECPTR(recptr,Insert,curridx)  \
- 	( \
- 	  (recptr).xlogid = XLogCtl->xlblocks[curridx].xlogid, \
- 	  (recptr).xrecoff = \
- 		XLogCtl->xlblocks[curridx].xrecoff - INSERT_FREESPACE(Insert) \
- 	)
  
! #define PrevBufIdx(idx)		\
! 		(((idx) == 0) ? XLogCtl->XLogCacheBlck : ((idx) - 1))
  
! #define NextBufIdx(idx)		\
! 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
--- 598,628 ----
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Calculate the amount of space left on the page after 'endptr'.
!  * Beware multiple evaluation!
   */
+ #define INSERT_FREESPACE(endptr)	\
+ 	(((endptr).xrecoff % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr).xrecoff % XLOG_BLCKSZ))
  
! #define NextBufIdx(idx)		\
! 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  
! #define NextSlotNo(idx)		\
! 		(((idx) == NumXLogInsertSlots) ? 0 : ((idx) + 1))
  
! /*
!  * XLogRecPtrToBufIdx returns the index of the WAL buffer that holds, or
!  * would hold if it was in cache, the page containing 'recptr'.
!  *
!  * XLogRecEndPtrToBufIdx is the same, but a pointer to the first byte of a
!  * page is taken to mean the previous page.
!  */
! #define XLogRecPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogSegsPerFile * XLogSegSize) + (recptr).xrecoff)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
! 
! #define XLogRecEndPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogSegsPerFile * XLogSegSize) + (recptr).xrecoff - 1)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
***************
*** 641,649 **** static void KeepLogSeg(XLogRecPtr recptr, uint32 *logId, uint32 *logSeg);
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static bool AdvanceXLInsertBuffer(bool new_segment);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
--- 748,756 ----
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static void AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
***************
*** 690,695 **** static bool read_backup_label(XLogRecPtr *checkPointLoc,
--- 797,820 ----
  static void rm_redo_error_callback(void *arg);
  static int	get_sync_bit(int method);
  
+ static XLogRecPtr PerformXLogInsert(int write_len,
+ 				  bool isLogSwitch,
+ 				  XLogRecord *rechdr,
+ 				  XLogRecData *rdata, pg_crc32 rdata_crc,
+ 				  bool didPageWrites);
+ static bool ReserveXLogInsertLocation(int size, bool forcePageWrites,
+ 						  bool isLogSwitch,
+ 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
+ 						  XLogRecPtr *EndPos_p,
+ 						  XLogInsertSlot **myslot_p, bool *updrqst_p);
+ static void UpdateSlotCurrPos(volatile XLogInsertSlot *myslot,
+ 				  XLogRecPtr CurrPos);
+ static XLogRecPtr WaitXLogInsertionsToFinish(XLogRecPtr upto,
+ 						   XLogRecPtr CurrPos);
+ static void WaitForXLogInsertionSlotToBecomeFree(void);
+ static char *GetXLogBuffer(XLogRecPtr ptr);
+ static XLogRecPtr AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr);
+ 
  
  /*
   * Insert an XLOG record having the specified RMID and info bytes,
***************
*** 710,721 **** XLogRecPtr
  XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
- 	XLogRecord *record;
- 	XLogContRecord *contrecord;
  	XLogRecPtr	RecPtr;
- 	XLogRecPtr	WriteRqst;
- 	uint32		freespace;
- 	int			curridx;
  	XLogRecData *rdt;
  	XLogRecData *rdt_lastnormal;
  	Buffer		dtbuf[XLR_MAX_BKP_BLOCKS];
--- 835,841 ----
***************
*** 729,739 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  	uint32		len,
  				write_len;
  	unsigned	i;
- 	bool		updrqst;
  	bool		doPageWrites;
! 	bool		isLogSwitch = false;
! 	bool		fpwChange = false;
  	uint8		info_orig = info;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
--- 849,858 ----
  	uint32		len,
  				write_len;
  	unsigned	i;
  	bool		doPageWrites;
! 	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
  	uint8		info_orig = info;
+ 	XLogRecord	rechdr;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
***************
*** 746,775 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  	TRACE_POSTGRESQL_XLOG_INSERT(rmid, info);
  
  	/*
! 	 * Handle special cases/records.
  	 */
! 	if (rmid == RM_XLOG_ID)
  	{
- 		switch (info)
- 		{
- 			case XLOG_SWITCH:
- 				isLogSwitch = true;
- 				break;
- 
- 			case XLOG_FPW_CHANGE:
- 				fpwChange = true;
- 				break;
- 
- 			default:
- 				break;
- 		}
- 	}
- 	else if (IsBootstrapProcessingMode())
- 	{
- 		/*
- 		 * In bootstrap mode, we don't actually log anything but XLOG resources;
- 		 * return a phony record pointer.
- 		 */
  		RecPtr.xlogid = 0;
  		RecPtr.xrecoff = SizeOfXLogLongPHD;		/* start of 1st chkpt record */
  		return RecPtr;
--- 865,875 ----
  	TRACE_POSTGRESQL_XLOG_INSERT(rmid, info);
  
  	/*
! 	 * In bootstrap mode, we don't actually log anything but XLOG resources;
! 	 * return a phony record pointer.
  	 */
! 	if (IsBootstrapProcessingMode() && rmid != RM_XLOG_ID)
  	{
  		RecPtr.xlogid = 0;
  		RecPtr.xrecoff = SizeOfXLogLongPHD;		/* start of 1st chkpt record */
  		return RecPtr;
***************
*** 939,1072 **** begin:;
  	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
  		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
- 	START_CRIT_SECTION();
- 
- 	/* Now wait to get insert lock */
- 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
- 
  	/*
! 	 * Check to see if my RedoRecPtr is out of date.  If so, may have to go
! 	 * back and recompute everything.  This can only happen just after a
! 	 * checkpoint, so it's better to be slow in this case and fast otherwise.
! 	 *
! 	 * If we aren't doing full-page writes then RedoRecPtr doesn't actually
! 	 * affect the contents of the XLOG record, so we'll update our local copy
! 	 * but not force a recomputation.
  	 */
! 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr))
! 	{
! 		Assert(XLByteLT(RedoRecPtr, Insert->RedoRecPtr));
! 		RedoRecPtr = Insert->RedoRecPtr;
  
! 		if (doPageWrites)
! 		{
! 			for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
! 			{
! 				if (dtbuf[i] == InvalidBuffer)
! 					continue;
! 				if (dtbuf_bkp[i] == false &&
! 					XLByteLE(dtbuf_lsn[i], RedoRecPtr))
! 				{
! 					/*
! 					 * Oops, this buffer now needs to be backed up, but we
! 					 * didn't think so above.  Start over.
! 					 */
! 					LWLockRelease(WALInsertLock);
! 					END_CRIT_SECTION();
! 					rdt_lastnormal->next = NULL;
! 					info = info_orig;
! 					goto begin;
! 				}
! 			}
! 		}
! 	}
  
  	/*
! 	 * Also check to see if fullPageWrites or forcePageWrites was just turned on;
! 	 * if we weren't already doing full-page writes then go back and recompute.
! 	 * (If it was just turned off, we could recompute the record without full pages,
! 	 * but we choose not to bother.)
  	 */
! 	if ((Insert->fullPageWrites || Insert->forcePageWrites) && !doPageWrites)
  	{
! 		/* Oops, must redo it with full-page data. */
! 		LWLockRelease(WALInsertLock);
! 		END_CRIT_SECTION();
  		rdt_lastnormal->next = NULL;
  		info = info_orig;
  		goto begin;
  	}
  
- 	/*
- 	 * If there isn't enough space on the current XLOG page for a record
- 	 * header, advance to the next page (leaving the unused space as zeroes).
- 	 */
- 	updrqst = false;
- 	freespace = INSERT_FREESPACE(Insert);
- 	if (freespace < SizeOfXLogRecord)
- 	{
- 		updrqst = AdvanceXLInsertBuffer(false);
- 		freespace = INSERT_FREESPACE(Insert);
- 	}
- 
- 	/* Compute record's XLOG location */
- 	curridx = Insert->curridx;
- 	INSERT_RECPTR(RecPtr, Insert, curridx);
- 
- 	/*
- 	 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
- 	 * segment, we need not insert it (and don't want to because we'd like
- 	 * consecutive switch requests to be no-ops).  Instead, make sure
- 	 * everything is written and flushed through the end of the prior segment,
- 	 * and return the prior segment's end address.
- 	 */
- 	if (isLogSwitch &&
- 		(RecPtr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
- 	{
- 		/* We can release insert lock immediately */
- 		LWLockRelease(WALInsertLock);
- 
- 		RecPtr.xrecoff -= SizeOfXLogLongPHD;
- 		if (RecPtr.xrecoff == 0)
- 		{
- 			/* crossing a logid boundary */
- 			RecPtr.xlogid -= 1;
- 			RecPtr.xrecoff = XLogFileSize;
- 		}
- 
- 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
- 		LogwrtResult = XLogCtl->Write.LogwrtResult;
- 		if (!XLByteLE(RecPtr, LogwrtResult.Flush))
- 		{
- 			XLogwrtRqst FlushRqst;
- 
- 			FlushRqst.Write = RecPtr;
- 			FlushRqst.Flush = RecPtr;
- 			XLogWrite(FlushRqst, false, false);
- 		}
- 		LWLockRelease(WALWriteLock);
- 
- 		END_CRIT_SECTION();
- 
- 		return RecPtr;
- 	}
- 
- 	/* Insert record header */
- 
- 	record = (XLogRecord *) Insert->currpos;
- 	record->xl_prev = Insert->PrevRecord;
- 	record->xl_xid = GetCurrentTransactionIdIfAny();
- 	record->xl_tot_len = SizeOfXLogRecord + write_len;
- 	record->xl_len = len;		/* doesn't include backup blocks */
- 	record->xl_info = info;
- 	record->xl_rmid = rmid;
- 
- 	/* Now we can finish computing the record's CRC */
- 	COMP_CRC32(rdata_crc, (char *) record + sizeof(pg_crc32),
- 			   SizeOfXLogRecord - sizeof(pg_crc32));
- 	FIN_CRC32(rdata_crc);
- 	record->xl_crc = rdata_crc;
- 
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
  	{
--- 1039,1078 ----
  	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
  		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
  	/*
! 	 * Construct record header. We can't CRC it yet, because the prev-link
! 	 * needs to be covered by the CRC and we don't know that yet. We will
! 	 * finish computing the CRC when we do.
  	 */
! 	MemSet(&rechdr, 0, sizeof(rechdr));
! 	/* rechdr.xl_prev is set in PerformXLogInsert() */
! 	rechdr.xl_xid = GetCurrentTransactionIdIfAny();
! 	rechdr.xl_tot_len = SizeOfXLogRecord + write_len;
! 	rechdr.xl_len = len;		/* doesn't include backup blocks */
! 	rechdr.xl_info = info;
! 	rechdr.xl_rmid = rmid;
  
! 	START_CRIT_SECTION();
  
  	/*
! 	 * Try to do the insertion.
  	 */
! 	RecPtr = PerformXLogInsert(write_len, isLogSwitch, &rechdr,
! 							   rdata, rdata_crc, doPageWrites);
! 	END_CRIT_SECTION();
! 
! 	if (XLogRecPtrIsInvalid(RecPtr))
  	{
! 		/*
! 		 * Oops, must redo it with full-page data. Unlink the backup blocks
! 		 * from the chain and reset info bitmask to undo the changes we've
! 		 * done.
! 		 */
  		rdt_lastnormal->next = NULL;
  		info = info_orig;
  		goto begin;
  	}
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
  	{
***************
*** 1075,1267 **** begin:;
  		initStringInfo(&buf);
  		appendStringInfo(&buf, "INSERT @ %X/%X: ",
  						 RecPtr.xlogid, RecPtr.xrecoff);
! 		xlog_outrec(&buf, record);
  		if (rdata->data != NULL)
  		{
  			appendStringInfo(&buf, " - ");
! 			RmgrTable[record->xl_rmid].rm_desc(&buf, record->xl_info, rdata->data);
  		}
  		elog(LOG, "%s", buf.data);
  		pfree(buf.data);
  	}
  #endif
  
! 	/* Record begin of record in appropriate places */
! 	ProcLastRecPtr = RecPtr;
! 	Insert->PrevRecord = RecPtr;
  
! 	Insert->currpos += SizeOfXLogRecord;
! 	freespace -= SizeOfXLogRecord;
  
  	/*
! 	 * Append the data, including backup blocks if any
  	 */
! 	while (write_len)
! 	{
! 		while (rdata->data == NULL)
! 			rdata = rdata->next;
  
! 		if (freespace > 0)
  		{
! 			if (rdata->len > freespace)
  			{
! 				memcpy(Insert->currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				write_len -= freespace;
! 			}
! 			else
! 			{
! 				memcpy(Insert->currpos, rdata->data, rdata->len);
! 				freespace -= rdata->len;
! 				write_len -= rdata->len;
! 				Insert->currpos += rdata->len;
! 				rdata = rdata->next;
! 				continue;
  			}
  		}
  
! 		/* Use next buffer */
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		curridx = Insert->curridx;
! 		/* Insert cont-record header */
! 		Insert->currpage->xlp_info |= XLP_FIRST_IS_CONTRECORD;
! 		contrecord = (XLogContRecord *) Insert->currpos;
! 		contrecord->xl_rem_len = write_len;
! 		Insert->currpos += SizeOfXLogContRecord;
! 		freespace = INSERT_FREESPACE(Insert);
  	}
  
! 	/* Ensure next record will be properly aligned */
! 	Insert->currpos = (char *) Insert->currpage +
! 		MAXALIGN(Insert->currpos - (char *) Insert->currpage);
! 	freespace = INSERT_FREESPACE(Insert);
  
  	/*
! 	 * The recptr I return is the beginning of the *next* record. This will be
! 	 * stored as LSN for changed data pages...
  	 */
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, we must now write and flush all the
! 	 * existing data, and then forcibly advance to the start of the next
! 	 * segment.  It's not good to do this I/O while holding the insert lock,
! 	 * but there seems too much risk of confusion if we try to release the
! 	 * lock sooner.  Fortunately xlog switch needn't be a high-performance
! 	 * operation anyway...
  	 */
! 	if (isLogSwitch)
  	{
! 		XLogCtlWrite *Write = &XLogCtl->Write;
! 		XLogwrtRqst FlushRqst;
! 		XLogRecPtr	OldSegEnd;
  
! 		TRACE_POSTGRESQL_XLOG_SWITCH();
  
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  
  		/*
! 		 * Flush through the end of the page containing XLOG_SWITCH, and
! 		 * perform end-of-segment actions (eg, notifying archiver).
  		 */
! 		WriteRqst = XLogCtl->xlblocks[curridx];
! 		FlushRqst.Write = WriteRqst;
! 		FlushRqst.Flush = WriteRqst;
! 		XLogWrite(FlushRqst, false, true);
! 
! 		/* Set up the next buffer as first page of next segment */
! 		/* Note: AdvanceXLInsertBuffer cannot need to do I/O here */
! 		(void) AdvanceXLInsertBuffer(true);
! 
! 		/* There should be no unwritten data */
! 		curridx = Insert->curridx;
! 		Assert(curridx == Write->curridx);
! 
! 		/* Compute end address of old segment */
! 		OldSegEnd = XLogCtl->xlblocks[curridx];
! 		OldSegEnd.xrecoff -= XLOG_BLCKSZ;
! 		if (OldSegEnd.xrecoff == 0)
! 		{
! 			/* crossing a logid boundary */
! 			OldSegEnd.xlogid -= 1;
! 			OldSegEnd.xrecoff = XLogFileSize;
! 		}
  
! 		/* Make it look like we've written and synced all of old segment */
! 		LogwrtResult.Write = OldSegEnd;
! 		LogwrtResult.Flush = OldSegEnd;
  
  		/*
! 		 * Update shared-memory status --- this code should match XLogWrite
  		 */
  		{
! 			/* use volatile pointer to prevent code rearrangement */
! 			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			SpinLockAcquire(&xlogctl->info_lck);
! 			xlogctl->LogwrtResult = LogwrtResult;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, LogwrtResult.Write))
! 				xlogctl->LogwrtRqst.Write = LogwrtResult.Write;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Flush, LogwrtResult.Flush))
! 				xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
! 			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		Write->LogwrtResult = LogwrtResult;
  
! 		LWLockRelease(WALWriteLock);
  
! 		updrqst = false;		/* done already */
  	}
  	else
  	{
! 		/* normal case, ie not xlog switch */
  
! 		/* Need to update shared LogwrtRqst if some block was filled up */
! 		if (freespace < SizeOfXLogRecord)
  		{
! 			/* curridx is filled and available for writing out */
! 			updrqst = true;
  		}
  		else
  		{
! 			/* if updrqst already set, write through end of previous buf */
! 			curridx = PrevBufIdx(curridx);
  		}
- 		WriteRqst = XLogCtl->xlblocks[curridx];
  	}
  
  	/*
! 	 * If the record is an XLOG_FPW_CHANGE, we update full_page_writes
! 	 * in shared memory before releasing WALInsertLock. This ensures that
! 	 * an XLOG_FPW_CHANGE record precedes any WAL record affected
! 	 * by this change of full_page_writes.
  	 */
! 	if (fpwChange)
! 		Insert->fullPageWrites = fullPageWrites;
  
! 	LWLockRelease(WALInsertLock);
! 
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
  
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, WriteRqst))
! 			xlogctl->LogwrtRqst.Write = WriteRqst;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
  	}
  
! 	XactLastRecEnd = RecPtr;
  
! 	END_CRIT_SECTION();
  
! 	return RecPtr;
  }
  
  /*
--- 1081,1796 ----
  		initStringInfo(&buf);
  		appendStringInfo(&buf, "INSERT @ %X/%X: ",
  						 RecPtr.xlogid, RecPtr.xrecoff);
! 		xlog_outrec(&buf, &rechdr);
  		if (rdata->data != NULL)
  		{
  			appendStringInfo(&buf, " - ");
! 			RmgrTable[rmid].rm_desc(&buf, rechdr.xl_info, rdata->data);
  		}
  		elog(LOG, "%s", buf.data);
  		pfree(buf.data);
  	}
  #endif
  
! 	/*
! 	 * The recptr I return is the beginning of the *next* record. This will be
! 	 * stored as LSN for changed data pages...
! 	 */
! 	return RecPtr;
! }
! 
! /*
!  * Subroutine of XLogInsert. All the changes to shared state are done here,
!  * XLogInsert only prepares the record for insertion.
!  *
!  * On success, returns pointer to end of inserted record like XLogInsert().
!  * If RedoRecPtr or forcePageWrites had changed, returns InvalidRecPtr, and
!  * the caller must recalculate full-page-images and retry.
!  */
! static XLogRecPtr
! PerformXLogInsert(int write_len, bool isLogSwitch, XLogRecord *rechdr,
! 				  XLogRecData *rdata, pg_crc32 rdata_crc,
! 				  bool didPageWrites)
! {
! 	volatile XLogInsertSlot *myslot = NULL;
! 	char	   *currpos;
! 	XLogRecord *record;
! 	int			tot_len;
! 	int			freespace;
! 	int			written;
! 	XLogRecPtr	PrevRecord;
! 	XLogRecPtr	StartPos;
! 	XLogRecPtr	EndPos;
! 	XLogRecPtr	CurrPos;
! 	bool		updrqst;
  
! 	/* Get an insert location  */
! 	tot_len = SizeOfXLogRecord + write_len;
! 	if (!ReserveXLogInsertLocation(tot_len, didPageWrites, isLogSwitch,
! 								   &PrevRecord, &StartPos, &EndPos,
! 								   (XLogInsertSlot **) &myslot, &updrqst))
! 	{
! 		return EndPos;
! 	}
  
  	/*
! 	 * Got it! Now that we know the prev-link, we can finish computing the
! 	 * record's CRC.
  	 */
! 	rechdr->xl_prev = PrevRecord;
! 
! 	/* Get the right WAL page to start inserting to */
! 	CurrPos = StartPos;
! 	currpos = GetXLogBuffer(CurrPos);
! 
! 	/* Copy the record header in place */
! 	record = (XLogRecord *) currpos;
! 	memcpy(record, rechdr, sizeof(XLogRecord));
! 	COMP_CRC32(rdata_crc, currpos + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	record->xl_crc = rdata_crc;
! 
! 	currpos += SizeOfXLogRecord;
! 	CurrPos.xrecoff += SizeOfXLogRecord;
  
! 	if (!isLogSwitch)
! 	{
! 		/* Copy record data */
! 		written = 0;
! 		freespace = INSERT_FREESPACE(CurrPos);
! 		while (rdata != NULL)
  		{
! 			while (rdata->len > freespace)
  			{
! 				/*
! 				 * Write what fits on this page, then write the continuation
! 				 * record, and continue.
! 				 */
! 				XLogContRecord *contrecord;
! 
! 				memcpy(currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				written += freespace;
! 				CurrPos.xrecoff += freespace;
! 
! 				/*
! 				 * CurrPos now points to the page boundary, ie. the first byte
! 				 * of the next page. Advertise that as our CurrPos before
! 				 * calling GetXLogBuffer(), because GetXLogBuffer() might need
! 				 * to wait for some insertions to finish so that it can write
! 				 * out a buffer to make room for the new page. Updating CurrPos
! 				 * before waiting for a new buffer ensures that we don't
! 				 * deadlock with ourselves if we run out of clean buffers.
! 				 *
! 				 * However, we must not advance CurrPos past the page header
! 				 * yet, otherwise someone might try to flush up to that point,
! 				 * which would fail if the next page was not initialized yet.
! 				 */
! 				UpdateSlotCurrPos(myslot, CurrPos);
! 
! 				/*
! 				 * Get pointer to beginning of next page, and set the
! 				 * XLP_FIRST_IS_CONTRECORD flag in the page header.
! 				 *
! 				 * It's safe to set the contrecord flag without a lock on the
! 				 * page. All the other flags are set in AdvanceXLInsertBuffer,
! 				 * and we're the only backend that needs to set the contrecord
! 				 * flag.
! 				 */
! 				currpos = GetXLogBuffer(CurrPos);
! 				((XLogPageHeader) currpos)->xlp_info |= XLP_FIRST_IS_CONTRECORD;
! 
! 				/* skip over the page header, and write continuation record */
! 				CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
! 				currpos = GetXLogBuffer(CurrPos);
! 
! 				contrecord = (XLogContRecord *) currpos;
! 				contrecord->xl_rem_len = write_len - written;
! 
! 				currpos += SizeOfXLogContRecord;
! 				CurrPos.xrecoff += SizeOfXLogContRecord;
! 
! 				freespace = INSERT_FREESPACE(CurrPos);
  			}
+ 
+ 			memcpy(currpos, rdata->data, rdata->len);
+ 			currpos += rdata->len;
+ 			CurrPos.xrecoff += rdata->len;
+ 			freespace -= rdata->len;
+ 			written += rdata->len;
+ 
+ 			rdata = rdata->next;
  		}
+ 		Assert(written == write_len);
  
! 		CurrPos.xrecoff = MAXALIGN(CurrPos.xrecoff);
! 		Assert(XLByteEQ(CurrPos, EndPos));
  	}
+ 	else
+ 	{
+ 		/* An xlog-switch record doesn't contain any data besides the header */
+ 		Assert(write_len == 0);
  
! 		/*
! 		 * An xlog-switch record consumes all the remaining space on the
! 		 * WAL segment. We have already reserved it for us, but we still need
! 		 * to make sure it's been allocated and zeroed in the WAL buffers so
! 		 * that when the caller (or someone else) does XLogWrite(), it can
! 		 * really write out all the zeros.
! 		 *
! 		 * We do this one page at a time, to make sure we don't deadlock
! 		 * against ourselves if wal_buffers < XLOG_SEG_SIZE.
! 		 */
! 		while (XLByteLT(CurrPos, EndPos))
! 		{
! 			/* use up all the remaining space in this page */
! 			freespace = INSERT_FREESPACE(CurrPos);
! 			XLByteAdvance(CurrPos, freespace);
! 			/*
! 			 * like in the non-xlog-switch codepath, let others know that
! 			 * we're done writing up to the end of this page
! 			 */
! 			UpdateSlotCurrPos(myslot, CurrPos);
! 			/*
! 			 * let GetXLogBuffer initialize next page if necessary.
! 			 */
! 			CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
! 			(void) GetXLogBuffer(CurrPos);
! 		}
! 
! 		/*
! 		 * Even though we reserved the rest of the segment for us, which
! 		 * is reflected in EndPos, we need to return a value that points just
! 		 * to the end of the xlog-switch record.
! 		 */
! 		EndPos.xlogid = StartPos.xlogid;
! 		EndPos.xrecoff = StartPos.xrecoff + SizeOfXLogRecord;
! 	}
  
  	/*
! 	 * Done! Clear CurrPos in our slot to let others know that we're
! 	 * finished.
  	 */
! 	UpdateSlotCurrPos(myslot, InvalidXLogRecPtr);
  
  	/*
! 	 * Update shared LogwrtRqst.Write, if we crossed page boundary.
  	 */
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
! 
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, EndPos))
! 			xlogctl->LogwrtRqst.Write = EndPos;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
! 	}
  
! 	/* update our global variables */
! 	ProcLastRecPtr = StartPos;
! 	XactLastRecEnd = EndPos;
  
! 	return EndPos;
! }
  
+ /*
+  * Reserves the right amount of space for a record of given size from the WAL.
+  * *StartPos_p is set to the beginning of the reserved section, *EndPos_p to
+  * its end, and *Prev_record_p points to the beginning of the previous record
+  * to set to the prev-link of the record header.
+  *
+  * A log-switch record is handled slightly differently. The rest of the
+  * segment will be reserved for this insertion, as indicated by the returned
+  * *EndPos_p value. However, if we are already at the beginning of the current
+  * segment, the *EndPos_p is set to the current location without reserving
+  * any space, and the function returns false.
+  *
+  * *updrqst_p is set to true, if this record ends on different page than
+  * the previous one - the caller should update the shared LogwrtRqst value
+  * after it's done inserting the record in that case, so that the WAL page
+  * that filled up gets written out at the next convenient moment.
+  *
+  * While holding insertpos_lck, sets myslot->CurrPos to the starting position,
+  * (or the end of previous record, to be exact) to let others know that we're
+  * busy inserting to the reserved area. The caller must clear it when the
+  * insertion is finished.
+  *
+  * Returns true on success, or false if RedoRecPtr or forcePageWrites was
+  * changed. On failure, the shared state is not modified.
+  *
+  * This is the performance critical part of XLogInsert that must be
+  * serialized across backends. The rest can happen mostly in parallel.
+  *
+  * NB: The space calculation here must match the code in PerformXLogInsert,
+  * where we actually copy the record to the reserved space.
+  */
+ static bool
+ ReserveXLogInsertLocation(int size, bool didPageWrites,
+ 						  bool isLogSwitch,
+ 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
+ 						  XLogRecPtr *EndPos_p,
+ 						  XLogInsertSlot **myslot_p, bool *updrqst_p)
+ {
+ 	volatile XLogInsertSlot *myslot;
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 	int			freespace;
+ 	XLogRecPtr	ptr;
+ 	XLogRecPtr	StartPos;
+ 	XLogRecPtr	LastEndPos;
+ 	int32		nextslot;
+ 	int32		lastslot;
+ 	bool		updrqst = false;
+ 
+ retry:
+ 	SpinLockAcquire(&Insert->insertpos_lck);
+ 
+ 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr) ||
+ 		(!didPageWrites && (Insert->forcePageWrites || Insert->fullPageWrites)))
+ 	{
  		/*
! 		 * Oops, a checkpoint just happened, or forcePageWrites was just
! 		 * turned on. Start XLogInsert() all over, because we might have to
! 		 * include more full-page images in the record.
  		 */
! 		RedoRecPtr = Insert->RedoRecPtr;
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		*EndPos_p = InvalidXLogRecPtr;
! 		return false;
! 	}
! 
! 	/*
! 	 * Reserve the next insertion slot for us.
! 	 *
! 	 * First check that the slot is not still in use. Modifications to
! 	 * lastslot are protected by WALInsertTailLock, but here we assume that
! 	 * reading an int32 is atomic. Another process might advance lastslot at
! 	 * the same time, but not past nextslot.
! 	 */
! 	lastslot = Insert->lastslot;
! 	nextslot = Insert->nextslot;
! 	if (NextSlotNo(nextslot) == lastslot)
! 	{
! 		/*
! 		 * Oops, we've "caught our tail" and the oldest slot is still in use.
! 		 * Have to wait for it to become vacant.
! 		 */
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		WaitForXLogInsertionSlotToBecomeFree();
! 		goto retry;
! 	}
! 	myslot = &XLogCtl->XLogInsertSlots[nextslot];
! 	nextslot = NextSlotNo(nextslot);
! 
! 	/*
! 	 * Got the slot, now reserve the right amount of space from the WAL for
! 	 * our record.
! 	 */
! 	LastEndPos = ptr = Insert->CurrPos;
! 	*PrevRecord_p = Insert->PrevRecord;
! 
! 	/*
! 	 * If there isn't enough space on the current XLOG page for a record
! 	 * header, advance to the next page (leaving the unused space as zeroes).
! 	 */
! 	freespace = INSERT_FREESPACE(ptr);
! 	if (freespace < SizeOfXLogRecord)
! 	{
! 		ptr = AdvanceXLogRecPtrToNextPage(ptr);
! 		freespace = INSERT_FREESPACE(ptr);
! 		updrqst = true;
! 	}
  
! 	/*
! 	 * We are now at the starting position of our record. Now figure out how
! 	 * the data will be split across the WAL pages, to calculate where the
! 	 * record ends.
! 	 */
! 	StartPos = ptr;
  
+ 	if (isLogSwitch)
+ 	{
  		/*
! 		 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
! 		 * segment, we need not insert it (and don't want to because we'd like
! 		 * consecutive switch requests to be no-ops). Otherwise the XLOG_SWITCH
! 		 * record should consume all the remaining space on the current segment.
  		 */
+ 		Assert(size == SizeOfXLogRecord);
+ 		if ((ptr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
  		{
! 			/* We can release insert lock immediately */
! 			SpinLockRelease(&Insert->insertpos_lck);
  
! 			ptr.xrecoff -= SizeOfXLogLongPHD;
! 			if (ptr.xrecoff == 0)
! 			{
! 				/* crossing a logid boundary */
! 				ptr.xlogid -= 1;
! 				ptr.xrecoff = XLogFileSize;
! 			}
! 
! 			*EndPos_p = ptr;
! 			*StartPos_p = ptr;
! 			*myslot_p = NULL;
! 
! 			return false;
! 		}
! 		else
! 		{
! 			if (ptr.xrecoff % XLOG_SEG_SIZE != 0)
! 			{
! 				int segleft = XLOG_SEG_SIZE - (ptr.xrecoff % XLOG_SEG_SIZE);
! 				XLByteAdvance(ptr, segleft);
! 			}
! 			updrqst = true;
  		}
+ 	}
+ 	else
+ 	{
+ 		/* A normal record, ie. not xlog-switch */
+ 		int sizeleft = size;
+ 		while (freespace < sizeleft)
+ 		{
+ 			/* fill this page, and continue on next page */
+ 			sizeleft -= freespace;
+ 			ptr = AdvanceXLogRecPtrToNextPage(ptr);
  
! 			/* account for continuation record header */
! 			ptr.xrecoff += SizeOfXLogContRecord;
! 			freespace = INSERT_FREESPACE(ptr);
  
! 			updrqst = true;
! 		}
! 		/* the rest fits on this page */
! 		ptr.xrecoff += sizeleft;
! 
! 		/* Align the end position, so that the next record starts aligned */
! 		ptr.xrecoff = MAXALIGN(ptr.xrecoff);
! 	}
! 
! 	/* Update the shared state, and our slot, before releasing the lock */
! 	myslot->CurrPos = LastEndPos;
! 	Insert->CurrPos = ptr;
! 	Insert->PrevRecord = StartPos;
! 	Insert->nextslot = nextslot;
! 
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! #ifdef RESERVE_XLOGINSERT_LOCATION_DEBUG
! 	elog(LOG, "reserved xlog: prev %X/%X, start %X/%X, end %X/%X (len %d)",
! 		 PrevRecord_p->xlogid, PrevRecord_p->xrecoff,
! 		 StartPos.xlogid, StartPos.xrecoff,
! 		 ptr.xlogid, ptr.xrecoff,
! 		 size);
! #endif
! 
! 	*EndPos_p = ptr;
! 	*StartPos_p = StartPos;
! 	*myslot_p = (XLogInsertSlot *) myslot;
! 	*updrqst_p = updrqst;
! 
! 	return true;
! }
! 
! /*
!  * Update slot's CurrPos variable, and wake up anyone waiting on it.
!  */
! static void
! UpdateSlotCurrPos(volatile XLogInsertSlot *myslot, XLogRecPtr CurrPos)
! {
! 	PGPROC	   *head;
! 
! 	/*
! 	 * The write-barrier ensures that the changes we made to the WAL pages
! 	 * are visible to everyone before the update of CurrPos.
! 	 *
! 	 * XXX: I'm not sure if this is necessary. Does a function call act
! 	 * as an implicit barrier?
! 	 */
! 	pg_write_barrier();
  
! 	SpinLockAcquire(&myslot->lck);
! 	myslot->CurrPos = CurrPos;
! 	head = myslot->head;
! 	myslot->head = myslot->tail = NULL;
! 	SpinLockRelease(&myslot->lck);
! 	while (head != NULL)
! 	{
! 		PGPROC *proc = head;
! 		head = proc->lwWaitLink;
! 		proc->lwWaitLink = NULL;
! 		proc->lwWaiting = false;
! 		PGSemaphoreUnlock(&proc->sem);
  	}
+ }
+ 
+ /*
+  * Get a pointer to the right location in the WAL buffer containing the
+  * given XLogRecPtr.
+  *
+  * If the page is not initialized yet, it is initialized. That might require
+  * evicting an old dirty buffer from the buffer cache, which means I/O.
+  *
+  * The caller must ensure that the page containing the requested location
+  * isn't evicted yet, and won't be evicted, by holding onto an
+  * XLogInsertSlot with CurrPos set to 'ptr'. Setting it to some value
+  * less than 'ptr' would suffice for GetXLogBuffer(), but risks deadlock:
+  * if we have to evict a buffer, we might have to wait for someone else to
+  * finish a write. And that someone else might not be able to finish the write
+  * if our CurrPos points to a buffer that's still in the buffer cache.
+  */
+ static char *
+ GetXLogBuffer(XLogRecPtr ptr)
+ {
+ 	int			idx;
+ 	XLogRecPtr	endptr;
+ 
+ 	/*
+ 	 * The XLog buffer cache is organized so that we can easily calculate the
+ 	 * buffer a given page must be loaded into from the XLogRecPtr alone.
+ 	 * A page must always be loaded to a particular buffer.
+ 	 */
+ 	idx = XLogRecPtrToBufIdx(ptr);
+ 
+ 	/*
+ 	 * See what page is loaded in the buffer at the moment. It could be the
+ 	 * page we're looking for, or something older. It can't be anything
+ 	 * newer - that would imply the page we're looking for has already
+ 	 * been written out to disk, which shouldn't happen as long as the caller
+ 	 * has set its slot's CurrPos correctly.
+ 	 *
+ 	 * However, we don't hold a lock while we read the value. If someone has
+ 	 * just initialized the page, it's possible that we get a "torn read",
+ 	 * and read a bogus value. That's ok, we'll grab the mapping lock (in
+ 	 * AdvanceXLInsertBuffer) and retry if we see anything else than the page
+ 	 * we're looking for. But it means that when we do this unlocked read, we
+ 	 * might see a value that appears to be ahead of the page we're looking
+ 	 * for. So don't PANIC on that, until we've verified the value while
+ 	 * holding the lock.
+ 	 */
+ 	endptr = XLogCtl->xlblocks[idx];
+ 	if (ptr.xlogid != endptr.xlogid ||
+ 		!(ptr.xrecoff < endptr.xrecoff &&
+ 		  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
+ 	{
+ 		AdvanceXLInsertBuffer(ptr, false);
+ 		endptr = XLogCtl->xlblocks[idx];
+ 
+ 		if (ptr.xlogid != endptr.xlogid ||
+ 			!(ptr.xrecoff < endptr.xrecoff &&
+ 			  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
+ 		{
+ 			elog(PANIC, "could not find WAL buffer for %X/%X",
+ 				 ptr.xlogid, ptr.xrecoff);
+ 		}
+ 	}
+ 
+ 	/*
+ 	 * Found the buffer holding this page. Return a pointer to the right
+ 	 * offset within the page.
+ 	 */
+ 	return (char *) XLogCtl->pages + idx * (Size) XLOG_BLCKSZ +
+ 		ptr.xrecoff % XLOG_BLCKSZ;
+ }
+ 
+ /*
+  * Advance an XLogRecPtr to the first valid insertion location on the next
+  * page, right after the page header. An XLogRecPtr pointing to a boundary,
+  * ie. the first byte of a page, is taken to belong to the previous page.
+  */
+ static XLogRecPtr
+ AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr)
+ {
+ 	int			freespace;
+ 
+ 	freespace = INSERT_FREESPACE(ptr);
+ 	XLByteAdvance(ptr, freespace);
+ 	if (ptr.xrecoff % XLogSegSize == 0)
+ 		ptr.xrecoff += SizeOfXLogLongPHD;
  	else
+ 		ptr.xrecoff += SizeOfXLogShortPHD;
+ 
+ 	return ptr;
+ }
+ 
+ /*
+  * Wait for any insertions < upto to finish.
+  *
+  * Returns a value >= upto, which indicates the oldest in-progress insertion
+  * that we saw in the array, or CurrPos if there are no insertions in-progress
+  * at exit.
+  */
+ static XLogRecPtr
+ WaitXLogInsertionsToFinish(XLogRecPtr upto, XLogRecPtr CurrPos)
+ {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 	int			lastslot;
+ 	int			nextslot;
+ 	volatile XLogInsertSlot *slot;
+ 	XLogRecPtr	slotptr = InvalidXLogRecPtr;
+ 	XLogRecPtr	LastPos;
+ 	int			extraWaits = 0;
+ 
+ 	if (MyProc == NULL)
+ 		elog(PANIC, "cannot wait without a PGPROC structure");
+ 
+ 	LastPos = CurrPos;
+ 
+ 	LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
+ 
+ 	lastslot = Insert->lastslot;
+ 	nextslot = Insert->nextslot;
+ 
+ 	/* Skip over slots that have finished already */
+ 	while (lastslot != nextslot)
  	{
! 		slot = &XLogCtl->XLogInsertSlots[lastslot];
! 		SpinLockAcquire(&slot->lck);
! 		slotptr = slot->CurrPos;
  
! 		if (XLogRecPtrIsInvalid(slotptr))
  		{
! 			lastslot = NextSlotNo(lastslot);
! 			SpinLockRelease(&slot->lck);
  		}
  		else
  		{
! 			/*
! 			 * This insertion is still in-progress. Wait for it to finish
! 			 * if it's <= upto, otherwise we're done.
! 			 */
! 			Insert->lastslot = lastslot;
! 
! 			if (XLogRecPtrIsInvalid(upto) || XLByteLE(upto, slotptr))
! 			{
! 				LastPos = slotptr;
! 				SpinLockRelease(&slot->lck);
! 				break;
! 			}
! 
! 			/* wait */
! 			MyProc->lwWaiting = true;
! 			MyProc->lwWaitMode = 0; /* doesn't matter */
! 			MyProc->lwWaitLink = NULL;
! 			if (slot->head == NULL)
! 				slot->head = MyProc;
! 			else
! 				slot->tail->lwWaitLink = MyProc;
! 			slot->tail = MyProc;
! 			SpinLockRelease(&slot->lck);
! 			LWLockRelease(WALInsertTailLock);
! 			for (;;)
! 			{
! 				PGSemaphoreLock(&MyProc->sem, false);
! 				if (!MyProc->lwWaiting)
! 					break;
! 				extraWaits++;
! 			}
! 			LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
! 			lastslot = Insert->lastslot;
! 			nextslot = Insert->nextslot;
  		}
  	}
  
+ 	Insert->lastslot = lastslot;
+ 	LWLockRelease(WALInsertTailLock);
+ 
+ 	while (extraWaits-- > 0)
+ 		PGSemaphoreUnlock(&MyProc->sem);
+ 
+ 	return LastPos;
+ }
+ 
+ /*
+  * Wait for the next insertion slot to become vacant.
+  */
+ static void
+ WaitForXLogInsertionSlotToBecomeFree(void)
+ {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 	int			lastslot;
+ 	int			nextslot;
+ 	int			extraWaits = 0;
+ 
+ 	if (MyProc == NULL)
+ 		elog(PANIC, "cannot wait without a PGPROC structure");
+ 
+ 	LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
+ 
  	/*
! 	 * Re-read lastslot and nextslot, now that we have the wait-lock.
! 	 * We're reading nextslot without holding insertpos_lck. It could advance
! 	 * at the same time, but it can't advance beyond lastslot - 1.
  	 */
! 	lastslot = Insert->lastslot;
! 	nextslot = Insert->nextslot;
  
! 	/*
! 	 * If there are still no slots available, wait for the oldest slot to
! 	 * become vacant.
! 	 */
! 	while (NextSlotNo(nextslot) == lastslot)
  	{
! 		volatile XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[lastslot];
  
! 		SpinLockAcquire(&slot->lck);
! 		if (XLogRecPtrIsInvalid(slot->CurrPos))
! 		{
! 			SpinLockRelease(&slot->lck);
! 			break;
! 		}
! 
! 		/* wait */
! 		MyProc->lwWaiting = true;
! 		MyProc->lwWaitMode = 0; /* doesn't matter */
! 		MyProc->lwWaitLink = NULL;
! 		if (slot->head == NULL)
! 			slot->head = MyProc;
! 		else
! 			slot->tail->lwWaitLink = MyProc;
! 		slot->tail = MyProc;
! 		SpinLockRelease(&slot->lck);
! 		LWLockRelease(WALInsertTailLock);
! 		for (;;)
! 		{
! 			PGSemaphoreLock(&MyProc->sem, false);
! 			if (!MyProc->lwWaiting)
! 				break;
! 			extraWaits++;
! 		}
! 		LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
! 		lastslot = Insert->lastslot;
! 		nextslot = Insert->nextslot;
  	}
  
! 	/*
! 	 * Ok, there is at least one empty slot now. That's enouugh for our
! 	 * insertion, but ẃhile we're at it, advance lastslot as much as we
! 	 * can. That way we don't need to come back here on the next call
! 	 * again.
! 	 */
! 	while (lastslot != nextslot)
! 	{
! 		volatile XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[lastslot];
! 		/*
! 		 * Don't need to grab the slot's spinlock here, because we're not
! 		 * interested in the exact value of CurrPos, only whether it's
! 		 * valid or not.
! 		 */
! 		if (!XLogRecPtrIsInvalid(slot->CurrPos))
! 			break;
  
! 		lastslot = NextSlotNo(lastslot);
! 	}
! 	Insert->lastslot = lastslot;
  
! 	LWLockRelease(WALInsertTailLock);
  }
  
  /*
***************
*** 1488,1522 **** XLogArchiveCleanup(const char *xlog)
  }
  
  /*
!  * Advance the Insert state to the next buffer page, writing out the next
!  * buffer if it still contains unwritten data.
!  *
!  * If new_segment is TRUE then we set up the next buffer page as the first
!  * page of the next xlog segment file, possibly but not usually the next
!  * consecutive file page.
!  *
!  * The global LogwrtRqst.Write pointer needs to be advanced to include the
!  * just-filled page.  If we can do this for free (without an extra lock),
!  * we do so here.  Otherwise the caller must do it.  We return TRUE if the
!  * request update still needs to be done, FALSE if we did it internally.
!  *
!  * Must be called with WALInsertLock held.
   */
! static bool
! AdvanceXLInsertBuffer(bool new_segment)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	XLogCtlWrite *Write = &XLogCtl->Write;
! 	int			nextidx = NextBufIdx(Insert->curridx);
! 	bool		update_needed = true;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
! 	XLogRecPtr	NewPageEndPtr;
  	XLogPageHeader NewPage;
  
! 	/* Use Insert->LogwrtResult copy if it's more fresh */
! 	if (XLByteLT(LogwrtResult.Write, Insert->LogwrtResult.Write))
! 		LogwrtResult = Insert->LogwrtResult;
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
--- 2017,2050 ----
  }
  
  /*
!  * Initialize XLOG buffers, writing out old buffers if they still contain
!  * unwritten data, upto the page containing 'upto'. Or if 'opportunistic' is
!  * true, initialize as many pages as we can without having to write out
!  * unwritten data. Any new pages are initialized to zeros, with pages headers
!  * initialized properly.
   */
! static void
! AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			nextidx;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
! 	XLogRecPtr	NewPageEndPtr = InvalidXLogRecPtr;
  	XLogPageHeader NewPage;
+ 	bool		needflush;
+ 	int			npages = 0;
  
! 	LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
! 
! 	/*
! 	 * Now that we have the lock, check if someone initialized the page
! 	 * already.
! 	 */
! /* XXX: fix indentation before commit */
! while (!XLByteLT(upto, XLogCtl->xlblocks[XLogCtl->curridx]) || opportunistic)
! {
! 	nextidx = NextBufIdx(XLogCtl->curridx);
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
***************
*** 1524,1535 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
- 	if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
- 	{
- 		/* nope, got work to do... */
- 		XLogRecPtr	FinishedPageRqstPtr;
  
! 		FinishedPageRqstPtr = XLogCtl->xlblocks[Insert->curridx];
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
--- 2052,2068 ----
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
  
! 	needflush = !XLByteLE(OldPageRqstPtr, LogwrtResult.Write);
! 
! 	if (needflush)
! 	{
! 		/*
! 		 * Nope, got work to do. If we just want to pre-initialize as much as
! 		 * we can without flushing, give up now.
! 		 */
! 		if (opportunistic)
! 			break;
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
***************
*** 1537,1581 **** AdvanceXLInsertBuffer(bool new_segment)
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, FinishedPageRqstPtr))
! 				xlogctl->LogwrtRqst.Write = FinishedPageRqstPtr;
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		update_needed = false;	/* Did the shared-request update */
! 
! 		if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
! 		{
! 			/* OK, someone wrote it already */
! 			Insert->LogwrtResult = LogwrtResult;
! 		}
! 		else
  		{
! 			/* Must acquire write lock */
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 			LogwrtResult = Write->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding insert lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false, false);
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
  		}
  	}
  
--- 2070,2119 ----
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, OldPageRqstPtr))
! 			{
! 				Assert(XLByteLE(OldPageRqstPtr, xlogctl->Insert.CurrPos));
! 				xlogctl->LogwrtRqst.Write = OldPageRqstPtr;
! 			}
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/*
! 			 * Must acquire write lock. Release WALBufMappingLock first, to
! 			 * make sure that all insertions that we need to wait for can
! 			 * finish (up to this same position). Otherwise we risk deadlock.
! 			 */
! 			LWLockRelease(WALBufMappingLock);
! 
! 			WaitXLogInsertionsToFinish(OldPageRqstPtr, InvalidXLogRecPtr);
! 
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 			LogwrtResult = XLogCtl->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding mapping lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false);
  				LWLockRelease(WALWriteLock);
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
+ 			/* Re-acquire WALBufMappingLock and retry */
+ 			LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
+ 			continue;
  		}
  	}
  
***************
*** 1583,1596 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[Insert->curridx];
! 
! 	if (new_segment)
! 	{
! 		/* force it to a segment start point */
! 		NewPageEndPtr.xrecoff += XLogSegSize - 1;
! 		NewPageEndPtr.xrecoff -= NewPageEndPtr.xrecoff % XLogSegSize;
! 	}
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
--- 2121,2127 ----
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[XLogCtl->curridx];
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
***************
*** 1600,1612 **** AdvanceXLInsertBuffer(bool new_segment)
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
! 	XLogCtl->xlblocks[nextidx] = NewPageEndPtr;
! 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
! 	Insert->curridx = nextidx;
! 	Insert->currpage = NewPage;
! 
! 	Insert->currpos = ((char *) NewPage) +SizeOfXLogShortPHD;
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
--- 2131,2140 ----
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
! 	Assert(NewPageEndPtr.xrecoff % XLOG_BLCKSZ == 0);
! 	Assert(XLogRecEndPtrToBufIdx(NewPageEndPtr) == nextidx);
  
! 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
***************
*** 1650,1660 **** AdvanceXLInsertBuffer(bool new_segment)
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
- 
- 		Insert->currpos = ((char *) NewPage) +SizeOfXLogLongPHD;
  	}
  
! 	return update_needed;
  }
  
  /*
--- 2178,2205 ----
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
  	}
  
! 	/*
! 	 * Make sure the initialization of the page becomes visible to others
! 	 * before the xlblocks update. GetXLogBuffer() reads xlblocks without
! 	 * holding a lock.
! 	 */
! 	pg_write_barrier();
! 
! 	*((volatile XLogRecPtr *) &XLogCtl->xlblocks[nextidx]) = NewPageEndPtr;
! 
! 	XLogCtl->curridx = nextidx;
! 
! 	npages++;
! }
! 	LWLockRelease(WALBufMappingLock);
! 
! #ifdef WAL_DEBUG
! 	if (npages > 0)
! 		elog(DEBUG1, "initialized %d pages, upto %X/%X",
! 			 npages, NewPageEndPtr.xlogid, NewPageEndPtr.xrecoff);
! #endif
  }
  
  /*
***************
*** 1699,1714 **** XLogCheckpointNeeded(uint32 logid, uint32 logseg)
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * If xlog_switch == TRUE, we are intending an xlog segment switch, so
!  * perform end-of-segment actions after writing the last page, even if
!  * it's not physically the end of its segment.  (NB: this will work properly
!  * only if caller specifies WriteRqst == page-end and flexible == false,
!  * and there is some data to write.)
!  *
!  * Must be called with WALWriteLock held.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
--- 2244,2255 ----
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * Must be called with WALWriteLock held. And you must've called
!  * WaitXLogInsertionsToFinish(WriteRqst) before grabbing the lock to make sure
!  * the data is ready to write.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
***************
*** 1726,1732 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  	/*
  	 * Update local LogwrtResult (caller probably did this already, but...)
  	 */
! 	LogwrtResult = Write->LogwrtResult;
  
  	/*
  	 * Since successive pages in the xlog cache are consecutively allocated,
--- 2267,2273 ----
  	/*
  	 * Update local LogwrtResult (caller probably did this already, but...)
  	 */
! 	LogwrtResult = XLogCtl->LogwrtResult;
  
  	/*
  	 * Since successive pages in the xlog cache are consecutively allocated,
***************
*** 1757,1770 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  		 * if we're passed a bogus WriteRqst.Write that is past the end of the
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
! 		if (!XLByteLT(LogwrtResult.Write, XLogCtl->xlblocks[curridx]))
  			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
! 				 XLogCtl->xlblocks[curridx].xlogid,
! 				 XLogCtl->xlblocks[curridx].xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
! 		LogwrtResult.Write = XLogCtl->xlblocks[curridx];
  		ispartialpage = XLByteLT(WriteRqst.Write, LogwrtResult.Write);
  
  		if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
--- 2298,2311 ----
  		 * if we're passed a bogus WriteRqst.Write that is past the end of the
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
! 		XLogRecPtr EndPtr = XLogCtl->xlblocks[curridx];
! 		if (!XLByteLT(LogwrtResult.Write, EndPtr))
  			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
! 				 EndPtr.xlogid, EndPtr.xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
! 		LogwrtResult.Write = EndPtr;
  		ispartialpage = XLByteLT(WriteRqst.Write, LogwrtResult.Write);
  
  		if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
***************
*** 1861,1876 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
- 			 * We also do this if this is the last page written for an xlog
- 			 * switch.
- 			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg || (xlog_switch && last_iteration))
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
--- 2402,2414 ----
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg)
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
***************
*** 1960,1967 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  			xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
  		SpinLockRelease(&xlogctl->info_lck);
  	}
- 
- 	Write->LogwrtResult = LogwrtResult;
  }
  
  /*
--- 2498,2503 ----
***************
*** 2124,2131 **** XLogFlush(XLogRecPtr record)
  	 */
  	for (;;)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
  		volatile XLogCtlData *xlogctl = XLogCtl;
  
  		/* read LogwrtResult and update local state */
  		SpinLockAcquire(&xlogctl->info_lck);
--- 2660,2670 ----
  	 */
  	for (;;)
  	{
! 		/* use volatile pointers to prevent code rearrangement */
  		volatile XLogCtlData *xlogctl = XLogCtl;
+ 		volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 		uint32		freespace;
+ 		XLogRecPtr	insertpos;
  
  		/* read LogwrtResult and update local state */
  		SpinLockAcquire(&xlogctl->info_lck);
***************
*** 2139,2144 **** XLogFlush(XLogRecPtr record)
--- 2678,2712 ----
  			break;
  
  		/*
+ 		 * Get the current insert position.
+ 		 *
+ 		 * XXX: This used to do LWLockConditionalAcquire(WALInsertLock),
+ 		 * fall back to writing just up to 'record' if we couldn't get t
+ 		 * lock. I wonder if it would be a good idea to have a
+ 		 * SpinLockConditionalAcquire function and use that? On one hand
+ 		 * it would be good to not cause more contention on the lock if
+ 		 * busy, but on the other hand, this spinlock is much more light
+ 		 * than the WALInsertLock was, so maybe it's better to just grab
+ 		 * spinlock. Also note that if we stored the XLogRecPtr as one 6
+ 		 * integer, we could just read it with no lock on platforms wher
+ 		 * 64-bit integer accesses are atomic, which covers many common
+ 		 * platforms nowadays.
+ 		 */
+ 		SpinLockAcquire(&Insert->insertpos_lck);
+ 		insertpos = Insert->CurrPos;
+ 		SpinLockRelease(&Insert->insertpos_lck);
+ 
+ 		freespace = INSERT_FREESPACE(insertpos);
+ 		if (freespace < SizeOfXLogRecord)               /* buffer is full */
+ 			insertpos.xrecoff += freespace;
+ 
+ 		/*
+ 		 * Before actually performing the write, wait for all in-flight
+ 		 * insertions to the pages we're about to write to finish.
+ 		 */
+ 		insertpos = WaitXLogInsertionsToFinish(WriteRqstPtr, insertpos);
+ 
+ 		/*
  		 * Try to get the write lock. If we can't get it immediately, wait
  		 * until it's released, and recheck if we still need to do the flush
  		 * or if the backend that held the lock did it for us already. This
***************
*** 2155,2186 **** XLogFlush(XLogRecPtr record)
  			continue;
  		}
  		/* Got the lock */
! 		LogwrtResult = XLogCtl->Write.LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			/* try to write/flush later additions to XLOG as well */
! 			if (LWLockConditionalAcquire(WALInsertLock, LW_EXCLUSIVE))
! 			{
! 				XLogCtlInsert *Insert = &XLogCtl->Insert;
! 				uint32		freespace = INSERT_FREESPACE(Insert);
  
! 				if (freespace < SizeOfXLogRecord)		/* buffer is full */
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 				else
! 				{
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 					WriteRqstPtr.xrecoff -= freespace;
! 				}
! 				LWLockRelease(WALInsertLock);
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = WriteRqstPtr;
! 			}
! 			else
! 			{
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = record;
! 			}
! 			XLogWrite(WriteRqst, false, false);
  		}
  		LWLockRelease(WALWriteLock);
  		/* done */
--- 2723,2735 ----
  			continue;
  		}
  		/* Got the lock */
! 		LogwrtResult = XLogCtl->LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			WriteRqst.Write = insertpos;
! 			WriteRqst.Flush = insertpos;
  
! 			XLogWrite(WriteRqst, false);
  		}
  		LWLockRelease(WALWriteLock);
  		/* done */
***************
*** 2292,2314 **** XLogBackgroundFlush(void)
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
- 
  	START_CRIT_SECTION();
  
! 	/* now wait for the write lock */
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 	LogwrtResult = XLogCtl->Write.LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
  	{
  		XLogwrtRqst WriteRqst;
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible, false);
  	}
! 	LWLockRelease(WALWriteLock);
  
  	END_CRIT_SECTION();
  }
  
  /*
--- 2841,2871 ----
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
  	START_CRIT_SECTION();
  
! 	/* now wait for any in-progress insertions to finish and get write lock */
! 	WaitXLogInsertionsToFinish(WriteRqstPtr, InvalidXLogRecPtr);
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 	LogwrtResult = XLogCtl->LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
  	{
  		XLogwrtRqst WriteRqst;
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible);
  	}
! 	LogwrtResult = XLogCtl->LogwrtResult;
  
  	END_CRIT_SECTION();
+ 
+ 	LWLockRelease(WALWriteLock);
+ 
+ 	/*
+ 	 * Great, done. To take some work off the critical path, try to initialize
+ 	 * as many of the no-longer-needed WAL buffers for future use as we can.
+ 	 */
+ 	AdvanceXLInsertBuffer(InvalidXLogRecPtr, true);
  }
  
  /*
***************
*** 5102,5107 **** XLOGShmemSize(void)
--- 5659,5667 ----
  	/* and the buffers themselves */
  	size = add_size(size, mul_size(XLOG_BLCKSZ, XLOGbuffers));
  
+ 	/* XLog insertion slots */
+ 	size = add_size(size, mul_size(sizeof(XLogInsertSlot), NumXLogInsertSlots));
+ 
  	/*
  	 * Note: we don't count ControlFileData, it comes out of the "slop factor"
  	 * added by CreateSharedMemoryAndSemaphores.  This lets us use this
***************
*** 5117,5122 **** XLOGShmemInit(void)
--- 5677,5683 ----
  	bool		foundCFile,
  				foundXLog;
  	char	   *allocptr;
+ 	int			i;
  
  	ControlFile = (ControlFileData *)
  		ShmemInitStruct("Control File", sizeof(ControlFileData), &foundCFile);
***************
*** 5142,5147 **** XLOGShmemInit(void)
--- 5703,5721 ----
  	memset(XLogCtl->xlblocks, 0, sizeof(XLogRecPtr) * XLOGbuffers);
  	allocptr += sizeof(XLogRecPtr) * XLOGbuffers;
  
+ 	/* Initialize insertion slots */
+ 	XLogCtl->XLogInsertSlots = (XLogInsertSlot *) allocptr;
+ 	for (i = 0; i < NumXLogInsertSlots; i++)
+ 	{
+ 		XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[i];
+ 		slot->CurrPos = InvalidXLogRecPtr;
+ 		slot->head = slot->tail = NULL;
+ 		SpinLockInit(&slot->lck);
+ 	}
+ 	XLogCtl->Insert.nextslot = 1;
+ 	XLogCtl->Insert.lastslot = 0;
+ 	allocptr += sizeof(XLogInsertSlot) * NumXLogInsertSlots;
+ 
  	/*
  	 * Align the start of the page buffers to an ALIGNOF_XLOG_BUFFER boundary.
  	 */
***************
*** 5156,5166 **** XLOGShmemInit(void)
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
- 	XLogCtl->Insert.currpage = (XLogPageHeader) (XLogCtl->pages);
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
--- 5730,5741 ----
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
+ 	SpinLockInit(&XLogCtl->Insert.insertpos_lck);
+ 
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
***************
*** 6038,6043 **** StartupXLOG(void)
--- 6613,6619 ----
  	bool		backupEndRequired = false;
  	bool		backupFromStandby = false;
  	DBState		dbstate_at_startup;
+ 	int			firstIdx;
  
  	/*
  	 * Read control file and check XLOG status looks valid.
***************
*** 6844,6851 **** StartupXLOG(void)
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 	XLogCtl->xlblocks[0].xlogid = openLogId;
! 	XLogCtl->xlblocks[0].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
--- 7420,7431 ----
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 
! 	firstIdx = XLogRecPtrToBufIdx(EndOfLog);
! 	XLogCtl->curridx = firstIdx;
! 
! 	XLogCtl->xlblocks[firstIdx].xlogid = openLogId;
! 	XLogCtl->xlblocks[firstIdx].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
***************
*** 6853,6878 **** StartupXLOG(void)
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[0].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) Insert->currpage, readBuf, XLOG_BLCKSZ);
! 	Insert->currpos = (char *) Insert->currpage +
! 		(EndOfLog.xrecoff + XLOG_BLCKSZ - XLogCtl->xlblocks[0].xrecoff);
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
- 	XLogCtl->Write.LogwrtResult = LogwrtResult;
- 	Insert->LogwrtResult = LogwrtResult;
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(Insert->currpos, 0, freespace);
! 		XLogCtl->Write.curridx = 0;
  	}
  	else
  	{
--- 7433,7455 ----
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[firstIdx].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) &XLogCtl->pages[firstIdx * XLOG_BLCKSZ], readBuf, XLOG_BLCKSZ);
! 	Insert->CurrPos = EndOfLog;
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = XLOG_BLCKSZ - EndRecPtr.xrecoff % XLOG_BLCKSZ;
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(&XLogCtl->pages[firstIdx * XLOG_BLCKSZ] + EndRecPtr.xrecoff % XLOG_BLCKSZ, 0, freespace);
! 		XLogCtl->Write.curridx = firstIdx;
  	}
  	else
  	{
***************
*** 6884,6890 **** StartupXLOG(void)
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(0);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
--- 7461,7467 ----
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(firstIdx);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
***************
*** 7390,7396 **** GetRedoRecPtr(void)
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire WALInsertLock which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
--- 7967,7973 ----
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire insertpos_lck which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
***************
*** 7666,7671 **** CreateCheckPoint(int flags)
--- 8243,8249 ----
  	uint32		insert_logSeg;
  	TransactionId *inCommitXids;
  	int			nInCommit;
+ 	XLogRecPtr	curInsert;
  
  	/*
  	 * An end-of-recovery checkpoint is really a shutdown checkpoint, just
***************
*** 7734,7743 **** CreateCheckPoint(int flags)
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * We must hold WALInsertLock while examining insert state to determine
! 	 * the checkpoint REDO pointer.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
--- 8312,8321 ----
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * Determine the checkpoint REDO pointer.
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	curInsert = Insert->CurrPos;
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
***************
*** 7749,7755 **** CreateCheckPoint(int flags)
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding the WALInsertLock we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
--- 8327,8333 ----
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding insertpos_lck we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
***************
*** 7758,7772 **** CreateCheckPoint(int flags)
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
- 		XLogRecPtr	curInsert;
- 
- 		INSERT_RECPTR(curInsert, Insert, Insert->curridx);
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			LWLockRelease(WALInsertLock);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
--- 8336,8347 ----
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
***************
*** 7793,7806 **** CreateCheckPoint(int flags)
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace < SizeOfXLogRecord)
! 	{
! 		(void) AdvanceXLInsertBuffer(false);
! 		/* OK to ignore update return flag, since we will do flush anyway */
! 		freespace = INSERT_FREESPACE(Insert);
! 	}
! 	INSERT_RECPTR(checkPoint.redo, Insert, Insert->curridx);
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
--- 8368,8377 ----
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(curInsert);
  	if (freespace < SizeOfXLogRecord)
! 		curInsert = AdvanceXLogRecPtrToNextPage(curInsert);
! 	checkPoint.redo = curInsert;
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
***************
*** 7826,7832 **** CreateCheckPoint(int flags)
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
--- 8397,8403 ----
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
***************
*** 7846,7852 **** CreateCheckPoint(int flags)
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released WALInsertLock, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
--- 8417,8423 ----
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released insertpos_lck, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
***************
*** 8213,8227 **** CreateRestartPoint(int flags)
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * You need to hold WALInsertLock and info_lck to update it, although
! 	 * during recovery acquiring WALInsertLock is just pro forma, because
! 	 * there is no other processes updating Insert.RedoRecPtr.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * Prepare to accumulate statistics.
--- 8784,8798 ----
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * Like in CreateCheckPoint(), you need both insertpos_lck and info_lck
! 	 * to update it, although during recovery acquiring insertpos_lck is just
! 	 * pro forma, because no WAL insertions are happening.
  	 */
! 	SpinLockAcquire(&xlogctl->Insert.insertpos_lck);
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
! 	SpinLockRelease(&xlogctl->Insert.insertpos_lck);
  
  	/*
  	 * Prepare to accumulate statistics.
***************
*** 8414,8419 **** RequestXLogSwitch(void)
--- 8985,8991 ----
  {
  	XLogRecPtr	RecPtr;
  	XLogRecData rdata;
+ 	XLogwrtRqst FlushRqst;
  
  	/* XLOG SWITCH, alone among xlog record types, has no data */
  	rdata.buffer = InvalidBuffer;
***************
*** 8423,8428 **** RequestXLogSwitch(void)
--- 8995,9021 ----
  
  	RecPtr = XLogInsert(RM_XLOG_ID, XLOG_SWITCH, &rdata);
  
+ 	/* XXX: before this patch, TRACE_POSTGRESQL_XLOG_SWITCH was not called
+ 	 * if the xlog switch had no work to do, ie. if we were already at the
+ 	 * beginning of a new XLOG segment. You can check if RecPtr points to
+ 	 * beginning of a segment if you want to keep the distinction.
+ 	 */
+ 	TRACE_POSTGRESQL_XLOG_SWITCH();
+ 
+ 	/*
+ 	 * Flush through the end of the page containing XLOG_SWITCH, and
+ 	 * perform end-of-segment actions (eg, notifying archiver).
+ 	 */
+ 	WaitXLogInsertionsToFinish(RecPtr, InvalidXLogRecPtr);
+ 
+ 	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
+ 	FlushRqst.Write = RecPtr;
+ 	FlushRqst.Flush = RecPtr;
+ 	START_CRIT_SECTION();
+ 	XLogWrite(FlushRqst, false);
+ 	END_CRIT_SECTION();
+ 	LWLockRelease(WALWriteLock);
+ 
  	return RecPtr;
  }
  
***************
*** 8501,8522 **** XLogReportParameters(void)
  /*
   * Update full_page_writes in shared memory, and write an
   * XLOG_FPW_CHANGE record if necessary.
   */
  void
  UpdateFullPageWrites(void)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  
  	/*
  	 * Do nothing if full_page_writes has not been changed.
  	 *
  	 * It's safe to check the shared full_page_writes without the lock,
! 	 * because we can guarantee that there is no concurrently running
! 	 * process which can update it.
  	 */
  	if (fullPageWrites == Insert->fullPageWrites)
  		return;
  
  	/*
  	 * Write an XLOG_FPW_CHANGE record. This allows us to keep
  	 * track of full_page_writes during archive recovery, if required.
--- 9094,9134 ----
  /*
   * Update full_page_writes in shared memory, and write an
   * XLOG_FPW_CHANGE record if necessary.
+  *
+  * Note: this function assumes there is no other process running
+  * concurrently that could update it.
   */
  void
  UpdateFullPageWrites(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  
  	/*
  	 * Do nothing if full_page_writes has not been changed.
  	 *
  	 * It's safe to check the shared full_page_writes without the lock,
! 	 * because we assume that there is no concurrently running process
! 	 * which can update it.
  	 */
  	if (fullPageWrites == Insert->fullPageWrites)
  		return;
  
+ 	START_CRIT_SECTION();
+ 
+ 	/*
+ 	 * It's always safe to take full page images, even when not strictly
+ 	 * required, but not the other round. So if we're setting full_page_writes
+ 	 * to true, first set it true and then write the WAL record. If we're
+ 	 * setting it to false, first write the WAL record and then set the
+ 	 * global flag.
+ 	 */
+ 	if (fullPageWrites)
+ 	{
+ 		SpinLockAcquire(&Insert->insertpos_lck);
+ 		Insert->fullPageWrites = true;
+ 		SpinLockRelease(&Insert->insertpos_lck);
+ 	}
+ 
  	/*
  	 * Write an XLOG_FPW_CHANGE record. This allows us to keep
  	 * track of full_page_writes during archive recovery, if required.
***************
*** 8532,8543 **** UpdateFullPageWrites(void)
  
  		XLogInsert(RM_XLOG_ID, XLOG_FPW_CHANGE, &rdata);
  	}
! 	else
  	{
! 		LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 		Insert->fullPageWrites = fullPageWrites;
! 		LWLockRelease(WALInsertLock);
  	}
  }
  
  /*
--- 9144,9157 ----
  
  		XLogInsert(RM_XLOG_ID, XLOG_FPW_CHANGE, &rdata);
  	}
! 
! 	if (!fullPageWrites)
  	{
! 		SpinLockAcquire(&Insert->insertpos_lck);
! 		Insert->fullPageWrites = false;
! 		SpinLockRelease(&Insert->insertpos_lck);
  	}
+ 	END_CRIT_SECTION();
  }
  
  /*
***************
*** 9063,9068 **** issue_xlog_fsync(int fd, uint32 log, uint32 seg)
--- 9677,9683 ----
  XLogRecPtr
  do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	bool		backup_started_in_recovery = false;
  	XLogRecPtr	checkpointloc;
***************
*** 9125,9150 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  	 * Note that forcePageWrites has no effect during an online backup from
  	 * the standby.
  	 *
! 	 * We must hold WALInsertLock to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
! 		if (XLogCtl->Insert.exclusiveBackup)
  		{
! 			LWLockRelease(WALInsertLock);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		XLogCtl->Insert.exclusiveBackup = true;
  	}
  	else
! 		XLogCtl->Insert.nonExclusiveBackups++;
! 	XLogCtl->Insert.forcePageWrites = true;
! 	LWLockRelease(WALInsertLock);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
--- 9740,9765 ----
  	 * Note that forcePageWrites has no effect during an online backup from
  	 * the standby.
  	 *
! 	 * We must hold insertpos_lck to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
! 		if (Insert->exclusiveBackup)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		Insert->exclusiveBackup = true;
  	}
  	else
! 		Insert->nonExclusiveBackups++;
! 	Insert->forcePageWrites = true;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
***************
*** 9257,9269 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			LWLockAcquire(WALInsertLock, LW_SHARED);
! 			if (XLByteLT(XLogCtl->Insert.lastBackupStart, startpoint))
  			{
! 				XLogCtl->Insert.lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			LWLockRelease(WALInsertLock);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
--- 9872,9884 ----
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			SpinLockAcquire(&Insert->insertpos_lck);
! 			if (XLByteLT(Insert->lastBackupStart, startpoint))
  			{
! 				Insert->lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			SpinLockRelease(&Insert->insertpos_lck);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
***************
*** 9347,9356 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
  		Assert(XLogCtl->Insert.exclusiveBackup);
--- 9962,9972 ----
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
  		Assert(XLogCtl->Insert.exclusiveBackup);
***************
*** 9367,9373 **** pg_start_backup_callback(int code, Datum arg)
  	{
  		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 9983,9989 ----
  	{
  		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9380,9385 **** pg_start_backup_callback(int code, Datum arg)
--- 9996,10002 ----
  XLogRecPtr
  do_pg_stop_backup(char *labelfile, bool waitforarchive)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	bool		backup_started_in_recovery = false;
  	XLogRecPtr	startpoint;
***************
*** 9433,9441 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
! 		XLogCtl->Insert.exclusiveBackup = false;
  	else
  	{
  		/*
--- 10050,10058 ----
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
! 		Insert->exclusiveBackup = false;
  	else
  	{
  		/*
***************
*** 9444,9459 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 		XLogCtl->Insert.nonExclusiveBackups--;
  	}
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  
  	if (exclusive)
  	{
--- 10061,10076 ----
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(Insert->nonExclusiveBackups > 0);
! 		Insert->nonExclusiveBackups--;
  	}
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	if (exclusive)
  	{
***************
*** 9731,9746 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  void
  do_pg_abort_backup(void)
  {
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 	Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 	XLogCtl->Insert.nonExclusiveBackups--;
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 10348,10365 ----
  void
  do_pg_abort_backup(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	Assert(Insert->nonExclusiveBackups > 0);
! 	Insert->nonExclusiveBackups--;
! 
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9794,9805 **** GetStandbyFlushRecPtr(void)
  XLogRecPtr
  GetXLogInsertRecPtr(void)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	LWLockAcquire(WALInsertLock, LW_SHARED);
! 	INSERT_RECPTR(current_recptr, Insert, Insert->curridx);
! 	LWLockRelease(WALInsertLock);
  
  	return current_recptr;
  }
--- 10413,10424 ----
  XLogRecPtr
  GetXLogInsertRecPtr(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	current_recptr = Insert->CurrPos;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	return current_recptr;
  }
*** a/src/backend/storage/lmgr/spin.c
--- b/src/backend/storage/lmgr/spin.c
***************
*** 56,61 **** SpinlockSemas(void)
--- 56,64 ----
  	 *
  	 * For now, though, we just need a few spinlocks (10 should be plenty)
  	 * plus one for each LWLock and one for each buffer header.
+ 	 *
+ 	 * XXX: remember to adjust this for the number of spinlocks needed by the
+ 	 * xlog.c changes before committing!
  	 */
  	return NumLWLocks() + NBuffers + 10;
  }
*** a/src/include/storage/lwlock.h
--- b/src/include/storage/lwlock.h
***************
*** 53,59 **** typedef enum LWLockId
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALInsertLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
--- 53,59 ----
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALBufMappingLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
***************
*** 79,84 **** typedef enum LWLockId
--- 79,85 ----
  	SerializablePredicateLockListLock,
  	OldSerXidLock,
  	SyncRepLock,
+ 	WALInsertTailLock,
  	/* Individual lock IDs end here */
  	FirstBufMappingLock,
  	FirstLockMgrLock = FirstBufMappingLock + NUM_BUFFER_PARTITIONS,

*** a/src/backend/access/transam/xlog.c
--- b/src/backend/access/transam/xlog.c
***************
*** 42,47 ****
--- 42,48 ----
  #include "postmaster/startup.h"
  #include "replication/walreceiver.h"
  #include "replication/walsender.h"
+ #include "storage/barrier.h"
  #include "storage/bufmgr.h"
  #include "storage/fd.h"
  #include "storage/ipc.h"
***************
*** 290,315 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There are actually three shared-memory copies of
!  * LogwrtResult, plus one unshared copy in each backend.  Here's how it works:
!  *		XLogCtl->LogwrtResult is protected by info_lck
!  *		XLogCtl->Write.LogwrtResult is protected by WALWriteLock
!  *		XLogCtl->Insert.LogwrtResult is protected by WALInsertLock
!  * One must hold the associated lock to read or write any of these, but
!  * of course no lock is needed to read/write the unshared LogwrtResult.
!  *
!  * XLogCtl->LogwrtResult and XLogCtl->Write.LogwrtResult are both "always
!  * right", since both are updated by a write or flush operation before
!  * it releases WALWriteLock.  The point of keeping XLogCtl->Write.LogwrtResult
!  * is that it can be examined/modified by code that already holds WALWriteLock
!  * without needing to grab info_lck as well.
!  *
!  * XLogCtl->Insert.LogwrtResult may lag behind the reality of the other two,
!  * but is updated when convenient.	Again, it exists for the convenience of
!  * code that is already holding WALInsertLock but not the other locks.
!  *
!  * The unshared LogwrtResult may lag behind any or all of these, and again
!  * is updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
--- 291,301 ----
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There is one shared-memory copy of LogwrtResult,
!  * plus one unshared copy in each backend. To read the shared copy, you need
!  * to hold info_lck *or* WALWriteLock. To update it, you need to hold both
!  * locks. The unshared LogwrtResult may lag behind the shared copy, and is
!  * updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
***************
*** 319,328 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  The other locks are held longer (potentially
!  * over I/O operations), so we use LWLocks for them.  These locks are:
   *
!  * WALInsertLock: must be held to insert a record into the WAL buffers.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
--- 305,319 ----
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  insertpos_lck protects the current logical
!  * insert location, ie. the head of reserved WAL space.  The other locks are
!  * held longer (potentially over I/O operations), so we use LWLocks for them.
!  * These locks are:
   *
!  * WALBufMappingLock: must be held to replace a page in the WAL buffer cache.
!  * This is only held while initializing and changing the mapping. If the
!  * contents of the buffer being replaced haven't been written yet, the mapping
!  * lock is released while the write is done, and reacquired afterwards.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
***************
*** 334,339 **** static XLogRecPtr RedoStartLSN = {0, 0};
--- 325,399 ----
   * only one checkpointer at a time; currently, with all checkpoints done by
   * the checkpointer, this is just pro forma).
   *
+  *
+  * Inserting a new WAL record is a two-step process:
+  *
+  * 1. Reserve the right amount of space from the WAL, and the next insertion
+  *    slot to advertise that the insertion is in progress. The current head
+  *    of reserved space is kept in Insert->CurrPos, and is protected by
+  *    insertpos_lck. Try to keep this section as short as possible,
+  *    insertpos_lck can be heavily contended on a busy system
+  *
+  * 2. Copy the record to the reserved WAL space. This involves finding the
+  *    correct WAL buffer containing the reserved space, and copying the
+  *    record in place. This can be done concurrently in multiple processes.
+  *
+  * To allow as much parallelism as possible for step 2, we try hard to avoid
+  * lock contention in that code path. Each insertion is asssigned its own
+  * "XLog insertion slot", which is used to advertise the position the backend
+  * is writing to. The slot is marked as in-use in step 1, while holding
+  * insertpos_lck, by setting the position field in the slot. When the backend
+  * is finished with the insertion, it clears its slot. Each slot is protected
+  * by a separate spinlock, to keep contention minimal.
+  *
+  * The insertion slots also provide a mechanism to wait for an insertion to
+  * finish. This is important when an XLOG page is written out - any
+  * in-progress insertions must finish copying data to the page first, or the
+  * on-disk copy will be incomplete. Waiting is done by the
+  * WaitXLogInsertionsToFinish() function. It adds the current process to the
+  * waiting queue in the slot it needs to wait for, and when that insertion
+  * finishes (or proceeds to the next page, at least), the inserter wakes up
+  * the process.
+  *
+  * The insertion slots form a ring. Insert->nextslot points to the next free
+  * slot, and Insert->lastslot points to the last slot that's still in use.
+  * lastslot can lag behind reality by any number of slots, as long as nextslot
+  * doesn't catch up with it. lastslot is advanced by
+  * WaitXLogInsertionsToFinish(), and is protected by WALInsertTailLock.
+  * nextslot is advanced in ReserveXLogInsertLocation() and is protected by
+  * insertpos_lck. Both slot variables are 32-bit integers, so that they can
+  * be read atomically without holding a lock.
+  *
+  * Whenever the ring fills up, ie. when nextslot wraps around and catches up
+  * with lastslot, ReserveXLogInsertLocation() has to wait for the oldest
+  * insertion to finish and advance lastslot, to make room for the new
+  * insertion. This is done by WaitForXLogInsertionSlotToBecomeFree() function,
+  * which is similar to WaitXLogInsertionsToFinish(), but instead of waiting
+  * for all insertions up to a given point to finish, it just waits for the
+  * inserter in the oldest slot to finish.
+  *
+  *
+  * Deadlock analysis
+  * -----------------
+  *
+  * It's important to call WaitXLogInsertionsToFinish() *before* acquiring
+  * WALWriteLock. Otherwise you might get stuck waiting for an insertion to
+  * finish (or at least advance to next uninitialized page), while you're
+  * holding WALWriteLock. That would be bad, because the backend you're waiting
+  * for might need to acquire WALWriteLock, too, to evict an old buffer, so
+  * you'd get deadlock.
+  *
+  * WaitXLogInsertionsToFinish() will not get stuck indefinitely, as long as
+  * it's called with a location that's known to be already allocated in the WAL
+  * buffers. Calling it with the position of a record you've already inserted
+  * satisfies that condition, so the common pattern:
+  *
+  *   recptr = XLogInsert(...)
+  *   XLogFlush(recptr)
+  *
+  * is safe. It can't get stuck, because an insertion to a WAL page that's
+  * already initialized in cache can always proceed without waiting on a lock.
+  *
   *----------
   */
  
***************
*** 354,364 **** typedef struct XLogwrtResult
   */
  typedef struct XLogCtlInsert
  {
! 	XLogwrtResult LogwrtResult; /* a recent value of LogwrtResult */
! 	XLogRecPtr	PrevRecord;		/* start of previously-inserted record */
! 	int			curridx;		/* current block index in cache */
! 	XLogPageHeader currpage;	/* points to header of block in cache */
! 	char	   *currpos;		/* current insertion point in cache */
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
--- 414,443 ----
   */
  typedef struct XLogCtlInsert
  {
! 	slock_t		insertpos_lck;	/* protects all the fields in this struct
! 								 * (except lastslot). */
! 
! 	int32		nextslot;		/* next insertion slot to use */
! 	int32		lastslot;		/* last in-use insertion slot (protected by
! 								 * WALInsertTailLock) */
! 
! 	/*
! 	 * CurrPos is the very tip of the reserved WAL space at the moment. The
! 	 * next record will be inserted there (or somewhere after it if there's
! 	 * not enough space on the current page). PrevRecord points to the
! 	 * beginning of the last record already reserved. It might not be fully
! 	 * copied into place yet, but we know its exact location already.
! 	 */
! 	XLogRecPtr	CurrPos;
! 	XLogRecPtr	PrevRecord;
! 
! 	/*
! 	 * padding to push RedoRecPtr and forcePageWrites, which rarely change,
! 	 * to a different cache line than the rapidly-changing CurrPos and
! 	 * PrevRecord values. XXX: verify if this makes any difference
! 	 */
! 	char		padding[128];
! 
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
***************
*** 388,406 **** typedef struct XLogCtlInsert
   */
  typedef struct XLogCtlWrite
  {
- 	XLogwrtResult LogwrtResult; /* current value of LogwrtResult */
  	int			curridx;		/* cache index of next block to write */
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by WALInsertLock: */
  	XLogCtlInsert Insert;
  
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
--- 467,500 ----
   */
  typedef struct XLogCtlWrite
  {
  	int			curridx;		/* cache index of next block to write */
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
+ 
+ /*
+  * Slots for in-progress WAL insertions.
+  */
+ typedef struct
+ {
+ 	slock_t		lck;
+ 	XLogRecPtr	CurrPos;	/* current position this process is inserting to */
+ 	PGPROC	   *head;		/* head of list of waiting PGPROCs */
+ 	PGPROC	   *tail;		/* tail of list of waiting PGPROCs */
+ } XLogInsertSlot;
+ 
+ #define NumXLogInsertSlots	1000
+ 
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by insertpos_lck: */
  	XLogCtlInsert Insert;
  
+ 	XLogInsertSlot *XLogInsertSlots;
+ 
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
***************
*** 414,422 **** typedef struct XLogCtlData
  	XLogCtlWrite Write;
  
  	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALInsertLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
--- 508,526 ----
  	XLogCtlWrite Write;
  
  	/*
+ 	 * To change curridx and the identity of a buffer, you need to hold
+ 	 * WALBufMappingLock. To change the identity of a buffer that's
+ 	 * still dirty, the old page needs to be written out first, and for that
+ 	 * you need WALWriteLock, and you need to ensure that there's no
+ 	 * in-progress insertions to the page by calling
+ 	 * WaitXLogInsertionsToFinish().
+ 	 */
+ 	int			curridx;		/* current (latest) block index in cache */
+ 
+ 	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALBufMappingLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
***************
*** 494,521 **** static XLogCtlData *XLogCtl = NULL;
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Macros for managing XLogInsert state.  In most cases, the calling routine
!  * has local copies of XLogCtl->Insert and/or XLogCtl->Insert->curridx,
!  * so these are passed as parameters instead of being fetched via XLogCtl.
   */
  
- /* Free space remaining in the current xlog page buffer */
- #define INSERT_FREESPACE(Insert)  \
- 	(XLOG_BLCKSZ - ((Insert)->currpos - (char *) (Insert)->currpage))
  
! /* Construct XLogRecPtr value for current insertion point */
! #define INSERT_RECPTR(recptr,Insert,curridx)  \
! 	( \
! 	  (recptr).xlogid = XLogCtl->xlblocks[curridx].xlogid, \
! 	  (recptr).xrecoff = \
! 		XLogCtl->xlblocks[curridx].xrecoff - INSERT_FREESPACE(Insert) \
! 	)
  
! #define PrevBufIdx(idx)		\
! 		(((idx) == 0) ? XLogCtl->XLogCacheBlck : ((idx) - 1))
  
! #define NextBufIdx(idx)		\
! 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
--- 598,628 ----
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Calculate the amount of space left on the page after 'endptr'.
!  * Beware multiple evaluation!
   */
+ #define INSERT_FREESPACE(endptr)	\
+ 	(((endptr).xrecoff % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr).xrecoff % XLOG_BLCKSZ))
+ 
+ #define NextBufIdx(idx)		\
+ 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  
! #define NextSlotNo(idx)		\
! 		(((idx) == NumXLogInsertSlots - 1) ? 0 : ((idx) + 1))
  
! /*
!  * XLogRecPtrToBufIdx returns the index of the WAL buffer that holds, or
!  * would hold if it was in cache, the page containing 'recptr'.
!  *
!  * XLogRecEndPtrToBufIdx is the same, but a pointer to the first byte of a
!  * page is taken to mean the previous page.
!  */
! #define XLogRecPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogSegsPerFile * XLogSegSize) + (recptr).xrecoff)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
  
! #define XLogRecEndPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogSegsPerFile * XLogSegSize) + (recptr).xrecoff - 1)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
***************
*** 641,649 **** static void KeepLogSeg(XLogRecPtr recptr, uint32 *logId, uint32 *logSeg);
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static bool AdvanceXLInsertBuffer(bool new_segment);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
--- 748,756 ----
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static void AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
***************
*** 690,695 **** static bool read_backup_label(XLogRecPtr *checkPointLoc,
--- 797,820 ----
  static void rm_redo_error_callback(void *arg);
  static int	get_sync_bit(int method);
  
+ static void CopyXLogRecordToWAL(int write_len, bool isLogSwitch,
+ 				  XLogRecord *rechdr,
+ 				  XLogRecData *rdata, pg_crc32 rdata_crc,
+ 				  XLogInsertSlot *myslot,
+ 				  XLogRecPtr StartPos, XLogRecPtr EndPos);
+ static bool ReserveXLogInsertLocation(int size, bool forcePageWrites,
+ 						  bool isLogSwitch,
+ 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
+ 						  XLogRecPtr *EndPos_p,
+ 						  XLogInsertSlot **myslot_p, bool *updrqst_p);
+ static void UpdateSlotCurrPos(volatile XLogInsertSlot *myslot,
+ 				  XLogRecPtr CurrPos);
+ static XLogRecPtr WaitXLogInsertionsToFinish(XLogRecPtr upto,
+ 						   XLogRecPtr CurrPos);
+ static void WaitForXLogInsertionSlotToBecomeFree(void);
+ static char *GetXLogBuffer(XLogRecPtr ptr);
+ static XLogRecPtr AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr);
+ 
  
  /*
   * Insert an XLOG record having the specified RMID and info bytes,
***************
*** 710,721 **** XLogRecPtr
  XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
- 	XLogRecord *record;
- 	XLogContRecord *contrecord;
- 	XLogRecPtr	RecPtr;
- 	XLogRecPtr	WriteRqst;
- 	uint32		freespace;
- 	int			curridx;
  	XLogRecData *rdt;
  	XLogRecData *rdt_lastnormal;
  	Buffer		dtbuf[XLR_MAX_BKP_BLOCKS];
--- 835,840 ----
***************
*** 729,739 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  	uint32		len,
  				write_len;
  	unsigned	i;
- 	bool		updrqst;
  	bool		doPageWrites;
! 	bool		isLogSwitch = false;
! 	bool		fpwChange = false;
  	uint8		info_orig = info;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
--- 848,862 ----
  	uint32		len,
  				write_len;
  	unsigned	i;
  	bool		doPageWrites;
! 	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
  	uint8		info_orig = info;
+ 	XLogRecord	rechdr;
+ 	XLogRecPtr	PrevRecord;
+ 	XLogRecPtr	StartPos;
+ 	XLogRecPtr	EndPos;
+ 	XLogInsertSlot *myslot;
+ 	bool		updrqst;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
***************
*** 746,778 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  	TRACE_POSTGRESQL_XLOG_INSERT(rmid, info);
  
  	/*
! 	 * Handle special cases/records.
  	 */
! 	if (rmid == RM_XLOG_ID)
! 	{
! 		switch (info)
! 		{
! 			case XLOG_SWITCH:
! 				isLogSwitch = true;
! 				break;
! 
! 			case XLOG_FPW_CHANGE:
! 				fpwChange = true;
! 				break;
! 
! 			default:
! 				break;
! 		}
! 	}
! 	else if (IsBootstrapProcessingMode())
  	{
! 		/*
! 		 * In bootstrap mode, we don't actually log anything but XLOG resources;
! 		 * return a phony record pointer.
! 		 */
! 		RecPtr.xlogid = 0;
! 		RecPtr.xrecoff = SizeOfXLogLongPHD;		/* start of 1st chkpt record */
! 		return RecPtr;
  	}
  
  	/*
--- 869,882 ----
  	TRACE_POSTGRESQL_XLOG_INSERT(rmid, info);
  
  	/*
! 	 * In bootstrap mode, we don't actually log anything but XLOG resources;
! 	 * return a phony record pointer.
  	 */
! 	if (IsBootstrapProcessingMode() && rmid != RM_XLOG_ID)
  	{
! 		EndPos.xlogid = 0;
! 		EndPos.xrecoff = SizeOfXLogLongPHD;		/* start of 1st chkpt record */
! 		return EndPos;
  	}
  
  	/*
***************
*** 939,1071 **** begin:;
  	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
  		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
! 	START_CRIT_SECTION();
  
! 	/* Now wait to get insert lock */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  
  	/*
! 	 * Check to see if my RedoRecPtr is out of date.  If so, may have to go
! 	 * back and recompute everything.  This can only happen just after a
! 	 * checkpoint, so it's better to be slow in this case and fast otherwise.
! 	 *
! 	 * If we aren't doing full-page writes then RedoRecPtr doesn't actually
! 	 * affect the contents of the XLOG record, so we'll update our local copy
! 	 * but not force a recomputation.
  	 */
! 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr))
  	{
! 		Assert(XLByteLT(RedoRecPtr, Insert->RedoRecPtr));
! 		RedoRecPtr = Insert->RedoRecPtr;
  
! 		if (doPageWrites)
  		{
! 			for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
! 			{
! 				if (dtbuf[i] == InvalidBuffer)
! 					continue;
! 				if (dtbuf_bkp[i] == false &&
! 					XLByteLE(dtbuf_lsn[i], RedoRecPtr))
! 				{
! 					/*
! 					 * Oops, this buffer now needs to be backed up, but we
! 					 * didn't think so above.  Start over.
! 					 */
! 					LWLockRelease(WALInsertLock);
! 					END_CRIT_SECTION();
! 					rdt_lastnormal->next = NULL;
! 					info = info_orig;
! 					goto begin;
! 				}
! 			}
  		}
- 	}
  
! 	/*
! 	 * Also check to see if fullPageWrites or forcePageWrites was just turned on;
! 	 * if we weren't already doing full-page writes then go back and recompute.
! 	 * (If it was just turned off, we could recompute the record without full pages,
! 	 * but we choose not to bother.)
! 	 */
! 	if ((Insert->fullPageWrites || Insert->forcePageWrites) && !doPageWrites)
! 	{
! 		/* Oops, must redo it with full-page data. */
! 		LWLockRelease(WALInsertLock);
! 		END_CRIT_SECTION();
  		rdt_lastnormal->next = NULL;
  		info = info_orig;
  		goto begin;
  	}
! 
! 	/*
! 	 * If there isn't enough space on the current XLOG page for a record
! 	 * header, advance to the next page (leaving the unused space as zeroes).
! 	 */
! 	updrqst = false;
! 	freespace = INSERT_FREESPACE(Insert);
! 	if (freespace < SizeOfXLogRecord)
  	{
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		freespace = INSERT_FREESPACE(Insert);
  	}
  
! 	/* Compute record's XLOG location */
! 	curridx = Insert->curridx;
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
! 	 * segment, we need not insert it (and don't want to because we'd like
! 	 * consecutive switch requests to be no-ops).  Instead, make sure
! 	 * everything is written and flushed through the end of the prior segment,
! 	 * and return the prior segment's end address.
  	 */
! 	if (isLogSwitch &&
! 		(RecPtr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
  	{
! 		/* We can release insert lock immediately */
! 		LWLockRelease(WALInsertLock);
! 
! 		RecPtr.xrecoff -= SizeOfXLogLongPHD;
! 		if (RecPtr.xrecoff == 0)
! 		{
! 			/* crossing a logid boundary */
! 			RecPtr.xlogid -= 1;
! 			RecPtr.xrecoff = XLogFileSize;
! 		}
! 
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 		LogwrtResult = XLogCtl->Write.LogwrtResult;
! 		if (!XLByteLE(RecPtr, LogwrtResult.Flush))
! 		{
! 			XLogwrtRqst FlushRqst;
! 
! 			FlushRqst.Write = RecPtr;
! 			FlushRqst.Flush = RecPtr;
! 			XLogWrite(FlushRqst, false, false);
! 		}
! 		LWLockRelease(WALWriteLock);
! 
! 		END_CRIT_SECTION();
  
! 		return RecPtr;
  	}
  
! 	/* Insert record header */
  
! 	record = (XLogRecord *) Insert->currpos;
! 	record->xl_prev = Insert->PrevRecord;
! 	record->xl_xid = GetCurrentTransactionIdIfAny();
! 	record->xl_tot_len = SizeOfXLogRecord + write_len;
! 	record->xl_len = len;		/* doesn't include backup blocks */
! 	record->xl_info = info;
! 	record->xl_rmid = rmid;
  
! 	/* Now we can finish computing the record's CRC */
! 	COMP_CRC32(rdata_crc, (char *) record + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	record->xl_crc = rdata_crc;
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
--- 1043,1148 ----
  	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
  		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
! 	/*
! 	 * Construct record header. We can't CRC it yet, because the prev-link
! 	 * needs to be covered by the CRC and we don't know that yet. We will
! 	 * finish computing the CRC when we do.
! 	 */
! 	MemSet(&rechdr, 0, sizeof(rechdr));
! 	/* rechdr.xl_prev is set later */
! 	rechdr.xl_xid = GetCurrentTransactionIdIfAny();
! 	rechdr.xl_tot_len = SizeOfXLogRecord + write_len;
! 	rechdr.xl_len = len;		/* doesn't include backup blocks */
! 	rechdr.xl_info = info;
! 	rechdr.xl_rmid = rmid;
  
! 	START_CRIT_SECTION();
  
  	/*
! 	 * Try to reserve space for the record from the WAL.
  	 */
! 	if (!ReserveXLogInsertLocation(write_len, doPageWrites, isLogSwitch,
! 								   &PrevRecord, &StartPos, &EndPos,
! 								   (XLogInsertSlot **) &myslot, &updrqst))
  	{
! 		END_CRIT_SECTION();
  
! 		/*
! 		 * If the record is an XLOG_SWITCH, and we were exactly at the start
! 		 * of a segment, we need not insert it (and don't want to because we'd
! 		 * like consecutive switch requests to be no-ops).  Instead, make sure
! 		 * everything is written and flushed through the end of the prior
! 		 * segment, and return the prior segment's end address.
! 		 */
! 		if (isLogSwitch && !XLogRecPtrIsInvalid(EndPos))
  		{
! 			XLogFlush(EndPos);
! 			return EndPos;
  		}
  
! 		/*
! 		 * Oops, must redo it with full-page data. Unlink the backup blocks
! 		 * from the chain and reset info bitmask to undo the changes we've
! 		 * done.
! 		 */
  		rdt_lastnormal->next = NULL;
  		info = info_orig;
  		goto begin;
  	}
! 	else
  	{
! 		/*
! 		 * Finish the record header by setting prev-link (now that we know it),
! 		 * and finish computing the record's CRC (in CopyXLogRecordToWAL). Then
! 		 * copy the record to the space we reserved.
! 		 */
! 		rechdr.xl_prev = PrevRecord;
! 		CopyXLogRecordToWAL(write_len, isLogSwitch, &rechdr,
! 							rdata, rdata_crc, myslot, StartPos, EndPos);
  	}
  
! 	END_CRIT_SECTION();
  
  	/*
! 	 * Update shared LogwrtRqst.Write, if we crossed page boundary.
  	 */
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
  
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, EndPos))
! 			xlogctl->LogwrtRqst.Write = EndPos;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
  	}
  
! 	/*
! 	 * If this was an XLOG_SWITCH record, flush the record and the empty
! 	 * padding space that fills the rest of the segment, and perform
! 	 * end-of-segment actions (eg, notifying archiver).
! 	 */
! 	if (isLogSwitch)
! 	{
! 		XLogFlush(EndPos);
  
! 		/*
! 		 * Even though we reserved the rest of the segment for us, which is
! 		 * reflected in EndPos, we return a pointer to just the end of the
! 		 * xlog-switch record.
! 		 */
! 		EndPos.xlogid = StartPos.xlogid;
! 		EndPos.xrecoff = StartPos.xrecoff + SizeOfXLogRecord;
! 	}
  
! 	/*
! 	 * Update our global variables
! 	 */
! 	ProcLastRecPtr = StartPos;
! 	XactLastRecEnd = EndPos;
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
***************
*** 1074,1267 **** begin:;
  
  		initStringInfo(&buf);
  		appendStringInfo(&buf, "INSERT @ %X/%X: ",
! 						 RecPtr.xlogid, RecPtr.xrecoff);
! 		xlog_outrec(&buf, record);
  		if (rdata->data != NULL)
  		{
  			appendStringInfo(&buf, " - ");
! 			RmgrTable[record->xl_rmid].rm_desc(&buf, record->xl_info, rdata->data);
  		}
  		elog(LOG, "%s", buf.data);
  		pfree(buf.data);
  	}
  #endif
  
- 	/* Record begin of record in appropriate places */
- 	ProcLastRecPtr = RecPtr;
- 	Insert->PrevRecord = RecPtr;
- 
- 	Insert->currpos += SizeOfXLogRecord;
- 	freespace -= SizeOfXLogRecord;
- 
  	/*
! 	 * Append the data, including backup blocks if any
  	 */
! 	while (write_len)
! 	{
! 		while (rdata->data == NULL)
! 			rdata = rdata->next;
  
! 		if (freespace > 0)
  		{
! 			if (rdata->len > freespace)
  			{
! 				memcpy(Insert->currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				write_len -= freespace;
! 			}
! 			else
! 			{
! 				memcpy(Insert->currpos, rdata->data, rdata->len);
! 				freespace -= rdata->len;
! 				write_len -= rdata->len;
! 				Insert->currpos += rdata->len;
! 				rdata = rdata->next;
! 				continue;
  			}
  		}
  
! 		/* Use next buffer */
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		curridx = Insert->curridx;
! 		/* Insert cont-record header */
! 		Insert->currpage->xlp_info |= XLP_FIRST_IS_CONTRECORD;
! 		contrecord = (XLogContRecord *) Insert->currpos;
! 		contrecord->xl_rem_len = write_len;
! 		Insert->currpos += SizeOfXLogContRecord;
! 		freespace = INSERT_FREESPACE(Insert);
  	}
  
! 	/* Ensure next record will be properly aligned */
! 	Insert->currpos = (char *) Insert->currpage +
! 		MAXALIGN(Insert->currpos - (char *) Insert->currpage);
! 	freespace = INSERT_FREESPACE(Insert);
  
  	/*
! 	 * The recptr I return is the beginning of the *next* record. This will be
! 	 * stored as LSN for changed data pages...
  	 */
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, we must now write and flush all the
! 	 * existing data, and then forcibly advance to the start of the next
! 	 * segment.  It's not good to do this I/O while holding the insert lock,
! 	 * but there seems too much risk of confusion if we try to release the
! 	 * lock sooner.  Fortunately xlog switch needn't be a high-performance
! 	 * operation anyway...
  	 */
! 	if (isLogSwitch)
  	{
! 		XLogCtlWrite *Write = &XLogCtl->Write;
! 		XLogwrtRqst FlushRqst;
! 		XLogRecPtr	OldSegEnd;
  
! 		TRACE_POSTGRESQL_XLOG_SWITCH();
  
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  
  		/*
! 		 * Flush through the end of the page containing XLOG_SWITCH, and
! 		 * perform end-of-segment actions (eg, notifying archiver).
  		 */
! 		WriteRqst = XLogCtl->xlblocks[curridx];
! 		FlushRqst.Write = WriteRqst;
! 		FlushRqst.Flush = WriteRqst;
! 		XLogWrite(FlushRqst, false, true);
! 
! 		/* Set up the next buffer as first page of next segment */
! 		/* Note: AdvanceXLInsertBuffer cannot need to do I/O here */
! 		(void) AdvanceXLInsertBuffer(true);
! 
! 		/* There should be no unwritten data */
! 		curridx = Insert->curridx;
! 		Assert(curridx == Write->curridx);
! 
! 		/* Compute end address of old segment */
! 		OldSegEnd = XLogCtl->xlblocks[curridx];
! 		OldSegEnd.xrecoff -= XLOG_BLCKSZ;
! 		if (OldSegEnd.xrecoff == 0)
  		{
! 			/* crossing a logid boundary */
! 			OldSegEnd.xlogid -= 1;
! 			OldSegEnd.xrecoff = XLogFileSize;
! 		}
  
! 		/* Make it look like we've written and synced all of old segment */
! 		LogwrtResult.Write = OldSegEnd;
! 		LogwrtResult.Flush = OldSegEnd;
  
! 		/*
! 		 * Update shared-memory status --- this code should match XLogWrite
! 		 */
  		{
! 			/* use volatile pointer to prevent code rearrangement */
! 			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			SpinLockAcquire(&xlogctl->info_lck);
! 			xlogctl->LogwrtResult = LogwrtResult;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, LogwrtResult.Write))
! 				xlogctl->LogwrtRqst.Write = LogwrtResult.Write;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Flush, LogwrtResult.Flush))
! 				xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
! 			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		Write->LogwrtResult = LogwrtResult;
  
! 		LWLockRelease(WALWriteLock);
  
! 		updrqst = false;		/* done already */
  	}
  	else
  	{
! 		/* normal case, ie not xlog switch */
  
! 		/* Need to update shared LogwrtRqst if some block was filled up */
! 		if (freespace < SizeOfXLogRecord)
  		{
! 			/* curridx is filled and available for writing out */
! 			updrqst = true;
  		}
  		else
  		{
! 			/* if updrqst already set, write through end of previous buf */
! 			curridx = PrevBufIdx(curridx);
  		}
- 		WriteRqst = XLogCtl->xlblocks[curridx];
  	}
  
  	/*
! 	 * If the record is an XLOG_FPW_CHANGE, we update full_page_writes
! 	 * in shared memory before releasing WALInsertLock. This ensures that
! 	 * an XLOG_FPW_CHANGE record precedes any WAL record affected
! 	 * by this change of full_page_writes.
  	 */
! 	if (fpwChange)
! 		Insert->fullPageWrites = fullPageWrites;
  
! 	LWLockRelease(WALInsertLock);
! 
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
  
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, WriteRqst))
! 			xlogctl->LogwrtRqst.Write = WriteRqst;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
  	}
  
! 	XactLastRecEnd = RecPtr;
  
! 	END_CRIT_SECTION();
  
! 	return RecPtr;
  }
  
  /*
--- 1151,1815 ----
  
  		initStringInfo(&buf);
  		appendStringInfo(&buf, "INSERT @ %X/%X: ",
! 						 EndPos.xlogid, EndPos.xrecoff);
! 		xlog_outrec(&buf, &rechdr);
  		if (rdata->data != NULL)
  		{
  			appendStringInfo(&buf, " - ");
! 			RmgrTable[rmid].rm_desc(&buf, rechdr.xl_info, rdata->data);
  		}
  		elog(LOG, "%s", buf.data);
  		pfree(buf.data);
  	}
  #endif
  
  	/*
! 	 * The recptr I return is the beginning of the *next* record. This will be
! 	 * stored as LSN for changed data pages...
  	 */
! 	return EndPos;
! }
  
! /*
!  * Subroutine of XLogInsert. Copies a WAL record to an already-reserved area
!  * in the WAL.
!  */
! static void
! CopyXLogRecordToWAL(int write_len, bool isLogSwitch, XLogRecord *rechdr,
! 					XLogRecData *rdata, pg_crc32 rdata_crc,
! 					XLogInsertSlot *myslot_p,
! 					XLogRecPtr StartPos, XLogRecPtr EndPos)
! {
! 	volatile XLogInsertSlot *myslot = myslot_p;
! 	char	   *currpos;
! 	XLogRecord *record;
! 	int			freespace;
! 	int			written;
! 	XLogRecPtr	CurrPos;
! 
! 	/* Get the right WAL page to start inserting to */
! 	CurrPos = StartPos;
! 	currpos = GetXLogBuffer(CurrPos);
! 
! 	/* Copy the record header in place, and finish calculating CRC */
! 	record = (XLogRecord *) currpos;
! 	memcpy(record, rechdr, sizeof(XLogRecord));
! 	COMP_CRC32(rdata_crc, currpos + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	record->xl_crc = rdata_crc;
! 
! 	currpos += SizeOfXLogRecord;
! 	CurrPos.xrecoff += SizeOfXLogRecord;
! 
! 	if (!isLogSwitch)
! 	{
! 		/* Copy record data */
! 		written = 0;
! 		freespace = INSERT_FREESPACE(CurrPos);
! 		while (rdata != NULL)
  		{
! 			while (rdata->len > freespace)
  			{
! 				/*
! 				 * Write what fits on this page, then write the continuation
! 				 * record, and continue.
! 				 */
! 				XLogContRecord *contrecord;
! 
! 				memcpy(currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				written += freespace;
! 				CurrPos.xrecoff += freespace;
! 
! 				/*
! 				 * CurrPos now points to the page boundary, ie. the first byte
! 				 * of the next page. Advertise that as our CurrPos before
! 				 * calling GetXLogBuffer(), because GetXLogBuffer() might need
! 				 * to wait for some insertions to finish so that it can write
! 				 * out a buffer to make room for the new page. Updating CurrPos
! 				 * before waiting for a new buffer ensures that we don't
! 				 * deadlock with ourselves if we run out of clean buffers.
! 				 *
! 				 * However, we must not advance CurrPos past the page header
! 				 * yet, otherwise someone might try to flush up to that point,
! 				 * which would fail if the next page was not initialized yet.
! 				 */
! 				UpdateSlotCurrPos(myslot, CurrPos);
! 
! 				/*
! 				 * Get pointer to beginning of next page, and set the
! 				 * XLP_FIRST_IS_CONTRECORD flag in the page header.
! 				 *
! 				 * It's safe to set the contrecord flag without a lock on the
! 				 * page. All the other flags are set in AdvanceXLInsertBuffer,
! 				 * and we're the only backend that needs to set the contrecord
! 				 * flag.
! 				 */
! 				currpos = GetXLogBuffer(CurrPos);
! 				((XLogPageHeader) currpos)->xlp_info |= XLP_FIRST_IS_CONTRECORD;
! 
! 				/* skip over the page header, and write continuation record */
! 				CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
! 				currpos = GetXLogBuffer(CurrPos);
! 
! 				contrecord = (XLogContRecord *) currpos;
! 				contrecord->xl_rem_len = write_len - written;
! 
! 				currpos += SizeOfXLogContRecord;
! 				CurrPos.xrecoff += SizeOfXLogContRecord;
! 
! 				freespace = INSERT_FREESPACE(CurrPos);
  			}
+ 
+ 			memcpy(currpos, rdata->data, rdata->len);
+ 			currpos += rdata->len;
+ 			CurrPos.xrecoff += rdata->len;
+ 			freespace -= rdata->len;
+ 			written += rdata->len;
+ 
+ 			rdata = rdata->next;
  		}
+ 		Assert(written == write_len);
  
! 		CurrPos.xrecoff = MAXALIGN(CurrPos.xrecoff);
! 		Assert(XLByteEQ(CurrPos, EndPos));
  	}
+ 	else
+ 	{
+ 		/* An xlog-switch record doesn't contain any data besides the header */
+ 		Assert(write_len == 0);
  
! 		/*
! 		 * An xlog-switch record consumes all the remaining space on the
! 		 * WAL segment. We have already reserved it for us, but we still need
! 		 * to make sure it's been allocated and zeroed in the WAL buffers so
! 		 * that when the caller (or someone else) does XLogWrite(), it can
! 		 * really write out all the zeros.
! 		 *
! 		 * We do this one page at a time, to make sure we don't deadlock
! 		 * against ourselves if wal_buffers < XLOG_SEG_SIZE.
! 		 */
! 		while (XLByteLT(CurrPos, EndPos))
! 		{
! 			/* use up all the remaining space in this page */
! 			freespace = INSERT_FREESPACE(CurrPos);
! 			XLByteAdvance(CurrPos, freespace);
! 			/*
! 			 * like in the non-xlog-switch codepath, let others know that
! 			 * we're done writing up to the end of this page
! 			 */
! 			UpdateSlotCurrPos(myslot, CurrPos);
! 			/*
! 			 * let GetXLogBuffer initialize next page if necessary.
! 			 */
! 			CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
! 			(void) GetXLogBuffer(CurrPos);
! 		}
! 	}
  
  	/*
! 	 * Done! Clear CurrPos in our slot to let others know that we're
! 	 * finished.
  	 */
! 	UpdateSlotCurrPos(myslot, InvalidXLogRecPtr);
! }
! 
! /*
!  * Reserves the right amount of space for a record of given size from the WAL.
!  * *StartPos_p is set to the beginning of the reserved section, *EndPos_p to
!  * its end, and *Prev_record_p points to the beginning of the previous record
!  * to set to the prev-link of the record header.
!  *
!  * A log-switch record is handled slightly differently. The rest of the
!  * segment will be reserved for this insertion, as indicated by the returned
!  * *EndPos_p value. However, if we are already at the beginning of the current
!  * segment, the *EndPos_p is set to the current location without reserving
!  * any space, and the function returns false.
!  *
!  * *updrqst_p is set to true, if this record ends on different page than
!  * the previous one - the caller should update the shared LogwrtRqst value
!  * after it's done inserting the record in that case, so that the WAL page
!  * that filled up gets written out at the next convenient moment.
!  *
!  * While holding insertpos_lck, sets myslot->CurrPos to the starting position,
!  * (or the end of previous record, to be exact) to let others know that we're
!  * busy inserting to the reserved area. The caller must clear it when the
!  * insertion is finished.
!  *
!  * Returns true on success, or false if RedoRecPtr or forcePageWrites was
!  * changed. On failure, the shared state is not modified.
!  *
!  * This is the performance critical part of XLogInsert that must be
!  * serialized across backends. The rest can happen mostly in parallel.
!  *
!  * NB: The space calculation here must match the code in PerformXLogInsert,
!  * where we actually copy the record to the reserved space.
!  */
! static bool
! ReserveXLogInsertLocation(int size, bool didPageWrites,
! 						  bool isLogSwitch,
! 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
! 						  XLogRecPtr *EndPos_p,
! 						  XLogInsertSlot **myslot_p, bool *updrqst_p)
! {
! 	volatile XLogInsertSlot *myslot;
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			freespace;
! 	XLogRecPtr	ptr;
! 	XLogRecPtr	StartPos;
! 	XLogRecPtr	LastEndPos;
! 	int32		nextslot;
! 	int32		lastslot;
! 	bool		updrqst = false;
! 
! 	size = SizeOfXLogRecord + size;
! 
! retry:
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 
! 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr) ||
! 		(!didPageWrites && (Insert->forcePageWrites || Insert->fullPageWrites)))
! 	{
! 		/*
! 		 * Oops, a checkpoint just happened, or forcePageWrites was just
! 		 * turned on. Start XLogInsert() all over, because we might have to
! 		 * include more full-page images in the record.
! 		 */
! 		RedoRecPtr = Insert->RedoRecPtr;
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		*EndPos_p = InvalidXLogRecPtr;
! 		return false;
! 	}
  
  	/*
! 	 * Reserve the next insertion slot for us.
! 	 *
! 	 * First check that the slot is not still in use. Modifications to
! 	 * lastslot are protected by WALInsertTailLock, but here we assume that
! 	 * reading an int32 is atomic. Another process might advance lastslot at
! 	 * the same time, but not past nextslot.
  	 */
! 	lastslot = Insert->lastslot;
! 	nextslot = Insert->nextslot;
! 	if (NextSlotNo(nextslot) == lastslot)
  	{
! 		/*
! 		 * Oops, we've "caught our tail" and the oldest slot is still in use.
! 		 * Have to wait for it to become vacant.
! 		 */
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		WaitForXLogInsertionSlotToBecomeFree();
! 		goto retry;
! 	}
! 	myslot = &XLogCtl->XLogInsertSlots[nextslot];
! 	nextslot = NextSlotNo(nextslot);
  
! 	/*
! 	 * Got the slot, now reserve the right amount of space from the WAL for
! 	 * our record.
! 	 */
! 	LastEndPos = ptr = Insert->CurrPos;
! 	*PrevRecord_p = Insert->PrevRecord;
! 
! 	/*
! 	 * If there isn't enough space on the current XLOG page for a record
! 	 * header, advance to the next page (leaving the unused space as zeroes).
! 	 */
! 	freespace = INSERT_FREESPACE(ptr);
! 	if (freespace < SizeOfXLogRecord)
! 	{
! 		ptr = AdvanceXLogRecPtrToNextPage(ptr);
! 		freespace = INSERT_FREESPACE(ptr);
! 		updrqst = true;
! 	}
  
! 	/*
! 	 * We are now at the starting position of our record. Now figure out how
! 	 * the data will be split across the WAL pages, to calculate where the
! 	 * record ends.
! 	 */
! 	StartPos = ptr;
  
+ 	if (isLogSwitch)
+ 	{
  		/*
! 		 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
! 		 * segment, we need not insert it (and don't want to because we'd like
! 		 * consecutive switch requests to be no-ops). Otherwise the XLOG_SWITCH
! 		 * record should consume all the remaining space on the current segment.
  		 */
! 		Assert(size == SizeOfXLogRecord);
! 		if ((ptr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
  		{
! 			/* We can release insert lock immediately */
! 			SpinLockRelease(&Insert->insertpos_lck);
  
! 			ptr.xrecoff -= SizeOfXLogLongPHD;
! 			if (ptr.xrecoff == 0)
! 			{
! 				/* crossing a logid boundary */
! 				ptr.xlogid -= 1;
! 				ptr.xrecoff = XLogFileSize;
! 			}
  
! 			*EndPos_p = ptr;
! 			*StartPos_p = ptr;
! 			*myslot_p = NULL;
! 
! 			return false;
! 		}
! 		else
  		{
! 			if (ptr.xrecoff % XLOG_SEG_SIZE != 0)
! 			{
! 				int segleft = XLOG_SEG_SIZE - (ptr.xrecoff % XLOG_SEG_SIZE);
! 				XLByteAdvance(ptr, segleft);
! 			}
! 			updrqst = true;
! 		}
! 	}
! 	else
! 	{
! 		/* A normal record, ie. not xlog-switch */
! 		int sizeleft = size;
! 		while (freespace < sizeleft)
! 		{
! 			/* fill this page, and continue on next page */
! 			sizeleft -= freespace;
! 			ptr = AdvanceXLogRecPtrToNextPage(ptr);
  
! 			/* account for continuation record header */
! 			ptr.xrecoff += SizeOfXLogContRecord;
! 			freespace = INSERT_FREESPACE(ptr);
! 
! 			updrqst = true;
  		}
+ 		/* the rest fits on this page */
+ 		ptr.xrecoff += sizeleft;
  
! 		/* Align the end position, so that the next record starts aligned */
! 		ptr.xrecoff = MAXALIGN(ptr.xrecoff);
! 	}
  
! 	/* Update the shared state, and our slot, before releasing the lock */
! 	myslot->CurrPos = LastEndPos;
! 	Insert->CurrPos = ptr;
! 	Insert->PrevRecord = StartPos;
! 	Insert->nextslot = nextslot;
! 
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! #ifdef RESERVE_XLOGINSERT_LOCATION_DEBUG
! 	elog(LOG, "reserved xlog: prev %X/%X, start %X/%X, end %X/%X (len %d)",
! 		 PrevRecord_p->xlogid, PrevRecord_p->xrecoff,
! 		 StartPos.xlogid, StartPos.xrecoff,
! 		 ptr.xlogid, ptr.xrecoff,
! 		 size);
! #endif
! 
! 	*EndPos_p = ptr;
! 	*StartPos_p = StartPos;
! 	*myslot_p = (XLogInsertSlot *) myslot;
! 	*updrqst_p = updrqst;
  
! 	return true;
! }
! 
! /*
!  * Update slot's CurrPos variable, and wake up anyone waiting on it.
!  */
! static void
! UpdateSlotCurrPos(volatile XLogInsertSlot *myslot, XLogRecPtr CurrPos)
! {
! 	PGPROC	   *head;
! 
! 	/*
! 	 * The write-barrier ensures that the changes we made to the WAL pages
! 	 * are visible to everyone before the update of CurrPos.
! 	 *
! 	 * XXX: I'm not sure if this is necessary. Does a function call act
! 	 * as an implicit barrier?
! 	 */
! 	pg_write_barrier();
! 
! 	SpinLockAcquire(&myslot->lck);
! 	myslot->CurrPos = CurrPos;
! 	head = myslot->head;
! 	myslot->head = myslot->tail = NULL;
! 	SpinLockRelease(&myslot->lck);
! 	while (head != NULL)
! 	{
! 		PGPROC *proc = head;
! 		head = proc->lwWaitLink;
! 		proc->lwWaitLink = NULL;
! 		proc->lwWaiting = false;
! 		PGSemaphoreUnlock(&proc->sem);
  	}
+ }
+ 
+ /*
+  * Get a pointer to the right location in the WAL buffer containing the
+  * given XLogRecPtr.
+  *
+  * If the page is not initialized yet, it is initialized. That might require
+  * evicting an old dirty buffer from the buffer cache, which means I/O.
+  *
+  * The caller must ensure that the page containing the requested location
+  * isn't evicted yet, and won't be evicted, by holding onto an
+  * XLogInsertSlot with CurrPos set to 'ptr'. Setting it to some value
+  * less than 'ptr' would suffice for GetXLogBuffer(), but risks deadlock:
+  * if we have to evict a buffer, we might have to wait for someone else to
+  * finish a write. And that someone else might not be able to finish the write
+  * if our CurrPos points to a buffer that's still in the buffer cache.
+  */
+ static char *
+ GetXLogBuffer(XLogRecPtr ptr)
+ {
+ 	int			idx;
+ 	XLogRecPtr	endptr;
+ 
+ 	/*
+ 	 * The XLog buffer cache is organized so that we can easily calculate the
+ 	 * buffer a given page must be loaded into from the XLogRecPtr alone.
+ 	 * A page must always be loaded to a particular buffer.
+ 	 */
+ 	idx = XLogRecPtrToBufIdx(ptr);
+ 
+ 	/*
+ 	 * See what page is loaded in the buffer at the moment. It could be the
+ 	 * page we're looking for, or something older. It can't be anything
+ 	 * newer - that would imply the page we're looking for has already
+ 	 * been written out to disk, which shouldn't happen as long as the caller
+ 	 * has set its slot's CurrPos correctly.
+ 	 *
+ 	 * However, we don't hold a lock while we read the value. If someone has
+ 	 * just initialized the page, it's possible that we get a "torn read",
+ 	 * and read a bogus value. That's ok, we'll grab the mapping lock (in
+ 	 * AdvanceXLInsertBuffer) and retry if we see anything else than the page
+ 	 * we're looking for. But it means that when we do this unlocked read, we
+ 	 * might see a value that appears to be ahead of the page we're looking
+ 	 * for. So don't PANIC on that, until we've verified the value while
+ 	 * holding the lock.
+ 	 */
+ 	endptr = XLogCtl->xlblocks[idx];
+ 	if (ptr.xlogid != endptr.xlogid ||
+ 		!(ptr.xrecoff < endptr.xrecoff &&
+ 		  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
+ 	{
+ 		AdvanceXLInsertBuffer(ptr, false);
+ 		endptr = XLogCtl->xlblocks[idx];
+ 
+ 		if (ptr.xlogid != endptr.xlogid ||
+ 			!(ptr.xrecoff < endptr.xrecoff &&
+ 			  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
+ 		{
+ 			elog(PANIC, "could not find WAL buffer for %X/%X",
+ 				 ptr.xlogid, ptr.xrecoff);
+ 		}
+ 	}
+ 
+ 	/*
+ 	 * Found the buffer holding this page. Return a pointer to the right
+ 	 * offset within the page.
+ 	 */
+ 	return (char *) XLogCtl->pages + idx * (Size) XLOG_BLCKSZ +
+ 		ptr.xrecoff % XLOG_BLCKSZ;
+ }
+ 
+ /*
+  * Advance an XLogRecPtr to the first valid insertion location on the next
+  * page, right after the page header. An XLogRecPtr pointing to a boundary,
+  * ie. the first byte of a page, is taken to belong to the previous page.
+  */
+ static XLogRecPtr
+ AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr)
+ {
+ 	int			freespace;
+ 
+ 	freespace = INSERT_FREESPACE(ptr);
+ 	XLByteAdvance(ptr, freespace);
+ 	if (ptr.xrecoff % XLogSegSize == 0)
+ 		ptr.xrecoff += SizeOfXLogLongPHD;
  	else
+ 		ptr.xrecoff += SizeOfXLogShortPHD;
+ 
+ 	return ptr;
+ }
+ 
+ /*
+  * Wait for any insertions < upto to finish.
+  *
+  * Returns a value >= upto, which indicates the oldest in-progress insertion
+  * that we saw in the array, or CurrPos if there are no insertions in-progress
+  * at exit.
+  */
+ static XLogRecPtr
+ WaitXLogInsertionsToFinish(XLogRecPtr upto, XLogRecPtr CurrPos)
+ {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 	int			lastslot;
+ 	int			nextslot;
+ 	volatile XLogInsertSlot *slot;
+ 	XLogRecPtr	slotptr = InvalidXLogRecPtr;
+ 	XLogRecPtr	LastPos;
+ 	int			extraWaits = 0;
+ 
+ 	if (MyProc == NULL)
+ 		elog(PANIC, "cannot wait without a PGPROC structure");
+ 
+ 	LastPos = CurrPos;
+ 
+ 	LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
+ 
+ 	lastslot = Insert->lastslot;
+ 	nextslot = Insert->nextslot;
+ 
+ 	/* Skip over slots that have finished already */
+ 	while (lastslot != nextslot)
  	{
! 		slot = &XLogCtl->XLogInsertSlots[lastslot];
! 		SpinLockAcquire(&slot->lck);
! 		slotptr = slot->CurrPos;
  
! 		if (XLogRecPtrIsInvalid(slotptr))
  		{
! 			lastslot = NextSlotNo(lastslot);
! 			SpinLockRelease(&slot->lck);
  		}
  		else
  		{
! 			/*
! 			 * This insertion is still in-progress. Wait for it to finish
! 			 * if it's <= upto, otherwise we're done.
! 			 */
! 			Insert->lastslot = lastslot;
! 
! 			if (XLogRecPtrIsInvalid(upto) || XLByteLE(upto, slotptr))
! 			{
! 				LastPos = slotptr;
! 				SpinLockRelease(&slot->lck);
! 				break;
! 			}
! 
! 			/* wait */
! 			MyProc->lwWaiting = true;
! 			MyProc->lwWaitMode = 0; /* doesn't matter */
! 			MyProc->lwWaitLink = NULL;
! 			if (slot->head == NULL)
! 				slot->head = MyProc;
! 			else
! 				slot->tail->lwWaitLink = MyProc;
! 			slot->tail = MyProc;
! 			SpinLockRelease(&slot->lck);
! 			LWLockRelease(WALInsertTailLock);
! 			for (;;)
! 			{
! 				PGSemaphoreLock(&MyProc->sem, false);
! 				if (!MyProc->lwWaiting)
! 					break;
! 				extraWaits++;
! 			}
! 			LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
! 			lastslot = Insert->lastslot;
! 			nextslot = Insert->nextslot;
  		}
  	}
  
+ 	Insert->lastslot = lastslot;
+ 	LWLockRelease(WALInsertTailLock);
+ 
+ 	while (extraWaits-- > 0)
+ 		PGSemaphoreUnlock(&MyProc->sem);
+ 
+ 	return LastPos;
+ }
+ 
+ /*
+  * Wait for the next insertion slot to become vacant.
+  */
+ static void
+ WaitForXLogInsertionSlotToBecomeFree(void)
+ {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 	int			lastslot;
+ 	int			nextslot;
+ 	int			extraWaits = 0;
+ 
+ 	if (MyProc == NULL)
+ 		elog(PANIC, "cannot wait without a PGPROC structure");
+ 
+ 	LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
+ 
  	/*
! 	 * Re-read lastslot and nextslot, now that we have the wait-lock.
! 	 * We're reading nextslot without holding insertpos_lck. It could advance
! 	 * at the same time, but it can't advance beyond lastslot - 1.
  	 */
! 	lastslot = Insert->lastslot;
! 	nextslot = Insert->nextslot;
  
! 	/*
! 	 * If there are still no slots available, wait for the oldest slot to
! 	 * become vacant.
! 	 */
! 	while (NextSlotNo(nextslot) == lastslot)
  	{
! 		volatile XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[lastslot];
  
! 		SpinLockAcquire(&slot->lck);
! 		if (XLogRecPtrIsInvalid(slot->CurrPos))
! 		{
! 			SpinLockRelease(&slot->lck);
! 			break;
! 		}
! 
! 		/* wait */
! 		MyProc->lwWaiting = true;
! 		MyProc->lwWaitMode = 0; /* doesn't matter */
! 		MyProc->lwWaitLink = NULL;
! 		if (slot->head == NULL)
! 			slot->head = MyProc;
! 		else
! 			slot->tail->lwWaitLink = MyProc;
! 		slot->tail = MyProc;
! 		SpinLockRelease(&slot->lck);
! 		LWLockRelease(WALInsertTailLock);
! 		for (;;)
! 		{
! 			PGSemaphoreLock(&MyProc->sem, false);
! 			if (!MyProc->lwWaiting)
! 				break;
! 			extraWaits++;
! 		}
! 		LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
! 		lastslot = Insert->lastslot;
! 		nextslot = Insert->nextslot;
  	}
  
! 	/*
! 	 * Ok, there is at least one empty slot now. That's enouugh for our
! 	 * insertion, but ẃhile we're at it, advance lastslot as much as we
! 	 * can. That way we don't need to come back here on the next call
! 	 * again.
! 	 */
! 	while (lastslot != nextslot)
! 	{
! 		volatile XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[lastslot];
! 		/*
! 		 * Don't need to grab the slot's spinlock here, because we're not
! 		 * interested in the exact value of CurrPos, only whether it's
! 		 * valid or not.
! 		 */
! 		if (!XLogRecPtrIsInvalid(slot->CurrPos))
! 			break;
  
! 		lastslot = NextSlotNo(lastslot);
! 	}
! 	Insert->lastslot = lastslot;
  
! 	LWLockRelease(WALInsertTailLock);
  }
  
  /*
***************
*** 1488,1522 **** XLogArchiveCleanup(const char *xlog)
  }
  
  /*
!  * Advance the Insert state to the next buffer page, writing out the next
!  * buffer if it still contains unwritten data.
!  *
!  * If new_segment is TRUE then we set up the next buffer page as the first
!  * page of the next xlog segment file, possibly but not usually the next
!  * consecutive file page.
!  *
!  * The global LogwrtRqst.Write pointer needs to be advanced to include the
!  * just-filled page.  If we can do this for free (without an extra lock),
!  * we do so here.  Otherwise the caller must do it.  We return TRUE if the
!  * request update still needs to be done, FALSE if we did it internally.
!  *
!  * Must be called with WALInsertLock held.
   */
! static bool
! AdvanceXLInsertBuffer(bool new_segment)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	XLogCtlWrite *Write = &XLogCtl->Write;
! 	int			nextidx = NextBufIdx(Insert->curridx);
! 	bool		update_needed = true;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
! 	XLogRecPtr	NewPageEndPtr;
  	XLogPageHeader NewPage;
  
! 	/* Use Insert->LogwrtResult copy if it's more fresh */
! 	if (XLByteLT(LogwrtResult.Write, Insert->LogwrtResult.Write))
! 		LogwrtResult = Insert->LogwrtResult;
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
--- 2036,2069 ----
  }
  
  /*
!  * Initialize XLOG buffers, writing out old buffers if they still contain
!  * unwritten data, upto the page containing 'upto'. Or if 'opportunistic' is
!  * true, initialize as many pages as we can without having to write out
!  * unwritten data. Any new pages are initialized to zeros, with pages headers
!  * initialized properly.
   */
! static void
! AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			nextidx;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
! 	XLogRecPtr	NewPageEndPtr = InvalidXLogRecPtr;
  	XLogPageHeader NewPage;
+ 	bool		needflush;
+ 	int			npages = 0;
  
! 	LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
! 
! 	/*
! 	 * Now that we have the lock, check if someone initialized the page
! 	 * already.
! 	 */
! /* XXX: fix indentation before commit */
! while (!XLByteLT(upto, XLogCtl->xlblocks[XLogCtl->curridx]) || opportunistic)
! {
! 	nextidx = NextBufIdx(XLogCtl->curridx);
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
***************
*** 1524,1535 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
- 	if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
- 	{
- 		/* nope, got work to do... */
- 		XLogRecPtr	FinishedPageRqstPtr;
  
! 		FinishedPageRqstPtr = XLogCtl->xlblocks[Insert->curridx];
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
--- 2071,2087 ----
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
  
! 	needflush = !XLByteLE(OldPageRqstPtr, LogwrtResult.Write);
! 
! 	if (needflush)
! 	{
! 		/*
! 		 * Nope, got work to do. If we just want to pre-initialize as much as
! 		 * we can without flushing, give up now.
! 		 */
! 		if (opportunistic)
! 			break;
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
***************
*** 1537,1581 **** AdvanceXLInsertBuffer(bool new_segment)
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, FinishedPageRqstPtr))
! 				xlogctl->LogwrtRqst.Write = FinishedPageRqstPtr;
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		update_needed = false;	/* Did the shared-request update */
! 
! 		if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/* OK, someone wrote it already */
! 			Insert->LogwrtResult = LogwrtResult;
! 		}
! 		else
! 		{
! 			/* Must acquire write lock */
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 			LogwrtResult = Write->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding insert lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false, false);
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
  		}
  	}
  
--- 2089,2138 ----
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, OldPageRqstPtr))
! 			{
! 				Assert(XLByteLE(OldPageRqstPtr, xlogctl->Insert.CurrPos));
! 				xlogctl->LogwrtRqst.Write = OldPageRqstPtr;
! 			}
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/*
! 			 * Must acquire write lock. Release WALBufMappingLock first, to
! 			 * make sure that all insertions that we need to wait for can
! 			 * finish (up to this same position). Otherwise we risk deadlock.
! 			 */
! 			LWLockRelease(WALBufMappingLock);
! 
! 			WaitXLogInsertionsToFinish(OldPageRqstPtr, InvalidXLogRecPtr);
! 
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 			LogwrtResult = XLogCtl->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding mapping lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false);
  				LWLockRelease(WALWriteLock);
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
+ 			/* Re-acquire WALBufMappingLock and retry */
+ 			LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
+ 			continue;
  		}
  	}
  
***************
*** 1583,1596 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[Insert->curridx];
! 
! 	if (new_segment)
! 	{
! 		/* force it to a segment start point */
! 		NewPageEndPtr.xrecoff += XLogSegSize - 1;
! 		NewPageEndPtr.xrecoff -= NewPageEndPtr.xrecoff % XLogSegSize;
! 	}
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
--- 2140,2146 ----
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[XLogCtl->curridx];
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
***************
*** 1600,1612 **** AdvanceXLInsertBuffer(bool new_segment)
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
! 	XLogCtl->xlblocks[nextidx] = NewPageEndPtr;
! 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
! 
! 	Insert->curridx = nextidx;
! 	Insert->currpage = NewPage;
  
! 	Insert->currpos = ((char *) NewPage) +SizeOfXLogShortPHD;
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
--- 2150,2159 ----
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
! 	Assert(NewPageEndPtr.xrecoff % XLOG_BLCKSZ == 0);
! 	Assert(XLogRecEndPtrToBufIdx(NewPageEndPtr) == nextidx);
  
! 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
***************
*** 1650,1660 **** AdvanceXLInsertBuffer(bool new_segment)
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
- 
- 		Insert->currpos = ((char *) NewPage) +SizeOfXLogLongPHD;
  	}
  
! 	return update_needed;
  }
  
  /*
--- 2197,2224 ----
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
  	}
  
! 	/*
! 	 * Make sure the initialization of the page becomes visible to others
! 	 * before the xlblocks update. GetXLogBuffer() reads xlblocks without
! 	 * holding a lock.
! 	 */
! 	pg_write_barrier();
! 
! 	*((volatile XLogRecPtr *) &XLogCtl->xlblocks[nextidx]) = NewPageEndPtr;
! 
! 	XLogCtl->curridx = nextidx;
! 
! 	npages++;
! }
! 	LWLockRelease(WALBufMappingLock);
! 
! #ifdef WAL_DEBUG
! 	if (npages > 0)
! 		elog(DEBUG1, "initialized %d pages, upto %X/%X",
! 			 npages, NewPageEndPtr.xlogid, NewPageEndPtr.xrecoff);
! #endif
  }
  
  /*
***************
*** 1699,1714 **** XLogCheckpointNeeded(uint32 logid, uint32 logseg)
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * If xlog_switch == TRUE, we are intending an xlog segment switch, so
!  * perform end-of-segment actions after writing the last page, even if
!  * it's not physically the end of its segment.  (NB: this will work properly
!  * only if caller specifies WriteRqst == page-end and flexible == false,
!  * and there is some data to write.)
!  *
!  * Must be called with WALWriteLock held.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
--- 2263,2274 ----
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * Must be called with WALWriteLock held. And you must've called
!  * WaitXLogInsertionsToFinish(WriteRqst) before grabbing the lock to make sure
!  * the data is ready to write.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
***************
*** 1726,1732 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  	/*
  	 * Update local LogwrtResult (caller probably did this already, but...)
  	 */
! 	LogwrtResult = Write->LogwrtResult;
  
  	/*
  	 * Since successive pages in the xlog cache are consecutively allocated,
--- 2286,2292 ----
  	/*
  	 * Update local LogwrtResult (caller probably did this already, but...)
  	 */
! 	LogwrtResult = XLogCtl->LogwrtResult;
  
  	/*
  	 * Since successive pages in the xlog cache are consecutively allocated,
***************
*** 1757,1770 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  		 * if we're passed a bogus WriteRqst.Write that is past the end of the
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
! 		if (!XLByteLT(LogwrtResult.Write, XLogCtl->xlblocks[curridx]))
  			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
! 				 XLogCtl->xlblocks[curridx].xlogid,
! 				 XLogCtl->xlblocks[curridx].xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
! 		LogwrtResult.Write = XLogCtl->xlblocks[curridx];
  		ispartialpage = XLByteLT(WriteRqst.Write, LogwrtResult.Write);
  
  		if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
--- 2317,2330 ----
  		 * if we're passed a bogus WriteRqst.Write that is past the end of the
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
! 		XLogRecPtr EndPtr = XLogCtl->xlblocks[curridx];
! 		if (!XLByteLT(LogwrtResult.Write, EndPtr))
  			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
! 				 EndPtr.xlogid, EndPtr.xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
! 		LogwrtResult.Write = EndPtr;
  		ispartialpage = XLByteLT(WriteRqst.Write, LogwrtResult.Write);
  
  		if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
***************
*** 1861,1876 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
- 			 * We also do this if this is the last page written for an xlog
- 			 * switch.
- 			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg || (xlog_switch && last_iteration))
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
--- 2421,2433 ----
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg)
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
***************
*** 1960,1967 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  			xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
  		SpinLockRelease(&xlogctl->info_lck);
  	}
- 
- 	Write->LogwrtResult = LogwrtResult;
  }
  
  /*
--- 2517,2522 ----
***************
*** 2124,2131 **** XLogFlush(XLogRecPtr record)
  	 */
  	for (;;)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
  		volatile XLogCtlData *xlogctl = XLogCtl;
  
  		/* read LogwrtResult and update local state */
  		SpinLockAcquire(&xlogctl->info_lck);
--- 2679,2689 ----
  	 */
  	for (;;)
  	{
! 		/* use volatile pointers to prevent code rearrangement */
  		volatile XLogCtlData *xlogctl = XLogCtl;
+ 		volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 		uint32		freespace;
+ 		XLogRecPtr	insertpos;
  
  		/* read LogwrtResult and update local state */
  		SpinLockAcquire(&xlogctl->info_lck);
***************
*** 2139,2144 **** XLogFlush(XLogRecPtr record)
--- 2697,2731 ----
  			break;
  
  		/*
+ 		 * Get the current insert position.
+ 		 *
+ 		 * XXX: This used to do LWLockConditionalAcquire(WALInsertLock),
+ 		 * fall back to writing just up to 'record' if we couldn't get t
+ 		 * lock. I wonder if it would be a good idea to have a
+ 		 * SpinLockConditionalAcquire function and use that? On one hand
+ 		 * it would be good to not cause more contention on the lock if
+ 		 * busy, but on the other hand, this spinlock is much more light
+ 		 * than the WALInsertLock was, so maybe it's better to just grab
+ 		 * spinlock. Also note that if we stored the XLogRecPtr as one 6
+ 		 * integer, we could just read it with no lock on platforms wher
+ 		 * 64-bit integer accesses are atomic, which covers many common
+ 		 * platforms nowadays.
+ 		 */
+ 		SpinLockAcquire(&Insert->insertpos_lck);
+ 		insertpos = Insert->CurrPos;
+ 		SpinLockRelease(&Insert->insertpos_lck);
+ 
+ 		freespace = INSERT_FREESPACE(insertpos);
+ 		if (freespace < SizeOfXLogRecord)               /* buffer is full */
+ 			insertpos.xrecoff += freespace;
+ 
+ 		/*
+ 		 * Before actually performing the write, wait for all in-flight
+ 		 * insertions to the pages we're about to write to finish.
+ 		 */
+ 		insertpos = WaitXLogInsertionsToFinish(WriteRqstPtr, insertpos);
+ 
+ 		/*
  		 * Try to get the write lock. If we can't get it immediately, wait
  		 * until it's released, and recheck if we still need to do the flush
  		 * or if the backend that held the lock did it for us already. This
***************
*** 2155,2186 **** XLogFlush(XLogRecPtr record)
  			continue;
  		}
  		/* Got the lock */
! 		LogwrtResult = XLogCtl->Write.LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			/* try to write/flush later additions to XLOG as well */
! 			if (LWLockConditionalAcquire(WALInsertLock, LW_EXCLUSIVE))
! 			{
! 				XLogCtlInsert *Insert = &XLogCtl->Insert;
! 				uint32		freespace = INSERT_FREESPACE(Insert);
  
! 				if (freespace < SizeOfXLogRecord)		/* buffer is full */
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 				else
! 				{
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 					WriteRqstPtr.xrecoff -= freespace;
! 				}
! 				LWLockRelease(WALInsertLock);
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = WriteRqstPtr;
! 			}
! 			else
! 			{
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = record;
! 			}
! 			XLogWrite(WriteRqst, false, false);
  		}
  		LWLockRelease(WALWriteLock);
  		/* done */
--- 2742,2754 ----
  			continue;
  		}
  		/* Got the lock */
! 		LogwrtResult = XLogCtl->LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			WriteRqst.Write = insertpos;
! 			WriteRqst.Flush = insertpos;
  
! 			XLogWrite(WriteRqst, false);
  		}
  		LWLockRelease(WALWriteLock);
  		/* done */
***************
*** 2292,2314 **** XLogBackgroundFlush(void)
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
- 
  	START_CRIT_SECTION();
  
! 	/* now wait for the write lock */
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 	LogwrtResult = XLogCtl->Write.LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
  	{
  		XLogwrtRqst WriteRqst;
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible, false);
  	}
! 	LWLockRelease(WALWriteLock);
  
  	END_CRIT_SECTION();
  }
  
  /*
--- 2860,2890 ----
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
  	START_CRIT_SECTION();
  
! 	/* now wait for any in-progress insertions to finish and get write lock */
! 	WaitXLogInsertionsToFinish(WriteRqstPtr, InvalidXLogRecPtr);
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 	LogwrtResult = XLogCtl->LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
  	{
  		XLogwrtRqst WriteRqst;
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible);
  	}
! 	LogwrtResult = XLogCtl->LogwrtResult;
  
  	END_CRIT_SECTION();
+ 
+ 	LWLockRelease(WALWriteLock);
+ 
+ 	/*
+ 	 * Great, done. To take some work off the critical path, try to initialize
+ 	 * as many of the no-longer-needed WAL buffers for future use as we can.
+ 	 */
+ 	AdvanceXLInsertBuffer(InvalidXLogRecPtr, true);
  }
  
  /*
***************
*** 5102,5107 **** XLOGShmemSize(void)
--- 5678,5686 ----
  	/* and the buffers themselves */
  	size = add_size(size, mul_size(XLOG_BLCKSZ, XLOGbuffers));
  
+ 	/* XLog insertion slots */
+ 	size = add_size(size, mul_size(sizeof(XLogInsertSlot), NumXLogInsertSlots));
+ 
  	/*
  	 * Note: we don't count ControlFileData, it comes out of the "slop factor"
  	 * added by CreateSharedMemoryAndSemaphores.  This lets us use this
***************
*** 5117,5122 **** XLOGShmemInit(void)
--- 5696,5702 ----
  	bool		foundCFile,
  				foundXLog;
  	char	   *allocptr;
+ 	int			i;
  
  	ControlFile = (ControlFileData *)
  		ShmemInitStruct("Control File", sizeof(ControlFileData), &foundCFile);
***************
*** 5142,5147 **** XLOGShmemInit(void)
--- 5722,5740 ----
  	memset(XLogCtl->xlblocks, 0, sizeof(XLogRecPtr) * XLOGbuffers);
  	allocptr += sizeof(XLogRecPtr) * XLOGbuffers;
  
+ 	/* Initialize insertion slots */
+ 	XLogCtl->XLogInsertSlots = (XLogInsertSlot *) allocptr;
+ 	for (i = 0; i < NumXLogInsertSlots; i++)
+ 	{
+ 		XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[i];
+ 		slot->CurrPos = InvalidXLogRecPtr;
+ 		slot->head = slot->tail = NULL;
+ 		SpinLockInit(&slot->lck);
+ 	}
+ 	XLogCtl->Insert.nextslot = 1;
+ 	XLogCtl->Insert.lastslot = 0;
+ 	allocptr += sizeof(XLogInsertSlot) * NumXLogInsertSlots;
+ 
  	/*
  	 * Align the start of the page buffers to an ALIGNOF_XLOG_BUFFER boundary.
  	 */
***************
*** 5156,5166 **** XLOGShmemInit(void)
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
- 	XLogCtl->Insert.currpage = (XLogPageHeader) (XLogCtl->pages);
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
--- 5749,5760 ----
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
+ 	SpinLockInit(&XLogCtl->Insert.insertpos_lck);
+ 
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
***************
*** 6038,6043 **** StartupXLOG(void)
--- 6632,6638 ----
  	bool		backupEndRequired = false;
  	bool		backupFromStandby = false;
  	DBState		dbstate_at_startup;
+ 	int			firstIdx;
  
  	/*
  	 * Read control file and check XLOG status looks valid.
***************
*** 6844,6851 **** StartupXLOG(void)
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 	XLogCtl->xlblocks[0].xlogid = openLogId;
! 	XLogCtl->xlblocks[0].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
--- 7439,7450 ----
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 
! 	firstIdx = XLogRecPtrToBufIdx(EndOfLog);
! 	XLogCtl->curridx = firstIdx;
! 
! 	XLogCtl->xlblocks[firstIdx].xlogid = openLogId;
! 	XLogCtl->xlblocks[firstIdx].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
***************
*** 6853,6878 **** StartupXLOG(void)
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[0].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) Insert->currpage, readBuf, XLOG_BLCKSZ);
! 	Insert->currpos = (char *) Insert->currpage +
! 		(EndOfLog.xrecoff + XLOG_BLCKSZ - XLogCtl->xlblocks[0].xrecoff);
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
- 	XLogCtl->Write.LogwrtResult = LogwrtResult;
- 	Insert->LogwrtResult = LogwrtResult;
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(Insert->currpos, 0, freespace);
! 		XLogCtl->Write.curridx = 0;
  	}
  	else
  	{
--- 7452,7474 ----
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[firstIdx].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) &XLogCtl->pages[firstIdx * XLOG_BLCKSZ], readBuf, XLOG_BLCKSZ);
! 	Insert->CurrPos = EndOfLog;
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = XLOG_BLCKSZ - EndRecPtr.xrecoff % XLOG_BLCKSZ;
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(&XLogCtl->pages[firstIdx * XLOG_BLCKSZ] + EndRecPtr.xrecoff % XLOG_BLCKSZ, 0, freespace);
! 		XLogCtl->Write.curridx = firstIdx;
  	}
  	else
  	{
***************
*** 6884,6890 **** StartupXLOG(void)
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(0);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
--- 7480,7486 ----
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(firstIdx);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
***************
*** 7390,7396 **** GetRedoRecPtr(void)
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire WALInsertLock which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
--- 7986,7992 ----
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire insertpos_lck which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
***************
*** 7666,7671 **** CreateCheckPoint(int flags)
--- 8262,8268 ----
  	uint32		insert_logSeg;
  	TransactionId *inCommitXids;
  	int			nInCommit;
+ 	XLogRecPtr	curInsert;
  
  	/*
  	 * An end-of-recovery checkpoint is really a shutdown checkpoint, just
***************
*** 7734,7743 **** CreateCheckPoint(int flags)
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * We must hold WALInsertLock while examining insert state to determine
! 	 * the checkpoint REDO pointer.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
--- 8331,8340 ----
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * Determine the checkpoint REDO pointer.
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	curInsert = Insert->CurrPos;
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
***************
*** 7749,7755 **** CreateCheckPoint(int flags)
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding the WALInsertLock we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
--- 8346,8352 ----
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding insertpos_lck we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
***************
*** 7758,7772 **** CreateCheckPoint(int flags)
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
- 		XLogRecPtr	curInsert;
- 
- 		INSERT_RECPTR(curInsert, Insert, Insert->curridx);
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			LWLockRelease(WALInsertLock);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
--- 8355,8366 ----
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
***************
*** 7793,7806 **** CreateCheckPoint(int flags)
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace < SizeOfXLogRecord)
! 	{
! 		(void) AdvanceXLInsertBuffer(false);
! 		/* OK to ignore update return flag, since we will do flush anyway */
! 		freespace = INSERT_FREESPACE(Insert);
! 	}
! 	INSERT_RECPTR(checkPoint.redo, Insert, Insert->curridx);
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
--- 8387,8396 ----
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(curInsert);
  	if (freespace < SizeOfXLogRecord)
! 		curInsert = AdvanceXLogRecPtrToNextPage(curInsert);
! 	checkPoint.redo = curInsert;
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
***************
*** 7826,7832 **** CreateCheckPoint(int flags)
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
--- 8416,8422 ----
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
***************
*** 7846,7852 **** CreateCheckPoint(int flags)
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released WALInsertLock, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
--- 8436,8442 ----
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released insertpos_lck, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
***************
*** 8213,8227 **** CreateRestartPoint(int flags)
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * You need to hold WALInsertLock and info_lck to update it, although
! 	 * during recovery acquiring WALInsertLock is just pro forma, because
! 	 * there is no other processes updating Insert.RedoRecPtr.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * Prepare to accumulate statistics.
--- 8803,8817 ----
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * Like in CreateCheckPoint(), you need both insertpos_lck and info_lck
! 	 * to update it, although during recovery acquiring insertpos_lck is just
! 	 * pro forma, because no WAL insertions are happening.
  	 */
! 	SpinLockAcquire(&xlogctl->Insert.insertpos_lck);
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
! 	SpinLockRelease(&xlogctl->Insert.insertpos_lck);
  
  	/*
  	 * Prepare to accumulate statistics.
***************
*** 8412,8418 **** XLogPutNextOid(Oid nextOid)
  XLogRecPtr
  RequestXLogSwitch(void)
  {
! 	XLogRecPtr	RecPtr;
  	XLogRecData rdata;
  
  	/* XLOG SWITCH, alone among xlog record types, has no data */
--- 9002,9008 ----
  XLogRecPtr
  RequestXLogSwitch(void)
  {
! 	XLogRecPtr	EndPos;
  	XLogRecData rdata;
  
  	/* XLOG SWITCH, alone among xlog record types, has no data */
***************
*** 8421,8429 **** RequestXLogSwitch(void)
  	rdata.len = 0;
  	rdata.next = NULL;
  
! 	RecPtr = XLogInsert(RM_XLOG_ID, XLOG_SWITCH, &rdata);
  
! 	return RecPtr;
  }
  
  /*
--- 9011,9031 ----
  	rdata.len = 0;
  	rdata.next = NULL;
  
! 	EndPos = XLogInsert(RM_XLOG_ID, XLOG_SWITCH, &rdata);
  
! 	/* XXX: before this patch, TRACE_POSTGRESQL_XLOG_SWITCH was not called
! 	 * if the xlog switch had no work to do, ie. if we were already at the
! 	 * beginning of a new XLOG segment. You can check if RecPtr points to
! 	 * beginning of a segment if you want to keep the distinction.
! 	 */
! 	TRACE_POSTGRESQL_XLOG_SWITCH();
! 
! 	/*
! 	 * XLogInsert returns a pointer to the end of segment, but we want
! 	 * to return a pointer to just the end of the xlog-switch record. The
! 	 * rest of the segment is padded out.
! 	 */
! 	return EndPos;
  }
  
  /*
***************
*** 8501,8522 **** XLogReportParameters(void)
  /*
   * Update full_page_writes in shared memory, and write an
   * XLOG_FPW_CHANGE record if necessary.
   */
  void
  UpdateFullPageWrites(void)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  
  	/*
  	 * Do nothing if full_page_writes has not been changed.
  	 *
  	 * It's safe to check the shared full_page_writes without the lock,
! 	 * because we can guarantee that there is no concurrently running
! 	 * process which can update it.
  	 */
  	if (fullPageWrites == Insert->fullPageWrites)
  		return;
  
  	/*
  	 * Write an XLOG_FPW_CHANGE record. This allows us to keep
  	 * track of full_page_writes during archive recovery, if required.
--- 9103,9143 ----
  /*
   * Update full_page_writes in shared memory, and write an
   * XLOG_FPW_CHANGE record if necessary.
+  *
+  * Note: this function assumes there is no other process running
+  * concurrently that could update it.
   */
  void
  UpdateFullPageWrites(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  
  	/*
  	 * Do nothing if full_page_writes has not been changed.
  	 *
  	 * It's safe to check the shared full_page_writes without the lock,
! 	 * because we assume that there is no concurrently running process
! 	 * which can update it.
  	 */
  	if (fullPageWrites == Insert->fullPageWrites)
  		return;
  
+ 	START_CRIT_SECTION();
+ 
+ 	/*
+ 	 * It's always safe to take full page images, even when not strictly
+ 	 * required, but not the other round. So if we're setting full_page_writes
+ 	 * to true, first set it true and then write the WAL record. If we're
+ 	 * setting it to false, first write the WAL record and then set the
+ 	 * global flag.
+ 	 */
+ 	if (fullPageWrites)
+ 	{
+ 		SpinLockAcquire(&Insert->insertpos_lck);
+ 		Insert->fullPageWrites = true;
+ 		SpinLockRelease(&Insert->insertpos_lck);
+ 	}
+ 
  	/*
  	 * Write an XLOG_FPW_CHANGE record. This allows us to keep
  	 * track of full_page_writes during archive recovery, if required.
***************
*** 8532,8543 **** UpdateFullPageWrites(void)
  
  		XLogInsert(RM_XLOG_ID, XLOG_FPW_CHANGE, &rdata);
  	}
! 	else
  	{
! 		LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 		Insert->fullPageWrites = fullPageWrites;
! 		LWLockRelease(WALInsertLock);
  	}
  }
  
  /*
--- 9153,9166 ----
  
  		XLogInsert(RM_XLOG_ID, XLOG_FPW_CHANGE, &rdata);
  	}
! 
! 	if (!fullPageWrites)
  	{
! 		SpinLockAcquire(&Insert->insertpos_lck);
! 		Insert->fullPageWrites = false;
! 		SpinLockRelease(&Insert->insertpos_lck);
  	}
+ 	END_CRIT_SECTION();
  }
  
  /*
***************
*** 9063,9068 **** issue_xlog_fsync(int fd, uint32 log, uint32 seg)
--- 9686,9692 ----
  XLogRecPtr
  do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	bool		backup_started_in_recovery = false;
  	XLogRecPtr	checkpointloc;
***************
*** 9125,9150 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  	 * Note that forcePageWrites has no effect during an online backup from
  	 * the standby.
  	 *
! 	 * We must hold WALInsertLock to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
! 		if (XLogCtl->Insert.exclusiveBackup)
  		{
! 			LWLockRelease(WALInsertLock);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		XLogCtl->Insert.exclusiveBackup = true;
  	}
  	else
! 		XLogCtl->Insert.nonExclusiveBackups++;
! 	XLogCtl->Insert.forcePageWrites = true;
! 	LWLockRelease(WALInsertLock);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
--- 9749,9774 ----
  	 * Note that forcePageWrites has no effect during an online backup from
  	 * the standby.
  	 *
! 	 * We must hold insertpos_lck to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
! 		if (Insert->exclusiveBackup)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		Insert->exclusiveBackup = true;
  	}
  	else
! 		Insert->nonExclusiveBackups++;
! 	Insert->forcePageWrites = true;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
***************
*** 9257,9269 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			LWLockAcquire(WALInsertLock, LW_SHARED);
! 			if (XLByteLT(XLogCtl->Insert.lastBackupStart, startpoint))
  			{
! 				XLogCtl->Insert.lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			LWLockRelease(WALInsertLock);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
--- 9881,9893 ----
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			SpinLockAcquire(&Insert->insertpos_lck);
! 			if (XLByteLT(Insert->lastBackupStart, startpoint))
  			{
! 				Insert->lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			SpinLockRelease(&Insert->insertpos_lck);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
***************
*** 9347,9356 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
  		Assert(XLogCtl->Insert.exclusiveBackup);
--- 9971,9981 ----
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
  		Assert(XLogCtl->Insert.exclusiveBackup);
***************
*** 9367,9373 **** pg_start_backup_callback(int code, Datum arg)
  	{
  		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 9992,9998 ----
  	{
  		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9380,9385 **** pg_start_backup_callback(int code, Datum arg)
--- 10005,10011 ----
  XLogRecPtr
  do_pg_stop_backup(char *labelfile, bool waitforarchive)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	bool		backup_started_in_recovery = false;
  	XLogRecPtr	startpoint;
***************
*** 9433,9441 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
! 		XLogCtl->Insert.exclusiveBackup = false;
  	else
  	{
  		/*
--- 10059,10067 ----
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
! 		Insert->exclusiveBackup = false;
  	else
  	{
  		/*
***************
*** 9444,9459 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 		XLogCtl->Insert.nonExclusiveBackups--;
  	}
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  
  	if (exclusive)
  	{
--- 10070,10085 ----
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(Insert->nonExclusiveBackups > 0);
! 		Insert->nonExclusiveBackups--;
  	}
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	if (exclusive)
  	{
***************
*** 9731,9746 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  void
  do_pg_abort_backup(void)
  {
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 	Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 	XLogCtl->Insert.nonExclusiveBackups--;
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 10357,10374 ----
  void
  do_pg_abort_backup(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	Assert(Insert->nonExclusiveBackups > 0);
! 	Insert->nonExclusiveBackups--;
! 
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9794,9805 **** GetStandbyFlushRecPtr(void)
  XLogRecPtr
  GetXLogInsertRecPtr(void)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	LWLockAcquire(WALInsertLock, LW_SHARED);
! 	INSERT_RECPTR(current_recptr, Insert, Insert->curridx);
! 	LWLockRelease(WALInsertLock);
  
  	return current_recptr;
  }
--- 10422,10433 ----
  XLogRecPtr
  GetXLogInsertRecPtr(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	current_recptr = Insert->CurrPos;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	return current_recptr;
  }
*** a/src/backend/storage/lmgr/spin.c
--- b/src/backend/storage/lmgr/spin.c
***************
*** 56,61 **** SpinlockSemas(void)
--- 56,64 ----
  	 *
  	 * For now, though, we just need a few spinlocks (10 should be plenty)
  	 * plus one for each LWLock and one for each buffer header.
+ 	 *
+ 	 * XXX: remember to adjust this for the number of spinlocks needed by the
+ 	 * xlog.c changes before committing!
  	 */
  	return NumLWLocks() + NBuffers + 10;
  }
*** a/src/include/storage/lwlock.h
--- b/src/include/storage/lwlock.h
***************
*** 53,59 **** typedef enum LWLockId
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALInsertLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
--- 53,59 ----
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALBufMappingLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
***************
*** 79,84 **** typedef enum LWLockId
--- 79,85 ----
  	SerializablePredicateLockListLock,
  	OldSerXidLock,
  	SyncRepLock,
+ 	WALInsertTailLock,
  	/* Individual lock IDs end here */
  	FirstBufMappingLock,
  	FirstLockMgrLock = FirstBufMappingLock + NUM_BUFFER_PARTITIONS,

diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c
new file mode 100644
index 5d7888a..4aa7115
*** a/src/backend/postmaster/postmaster.c
--- b/src/backend/postmaster/postmaster.c
*************** checkDataDir(void)
*** 1235,1241 ****
  	 * reasonable check to apply on Windows.
  	 */
  #if !defined(WIN32) && !defined(__CYGWIN__)
! 	if (stat_buf.st_mode & (S_IRWXG | S_IRWXO))
  		ereport(FATAL,
  				(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  				 errmsg("data directory \"%s\" has group or world access",
--- 1235,1241 ----
  	 * reasonable check to apply on Windows.
  	 */
  #if !defined(WIN32) && !defined(__CYGWIN__)
! 	if (0 && stat_buf.st_mode & (S_IRWXG | S_IRWXO))
  		ereport(FATAL,
  				(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  				 errmsg("data directory \"%s\" has group or world access",
diff --git a/src/backend/storage/smgr/md.c b/src/backend/storage/smgr/md.c
new file mode 100644
index bfc9f06..bf5cfe7
*** a/src/backend/storage/smgr/md.c
--- b/src/backend/storage/smgr/md.c
***************
*** 59,64 ****
--- 59,66 ----
  #define FILE_POSSIBLY_DELETED(err)	((err) == ENOENT || (err) == EACCES)
  #endif
  
+ int JJ_torn_page=0;
+ 
  /*
   *	The magnetic disk storage manager keeps track of open file
   *	descriptors in its own descriptor pool.  This is done to make it
*************** mdwrite(SMgrRelation reln, ForkNumber fo
*** 689,694 ****
--- 691,697 ----
  	off_t		seekpos;
  	int			nbytes;
  	MdfdVec    *v;
+         static int counter=0;
  
  	/* This assert is too expensive to have on normally ... */
  #ifdef CHECK_WRITE_VS_EXTEND
*************** mdwrite(SMgrRelation reln, ForkNumber fo
*** 713,719 ****
  				 errmsg("could not seek to block %u in file \"%s\": %m",
  						blocknum, FilePathName(v->mdfd_vfd))));
  
! 	nbytes = FileWrite(v->mdfd_vfd, buffer, BLCKSZ);
  
  	TRACE_POSTGRESQL_SMGR_MD_WRITE_DONE(forknum, blocknum,
  										reln->smgr_rnode.node.spcNode,
--- 716,733 ----
  				 errmsg("could not seek to block %u in file \"%s\": %m",
  						blocknum, FilePathName(v->mdfd_vfd))));
  
!         if (JJ_torn_page > 0 && counter++ > JJ_torn_page) {
! 	  nbytes = FileWrite(v->mdfd_vfd, buffer, BLCKSZ/3);
! 		ereport(FATAL,
! 				(errcode(ERRCODE_DISK_FULL),
! 				 errmsg("could not write block %u of relation %s: wrote only %d of %d bytes",
! 						blocknum,
! 						relpath(reln->smgr_rnode, forknum),
! 						nbytes, BLCKSZ),
! 				 errhint("JJ is screwing with the database.")));
!         } else {
! 	  nbytes = FileWrite(v->mdfd_vfd, buffer, BLCKSZ);
! 	}
  
  	TRACE_POSTGRESQL_SMGR_MD_WRITE_DONE(forknum, blocknum,
  										reln->smgr_rnode.node.spcNode,
diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
new file mode 100644
index a5becbe..b6d8ebf
*** a/src/backend/utils/misc/guc.c
--- b/src/backend/utils/misc/guc.c
***************
*** 127,132 ****
--- 127,133 ----
  /* XXX these should appear in other modules' header files */
  extern bool Log_disconnections;
  extern int	CommitDelay;
+ int	JJ_torn_page;
  extern int	CommitSiblings;
  extern char *default_tablespace;
  extern char *temp_tablespaces;
*************** static struct config_int ConfigureNamesI
*** 2031,2036 ****
--- 2032,2046 ----
  	},
  
  	{
+ 		{"JJ_torn_page", PGC_USERSET, WAL_SETTINGS,
+ 			gettext_noop("Simulate a torn-page crash after this number of page writes (0 to turn off)"),
+ 			NULL
+ 		},
+ 		&JJ_torn_page,
+ 		0, 0, 100000, NULL, NULL
+ 	},
+ 
+ 	{
  		{"commit_siblings", PGC_USERSET, WAL_SETTINGS,
  			gettext_noop("Sets the minimum concurrent open transactions before performing "
  						 "commit_delay."),
diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
new file mode 100644
index 96da086..1cdebbb
*** a/src/backend/utils/misc/postgresql.conf.sample
--- b/src/backend/utils/misc/postgresql.conf.sample
***************
*** 159,165 ****
  
  # - Settings -
  
! #wal_level = minimal			# minimal, archive, or hot_standby
  					# (change requires restart)
  #fsync = on				# turns forced synchronization on or off
  #synchronous_commit = on		# synchronization level; on, off, or local
--- 159,165 ----
  
  # - Settings -
  
! wal_level = archive			# minimal, archive, or hot_standby
  					# (change requires restart)
  #fsync = on				# turns forced synchronization on or off
  #synchronous_commit = on		# synchronization level; on, off, or local
***************
*** 180,199 ****
  
  # - Checkpoints -
  
! #checkpoint_segments = 3		# in logfile segments, min 1, 16MB each
! #checkpoint_timeout = 5min		# range 30s-1h
  #checkpoint_completion_target = 0.5	# checkpoint target duration, 0.0 - 1.0
  #checkpoint_warning = 30s		# 0 disables
  
  # - Archiving -
  
! #archive_mode = off		# allows archiving to be done
  				# (change requires restart)
! #archive_command = ''		# command to use to archive a logfile segment
  				# placeholders: %p = path of file to archive
  				#               %f = file name only
  				# e.g. 'test ! -f /mnt/server/archivedir/%f && cp %p /mnt/server/archivedir/%f'
! #archive_timeout = 0		# force a logfile segment switch after this
  				# number of seconds; 0 disables
  
  
--- 180,199 ----
  
  # - Checkpoints -
  
! checkpoint_segments = 1		# in logfile segments, min 1, 16MB each
! checkpoint_timeout = 30s		# range 30s-1h
  #checkpoint_completion_target = 0.5	# checkpoint target duration, 0.0 - 1.0
  #checkpoint_warning = 30s		# 0 disables
  
  # - Archiving -
  
! archive_mode = on		# allows archiving to be done
  				# (change requires restart)
! archive_command = 'echo archive_command %p %f `date`'		# command to use to archive a logfile segment
  				# placeholders: %p = path of file to archive
  				#               %f = file name only
  				# e.g. 'test ! -f /mnt/server/archivedir/%f && cp %p /mnt/server/archivedir/%f'
! archive_timeout = 30		# force a logfile segment switch after this
  				# number of seconds; 0 disables
  
  
***************
*** 382,394 ****
  #debug_print_rewritten = off
  #debug_print_plan = off
  #debug_pretty_print = on
! #log_checkpoints = off
  #log_connections = off
  #log_disconnections = off
  #log_duration = off
  #log_error_verbosity = default		# terse, default, or verbose messages
  #log_hostname = off
! #log_line_prefix = ''			# special values:
  					#   %a = application name
  					#   %u = user name
  					#   %d = database name
--- 382,394 ----
  #debug_print_rewritten = off
  #debug_print_plan = off
  #debug_pretty_print = on
! log_checkpoints = on
  #log_connections = off
  #log_disconnections = off
  #log_duration = off
  #log_error_verbosity = default		# terse, default, or verbose messages
  #log_hostname = off
! log_line_prefix = '%p %i %m:'			# special values:
  					#   %a = application name
  					#   %u = user name
  					#   %d = database name

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 266c0de..eb7932e 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -731,8 +731,7 @@ XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
 	unsigned	i;
 	bool		updrqst;
 	bool		doPageWrites;
-	bool		isLogSwitch = false;
-	bool		fpwChange = false;
+	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
 	uint8		info_orig = info;
 
 	/* cross-check on whether we should be here or not */
@@ -746,30 +745,11 @@ XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
 	TRACE_POSTGRESQL_XLOG_INSERT(rmid, info);
 
 	/*
-	 * Handle special cases/records.
+	 * In bootstrap mode, we don't actually log anything but XLOG resources;
+	 * return a phony record pointer.
 	 */
-	if (rmid == RM_XLOG_ID)
+	if (IsBootstrapProcessingMode() && rmid != RM_XLOG_ID)
 	{
-		switch (info)
-		{
-			case XLOG_SWITCH:
-				isLogSwitch = true;
-				break;
-
-			case XLOG_FPW_CHANGE:
-				fpwChange = true;
-				break;
-
-			default:
-				break;
-		}
-	}
-	else if (IsBootstrapProcessingMode())
-	{
-		/*
-		 * In bootstrap mode, we don't actually log anything but XLOG resources;
-		 * return a phony record pointer.
-		 */
 		RecPtr.xlogid = 0;
 		RecPtr.xrecoff = SizeOfXLogLongPHD;		/* start of 1st chkpt record */
 		return RecPtr;
@@ -1232,15 +1212,6 @@ begin:;
 		WriteRqst = XLogCtl->xlblocks[curridx];
 	}
 
-	/*
-	 * If the record is an XLOG_FPW_CHANGE, we update full_page_writes
-	 * in shared memory before releasing WALInsertLock. This ensures that
-	 * an XLOG_FPW_CHANGE record precedes any WAL record affected
-	 * by this change of full_page_writes.
-	 */
-	if (fpwChange)
-		Insert->fullPageWrites = fullPageWrites;
-
 	LWLockRelease(WALInsertLock);
 
 	if (updrqst)
@@ -8517,6 +8488,22 @@ UpdateFullPageWrites(void)
 	if (fullPageWrites == Insert->fullPageWrites)
 		return;
 
+	START_CRIT_SECTION();
+
+	/*
+	 * It's always safe to take full page images, even when not strictly
+	 * required, but not the other round. So if we're setting full_page_writes
+	 * to true, first set it true and then write the WAL record. If we're
+	 * setting it to false, first write the WAL record and then set the
+	 * global flag.
+	 */
+	if (fullPageWrites)
+	{
+		LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
+		Insert->fullPageWrites = true;
+		LWLockRelease(WALInsertLock);
+	}
+
 	/*
 	 * Write an XLOG_FPW_CHANGE record. This allows us to keep
 	 * track of full_page_writes during archive recovery, if required.
@@ -8532,12 +8519,15 @@ UpdateFullPageWrites(void)
 
 		XLogInsert(RM_XLOG_ID, XLOG_FPW_CHANGE, &rdata);
 	}
-	else
+
+
+	if (!fullPageWrites)
 	{
 		LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
-		Insert->fullPageWrites = fullPageWrites;
+		Insert->fullPageWrites = false;
 		LWLockRelease(WALInsertLock);
 	}
+	END_CRIT_SECTION();
 }
 
 /*

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index eb7932e..61eb9bb 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -289,35 +289,16 @@ static XLogRecPtr RedoStartLSN = {0, 0};
  * These structs are identical but are declared separately to indicate their
  * slightly different functions.
  *
- * We do a lot of pushups to minimize the amount of access to lockable
- * shared memory values.  There are actually three shared-memory copies of
- * LogwrtResult, plus one unshared copy in each backend.  Here's how it works:
- *		XLogCtl->LogwrtResult is protected by info_lck
- *		XLogCtl->Write.LogwrtResult is protected by WALWriteLock
- *		XLogCtl->Insert.LogwrtResult is protected by WALInsertLock
- * One must hold the associated lock to read or write any of these, but
- * of course no lock is needed to read/write the unshared LogwrtResult.
- *
- * XLogCtl->LogwrtResult and XLogCtl->Write.LogwrtResult are both "always
- * right", since both are updated by a write or flush operation before
- * it releases WALWriteLock.  The point of keeping XLogCtl->Write.LogwrtResult
- * is that it can be examined/modified by code that already holds WALWriteLock
- * without needing to grab info_lck as well.
- *
- * XLogCtl->Insert.LogwrtResult may lag behind the reality of the other two,
- * but is updated when convenient.	Again, it exists for the convenience of
- * code that is already holding WALInsertLock but not the other locks.
- *
- * The unshared LogwrtResult may lag behind any or all of these, and again
- * is updated when convenient.
+ * To read XLogCtl->LogwrtResult, you must hold either info_lck or
+ * WALWriteLock.  To update it, you need to hold both locks.  The point of
+ * this arrangement is that the value can be examined by code that already
+ * holds WALWriteLock without needing to grab info_lck as well.  In addition
+ * to the shared variable, each backend has a private copy of LogwrtResult,
+ * which is updated when convenient.
  *
  * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
  * (protected by info_lck), but we don't need to cache any copies of it.
  *
- * Note that this all works because the request and result positions can only
- * advance forward, never back up, and so we can easily determine which of two
- * values is "more up to date".
- *
  * info_lck is only held long enough to read/update the protected variables,
  * so it's a plain spinlock.  The other locks are held longer (potentially
  * over I/O operations), so we use LWLocks for them.  These locks are:
@@ -354,7 +335,6 @@ typedef struct XLogwrtResult
  */
 typedef struct XLogCtlInsert
 {
-	XLogwrtResult LogwrtResult; /* a recent value of LogwrtResult */
 	XLogRecPtr	PrevRecord;		/* start of previously-inserted record */
 	int			curridx;		/* current block index in cache */
 	XLogPageHeader currpage;	/* points to header of block in cache */
@@ -388,7 +368,6 @@ typedef struct XLogCtlInsert
  */
 typedef struct XLogCtlWrite
 {
-	XLogwrtResult LogwrtResult; /* current value of LogwrtResult */
 	int			curridx;		/* cache index of next block to write */
 	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
 } XLogCtlWrite;
@@ -401,9 +380,14 @@ typedef struct XLogCtlData
 	/* Protected by WALInsertLock: */
 	XLogCtlInsert Insert;
 
+	/*
+	 * Protected by info_lck and WALWriteLock (you must hold either lock to
+	 * read it, but both to update)
+	 */
+	XLogwrtResult LogwrtResult;
+
 	/* Protected by info_lck: */
 	XLogwrtRqst LogwrtRqst;
-	XLogwrtResult LogwrtResult;
 	uint32		ckptXidEpoch;	/* nextXID & epoch of latest checkpoint */
 	TransactionId ckptXid;
 	XLogRecPtr	asyncXactLSN;	/* LSN of newest async commit/abort */
@@ -1015,7 +999,7 @@ begin:;
 		}
 
 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
-		LogwrtResult = XLogCtl->Write.LogwrtResult;
+		LogwrtResult = XLogCtl->LogwrtResult;
 		if (!XLByteLE(RecPtr, LogwrtResult.Flush))
 		{
 			XLogwrtRqst FlushRqst;
@@ -1188,8 +1172,6 @@ begin:;
 			SpinLockRelease(&xlogctl->info_lck);
 		}
 
-		Write->LogwrtResult = LogwrtResult;
-
 		LWLockRelease(WALWriteLock);
 
 		updrqst = false;		/* done already */
@@ -1477,7 +1459,6 @@ static bool
 AdvanceXLInsertBuffer(bool new_segment)
 {
 	XLogCtlInsert *Insert = &XLogCtl->Insert;
-	XLogCtlWrite *Write = &XLogCtl->Write;
 	int			nextidx = NextBufIdx(Insert->curridx);
 	bool		update_needed = true;
 	XLogRecPtr	OldPageRqstPtr;
@@ -1485,10 +1466,6 @@ AdvanceXLInsertBuffer(bool new_segment)
 	XLogRecPtr	NewPageEndPtr;
 	XLogPageHeader NewPage;
 
-	/* Use Insert->LogwrtResult copy if it's more fresh */
-	if (XLByteLT(LogwrtResult.Write, Insert->LogwrtResult.Write))
-		LogwrtResult = Insert->LogwrtResult;
-
 	/*
 	 * Get ending-offset of the buffer page we need to replace (this may be
 	 * zero if the buffer hasn't been used yet).  Fall through if it's already
@@ -1516,21 +1493,19 @@ AdvanceXLInsertBuffer(bool new_segment)
 
 		update_needed = false;	/* Did the shared-request update */
 
-		if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
-		{
-			/* OK, someone wrote it already */
-			Insert->LogwrtResult = LogwrtResult;
-		}
-		else
+		/*
+		 * Now that we have an up-to-date LogwrtResult value, see if we still
+		 * need to write it or if someone else already did.
+		 */
+		if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
 		{
 			/* Must acquire write lock */
 			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
-			LogwrtResult = Write->LogwrtResult;
+			LogwrtResult = XLogCtl->LogwrtResult;
 			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
 			{
 				/* OK, someone wrote it already */
 				LWLockRelease(WALWriteLock);
-				Insert->LogwrtResult = LogwrtResult;
 			}
 			else
 			{
@@ -1544,7 +1519,6 @@ AdvanceXLInsertBuffer(bool new_segment)
 				WriteRqst.Flush.xrecoff = 0;
 				XLogWrite(WriteRqst, false, false);
 				LWLockRelease(WALWriteLock);
-				Insert->LogwrtResult = LogwrtResult;
 				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
 			}
 		}
@@ -1697,7 +1671,7 @@ XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
 	/*
 	 * Update local LogwrtResult (caller probably did this already, but...)
 	 */
-	LogwrtResult = Write->LogwrtResult;
+	LogwrtResult = XLogCtl->LogwrtResult;
 
 	/*
 	 * Since successive pages in the xlog cache are consecutively allocated,
@@ -1931,8 +1905,6 @@ XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
 			xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
 		SpinLockRelease(&xlogctl->info_lck);
 	}
-
-	Write->LogwrtResult = LogwrtResult;
 }
 
 /*
@@ -2126,7 +2098,7 @@ XLogFlush(XLogRecPtr record)
 			continue;
 		}
 		/* Got the lock */
-		LogwrtResult = XLogCtl->Write.LogwrtResult;
+		LogwrtResult = XLogCtl->LogwrtResult;
 		if (!XLByteLE(record, LogwrtResult.Flush))
 		{
 			/* try to write/flush later additions to XLOG as well */
@@ -2268,7 +2240,7 @@ XLogBackgroundFlush(void)
 
 	/* now wait for the write lock */
 	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
-	LogwrtResult = XLogCtl->Write.LogwrtResult;
+	LogwrtResult = XLogCtl->LogwrtResult;
 	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
 	{
 		XLogwrtRqst WriteRqst;
@@ -6831,8 +6803,6 @@ StartupXLOG(void)
 
 	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
 
-	XLogCtl->Write.LogwrtResult = LogwrtResult;
-	Insert->LogwrtResult = LogwrtResult;
 	XLogCtl->LogwrtResult = LogwrtResult;
 
 	XLogCtl->LogwrtRqst.Write = EndOfLog;

*** a/src/backend/access/transam/xlog.c
--- b/src/backend/access/transam/xlog.c
***************
*** 42,47 ****
--- 42,48 ----
  #include "postmaster/startup.h"
  #include "replication/walreceiver.h"
  #include "replication/walsender.h"
+ #include "storage/barrier.h"
  #include "storage/bufmgr.h"
  #include "storage/fd.h"
  #include "storage/ipc.h"
***************
*** 290,315 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There are actually three shared-memory copies of
!  * LogwrtResult, plus one unshared copy in each backend.  Here's how it works:
!  *		XLogCtl->LogwrtResult is protected by info_lck
!  *		XLogCtl->Write.LogwrtResult is protected by WALWriteLock
!  *		XLogCtl->Insert.LogwrtResult is protected by WALInsertLock
!  * One must hold the associated lock to read or write any of these, but
!  * of course no lock is needed to read/write the unshared LogwrtResult.
!  *
!  * XLogCtl->LogwrtResult and XLogCtl->Write.LogwrtResult are both "always
!  * right", since both are updated by a write or flush operation before
!  * it releases WALWriteLock.  The point of keeping XLogCtl->Write.LogwrtResult
!  * is that it can be examined/modified by code that already holds WALWriteLock
!  * without needing to grab info_lck as well.
!  *
!  * XLogCtl->Insert.LogwrtResult may lag behind the reality of the other two,
!  * but is updated when convenient.	Again, it exists for the convenience of
!  * code that is already holding WALInsertLock but not the other locks.
!  *
!  * The unshared LogwrtResult may lag behind any or all of these, and again
!  * is updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
--- 291,301 ----
   * slightly different functions.
   *
   * We do a lot of pushups to minimize the amount of access to lockable
!  * shared memory values.  There is one shared-memory copy of LogwrtResult,
!  * plus one unshared copy in each backend. To read the shared copy, you need
!  * to hold info_lck *or* WALWriteLock. To update it, you need to hold both
!  * locks. The unshared LogwrtResult may lag behind the shared copy, and is
!  * updated when convenient.
   *
   * The request bookkeeping is simpler: there is a shared XLogCtl->LogwrtRqst
   * (protected by info_lck), but we don't need to cache any copies of it.
***************
*** 319,328 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  The other locks are held longer (potentially
!  * over I/O operations), so we use LWLocks for them.  These locks are:
   *
!  * WALInsertLock: must be held to insert a record into the WAL buffers.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
--- 305,319 ----
   * values is "more up to date".
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  insertpos_lck protects the current logical
!  * insert location, ie. the head of reserved WAL space.  The other locks are
!  * held longer (potentially over I/O operations), so we use LWLocks for them.
!  * These locks are:
   *
!  * WALBufMappingLock: must be held to replace a page in the WAL buffer cache.
!  * This is only held while initializing and changing the mapping. If the
!  * contents of the buffer being replaced haven't been written yet, the mapping
!  * lock is released while the write is done, and reacquired afterwards.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
***************
*** 334,339 **** static XLogRecPtr RedoStartLSN = {0, 0};
--- 325,397 ----
   * only one checkpointer at a time; currently, with all checkpoints done by
   * the checkpointer, this is just pro forma).
   *
+  *
+  * Inserting a new WAL record is a two-step process:
+  *
+  * 1. Reserve the right amount of space from the WAL, and the next insertion
+  *    slot to advertise that the insertion is in progress. The current head
+  *    of reserved space is kept in Insert->CurrPos, and is protected by
+  *    insertpos_lck. Try to keep this section as short as possible,
+  *    insertpos_lck can be heavily contended on a busy system
+  *
+  * 2. Copy the record to the reserved WAL space. This involves finding the
+  *    correct WAL buffer containing the reserved space, and copying the
+  *    record in place. This can be done concurrently in multiple processes.
+  *
+  * To allow as much parallelism as possible for step 2, we try hard to avoid
+  * lock contention in that code path. Each insertion is asssigned its own
+  * "XLog insertion slot", which is used to advertise the position the backend
+  * is writing to. The slot is marked as in-use in step 1, while holding
+  * insertpos_lck, by setting the position field in the slot. When the backend
+  * is finished with the insertion, it clears its slot. Each slot is protected
+  * by a separate spinlock, to keep contention minimal.
+  *
+  * The insertion slots also provide a mechanism to wait for an insertion to
+  * finish. This is important when an XLOG page is written out - any
+  * in-progress insertions must finish copying data to the page first, or the
+  * on-disk copy will be incomplete. Waiting is done by the
+  * WaitXLogInsertionsToFinish() function. It adds the current process to the
+  * waiting queue in the slot it needs to wait for, and when that insertion
+  * finishes (or proceeds to the next page, at least), the inserter wakes up
+  * the process.
+  *
+  * The insertion slots form a ring. Insert->nextslot points to the next free
+  * slot, and Insert->lastslot points to the last slot that's still in use.
+  * lastslot can lag behind reality by any number of slots, as long as nextslot
+  * doesn't catch up with it. lastslot is advanced by
+  * WaitXLogInsertionsToFinish(), and is protected by WALInsertTailLock.
+  * nextslot is advanced in ReserveXLogInsertLocation() and is protected by
+  * insertpos_lck. Both slot variables are 32-bit integers, so that they can
+  * be read atomically without holding a lock. nextslot == lastslot means that
+  * all the slots are empty.
+  *
+  * Whenever the ring fills up, ie. when nextslot wraps around and catches up
+  * with lastslot, ReserveXLogInsertLocation() has to wait for the oldest
+  * insertion to finish and advance lastslot, to make room for the new
+  * insertion. This is also handled by WaitXLogInsertionsToFinish().
+  *
+  *
+  * Deadlock analysis
+  * -----------------
+  *
+  * It's important to call WaitXLogInsertionsToFinish() *before* acquiring
+  * WALWriteLock. Otherwise you might get stuck waiting for an insertion to
+  * finish (or at least advance to next uninitialized page), while you're
+  * holding WALWriteLock. That would be bad, because the backend you're waiting
+  * for might need to acquire WALWriteLock, too, to evict an old buffer, so
+  * you'd get deadlock.
+  *
+  * WaitXLogInsertionsToFinish() will not get stuck indefinitely, as long as
+  * it's called with a location that's known to be already allocated in the WAL
+  * buffers. Calling it with the position of a record you've already inserted
+  * satisfies that condition, so the common pattern:
+  *
+  *   recptr = XLogInsert(...)
+  *   XLogFlush(recptr)
+  *
+  * is safe. It can't get stuck, because an insertion to a WAL page that's
+  * already initialized in cache can always proceed without waiting on a lock.
+  *
   *----------
   */
  
***************
*** 354,364 **** typedef struct XLogwrtResult
   */
  typedef struct XLogCtlInsert
  {
! 	XLogwrtResult LogwrtResult; /* a recent value of LogwrtResult */
! 	XLogRecPtr	PrevRecord;		/* start of previously-inserted record */
! 	int			curridx;		/* current block index in cache */
! 	XLogPageHeader currpage;	/* points to header of block in cache */
! 	char	   *currpos;		/* current insertion point in cache */
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
--- 412,441 ----
   */
  typedef struct XLogCtlInsert
  {
! 	slock_t		insertpos_lck;	/* protects all the fields in this struct
! 								 * (except lastslot). */
! 
! 	int32		nextslot;		/* next insertion slot to use */
! 	int32		lastslot;		/* last in-use insertion slot (protected by
! 								 * WALInsertTailLock) */
! 
! 	/*
! 	 * CurrPos is the very tip of the reserved WAL space at the moment. The
! 	 * next record will be inserted there (or somewhere after it if there's
! 	 * not enough space on the current page). PrevRecord points to the
! 	 * beginning of the last record already reserved. It might not be fully
! 	 * copied into place yet, but we know its exact location already.
! 	 */
! 	XLogRecPtr	CurrPos;
! 	XLogRecPtr	PrevRecord;
! 
! 	/*
! 	 * padding to push RedoRecPtr and forcePageWrites, which rarely change,
! 	 * to a different cache line than the rapidly-changing CurrPos and
! 	 * PrevRecord values. XXX: verify if this makes any difference
! 	 */
! 	char		padding[128];
! 
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
***************
*** 388,406 **** typedef struct XLogCtlInsert
   */
  typedef struct XLogCtlWrite
  {
- 	XLogwrtResult LogwrtResult; /* current value of LogwrtResult */
  	int			curridx;		/* cache index of next block to write */
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by WALInsertLock: */
  	XLogCtlInsert Insert;
  
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
--- 465,498 ----
   */
  typedef struct XLogCtlWrite
  {
  	int			curridx;		/* cache index of next block to write */
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
+ 
+ /*
+  * Slots for in-progress WAL insertions.
+  */
+ typedef struct
+ {
+ 	slock_t		lck;
+ 	XLogRecPtr	CurrPos;	/* current position this process is inserting to */
+ 	PGPROC	   *head;		/* head of list of waiting PGPROCs */
+ 	PGPROC	   *tail;		/* tail of list of waiting PGPROCs */
+ } XLogInsertSlot;
+ 
+ #define NumXLogInsertSlots	1000
+ 
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by insertpos_lck: */
  	XLogCtlInsert Insert;
  
+ 	XLogInsertSlot *XLogInsertSlots;
+ 
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	XLogwrtResult LogwrtResult;
***************
*** 414,422 **** typedef struct XLogCtlData
  	XLogCtlWrite Write;
  
  	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALInsertLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
--- 506,524 ----
  	XLogCtlWrite Write;
  
  	/*
+ 	 * To change curridx and the identity of a buffer, you need to hold
+ 	 * WALBufMappingLock. To change the identity of a buffer that's
+ 	 * still dirty, the old page needs to be written out first, and for that
+ 	 * you need WALWriteLock, and you need to ensure that there's no
+ 	 * in-progress insertions to the page by calling
+ 	 * WaitXLogInsertionsToFinish().
+ 	 */
+ 	int			curridx;		/* current (latest) block index in cache */
+ 
+ 	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALBufMappingLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
***************
*** 494,521 **** static XLogCtlData *XLogCtl = NULL;
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Macros for managing XLogInsert state.  In most cases, the calling routine
!  * has local copies of XLogCtl->Insert and/or XLogCtl->Insert->curridx,
!  * so these are passed as parameters instead of being fetched via XLogCtl.
   */
  
! /* Free space remaining in the current xlog page buffer */
! #define INSERT_FREESPACE(Insert)  \
! 	(XLOG_BLCKSZ - ((Insert)->currpos - (char *) (Insert)->currpage))
  
- /* Construct XLogRecPtr value for current insertion point */
- #define INSERT_RECPTR(recptr,Insert,curridx)  \
- 	( \
- 	  (recptr).xlogid = XLogCtl->xlblocks[curridx].xlogid, \
- 	  (recptr).xrecoff = \
- 		XLogCtl->xlblocks[curridx].xrecoff - INSERT_FREESPACE(Insert) \
- 	)
  
! #define PrevBufIdx(idx)		\
! 		(((idx) == 0) ? XLogCtl->XLogCacheBlck : ((idx) - 1))
  
! #define NextBufIdx(idx)		\
! 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
--- 596,626 ----
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Calculate the amount of space left on the page after 'endptr'.
!  * Beware multiple evaluation!
   */
+ #define INSERT_FREESPACE(endptr)	\
+ 	(((endptr).xrecoff % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr).xrecoff % XLOG_BLCKSZ))
  
! #define NextBufIdx(idx)		\
! 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  
! #define NextSlotNo(idx)		\
! 		(((idx) == NumXLogInsertSlots - 1) ? 0 : ((idx) + 1))
  
! /*
!  * XLogRecPtrToBufIdx returns the index of the WAL buffer that holds, or
!  * would hold if it was in cache, the page containing 'recptr'.
!  *
!  * XLogRecEndPtrToBufIdx is the same, but a pointer to the first byte of a
!  * page is taken to mean the previous page.
!  */
! #define XLogRecPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogFileSize) + (recptr).xrecoff)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
! 
! #define XLogRecEndPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogFileSize) + (recptr).xrecoff - 1)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
***************
*** 641,649 **** static void KeepLogSeg(XLogRecPtr recptr, uint32 *logId, uint32 *logSeg);
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static bool AdvanceXLInsertBuffer(bool new_segment);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
--- 746,754 ----
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static void AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
***************
*** 690,695 **** static bool read_backup_label(XLogRecPtr *checkPointLoc,
--- 795,816 ----
  static void rm_redo_error_callback(void *arg);
  static int	get_sync_bit(int method);
  
+ static void CopyXLogRecordToWAL(int write_len, bool isLogSwitch,
+ 				  XLogRecord *rechdr,
+ 				  XLogRecData *rdata, pg_crc32 rdata_crc,
+ 				  XLogInsertSlot *myslot,
+ 				  XLogRecPtr StartPos, XLogRecPtr EndPos);
+ static bool ReserveXLogInsertLocation(int size, bool forcePageWrites,
+ 						  bool isLogSwitch,
+ 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
+ 						  XLogRecPtr *EndPos_p,
+ 						  XLogInsertSlot **myslot_p, bool *updrqst_p);
+ static void UpdateSlotCurrPos(volatile XLogInsertSlot *myslot,
+ 				  XLogRecPtr CurrPos);
+ static XLogRecPtr WaitXLogInsertionsToFinish(XLogRecPtr upto);
+ static char *GetXLogBuffer(XLogRecPtr ptr);
+ static XLogRecPtr AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr);
+ 
  
  /*
   * Insert an XLOG record having the specified RMID and info bytes,
***************
*** 710,721 **** XLogRecPtr
  XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
- 	XLogRecord *record;
- 	XLogContRecord *contrecord;
- 	XLogRecPtr	RecPtr;
- 	XLogRecPtr	WriteRqst;
- 	uint32		freespace;
- 	int			curridx;
  	XLogRecData *rdt;
  	XLogRecData *rdt_lastnormal;
  	Buffer		dtbuf[XLR_MAX_BKP_BLOCKS];
--- 831,836 ----
***************
*** 729,739 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  	uint32		len,
  				write_len;
  	unsigned	i;
- 	bool		updrqst;
  	bool		doPageWrites;
! 	bool		isLogSwitch = false;
! 	bool		fpwChange = false;
  	uint8		info_orig = info;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
--- 844,858 ----
  	uint32		len,
  				write_len;
  	unsigned	i;
  	bool		doPageWrites;
! 	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
  	uint8		info_orig = info;
+ 	XLogRecord	rechdr;
+ 	XLogRecPtr	PrevRecord;
+ 	XLogRecPtr	StartPos;
+ 	XLogRecPtr	EndPos;
+ 	XLogInsertSlot *myslot;
+ 	bool		updrqst;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
***************
*** 746,778 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  	TRACE_POSTGRESQL_XLOG_INSERT(rmid, info);
  
  	/*
! 	 * Handle special cases/records.
  	 */
! 	if (rmid == RM_XLOG_ID)
  	{
! 		switch (info)
! 		{
! 			case XLOG_SWITCH:
! 				isLogSwitch = true;
! 				break;
! 
! 			case XLOG_FPW_CHANGE:
! 				fpwChange = true;
! 				break;
! 
! 			default:
! 				break;
! 		}
! 	}
! 	else if (IsBootstrapProcessingMode())
! 	{
! 		/*
! 		 * In bootstrap mode, we don't actually log anything but XLOG resources;
! 		 * return a phony record pointer.
! 		 */
! 		RecPtr.xlogid = 0;
! 		RecPtr.xrecoff = SizeOfXLogLongPHD;		/* start of 1st chkpt record */
! 		return RecPtr;
  	}
  
  	/*
--- 865,878 ----
  	TRACE_POSTGRESQL_XLOG_INSERT(rmid, info);
  
  	/*
! 	 * In bootstrap mode, we don't actually log anything but XLOG resources;
! 	 * return a phony record pointer.
  	 */
! 	if (IsBootstrapProcessingMode() && rmid != RM_XLOG_ID)
  	{
! 		EndPos.xlogid = 0;
! 		EndPos.xrecoff = SizeOfXLogLongPHD;		/* start of 1st chkpt record */
! 		return EndPos;
  	}
  
  	/*
***************
*** 939,1071 **** begin:;
  	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
  		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
! 	START_CRIT_SECTION();
  
! 	/* Now wait to get insert lock */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  
  	/*
! 	 * Check to see if my RedoRecPtr is out of date.  If so, may have to go
! 	 * back and recompute everything.  This can only happen just after a
! 	 * checkpoint, so it's better to be slow in this case and fast otherwise.
! 	 *
! 	 * If we aren't doing full-page writes then RedoRecPtr doesn't actually
! 	 * affect the contents of the XLOG record, so we'll update our local copy
! 	 * but not force a recomputation.
  	 */
! 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr))
  	{
! 		Assert(XLByteLT(RedoRecPtr, Insert->RedoRecPtr));
! 		RedoRecPtr = Insert->RedoRecPtr;
  
! 		if (doPageWrites)
  		{
! 			for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
! 			{
! 				if (dtbuf[i] == InvalidBuffer)
! 					continue;
! 				if (dtbuf_bkp[i] == false &&
! 					XLByteLE(dtbuf_lsn[i], RedoRecPtr))
! 				{
! 					/*
! 					 * Oops, this buffer now needs to be backed up, but we
! 					 * didn't think so above.  Start over.
! 					 */
! 					LWLockRelease(WALInsertLock);
! 					END_CRIT_SECTION();
! 					rdt_lastnormal->next = NULL;
! 					info = info_orig;
! 					goto begin;
! 				}
! 			}
  		}
- 	}
  
! 	/*
! 	 * Also check to see if fullPageWrites or forcePageWrites was just turned on;
! 	 * if we weren't already doing full-page writes then go back and recompute.
! 	 * (If it was just turned off, we could recompute the record without full pages,
! 	 * but we choose not to bother.)
! 	 */
! 	if ((Insert->fullPageWrites || Insert->forcePageWrites) && !doPageWrites)
! 	{
! 		/* Oops, must redo it with full-page data. */
! 		LWLockRelease(WALInsertLock);
! 		END_CRIT_SECTION();
  		rdt_lastnormal->next = NULL;
  		info = info_orig;
  		goto begin;
  	}
! 
! 	/*
! 	 * If there isn't enough space on the current XLOG page for a record
! 	 * header, advance to the next page (leaving the unused space as zeroes).
! 	 */
! 	updrqst = false;
! 	freespace = INSERT_FREESPACE(Insert);
! 	if (freespace < SizeOfXLogRecord)
  	{
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		freespace = INSERT_FREESPACE(Insert);
  	}
  
! 	/* Compute record's XLOG location */
! 	curridx = Insert->curridx;
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
! 	 * segment, we need not insert it (and don't want to because we'd like
! 	 * consecutive switch requests to be no-ops).  Instead, make sure
! 	 * everything is written and flushed through the end of the prior segment,
! 	 * and return the prior segment's end address.
  	 */
! 	if (isLogSwitch &&
! 		(RecPtr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
  	{
! 		/* We can release insert lock immediately */
! 		LWLockRelease(WALInsertLock);
! 
! 		RecPtr.xrecoff -= SizeOfXLogLongPHD;
! 		if (RecPtr.xrecoff == 0)
! 		{
! 			/* crossing a logid boundary */
! 			RecPtr.xlogid -= 1;
! 			RecPtr.xrecoff = XLogFileSize;
! 		}
  
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 		LogwrtResult = XLogCtl->Write.LogwrtResult;
! 		if (!XLByteLE(RecPtr, LogwrtResult.Flush))
! 		{
! 			XLogwrtRqst FlushRqst;
  
! 			FlushRqst.Write = RecPtr;
! 			FlushRqst.Flush = RecPtr;
! 			XLogWrite(FlushRqst, false, false);
! 		}
! 		LWLockRelease(WALWriteLock);
  
! 		END_CRIT_SECTION();
  
! 		return RecPtr;
  	}
  
! 	/* Insert record header */
! 
! 	record = (XLogRecord *) Insert->currpos;
! 	record->xl_prev = Insert->PrevRecord;
! 	record->xl_xid = GetCurrentTransactionIdIfAny();
! 	record->xl_tot_len = SizeOfXLogRecord + write_len;
! 	record->xl_len = len;		/* doesn't include backup blocks */
! 	record->xl_info = info;
! 	record->xl_rmid = rmid;
! 
! 	/* Now we can finish computing the record's CRC */
! 	COMP_CRC32(rdata_crc, (char *) record + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	record->xl_crc = rdata_crc;
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
--- 1039,1146 ----
  	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
  		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
! 	/*
! 	 * Construct record header. We can't CRC it yet, because the prev-link
! 	 * needs to be covered by the CRC and we don't know that yet. We will
! 	 * finish computing the CRC when we do.
! 	 */
! 	MemSet(&rechdr, 0, sizeof(rechdr));
! 	/* rechdr.xl_prev is set later */
! 	rechdr.xl_xid = GetCurrentTransactionIdIfAny();
! 	rechdr.xl_tot_len = SizeOfXLogRecord + write_len;
! 	rechdr.xl_len = len;		/* doesn't include backup blocks */
! 	rechdr.xl_info = info;
! 	rechdr.xl_rmid = rmid;
  
! 	START_CRIT_SECTION();
  
  	/*
! 	 * Try to reserve space for the record from the WAL.
  	 */
! 	if (!ReserveXLogInsertLocation(write_len, doPageWrites, isLogSwitch,
! 								   &PrevRecord, &StartPos, &EndPos,
! 								   (XLogInsertSlot **) &myslot, &updrqst))
  	{
! 		END_CRIT_SECTION();
  
! 		/*
! 		 * If the record is an XLOG_SWITCH, and we were exactly at the start
! 		 * of a segment, we need not insert it (and don't want to because we'd
! 		 * like consecutive switch requests to be no-ops).  Instead, make sure
! 		 * everything is written and flushed through the end of the prior
! 		 * segment, and return the prior segment's end address.
! 		 */
! 		if (isLogSwitch && !XLogRecPtrIsInvalid(EndPos))
  		{
! 			XLogFlush(EndPos);
! 			return EndPos;
  		}
  
! 		/*
! 		 * Oops, must redo it with full-page data. Unlink the backup blocks
! 		 * from the chain and reset info bitmask to undo the changes we've
! 		 * done.
! 		 */
  		rdt_lastnormal->next = NULL;
  		info = info_orig;
  		goto begin;
  	}
! 	else
  	{
! 		/*
! 		 * Finish the record header by setting prev-link (now that we know it),
! 		 * and finish computing the record's CRC (in CopyXLogRecordToWAL). Then
! 		 * copy the record to the space we reserved.
! 		 */
! 		rechdr.xl_prev = PrevRecord;
! 		CopyXLogRecordToWAL(write_len, isLogSwitch, &rechdr,
! 							rdata, rdata_crc, myslot, StartPos, EndPos);
  	}
  
! 	END_CRIT_SECTION();
  
  	/*
! 	 * Update shared LogwrtRqst.Write, if we crossed page boundary.
  	 */
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
  
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, EndPos))
! 			xlogctl->LogwrtRqst.Write = EndPos;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
! 	}
  
! 	/*
! 	 * If this was an XLOG_SWITCH record, flush the record and the empty
! 	 * padding space that fills the rest of the segment, and perform
! 	 * end-of-segment actions (eg, notifying archiver).
! 	 */
! 	if (isLogSwitch)
! 	{
! 		TRACE_POSTGRESQL_XLOG_SWITCH();
  
! 		XLogFlush(EndPos);
  
! 		/*
! 		 * Even though we reserved the rest of the segment for us, which is
! 		 * reflected in EndPos, we return a pointer to just the end of the
! 		 * xlog-switch record.
! 		 */
! 		EndPos.xlogid = StartPos.xlogid;
! 		EndPos.xrecoff = StartPos.xrecoff + SizeOfXLogRecord;
  	}
  
! 	/*
! 	 * Update our global variables
! 	 */
! 	ProcLastRecPtr = StartPos;
! 	XactLastRecEnd = EndPos;
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
***************
*** 1074,1267 **** begin:;
  
  		initStringInfo(&buf);
  		appendStringInfo(&buf, "INSERT @ %X/%X: ",
! 						 RecPtr.xlogid, RecPtr.xrecoff);
! 		xlog_outrec(&buf, record);
  		if (rdata->data != NULL)
  		{
  			appendStringInfo(&buf, " - ");
! 			RmgrTable[record->xl_rmid].rm_desc(&buf, record->xl_info, rdata->data);
  		}
  		elog(LOG, "%s", buf.data);
  		pfree(buf.data);
  	}
  #endif
  
- 	/* Record begin of record in appropriate places */
- 	ProcLastRecPtr = RecPtr;
- 	Insert->PrevRecord = RecPtr;
- 
- 	Insert->currpos += SizeOfXLogRecord;
- 	freespace -= SizeOfXLogRecord;
- 
  	/*
! 	 * Append the data, including backup blocks if any
  	 */
! 	while (write_len)
! 	{
! 		while (rdata->data == NULL)
! 			rdata = rdata->next;
  
! 		if (freespace > 0)
  		{
! 			if (rdata->len > freespace)
  			{
! 				memcpy(Insert->currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				write_len -= freespace;
! 			}
! 			else
! 			{
! 				memcpy(Insert->currpos, rdata->data, rdata->len);
! 				freespace -= rdata->len;
! 				write_len -= rdata->len;
! 				Insert->currpos += rdata->len;
! 				rdata = rdata->next;
! 				continue;
  			}
  		}
  
! 		/* Use next buffer */
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		curridx = Insert->curridx;
! 		/* Insert cont-record header */
! 		Insert->currpage->xlp_info |= XLP_FIRST_IS_CONTRECORD;
! 		contrecord = (XLogContRecord *) Insert->currpos;
! 		contrecord->xl_rem_len = write_len;
! 		Insert->currpos += SizeOfXLogContRecord;
! 		freespace = INSERT_FREESPACE(Insert);
  	}
  
! 	/* Ensure next record will be properly aligned */
! 	Insert->currpos = (char *) Insert->currpage +
! 		MAXALIGN(Insert->currpos - (char *) Insert->currpage);
! 	freespace = INSERT_FREESPACE(Insert);
  
  	/*
! 	 * The recptr I return is the beginning of the *next* record. This will be
! 	 * stored as LSN for changed data pages...
  	 */
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, we must now write and flush all the
! 	 * existing data, and then forcibly advance to the start of the next
! 	 * segment.  It's not good to do this I/O while holding the insert lock,
! 	 * but there seems too much risk of confusion if we try to release the
! 	 * lock sooner.  Fortunately xlog switch needn't be a high-performance
! 	 * operation anyway...
  	 */
! 	if (isLogSwitch)
  	{
! 		XLogCtlWrite *Write = &XLogCtl->Write;
! 		XLogwrtRqst FlushRqst;
! 		XLogRecPtr	OldSegEnd;
  
! 		TRACE_POSTGRESQL_XLOG_SWITCH();
  
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  
  		/*
! 		 * Flush through the end of the page containing XLOG_SWITCH, and
! 		 * perform end-of-segment actions (eg, notifying archiver).
  		 */
! 		WriteRqst = XLogCtl->xlblocks[curridx];
! 		FlushRqst.Write = WriteRqst;
! 		FlushRqst.Flush = WriteRqst;
! 		XLogWrite(FlushRqst, false, true);
! 
! 		/* Set up the next buffer as first page of next segment */
! 		/* Note: AdvanceXLInsertBuffer cannot need to do I/O here */
! 		(void) AdvanceXLInsertBuffer(true);
! 
! 		/* There should be no unwritten data */
! 		curridx = Insert->curridx;
! 		Assert(curridx == Write->curridx);
! 
! 		/* Compute end address of old segment */
! 		OldSegEnd = XLogCtl->xlblocks[curridx];
! 		OldSegEnd.xrecoff -= XLOG_BLCKSZ;
! 		if (OldSegEnd.xrecoff == 0)
  		{
! 			/* crossing a logid boundary */
! 			OldSegEnd.xlogid -= 1;
! 			OldSegEnd.xrecoff = XLogFileSize;
! 		}
  
! 		/* Make it look like we've written and synced all of old segment */
! 		LogwrtResult.Write = OldSegEnd;
! 		LogwrtResult.Flush = OldSegEnd;
  
! 		/*
! 		 * Update shared-memory status --- this code should match XLogWrite
! 		 */
  		{
! 			/* use volatile pointer to prevent code rearrangement */
! 			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			SpinLockAcquire(&xlogctl->info_lck);
! 			xlogctl->LogwrtResult = LogwrtResult;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, LogwrtResult.Write))
! 				xlogctl->LogwrtRqst.Write = LogwrtResult.Write;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Flush, LogwrtResult.Flush))
! 				xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
! 			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		Write->LogwrtResult = LogwrtResult;
  
! 		LWLockRelease(WALWriteLock);
  
! 		updrqst = false;		/* done already */
  	}
! 	else
  	{
! 		/* normal case, ie not xlog switch */
  
! 		/* Need to update shared LogwrtRqst if some block was filled up */
! 		if (freespace < SizeOfXLogRecord)
! 		{
! 			/* curridx is filled and available for writing out */
! 			updrqst = true;
! 		}
! 		else
  		{
! 			/* if updrqst already set, write through end of previous buf */
! 			curridx = PrevBufIdx(curridx);
  		}
- 		WriteRqst = XLogCtl->xlblocks[curridx];
  	}
  
  	/*
! 	 * If the record is an XLOG_FPW_CHANGE, we update full_page_writes
! 	 * in shared memory before releasing WALInsertLock. This ensures that
! 	 * an XLOG_FPW_CHANGE record precedes any WAL record affected
! 	 * by this change of full_page_writes.
  	 */
! 	if (fpwChange)
! 		Insert->fullPageWrites = fullPageWrites;
  
! 	LWLockRelease(WALInsertLock);
  
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
  
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, WriteRqst))
! 			xlogctl->LogwrtRqst.Write = WriteRqst;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
  	}
  
! 	XactLastRecEnd = RecPtr;
  
! 	END_CRIT_SECTION();
  
! 	return RecPtr;
  }
  
  /*
--- 1149,1767 ----
  
  		initStringInfo(&buf);
  		appendStringInfo(&buf, "INSERT @ %X/%X: ",
! 						 EndPos.xlogid, EndPos.xrecoff);
! 		xlog_outrec(&buf, &rechdr);
  		if (rdata->data != NULL)
  		{
  			appendStringInfo(&buf, " - ");
! 			RmgrTable[rmid].rm_desc(&buf, rechdr.xl_info, rdata->data);
  		}
  		elog(LOG, "%s", buf.data);
  		pfree(buf.data);
  	}
  #endif
  
  	/*
! 	 * The recptr I return is the beginning of the *next* record. This will be
! 	 * stored as LSN for changed data pages...
  	 */
! 	return EndPos;
! }
  
! /*
!  * Subroutine of XLogInsert. Copies a WAL record to an already-reserved area
!  * in the WAL.
!  */
! static void
! CopyXLogRecordToWAL(int write_len, bool isLogSwitch, XLogRecord *rechdr,
! 					XLogRecData *rdata, pg_crc32 rdata_crc,
! 					XLogInsertSlot *myslot_p,
! 					XLogRecPtr StartPos, XLogRecPtr EndPos)
! {
! 	volatile XLogInsertSlot *myslot = myslot_p;
! 	char	   *currpos;
! 	XLogRecord *record;
! 	int			freespace;
! 	int			written;
! 	XLogRecPtr	CurrPos;
! 
! 	/* Get the right WAL page to start inserting to */
! 	CurrPos = StartPos;
! 	currpos = GetXLogBuffer(CurrPos);
! 
! 	/* Copy the record header in place, and finish calculating CRC */
! 	record = (XLogRecord *) currpos;
! 	memcpy(record, rechdr, sizeof(XLogRecord));
! 	COMP_CRC32(rdata_crc, currpos + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	record->xl_crc = rdata_crc;
! 
! 	currpos += SizeOfXLogRecord;
! 	XLByteAdvance(CurrPos, SizeOfXLogRecord);
! 
! 	if (!isLogSwitch)
! 	{
! 		/* Copy record data */
! 		written = 0;
! 		freespace = INSERT_FREESPACE(CurrPos);
! 		while (rdata != NULL)
  		{
! 			while (rdata->len > freespace)
  			{
! 				/*
! 				 * Write what fits on this page, then write the continuation
! 				 * record, and continue on the next page.
! 				 */
! 				XLogContRecord *contrecord;
! 
! 				memcpy(currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				written += freespace;
! 				XLByteAdvance(CurrPos, freespace);
! 
! 				/*
! 				 * CurrPos now points to the page boundary, ie. the first byte
! 				 * of the next page. Advertise that as our CurrPos before
! 				 * calling GetXLogBuffer(), because GetXLogBuffer() might need
! 				 * to wait for some insertions to finish so that it can write
! 				 * out a buffer to make room for the new page. Updating CurrPos
! 				 * before waiting for a new buffer ensures that we don't
! 				 * deadlock with ourselves if we run out of clean buffers.
! 				 *
! 				 * However, we must not advance CurrPos past the page header
! 				 * yet, otherwise someone might try to flush up to that point,
! 				 * which would fail if the next page was not initialized yet.
! 				 */
! 				UpdateSlotCurrPos(myslot, CurrPos);
! 
! 				/*
! 				 * Get pointer to beginning of next page, and set the
! 				 * XLP_FIRST_IS_CONTRECORD flag in the page header.
! 				 *
! 				 * It's safe to set the contrecord flag without a lock on the
! 				 * page. All the other flags are set in AdvanceXLInsertBuffer,
! 				 * and we're the only backend that needs to set the contrecord
! 				 * flag.
! 				 */
! 				currpos = GetXLogBuffer(CurrPos);
! 				((XLogPageHeader) currpos)->xlp_info |= XLP_FIRST_IS_CONTRECORD;
! 
! 				/* skip over the page header, and write continuation record */
! 				CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
! 				currpos = GetXLogBuffer(CurrPos);
! 
! 				contrecord = (XLogContRecord *) currpos;
! 				contrecord->xl_rem_len = write_len - written;
! 
! 				currpos += SizeOfXLogContRecord;
! 				CurrPos.xrecoff += SizeOfXLogContRecord;
! 
! 				freespace = INSERT_FREESPACE(CurrPos);
  			}
+ 
+ 			memcpy(currpos, rdata->data, rdata->len);
+ 			currpos += rdata->len;
+ 			XLByteAdvance(CurrPos, rdata->len);
+ 			freespace -= rdata->len;
+ 			written += rdata->len;
+ 
+ 			rdata = rdata->next;
  		}
+ 		Assert(written == write_len);
  
! 		CurrPos.xrecoff = MAXALIGN(CurrPos.xrecoff);
! 		if (CurrPos.xrecoff >= XLogFileSize)
! 		{
! 			/* crossed a logid boundary */
! 			CurrPos.xlogid += 1;
! 			CurrPos.xrecoff = 0;
! 		}
! 		Assert(XLByteEQ(CurrPos, EndPos));
  	}
+ 	else
+ 	{
+ 		/* An xlog-switch record doesn't contain any data besides the header */
+ 		Assert(write_len == 0);
  
! 		/*
! 		 * An xlog-switch record consumes all the remaining space on the
! 		 * WAL segment. We have already reserved it for us, but we still need
! 		 * to make sure it's been allocated and zeroed in the WAL buffers so
! 		 * that when the caller (or someone else) does XLogWrite(), it can
! 		 * really write out all the zeros.
! 		 *
! 		 * We do this one page at a time, to make sure we don't deadlock
! 		 * against ourselves if wal_buffers < XLOG_SEG_SIZE.
! 		 */
! 		while (XLByteLT(CurrPos, EndPos))
! 		{
! 			/* use up all the remaining space in this page */
! 			freespace = INSERT_FREESPACE(CurrPos);
! 			XLByteAdvance(CurrPos, freespace);
! 			/*
! 			 * like in the non-xlog-switch codepath, let others know that
! 			 * we're done writing up to the end of this page
! 			 */
! 			UpdateSlotCurrPos(myslot, CurrPos);
! 			/*
! 			 * let GetXLogBuffer initialize next page if necessary.
! 			 */
! 			CurrPos = AdvanceXLogRecPtrToNextPage(CurrPos);
! 			(void) GetXLogBuffer(CurrPos);
! 		}
! 	}
  
  	/*
! 	 * Done! Clear CurrPos in our slot to let others know that we're
! 	 * finished.
  	 */
! 	UpdateSlotCurrPos(myslot, InvalidXLogRecPtr);
! }
! 
! /*
!  * Reserves the right amount of space for a record of given size from the WAL.
!  * *StartPos_p is set to the beginning of the reserved section, *EndPos_p to
!  * its end, and *Prev_record_p points to the beginning of the previous record
!  * to set to the prev-link of the record header.
!  *
!  * A log-switch record is handled slightly differently. The rest of the
!  * segment will be reserved for this insertion, as indicated by the returned
!  * *EndPos_p value. However, if we are already at the beginning of the current
!  * segment, the *EndPos_p is set to the current location without reserving
!  * any space, and the function returns false.
!  *
!  * *updrqst_p is set to true, if this record ends on different page than
!  * the previous one - the caller should update the shared LogwrtRqst value
!  * after it's done inserting the record in that case, so that the WAL page
!  * that filled up gets written out at the next convenient moment.
!  *
!  * While holding insertpos_lck, sets myslot->CurrPos to the starting position,
!  * (or the end of previous record, to be exact) to let others know that we're
!  * busy inserting to the reserved area. The caller must clear it when the
!  * insertion is finished.
!  *
!  * Returns true on success, or false if RedoRecPtr or forcePageWrites was
!  * changed. On failure, the shared state is not modified.
!  *
!  * This is the performance critical part of XLogInsert that must be serialized
!  * across backends. The rest can happen mostly in parallel.
!  *
!  * NB: The space calculation here must match the code in CopyXLogRecordToWAL,
!  * where we actually copy the record to the reserved space.
!  */
! static bool
! ReserveXLogInsertLocation(int size, bool didPageWrites,
! 						  bool isLogSwitch,
! 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
! 						  XLogRecPtr *EndPos_p,
! 						  XLogInsertSlot **myslot_p, bool *updrqst_p)
! {
! 	volatile XLogInsertSlot *myslot;
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			freespace;
! 	XLogRecPtr	ptr;
! 	XLogRecPtr	StartPos;
! 	XLogRecPtr	LastEndPos;
! 	int32		nextslot;
! 	int32		lastslot;
! 	bool		updrqst = false;
! 
! 	/* log-switch records should contain no data */
! 	Assert(!isLogSwitch || size == 0);
! 
! 	size = SizeOfXLogRecord + size;
! 
! retry:
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 
! 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr) ||
! 		(!didPageWrites && (Insert->forcePageWrites || Insert->fullPageWrites)))
! 	{
! 		/*
! 		 * Oops, a checkpoint just happened, or forcePageWrites was just
! 		 * turned on. Start XLogInsert() all over, because we might have to
! 		 * include more full-page images in the record.
! 		 */
! 		RedoRecPtr = Insert->RedoRecPtr;
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		*EndPos_p = InvalidXLogRecPtr;
! 		return false;
! 	}
  
  	/*
! 	 * Reserve the next insertion slot for us.
! 	 *
! 	 * First check that the slot is not still in use. Modifications to
! 	 * lastslot are protected by WALInsertTailLock, but here we assume that
! 	 * reading an int32 is atomic. Another process might advance lastslot at
! 	 * the same time, but not past nextslot.
  	 */
! 	lastslot = Insert->lastslot;
! 	nextslot = Insert->nextslot;
! 	if (NextSlotNo(nextslot) == lastslot)
  	{
! 		/*
! 		 * Oops, we've "caught our tail" and the oldest slot is still in use.
! 		 * Have to wait for it to become vacant.
! 		 */
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		WaitXLogInsertionsToFinish(InvalidXLogRecPtr);
! 		goto retry;
! 	}
! 	myslot = &XLogCtl->XLogInsertSlots[nextslot];
! 	nextslot = NextSlotNo(nextslot);
  
! 	/*
! 	 * Got the slot, now reserve the right amount of space from the WAL for
! 	 * our record.
! 	 */
! 	LastEndPos = ptr = Insert->CurrPos;
! 	*PrevRecord_p = Insert->PrevRecord;
! 
! 	/*
! 	 * If there isn't enough space on the current XLOG page for a record
! 	 * header, advance to the next page (leaving the unused space as zeroes).
! 	 */
! 	freespace = INSERT_FREESPACE(ptr);
! 	if (freespace < SizeOfXLogRecord)
! 	{
! 		ptr = AdvanceXLogRecPtrToNextPage(ptr);
! 		freespace = INSERT_FREESPACE(ptr);
! 		updrqst = true;
! 	}
  
! 	/*
! 	 * We are now at the starting position of our record. Now figure out how
! 	 * the data will be split across the WAL pages, to calculate where the
! 	 * record ends.
! 	 */
! 	StartPos = ptr;
  
+ 	if (isLogSwitch)
+ 	{
  		/*
! 		 * If the record is an XLOG_SWITCH, and we are exactly at the start
! 		 * of a segment, we need not insert it (and don't want to because
! 		 * we'd like consecutive switch requests to be no-ops). Otherwise the
! 		 * XLOG_SWITCH record should consume all the remaining space on the
! 		 * current segment.
  		 */
! 		if ((ptr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
  		{
! 			/* We can release insert lock immediately */
! 			SpinLockRelease(&Insert->insertpos_lck);
  
! 			ptr.xrecoff -= SizeOfXLogLongPHD;
! 			if (ptr.xrecoff == 0)
! 			{
! 				/* crossing a logid boundary */
! 				ptr.xlogid -= 1;
! 				ptr.xrecoff = XLogFileSize;
! 			}
  
! 			*EndPos_p = ptr;
! 			*StartPos_p = ptr;
! 			*myslot_p = NULL;
! 
! 			return false;
! 		}
! 		else
  		{
! 			if (ptr.xrecoff % XLOG_SEG_SIZE != 0)
! 			{
! 				int segleft = XLOG_SEG_SIZE - (ptr.xrecoff % XLOG_SEG_SIZE);
! 				XLByteAdvance(ptr, segleft);
! 			}
! 			updrqst = true;
! 		}
! 	}
! 	else
! 	{
! 		/* A normal record, ie. not xlog-switch */
! 		int sizeleft = size;
! 		while (freespace < sizeleft)
! 		{
! 			/* fill this page, and continue on next page */
! 			sizeleft -= freespace;
! 			ptr = AdvanceXLogRecPtrToNextPage(ptr);
  
! 			/* account for continuation record header */
! 			ptr.xrecoff += SizeOfXLogContRecord;
! 			freespace = INSERT_FREESPACE(ptr);
! 
! 			updrqst = true;
  		}
+ 		/* the rest fits on this page */
+ 		ptr.xrecoff += sizeleft;
  
! 		/* Align the end position, so that the next record starts aligned */
! 		ptr.xrecoff = MAXALIGN(ptr.xrecoff);
! 		if (ptr.xrecoff >= XLogFileSize)
! 		{
! 			/* crossed a logid boundary */
! 			ptr.xlogid += 1;
! 			ptr.xrecoff = 0;
! 		}
! 	}
  
! 	/* Update the shared state, and our slot, before releasing the lock */
! 	myslot->CurrPos = LastEndPos;
! 	Insert->CurrPos = ptr;
! 	Insert->PrevRecord = StartPos;
! 	Insert->nextslot = nextslot;
! 
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! #ifdef RESERVE_XLOGINSERT_LOCATION_DEBUG
! 	elog(LOG, "reserved xlog: prev %X/%X, start %X/%X, end %X/%X (len %d)",
! 		 PrevRecord_p->xlogid, PrevRecord_p->xrecoff,
! 		 StartPos.xlogid, StartPos.xrecoff,
! 		 ptr.xlogid, ptr.xrecoff,
! 		 size);
! #endif
! 
! 	*EndPos_p = ptr;
! 	*StartPos_p = StartPos;
! 	*myslot_p = (XLogInsertSlot *) myslot;
! 	*updrqst_p = updrqst;
  
! 	return true;
! }
! 
! /*
!  * Update slot's CurrPos variable, and wake up anyone waiting on it.
!  */
! static void
! UpdateSlotCurrPos(volatile XLogInsertSlot *myslot, XLogRecPtr CurrPos)
! {
! 	PGPROC	   *head;
! 
! 	/*
! 	 * The write-barrier ensures that the changes we made to the WAL pages
! 	 * are visible to everyone before the update of CurrPos.
! 	 *
! 	 * XXX: I'm not sure if this is necessary. Does a function call act
! 	 * as an implicit barrier?
! 	 */
! 	pg_write_barrier();
! 
! 	SpinLockAcquire(&myslot->lck);
! 	myslot->CurrPos = CurrPos;
! 	head = myslot->head;
! 	myslot->head = myslot->tail = NULL;
! 	SpinLockRelease(&myslot->lck);
! 	while (head != NULL)
! 	{
! 		PGPROC *proc = head;
! 		head = proc->lwWaitLink;
! 		proc->lwWaitLink = NULL;
! 		proc->lwWaiting = false;
! 		PGSemaphoreUnlock(&proc->sem);
  	}
! }
! 
! /*
!  * Get a pointer to the right location in the WAL buffer containing the
!  * given XLogRecPtr.
!  *
!  * If the page is not initialized yet, it is initialized. That might require
!  * evicting an old dirty buffer from the buffer cache, which means I/O.
!  *
!  * The caller must ensure that the page containing the requested location
!  * isn't evicted yet, and won't be evicted, by holding onto an
!  * XLogInsertSlot with CurrPos set to 'ptr'. Setting it to some value
!  * less than 'ptr' would suffice for GetXLogBuffer(), but risks deadlock:
!  * if we have to evict a buffer, we might have to wait for someone else to
!  * finish a write. And that someone else might not be able to finish the write
!  * if our CurrPos points to a buffer that's still in the buffer cache.
!  */
! static char *
! GetXLogBuffer(XLogRecPtr ptr)
! {
! 	int			idx;
! 	XLogRecPtr	endptr;
! 
! 	/*
! 	 * The XLog buffer cache is organized so that we can easily calculate the
! 	 * buffer a given page must be loaded into from the XLogRecPtr alone.
! 	 * A page must always be loaded to a particular buffer.
! 	 */
! 	idx = XLogRecPtrToBufIdx(ptr);
! 
! 	/*
! 	 * See what page is loaded in the buffer at the moment. It could be the
! 	 * page we're looking for, or something older. It can't be anything
! 	 * newer - that would imply the page we're looking for has already
! 	 * been written out to disk, which shouldn't happen as long as the caller
! 	 * has set its slot's CurrPos correctly.
! 	 *
! 	 * However, we don't hold a lock while we read the value. If someone has
! 	 * just initialized the page, it's possible that we get a "torn read",
! 	 * and read a bogus value. That's ok, we'll grab the mapping lock (in
! 	 * AdvanceXLInsertBuffer) and retry if we see anything else than the page
! 	 * we're looking for. But it means that when we do this unlocked read, we
! 	 * might see a value that appears to be ahead of the page we're looking
! 	 * for. So don't PANIC on that, until we've verified the value while
! 	 * holding the lock.
! 	 */
! 	endptr = XLogCtl->xlblocks[idx];
! 	if (ptr.xlogid != endptr.xlogid ||
! 		!(ptr.xrecoff < endptr.xrecoff &&
! 		  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
  	{
! 		AdvanceXLInsertBuffer(ptr, false);
! 		endptr = XLogCtl->xlblocks[idx];
  
! 		if (ptr.xlogid != endptr.xlogid ||
! 			!(ptr.xrecoff < endptr.xrecoff &&
! 			  ptr.xrecoff >= endptr.xrecoff - XLOG_BLCKSZ))
  		{
! 			elog(PANIC, "could not find WAL buffer for %X/%X",
! 				 ptr.xlogid, ptr.xrecoff);
  		}
  	}
  
  	/*
! 	 * Found the buffer holding this page. Return a pointer to the right
! 	 * offset within the page.
  	 */
! 	return (char *) XLogCtl->pages + idx * (Size) XLOG_BLCKSZ +
! 		ptr.xrecoff % XLOG_BLCKSZ;
! }
  
! /*
!  * Advance an XLogRecPtr to the first valid insertion location on the next
!  * page, right after the page header. An XLogRecPtr pointing to a boundary,
!  * ie. the first byte of a page, is taken to belong to the previous page.
!  */
! static XLogRecPtr
! AdvanceXLogRecPtrToNextPage(XLogRecPtr ptr)
! {
! 	int			freespace;
  
! 	freespace = INSERT_FREESPACE(ptr);
! 	XLByteAdvance(ptr, freespace);
! 	if (ptr.xrecoff % XLogSegSize == 0)
! 		ptr.xrecoff += SizeOfXLogLongPHD;
! 	else
! 		ptr.xrecoff += SizeOfXLogShortPHD;
! 
! 	return ptr;
! }
! 
! /*
!  * Wait for any insertions < upto to finish. If upto is invalid, we wait until
!  * at least one slot is available for insertion.
!  *
!  * Returns a value >= upto, which indicates the oldest in-progress insertion
!  * that we saw in the array, or InvalidXLogRecPtr if there are no insertions
!  * in-progress at exit.
!  */
! static XLogRecPtr
! WaitXLogInsertionsToFinish(XLogRecPtr upto)
! {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			lastslot;
! 	int			nextslot;
! 	XLogRecPtr	LastPos = InvalidXLogRecPtr;
! 	int			extraWaits = 0;
! 
! 	if (MyProc == NULL)
! 		elog(PANIC, "cannot wait without a PGPROC structure");
! 
! retry:
! 	/*
! 	 * Read lastslot and nextslot. lastslot cannot change while we hold the
! 	 * tail-lock. nextslot can advance while we run, but it not beyond
! 	 * lastslot - 1. We still have to acquire insertpos_lck to make sure that
! 	 * we see the CurrPos of the latest slot correctly.
! 	 */
! 	LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
! 	lastslot = Insert->lastslot;
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	nextslot = Insert->nextslot;
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! 	while (lastslot != nextslot)
  	{
! 		/*
! 		 * Examine the oldest slot still in use.
! 		 */
! 		volatile XLogInsertSlot *slot;
! 		XLogRecPtr	slotptr;
  
! 		slot = &XLogCtl->XLogInsertSlots[lastslot];
! 		SpinLockAcquire(&slot->lck);
! 		slotptr = slot->CurrPos;
! 
! 		if (XLogRecPtrIsInvalid(slotptr))
! 		{
! 			/*
! 			 * The insertion has already finished, we just need to advance
! 			 * lastslot to make the slot available for reuse.
! 			 */
! 			SpinLockRelease(&slot->lck);
! 			lastslot = NextSlotNo(lastslot);
! 			continue;
! 		}
! 		else
! 		{
! 			/*
! 			 * The insertion is still in-progress. If we just needed for
! 			 * any slot to become available and there is at least one slot
! 			 * free already, or if this slot's CurrPos >= upto, we can
! 			 * stop here. Otherwise we have to wait for it to finish.
! 			 */
! 			if ((XLogRecPtrIsInvalid(upto) && NextSlotNo(nextslot) != lastslot)
! 				|| (!XLogRecPtrIsInvalid(upto) && XLByteLE(upto, slotptr)))
! 			{
! 				SpinLockRelease(&slot->lck);
! 				LastPos = slotptr;
! 				break;
! 			}
! 			else
! 			{
! 				/* Wait for this insertion to finish. */
! 				MyProc->lwWaiting = true;
! 				MyProc->lwWaitMode = 0; /* doesn't matter */
! 				MyProc->lwWaitLink = NULL;
! 				if (slot->head == NULL)
! 					slot->head = MyProc;
! 				else
! 					slot->tail->lwWaitLink = MyProc;
! 				slot->tail = MyProc;
! 				SpinLockRelease(&slot->lck);
! 
! 				Insert->lastslot = lastslot;
! 				LWLockRelease(WALInsertTailLock);
! 				for (;;)
! 				{
! 					PGSemaphoreLock(&MyProc->sem, false);
! 					if (!MyProc->lwWaiting)
! 						break;
! 					extraWaits++;
! 				}
! 
! 				/*
! 				 * The insertion has now finished. Start all over. While we
! 				 * were not holding the tail-lock, someone might've filled up
! 				 * all slots again.
! 				 */
! 				goto retry;
! 			}
! 		}
  	}
  
! 	/* Update lastslot before we release the lock */
! 	Insert->lastslot = lastslot;
! 	LWLockRelease(WALInsertTailLock);
  
! 	while (extraWaits-- > 0)
! 		PGSemaphoreUnlock(&MyProc->sem);
  
! 	return LastPos;
  }
  
  /*
***************
*** 1488,1522 **** XLogArchiveCleanup(const char *xlog)
  }
  
  /*
!  * Advance the Insert state to the next buffer page, writing out the next
!  * buffer if it still contains unwritten data.
!  *
!  * If new_segment is TRUE then we set up the next buffer page as the first
!  * page of the next xlog segment file, possibly but not usually the next
!  * consecutive file page.
!  *
!  * The global LogwrtRqst.Write pointer needs to be advanced to include the
!  * just-filled page.  If we can do this for free (without an extra lock),
!  * we do so here.  Otherwise the caller must do it.  We return TRUE if the
!  * request update still needs to be done, FALSE if we did it internally.
!  *
!  * Must be called with WALInsertLock held.
   */
! static bool
! AdvanceXLInsertBuffer(bool new_segment)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	XLogCtlWrite *Write = &XLogCtl->Write;
! 	int			nextidx = NextBufIdx(Insert->curridx);
! 	bool		update_needed = true;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
! 	XLogRecPtr	NewPageEndPtr;
  	XLogPageHeader NewPage;
  
! 	/* Use Insert->LogwrtResult copy if it's more fresh */
! 	if (XLByteLT(LogwrtResult.Write, Insert->LogwrtResult.Write))
! 		LogwrtResult = Insert->LogwrtResult;
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
--- 1988,2021 ----
  }
  
  /*
!  * Initialize XLOG buffers, writing out old buffers if they still contain
!  * unwritten data, upto the page containing 'upto'. Or if 'opportunistic' is
!  * true, initialize as many pages as we can without having to write out
!  * unwritten data. Any new pages are initialized to zeros, with pages headers
!  * initialized properly.
   */
! static void
! AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			nextidx;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
! 	XLogRecPtr	NewPageEndPtr = InvalidXLogRecPtr;
  	XLogPageHeader NewPage;
+ 	bool		needflush;
+ 	int			npages = 0;
  
! 	LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
! 
! 	/*
! 	 * Now that we have the lock, check if someone initialized the page
! 	 * already.
! 	 */
! /* XXX: fix indentation before commit */
! while (!XLByteLT(upto, XLogCtl->xlblocks[XLogCtl->curridx]) || opportunistic)
! {
! 	nextidx = NextBufIdx(XLogCtl->curridx);
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
***************
*** 1524,1535 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
- 	if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
- 	{
- 		/* nope, got work to do... */
- 		XLogRecPtr	FinishedPageRqstPtr;
  
! 		FinishedPageRqstPtr = XLogCtl->xlblocks[Insert->curridx];
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
--- 2023,2039 ----
  	 * written out.
  	 */
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
  
! 	needflush = !XLByteLE(OldPageRqstPtr, LogwrtResult.Write);
! 
! 	if (needflush)
! 	{
! 		/*
! 		 * Nope, got work to do. If we just want to pre-initialize as much as
! 		 * we can without flushing, give up now.
! 		 */
! 		if (opportunistic)
! 			break;
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
***************
*** 1537,1581 **** AdvanceXLInsertBuffer(bool new_segment)
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, FinishedPageRqstPtr))
! 				xlogctl->LogwrtRqst.Write = FinishedPageRqstPtr;
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		update_needed = false;	/* Did the shared-request update */
! 
! 		if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/* OK, someone wrote it already */
! 			Insert->LogwrtResult = LogwrtResult;
! 		}
! 		else
! 		{
! 			/* Must acquire write lock */
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 			LogwrtResult = Write->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding insert lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false, false);
  				LWLockRelease(WALWriteLock);
- 				Insert->LogwrtResult = LogwrtResult;
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
  		}
  	}
  
--- 2041,2090 ----
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, OldPageRqstPtr))
! 			{
! 				Assert(XLByteLE(OldPageRqstPtr, xlogctl->Insert.CurrPos));
! 				xlogctl->LogwrtRqst.Write = OldPageRqstPtr;
! 			}
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
! 		if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/*
! 			 * Must acquire write lock. Release WALBufMappingLock first, to
! 			 * make sure that all insertions that we need to wait for can
! 			 * finish (up to this same position). Otherwise we risk deadlock.
! 			 */
! 			LWLockRelease(WALBufMappingLock);
! 
! 			WaitXLogInsertionsToFinish(OldPageRqstPtr);
! 
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 			LogwrtResult = XLogCtl->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  			{
  				/* OK, someone wrote it already */
  				LWLockRelease(WALWriteLock);
  			}
  			else
  			{
  				/*
! 				 * Have to write buffers while holding mapping lock. This is
  				 * not good, so only write as much as we absolutely must.
  				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false);
  				LWLockRelease(WALWriteLock);
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
+ 			/* Re-acquire WALBufMappingLock and retry */
+ 			LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
+ 			continue;
  		}
  	}
  
***************
*** 1583,1596 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[Insert->curridx];
! 
! 	if (new_segment)
! 	{
! 		/* force it to a segment start point */
! 		NewPageEndPtr.xrecoff += XLogSegSize - 1;
! 		NewPageEndPtr.xrecoff -= NewPageEndPtr.xrecoff % XLogSegSize;
! 	}
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
--- 2092,2098 ----
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[XLogCtl->curridx];
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
***************
*** 1600,1612 **** AdvanceXLInsertBuffer(bool new_segment)
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
! 	XLogCtl->xlblocks[nextidx] = NewPageEndPtr;
! 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
! 
! 	Insert->curridx = nextidx;
! 	Insert->currpage = NewPage;
  
! 	Insert->currpos = ((char *) NewPage) +SizeOfXLogShortPHD;
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
--- 2102,2111 ----
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
! 	Assert(NewPageEndPtr.xrecoff % XLOG_BLCKSZ == 0);
! 	Assert(XLogRecEndPtrToBufIdx(NewPageEndPtr) == nextidx);
  
! 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
***************
*** 1650,1660 **** AdvanceXLInsertBuffer(bool new_segment)
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
- 
- 		Insert->currpos = ((char *) NewPage) +SizeOfXLogLongPHD;
  	}
  
! 	return update_needed;
  }
  
  /*
--- 2149,2176 ----
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
  	}
  
! 	/*
! 	 * Make sure the initialization of the page becomes visible to others
! 	 * before the xlblocks update. GetXLogBuffer() reads xlblocks without
! 	 * holding a lock.
! 	 */
! 	pg_write_barrier();
! 
! 	*((volatile XLogRecPtr *) &XLogCtl->xlblocks[nextidx]) = NewPageEndPtr;
! 
! 	XLogCtl->curridx = nextidx;
! 
! 	npages++;
! }
! 	LWLockRelease(WALBufMappingLock);
! 
! #ifdef WAL_DEBUG
! 	if (npages > 0)
! 		elog(DEBUG1, "initialized %d pages, upto %X/%X",
! 			 npages, NewPageEndPtr.xlogid, NewPageEndPtr.xrecoff);
! #endif
  }
  
  /*
***************
*** 1699,1714 **** XLogCheckpointNeeded(uint32 logid, uint32 logseg)
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * If xlog_switch == TRUE, we are intending an xlog segment switch, so
!  * perform end-of-segment actions after writing the last page, even if
!  * it's not physically the end of its segment.  (NB: this will work properly
!  * only if caller specifies WriteRqst == page-end and flexible == false,
!  * and there is some data to write.)
!  *
!  * Must be called with WALWriteLock held.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
--- 2215,2226 ----
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * Must be called with WALWriteLock held. And you must've called
!  * WaitXLogInsertionsToFinish(WriteRqst) before grabbing the lock to make sure
!  * the data is ready to write.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
***************
*** 1726,1732 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  	/*
  	 * Update local LogwrtResult (caller probably did this already, but...)
  	 */
! 	LogwrtResult = Write->LogwrtResult;
  
  	/*
  	 * Since successive pages in the xlog cache are consecutively allocated,
--- 2238,2244 ----
  	/*
  	 * Update local LogwrtResult (caller probably did this already, but...)
  	 */
! 	LogwrtResult = XLogCtl->LogwrtResult;
  
  	/*
  	 * Since successive pages in the xlog cache are consecutively allocated,
***************
*** 1757,1770 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  		 * if we're passed a bogus WriteRqst.Write that is past the end of the
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
! 		if (!XLByteLT(LogwrtResult.Write, XLogCtl->xlblocks[curridx]))
  			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
! 				 XLogCtl->xlblocks[curridx].xlogid,
! 				 XLogCtl->xlblocks[curridx].xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
! 		LogwrtResult.Write = XLogCtl->xlblocks[curridx];
  		ispartialpage = XLByteLT(WriteRqst.Write, LogwrtResult.Write);
  
  		if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
--- 2269,2282 ----
  		 * if we're passed a bogus WriteRqst.Write that is past the end of the
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
! 		XLogRecPtr EndPtr = XLogCtl->xlblocks[curridx];
! 		if (!XLByteLT(LogwrtResult.Write, EndPtr))
  			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
! 				 EndPtr.xlogid, EndPtr.xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
! 		LogwrtResult.Write = EndPtr;
  		ispartialpage = XLByteLT(WriteRqst.Write, LogwrtResult.Write);
  
  		if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
***************
*** 1861,1876 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
- 			 * We also do this if this is the last page written for an xlog
- 			 * switch.
- 			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg || (xlog_switch && last_iteration))
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
--- 2373,2385 ----
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg)
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
***************
*** 1960,1967 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  			xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
  		SpinLockRelease(&xlogctl->info_lck);
  	}
- 
- 	Write->LogwrtResult = LogwrtResult;
  }
  
  /*
--- 2469,2474 ----
***************
*** 2124,2131 **** XLogFlush(XLogRecPtr record)
  	 */
  	for (;;)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
  		volatile XLogCtlData *xlogctl = XLogCtl;
  
  		/* read LogwrtResult and update local state */
  		SpinLockAcquire(&xlogctl->info_lck);
--- 2631,2642 ----
  	 */
  	for (;;)
  	{
! 		/* use volatile pointers to prevent code rearrangement */
  		volatile XLogCtlData *xlogctl = XLogCtl;
+ 		volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 		uint32		freespace;
+ 		XLogRecPtr	insertpos,
+ 					inprogresspos;
  
  		/* read LogwrtResult and update local state */
  		SpinLockAcquire(&xlogctl->info_lck);
***************
*** 2139,2144 **** XLogFlush(XLogRecPtr record)
--- 2650,2686 ----
  			break;
  
  		/*
+ 		 * Get the current insert position.
+ 		 *
+ 		 * XXX: This used to do LWLockConditionalAcquire(WALInsertLock),
+ 		 * fall back to writing just up to 'record' if we couldn't get t
+ 		 * lock. I wonder if it would be a good idea to have a
+ 		 * SpinLockConditionalAcquire function and use that? On one hand
+ 		 * it would be good to not cause more contention on the lock if
+ 		 * busy, but on the other hand, this spinlock is much more light
+ 		 * than the WALInsertLock was, so maybe it's better to just grab
+ 		 * spinlock. Also note that if we stored the XLogRecPtr as one 6
+ 		 * integer, we could just read it with no lock on platforms wher
+ 		 * 64-bit integer accesses are atomic, which covers many common
+ 		 * platforms nowadays.
+ 		 */
+ 		SpinLockAcquire(&Insert->insertpos_lck);
+ 		insertpos = Insert->CurrPos;
+ 		SpinLockRelease(&Insert->insertpos_lck);
+ 
+ 		freespace = INSERT_FREESPACE(insertpos);
+ 		if (freespace < SizeOfXLogRecord)               /* buffer is full */
+ 			insertpos.xrecoff += freespace;
+ 
+ 		/*
+ 		 * Before actually performing the write, wait for all in-flight
+ 		 * insertions to the pages we're about to write to finish.
+ 		 */
+ 		inprogresspos = WaitXLogInsertionsToFinish(WriteRqstPtr);
+ 		if (!XLogRecPtrIsInvalid(inprogresspos))
+ 			insertpos = inprogresspos;
+ 
+ 		/*
  		 * Try to get the write lock. If we can't get it immediately, wait
  		 * until it's released, and recheck if we still need to do the flush
  		 * or if the backend that held the lock did it for us already. This
***************
*** 2155,2186 **** XLogFlush(XLogRecPtr record)
  			continue;
  		}
  		/* Got the lock */
! 		LogwrtResult = XLogCtl->Write.LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			/* try to write/flush later additions to XLOG as well */
! 			if (LWLockConditionalAcquire(WALInsertLock, LW_EXCLUSIVE))
! 			{
! 				XLogCtlInsert *Insert = &XLogCtl->Insert;
! 				uint32		freespace = INSERT_FREESPACE(Insert);
  
! 				if (freespace < SizeOfXLogRecord)		/* buffer is full */
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 				else
! 				{
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 					WriteRqstPtr.xrecoff -= freespace;
! 				}
! 				LWLockRelease(WALInsertLock);
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = WriteRqstPtr;
! 			}
! 			else
! 			{
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = record;
! 			}
! 			XLogWrite(WriteRqst, false, false);
  		}
  		LWLockRelease(WALWriteLock);
  		/* done */
--- 2697,2709 ----
  			continue;
  		}
  		/* Got the lock */
! 		LogwrtResult = XLogCtl->LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			WriteRqst.Write = insertpos;
! 			WriteRqst.Flush = insertpos;
  
! 			XLogWrite(WriteRqst, false);
  		}
  		LWLockRelease(WALWriteLock);
  		/* done */
***************
*** 2292,2314 **** XLogBackgroundFlush(void)
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
- 
  	START_CRIT_SECTION();
  
! 	/* now wait for the write lock */
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 	LogwrtResult = XLogCtl->Write.LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
  	{
  		XLogwrtRqst WriteRqst;
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible, false);
  	}
! 	LWLockRelease(WALWriteLock);
  
  	END_CRIT_SECTION();
  }
  
  /*
--- 2815,2845 ----
  			 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
  			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
  #endif
  	START_CRIT_SECTION();
  
! 	/* now wait for any in-progress insertions to finish and get write lock */
! 	WaitXLogInsertionsToFinish(WriteRqstPtr);
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 	LogwrtResult = XLogCtl->LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
  	{
  		XLogwrtRqst WriteRqst;
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible);
  	}
! 	LogwrtResult = XLogCtl->LogwrtResult;
  
  	END_CRIT_SECTION();
+ 
+ 	LWLockRelease(WALWriteLock);
+ 
+ 	/*
+ 	 * Great, done. To take some work off the critical path, try to initialize
+ 	 * as many of the no-longer-needed WAL buffers for future use as we can.
+ 	 */
+ 	AdvanceXLInsertBuffer(InvalidXLogRecPtr, true);
  }
  
  /*
***************
*** 5102,5107 **** XLOGShmemSize(void)
--- 5633,5641 ----
  	/* and the buffers themselves */
  	size = add_size(size, mul_size(XLOG_BLCKSZ, XLOGbuffers));
  
+ 	/* XLog insertion slots */
+ 	size = add_size(size, mul_size(sizeof(XLogInsertSlot), NumXLogInsertSlots));
+ 
  	/*
  	 * Note: we don't count ControlFileData, it comes out of the "slop factor"
  	 * added by CreateSharedMemoryAndSemaphores.  This lets us use this
***************
*** 5117,5122 **** XLOGShmemInit(void)
--- 5651,5657 ----
  	bool		foundCFile,
  				foundXLog;
  	char	   *allocptr;
+ 	int			i;
  
  	ControlFile = (ControlFileData *)
  		ShmemInitStruct("Control File", sizeof(ControlFileData), &foundCFile);
***************
*** 5142,5147 **** XLOGShmemInit(void)
--- 5677,5695 ----
  	memset(XLogCtl->xlblocks, 0, sizeof(XLogRecPtr) * XLOGbuffers);
  	allocptr += sizeof(XLogRecPtr) * XLOGbuffers;
  
+ 	/* Initialize insertion slots */
+ 	XLogCtl->XLogInsertSlots = (XLogInsertSlot *) allocptr;
+ 	for (i = 0; i < NumXLogInsertSlots; i++)
+ 	{
+ 		XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[i];
+ 		slot->CurrPos = InvalidXLogRecPtr;
+ 		slot->head = slot->tail = NULL;
+ 		SpinLockInit(&slot->lck);
+ 	}
+ 	XLogCtl->Insert.nextslot = 0;
+ 	XLogCtl->Insert.lastslot = 0;
+ 	allocptr += sizeof(XLogInsertSlot) * NumXLogInsertSlots;
+ 
  	/*
  	 * Align the start of the page buffers to an ALIGNOF_XLOG_BUFFER boundary.
  	 */
***************
*** 5156,5166 **** XLOGShmemInit(void)
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
- 	XLogCtl->Insert.currpage = (XLogPageHeader) (XLogCtl->pages);
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
--- 5704,5715 ----
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
  
+ 	SpinLockInit(&XLogCtl->Insert.insertpos_lck);
+ 
  	/*
  	 * If we are not in bootstrap mode, pg_control should already exist. Read
  	 * and validate it immediately (see comments in ReadControlFile() for the
***************
*** 6038,6043 **** StartupXLOG(void)
--- 6587,6593 ----
  	bool		backupEndRequired = false;
  	bool		backupFromStandby = false;
  	DBState		dbstate_at_startup;
+ 	int			firstIdx;
  
  	/*
  	 * Read control file and check XLOG status looks valid.
***************
*** 6844,6851 **** StartupXLOG(void)
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 	XLogCtl->xlblocks[0].xlogid = openLogId;
! 	XLogCtl->xlblocks[0].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
--- 7394,7405 ----
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 
! 	firstIdx = XLogRecPtrToBufIdx(EndOfLog);
! 	XLogCtl->curridx = firstIdx;
! 
! 	XLogCtl->xlblocks[firstIdx].xlogid = openLogId;
! 	XLogCtl->xlblocks[firstIdx].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
***************
*** 6853,6878 **** StartupXLOG(void)
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[0].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) Insert->currpage, readBuf, XLOG_BLCKSZ);
! 	Insert->currpos = (char *) Insert->currpage +
! 		(EndOfLog.xrecoff + XLOG_BLCKSZ - XLogCtl->xlblocks[0].xrecoff);
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
- 	XLogCtl->Write.LogwrtResult = LogwrtResult;
- 	Insert->LogwrtResult = LogwrtResult;
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(Insert->currpos, 0, freespace);
! 		XLogCtl->Write.curridx = 0;
  	}
  	else
  	{
--- 7407,7429 ----
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[firstIdx].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) &XLogCtl->pages[firstIdx * XLOG_BLCKSZ], readBuf, XLOG_BLCKSZ);
! 	Insert->CurrPos = EndOfLog;
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
  	XLogCtl->LogwrtResult = LogwrtResult;
  
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = XLOG_BLCKSZ - EndOfLog.xrecoff % XLOG_BLCKSZ;
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(&XLogCtl->pages[firstIdx * XLOG_BLCKSZ] + EndOfLog.xrecoff % XLOG_BLCKSZ, 0, freespace);
! 		XLogCtl->Write.curridx = firstIdx;
  	}
  	else
  	{
***************
*** 6884,6890 **** StartupXLOG(void)
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(0);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
--- 7435,7441 ----
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(firstIdx);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
***************
*** 7390,7396 **** GetRedoRecPtr(void)
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire WALInsertLock which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
--- 7941,7947 ----
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire insertpos_lck which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
***************
*** 7666,7671 **** CreateCheckPoint(int flags)
--- 8217,8223 ----
  	uint32		insert_logSeg;
  	TransactionId *inCommitXids;
  	int			nInCommit;
+ 	XLogRecPtr	curInsert;
  
  	/*
  	 * An end-of-recovery checkpoint is really a shutdown checkpoint, just
***************
*** 7734,7743 **** CreateCheckPoint(int flags)
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * We must hold WALInsertLock while examining insert state to determine
! 	 * the checkpoint REDO pointer.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
--- 8286,8295 ----
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * Determine the checkpoint REDO pointer.
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	curInsert = Insert->CurrPos;
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
***************
*** 7749,7755 **** CreateCheckPoint(int flags)
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding the WALInsertLock we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
--- 8301,8307 ----
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding insertpos_lck we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
***************
*** 7758,7772 **** CreateCheckPoint(int flags)
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
- 		XLogRecPtr	curInsert;
- 
- 		INSERT_RECPTR(curInsert, Insert, Insert->curridx);
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			LWLockRelease(WALInsertLock);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
--- 8310,8321 ----
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
***************
*** 7793,7806 **** CreateCheckPoint(int flags)
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace < SizeOfXLogRecord)
! 	{
! 		(void) AdvanceXLInsertBuffer(false);
! 		/* OK to ignore update return flag, since we will do flush anyway */
! 		freespace = INSERT_FREESPACE(Insert);
! 	}
! 	INSERT_RECPTR(checkPoint.redo, Insert, Insert->curridx);
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
--- 8342,8351 ----
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(curInsert);
  	if (freespace < SizeOfXLogRecord)
! 		curInsert = AdvanceXLogRecPtrToNextPage(curInsert);
! 	checkPoint.redo = curInsert;
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
***************
*** 7826,7832 **** CreateCheckPoint(int flags)
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
--- 8371,8377 ----
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
***************
*** 7846,7852 **** CreateCheckPoint(int flags)
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released WALInsertLock, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
--- 8391,8397 ----
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released insertpos_lck, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
***************
*** 8213,8227 **** CreateRestartPoint(int flags)
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * You need to hold WALInsertLock and info_lck to update it, although
! 	 * during recovery acquiring WALInsertLock is just pro forma, because
! 	 * there is no other processes updating Insert.RedoRecPtr.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * Prepare to accumulate statistics.
--- 8758,8772 ----
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * Like in CreateCheckPoint(), you need both insertpos_lck and info_lck
! 	 * to update it, although during recovery acquiring insertpos_lck is just
! 	 * pro forma, because no WAL insertions are happening.
  	 */
! 	SpinLockAcquire(&xlogctl->Insert.insertpos_lck);
  	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
! 	SpinLockRelease(&xlogctl->Insert.insertpos_lck);
  
  	/*
  	 * Prepare to accumulate statistics.
***************
*** 8412,8418 **** XLogPutNextOid(Oid nextOid)
  XLogRecPtr
  RequestXLogSwitch(void)
  {
! 	XLogRecPtr	RecPtr;
  	XLogRecData rdata;
  
  	/* XLOG SWITCH, alone among xlog record types, has no data */
--- 8957,8963 ----
  XLogRecPtr
  RequestXLogSwitch(void)
  {
! 	XLogRecPtr	EndPos;
  	XLogRecData rdata;
  
  	/* XLOG SWITCH, alone among xlog record types, has no data */
***************
*** 8421,8429 **** RequestXLogSwitch(void)
  	rdata.len = 0;
  	rdata.next = NULL;
  
! 	RecPtr = XLogInsert(RM_XLOG_ID, XLOG_SWITCH, &rdata);
  
! 	return RecPtr;
  }
  
  /*
--- 8966,8979 ----
  	rdata.len = 0;
  	rdata.next = NULL;
  
! 	EndPos = XLogInsert(RM_XLOG_ID, XLOG_SWITCH, &rdata);
  
! 	/*
! 	 * XLogInsert returns a pointer to the end of segment, but we want
! 	 * to return a pointer to just the end of the xlog-switch record. The
! 	 * rest of the segment is padded out.
! 	 */
! 	return EndPos;
  }
  
  /*
***************
*** 8501,8522 **** XLogReportParameters(void)
  /*
   * Update full_page_writes in shared memory, and write an
   * XLOG_FPW_CHANGE record if necessary.
   */
  void
  UpdateFullPageWrites(void)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  
  	/*
  	 * Do nothing if full_page_writes has not been changed.
  	 *
  	 * It's safe to check the shared full_page_writes without the lock,
! 	 * because we can guarantee that there is no concurrently running
! 	 * process which can update it.
  	 */
  	if (fullPageWrites == Insert->fullPageWrites)
  		return;
  
  	/*
  	 * Write an XLOG_FPW_CHANGE record. This allows us to keep
  	 * track of full_page_writes during archive recovery, if required.
--- 9051,9091 ----
  /*
   * Update full_page_writes in shared memory, and write an
   * XLOG_FPW_CHANGE record if necessary.
+  *
+  * Note: this function assumes there is no other process running
+  * concurrently that could update it.
   */
  void
  UpdateFullPageWrites(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  
  	/*
  	 * Do nothing if full_page_writes has not been changed.
  	 *
  	 * It's safe to check the shared full_page_writes without the lock,
! 	 * because we assume that there is no concurrently running process
! 	 * which can update it.
  	 */
  	if (fullPageWrites == Insert->fullPageWrites)
  		return;
  
+ 	START_CRIT_SECTION();
+ 
+ 	/*
+ 	 * It's always safe to take full page images, even when not strictly
+ 	 * required, but not the other round. So if we're setting full_page_writes
+ 	 * to true, first set it true and then write the WAL record. If we're
+ 	 * setting it to false, first write the WAL record and then set the
+ 	 * global flag.
+ 	 */
+ 	if (fullPageWrites)
+ 	{
+ 		SpinLockAcquire(&Insert->insertpos_lck);
+ 		Insert->fullPageWrites = true;
+ 		SpinLockRelease(&Insert->insertpos_lck);
+ 	}
+ 
  	/*
  	 * Write an XLOG_FPW_CHANGE record. This allows us to keep
  	 * track of full_page_writes during archive recovery, if required.
***************
*** 8532,8543 **** UpdateFullPageWrites(void)
  
  		XLogInsert(RM_XLOG_ID, XLOG_FPW_CHANGE, &rdata);
  	}
! 	else
  	{
! 		LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 		Insert->fullPageWrites = fullPageWrites;
! 		LWLockRelease(WALInsertLock);
  	}
  }
  
  /*
--- 9101,9114 ----
  
  		XLogInsert(RM_XLOG_ID, XLOG_FPW_CHANGE, &rdata);
  	}
! 
! 	if (!fullPageWrites)
  	{
! 		SpinLockAcquire(&Insert->insertpos_lck);
! 		Insert->fullPageWrites = false;
! 		SpinLockRelease(&Insert->insertpos_lck);
  	}
+ 	END_CRIT_SECTION();
  }
  
  /*
***************
*** 9063,9068 **** issue_xlog_fsync(int fd, uint32 log, uint32 seg)
--- 9634,9640 ----
  XLogRecPtr
  do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	bool		backup_started_in_recovery = false;
  	XLogRecPtr	checkpointloc;
***************
*** 9125,9150 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  	 * Note that forcePageWrites has no effect during an online backup from
  	 * the standby.
  	 *
! 	 * We must hold WALInsertLock to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
! 		if (XLogCtl->Insert.exclusiveBackup)
  		{
! 			LWLockRelease(WALInsertLock);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		XLogCtl->Insert.exclusiveBackup = true;
  	}
  	else
! 		XLogCtl->Insert.nonExclusiveBackups++;
! 	XLogCtl->Insert.forcePageWrites = true;
! 	LWLockRelease(WALInsertLock);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
--- 9697,9722 ----
  	 * Note that forcePageWrites has no effect during an online backup from
  	 * the standby.
  	 *
! 	 * We must hold insertpos_lck to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
! 		if (Insert->exclusiveBackup)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		Insert->exclusiveBackup = true;
  	}
  	else
! 		Insert->nonExclusiveBackups++;
! 	Insert->forcePageWrites = true;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
***************
*** 9257,9269 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			LWLockAcquire(WALInsertLock, LW_SHARED);
! 			if (XLByteLT(XLogCtl->Insert.lastBackupStart, startpoint))
  			{
! 				XLogCtl->Insert.lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			LWLockRelease(WALInsertLock);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
--- 9829,9841 ----
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			SpinLockAcquire(&Insert->insertpos_lck);
! 			if (XLByteLT(Insert->lastBackupStart, startpoint))
  			{
! 				Insert->lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			SpinLockRelease(&Insert->insertpos_lck);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
***************
*** 9347,9373 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
! 		Assert(XLogCtl->Insert.exclusiveBackup);
! 		XLogCtl->Insert.exclusiveBackup = false;
  	}
  	else
  	{
! 		Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 		XLogCtl->Insert.nonExclusiveBackups--;
  	}
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 9919,9946 ----
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
! 		Assert(Insert->exclusiveBackup);
! 		Insert->exclusiveBackup = false;
  	}
  	else
  	{
! 		Assert(Insert->nonExclusiveBackups > 0);
! 		Insert->nonExclusiveBackups--;
  	}
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9380,9385 **** pg_start_backup_callback(int code, Datum arg)
--- 9953,9959 ----
  XLogRecPtr
  do_pg_stop_backup(char *labelfile, bool waitforarchive)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	bool		backup_started_in_recovery = false;
  	XLogRecPtr	startpoint;
***************
*** 9433,9441 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
! 		XLogCtl->Insert.exclusiveBackup = false;
  	else
  	{
  		/*
--- 10007,10015 ----
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
! 		Insert->exclusiveBackup = false;
  	else
  	{
  		/*
***************
*** 9444,9459 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 		XLogCtl->Insert.nonExclusiveBackups--;
  	}
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  
  	if (exclusive)
  	{
--- 10018,10033 ----
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(Insert->nonExclusiveBackups > 0);
! 		Insert->nonExclusiveBackups--;
  	}
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	if (exclusive)
  	{
***************
*** 9731,9746 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  void
  do_pg_abort_backup(void)
  {
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 	Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 	XLogCtl->Insert.nonExclusiveBackups--;
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 10305,10322 ----
  void
  do_pg_abort_backup(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	Assert(Insert->nonExclusiveBackups > 0);
! 	Insert->nonExclusiveBackups--;
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9794,9805 **** GetStandbyFlushRecPtr(void)
  XLogRecPtr
  GetXLogInsertRecPtr(void)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	LWLockAcquire(WALInsertLock, LW_SHARED);
! 	INSERT_RECPTR(current_recptr, Insert, Insert->curridx);
! 	LWLockRelease(WALInsertLock);
  
  	return current_recptr;
  }
--- 10370,10381 ----
  XLogRecPtr
  GetXLogInsertRecPtr(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	current_recptr = Insert->CurrPos;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	return current_recptr;
  }
*** a/src/backend/storage/ipc/procarray.c
--- b/src/backend/storage/ipc/procarray.c
***************
*** 1753,1761 **** GetOldestActiveTransactionId(void)
   * the result is somewhat indeterminate, but we don't really care.  Even in
   * a multiprocessor with delayed writes to shared memory, it should be certain
   * that setting of inCommit will propagate to shared memory when the backend
!  * takes the WALInsertLock, so we cannot fail to see an xact as inCommit if
!  * it's already inserted its commit record.  Whether it takes a little while
!  * for clearing of inCommit to propagate is unimportant for correctness.
   */
  int
  GetTransactionsInCommit(TransactionId **xids_p)
--- 1753,1762 ----
   * the result is somewhat indeterminate, but we don't really care.  Even in
   * a multiprocessor with delayed writes to shared memory, it should be certain
   * that setting of inCommit will propagate to shared memory when the backend
!  * takes a lock to write the WAL record, so we cannot fail to see an xact as
!  * inCommit if it's already inserted its commit record.  Whether it takes a
!  * little while for clearing of inCommit to propagate is unimportant for
!  * correctness.
   */
  int
  GetTransactionsInCommit(TransactionId **xids_p)
*** a/src/backend/storage/lmgr/spin.c
--- b/src/backend/storage/lmgr/spin.c
***************
*** 56,61 **** SpinlockSemas(void)
--- 56,64 ----
  	 *
  	 * For now, though, we just need a few spinlocks (10 should be plenty)
  	 * plus one for each LWLock and one for each buffer header.
+ 	 *
+ 	 * XXX: remember to adjust this for the number of spinlocks needed by the
+ 	 * xlog.c changes before committing!
  	 */
  	return NumLWLocks() + NBuffers + 10;
  }
*** a/src/include/storage/lwlock.h
--- b/src/include/storage/lwlock.h
***************
*** 53,59 **** typedef enum LWLockId
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALInsertLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
--- 53,59 ----
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALBufMappingLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
***************
*** 79,84 **** typedef enum LWLockId
--- 79,85 ----
  	SerializablePredicateLockListLock,
  	OldSerXidLock,
  	SyncRepLock,
+ 	WALInsertTailLock,
  	/* Individual lock IDs end here */
  	FirstBufMappingLock,
  	FirstLockMgrLock = FirstBufMappingLock + NUM_BUFFER_PARTITIONS,

*** a/src/backend/access/transam/xlog.c
--- b/src/backend/access/transam/xlog.c
***************
*** 42,47 ****
--- 42,48 ----
  #include "postmaster/startup.h"
  #include "replication/walreceiver.h"
  #include "replication/walsender.h"
+ #include "storage/barrier.h"
  #include "storage/bufmgr.h"
  #include "storage/fd.h"
  #include "storage/ipc.h"
***************
*** 262,268 **** XLogRecPtr	XactLastRecEnd = {0, 0};
   * CHECKPOINT record).	We update this from the shared-memory copy,
   * XLogCtl->Insert.RedoRecPtr, whenever we can safely do so (ie, when we
   * hold the Insert lock).  See XLogInsert for details.	We are also allowed
!  * to update from XLogCtl->Insert.RedoRecPtr if we hold the info_lck;
   * see GetRedoRecPtr.  A freshly spawned backend obtains the value during
   * InitXLOGAccess.
   */
--- 263,269 ----
   * CHECKPOINT record).	We update this from the shared-memory copy,
   * XLogCtl->Insert.RedoRecPtr, whenever we can safely do so (ie, when we
   * hold the Insert lock).  See XLogInsert for details.	We are also allowed
!  * to update from XLogCtl->RedoRecPtr if we hold the info_lck;
   * see GetRedoRecPtr.  A freshly spawned backend obtains the value during
   * InitXLOGAccess.
   */
***************
*** 300,309 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * (protected by info_lck), but we don't need to cache any copies of it.
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  The other locks are held longer (potentially
!  * over I/O operations), so we use LWLocks for them.  These locks are:
   *
!  * WALInsertLock: must be held to insert a record into the WAL buffers.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
--- 301,315 ----
   * (protected by info_lck), but we don't need to cache any copies of it.
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  insertpos_lck protects the current logical
!  * insert location, ie. the head of reserved WAL space.  The other locks are
!  * held longer (potentially over I/O operations), so we use LWLocks for them.
!  * These locks are:
   *
!  * WALBufMappingLock: must be held to replace a page in the WAL buffer cache.
!  * This is only held while initializing and changing the mapping. If the
!  * contents of the buffer being replaced haven't been written yet, the mapping
!  * lock is released while the write is done, and reacquired afterwards.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
***************
*** 315,320 **** static XLogRecPtr RedoStartLSN = {0, 0};
--- 321,393 ----
   * only one checkpointer at a time; currently, with all checkpoints done by
   * the checkpointer, this is just pro forma).
   *
+  *
+  * Inserting a new WAL record is a two-step process:
+  *
+  * 1. Reserve the right amount of space from the WAL, and the next insertion
+  *    slot to advertise that the insertion is in progress. The current head
+  *    of reserved space is kept in Insert->CurrPos, and is protected by
+  *    insertpos_lck. Try to keep this section as short as possible,
+  *    insertpos_lck can be heavily contended on a busy system
+  *
+  * 2. Copy the record to the reserved WAL space. This involves finding the
+  *    correct WAL buffer containing the reserved space, and copying the
+  *    record in place. This can be done concurrently in multiple processes.
+  *
+  * To allow as much parallelism as possible for step 2, we try hard to avoid
+  * lock contention in that code path. Each insertion is asssigned its own
+  * "XLog insertion slot", which is used to advertise the position the backend
+  * is writing to. The slot is marked as in-use in step 1, while holding
+  * insertpos_lck, by setting the position field in the slot. When the backend
+  * is finished with the insertion, it clears its slot. Each slot is protected
+  * by a separate spinlock, to keep contention minimal.
+  *
+  * The insertion slots also provide a mechanism to wait for an insertion to
+  * finish. This is important when an XLOG page is written out - any
+  * in-progress insertions must finish copying data to the page first, or the
+  * on-disk copy will be incomplete. Waiting is done by the
+  * WaitXLogInsertionsToFinish() function. It adds the current process to the
+  * waiting queue in the slot it needs to wait for, and when that insertion
+  * finishes (or proceeds to the next page, at least), the inserter wakes up
+  * the process.
+  *
+  * The insertion slots form a ring. Insert->nextslot points to the next free
+  * slot, and Insert->lastslot points to the last slot that's still in use.
+  * lastslot can lag behind reality by any number of slots, as long as nextslot
+  * doesn't catch up with it. lastslot is advanced by
+  * WaitXLogInsertionsToFinish(), and is protected by WALInsertTailLock.
+  * nextslot is advanced in ReserveXLogInsertLocation() and is protected by
+  * insertpos_lck. Both slot variables are 32-bit integers, so that they can
+  * be read atomically without holding a lock. nextslot == lastslot means that
+  * all the slots are empty.
+  *
+  * Whenever the ring fills up, ie. when nextslot wraps around and catches up
+  * with lastslot, ReserveXLogInsertLocation() has to wait for the oldest
+  * insertion to finish and advance lastslot, to make room for the new
+  * insertion. This is also handled by WaitXLogInsertionsToFinish().
+  *
+  *
+  * Deadlock analysis
+  * -----------------
+  *
+  * It's important to call WaitXLogInsertionsToFinish() *before* acquiring
+  * WALWriteLock. Otherwise you might get stuck waiting for an insertion to
+  * finish (or at least advance to next uninitialized page), while you're
+  * holding WALWriteLock. That would be bad, because the backend you're waiting
+  * for might need to acquire WALWriteLock, too, to evict an old buffer, so
+  * you'd get deadlock.
+  *
+  * WaitXLogInsertionsToFinish() will not get stuck indefinitely, as long as
+  * it's called with a location that's known to be already allocated in the WAL
+  * buffers. Calling it with the position of a record you've already inserted
+  * satisfies that condition, so the common pattern:
+  *
+  *   recptr = XLogInsert(...)
+  *   XLogFlush(recptr)
+  *
+  * is safe. It can't get stuck, because an insertion to a WAL page that's
+  * already initialized in cache can always proceed without waiting on a lock.
+  *
   *----------
   */
  
***************
*** 335,344 **** typedef struct XLogwrtResult
   */
  typedef struct XLogCtlInsert
  {
! 	XLogRecPtr	PrevRecord;		/* start of previously-inserted record */
! 	int			curridx;		/* current block index in cache */
! 	XLogPageHeader currpage;	/* points to header of block in cache */
! 	char	   *currpos;		/* current insertion point in cache */
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
--- 408,429 ----
   */
  typedef struct XLogCtlInsert
  {
! 	slock_t		insertpos_lck;	/* protects all the fields in this struct
! 								 * (except lastslot). */
! 
! 	int32		nextslot;		/* next insertion slot to use */
! 	int32		lastslot;		/* last in-use insertion slot (protected by
! 								 * WALInsertTailLock) */
! 
! 	/*
! 	 * CurrPos is the very tip of the reserved WAL space at the moment.
! 	 * The next record will be inserted there (or somewhere after it if
! 	 * there's not enough space on the current page).  PrevRecord points to
! 	 * the beginning of the last record already reserved.  It might not be
! 	 * fully copied into place yet, but we know its exact location already.
! 	 */
! 	XLogRecPtr	CurrPos;
! 	XLogRecPtr	PrevRecord;
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
***************
*** 372,387 **** typedef struct XLogCtlWrite
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by WALInsertLock: */
  	XLogCtlInsert Insert;
  
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	uint32		ckptXidEpoch;	/* nextXID & epoch of latest checkpoint */
  	TransactionId ckptXid;
  	XLogRecPtr	asyncXactLSN;	/* LSN of newest async commit/abort */
--- 457,489 ----
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
+ 
+ /*
+  * Slots for in-progress WAL insertions.
+  */
+ typedef struct
+ {
+ 	slock_t		lck;
+ 	XLogRecPtr	CurrPos;	/* current position this process is inserting to */
+ 	PGPROC	   *head;		/* head of list of waiting PGPROCs */
+ 	PGPROC	   *tail;		/* tail of list of waiting PGPROCs */
+ } XLogInsertSlot;
+ 
+ #define NumXLogInsertSlots	512
+ 
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by insertpos_lck: */
  	XLogCtlInsert Insert;
  
+ 	XLogInsertSlot XLogInsertSlots[NumXLogInsertSlots];
+ 
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
+ 	XLogRecPtr	RedoRecPtr;		/* a recent copy of Insert->RedoRecPtr */
  	uint32		ckptXidEpoch;	/* nextXID & epoch of latest checkpoint */
  	TransactionId ckptXid;
  	XLogRecPtr	asyncXactLSN;	/* LSN of newest async commit/abort */
***************
*** 398,406 **** typedef struct XLogCtlData
  	XLogwrtResult LogwrtResult;
  
  	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALInsertLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
--- 500,517 ----
  	XLogwrtResult LogwrtResult;
  
  	/*
+ 	 * To change curridx and the identity of a buffer, you need to hold
+ 	 * WALBufMappingLock.  To change the identity of a buffer that's still
+ 	 * dirty, the old page needs to be written out first, and for that you
+ 	 * need WALWriteLock, and you need to ensure that there's no in-progress
+ 	 * insertions to the page by calling WaitXLogInsertionsToFinish().
+ 	 */
+ 	int			curridx;		/* latest initialized block index in cache */
+ 
+ 	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALBufMappingLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
***************
*** 478,505 **** static XLogCtlData *XLogCtl = NULL;
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Macros for managing XLogInsert state.  In most cases, the calling routine
!  * has local copies of XLogCtl->Insert and/or XLogCtl->Insert->curridx,
!  * so these are passed as parameters instead of being fetched via XLogCtl.
   */
  
! /* Free space remaining in the current xlog page buffer */
! #define INSERT_FREESPACE(Insert)  \
! 	(XLOG_BLCKSZ - ((Insert)->currpos - (char *) (Insert)->currpage))
  
! /* Construct XLogRecPtr value for current insertion point */
! #define INSERT_RECPTR(recptr,Insert,curridx)  \
! 	( \
! 	  (recptr).xlogid = XLogCtl->xlblocks[curridx].xlogid, \
! 	  (recptr).xrecoff = \
! 		XLogCtl->xlblocks[curridx].xrecoff - INSERT_FREESPACE(Insert) \
! 	)
  
! #define PrevBufIdx(idx)		\
! 		(((idx) == 0) ? XLogCtl->XLogCacheBlck : ((idx) - 1))
  
! #define NextBufIdx(idx)		\
! 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
--- 589,620 ----
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Calculate the amount of space left on the page after 'endptr'.
!  * Beware multiple evaluation!
   */
+ #define INSERT_FREESPACE(endptr)	\
+ 	(((endptr).xrecoff % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr).xrecoff % XLOG_BLCKSZ))
  
! /*
!  * Macros to advance to next buffer index and insertion slot.
!  */
! #define NextBufIdx(idx)		\
! 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
! #define NextSlotNo(idx)		(((idx) + 1) % NumXLogInsertSlots)
  
! /*
!  * XLogRecPtrToBufIdx returns the index of the WAL buffer that holds, or
!  * would hold if it was in cache, the page containing 'recptr'.
!  *
!  * XLogRecEndPtrToBufIdx is the same, but a pointer to the first byte of a
!  * page is taken to mean the previous page.
!  */
! #define XLogRecPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogFileSize) + (recptr).xrecoff)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
  
! #define XLogRecEndPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogFileSize) + (recptr).xrecoff - 1)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
***************
*** 625,633 **** static void KeepLogSeg(XLogRecPtr recptr, uint32 *logId, uint32 *logSeg);
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static bool AdvanceXLInsertBuffer(bool new_segment);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
--- 740,748 ----
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static void AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
***************
*** 674,679 **** static bool read_backup_label(XLogRecPtr *checkPointLoc,
--- 789,810 ----
  static void rm_redo_error_callback(void *arg);
  static int	get_sync_bit(int method);
  
+ static void CopyXLogRecordToWAL(int write_len, bool isLogSwitch,
+ 				  XLogRecord *rechdr,
+ 				  XLogRecData *rdata, pg_crc32 rdata_crc,
+ 				  XLogInsertSlot *myslot,
+ 				  XLogRecPtr StartPos, XLogRecPtr EndPos);
+ static bool ReserveXLogInsertLocation(int size, bool forcePageWrites,
+ 						  bool isLogSwitch,
+ 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
+ 						  XLogRecPtr *EndPos_p,
+ 						  XLogInsertSlot **myslot_p, bool *updrqst_p);
+ static void UpdateSlotCurrPos(volatile XLogInsertSlot *myslot,
+ 				  XLogRecPtr CurrPos);
+ static void	ReuseOldSlots(void);
+ static XLogRecPtr WaitXLogInsertionsToFinish(XLogRecPtr upto);
+ static char *GetXLogBuffer(XLogRecPtr ptr);
+ 
  
  /*
   * Insert an XLOG record having the specified RMID and info bytes,
***************
*** 694,705 **** XLogRecPtr
  XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
- 	XLogRecord *record;
- 	XLogContRecord *contrecord;
- 	XLogRecPtr	RecPtr;
- 	XLogRecPtr	WriteRqst;
- 	uint32		freespace;
- 	int			curridx;
  	XLogRecData *rdt;
  	XLogRecData *rdt_lastnormal;
  	Buffer		dtbuf[XLR_MAX_BKP_BLOCKS];
--- 825,830 ----
***************
*** 717,722 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
--- 842,852 ----
  	bool		doPageWrites;
  	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
  	uint8		info_orig = info;
+ 	XLogRecord	rechdr;
+ 	XLogRecPtr	PrevRecord;
+ 	XLogRecPtr	StartPos;
+ 	XLogRecPtr	EndPos;
+ 	XLogInsertSlot *myslot;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
***************
*** 734,742 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  	 */
  	if (IsBootstrapProcessingMode() && rmid != RM_XLOG_ID)
  	{
! 		RecPtr.xlogid = 0;
! 		RecPtr.xrecoff = SizeOfXLogLongPHD;		/* start of 1st chkpt record */
! 		return RecPtr;
  	}
  
  	/*
--- 864,872 ----
  	 */
  	if (IsBootstrapProcessingMode() && rmid != RM_XLOG_ID)
  	{
! 		EndPos.xlogid = 0;
! 		EndPos.xrecoff = SizeOfXLogLongPHD;		/* start of 1st chkpt record */
! 		return EndPos;
  	}
  
  	/*
***************
*** 903,1035 **** begin:;
  	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
  		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
! 	START_CRIT_SECTION();
  
! 	/* Now wait to get insert lock */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  
  	/*
! 	 * Check to see if my RedoRecPtr is out of date.  If so, may have to go
! 	 * back and recompute everything.  This can only happen just after a
! 	 * checkpoint, so it's better to be slow in this case and fast otherwise.
! 	 *
! 	 * If we aren't doing full-page writes then RedoRecPtr doesn't actually
! 	 * affect the contents of the XLOG record, so we'll update our local copy
! 	 * but not force a recomputation.
  	 */
! 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr))
  	{
! 		Assert(XLByteLT(RedoRecPtr, Insert->RedoRecPtr));
! 		RedoRecPtr = Insert->RedoRecPtr;
  
! 		if (doPageWrites)
  		{
! 			for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
! 			{
! 				if (dtbuf[i] == InvalidBuffer)
! 					continue;
! 				if (dtbuf_bkp[i] == false &&
! 					XLByteLE(dtbuf_lsn[i], RedoRecPtr))
! 				{
! 					/*
! 					 * Oops, this buffer now needs to be backed up, but we
! 					 * didn't think so above.  Start over.
! 					 */
! 					LWLockRelease(WALInsertLock);
! 					END_CRIT_SECTION();
! 					rdt_lastnormal->next = NULL;
! 					info = info_orig;
! 					goto begin;
! 				}
! 			}
  		}
  	}
! 
! 	/*
! 	 * Also check to see if fullPageWrites or forcePageWrites was just turned on;
! 	 * if we weren't already doing full-page writes then go back and recompute.
! 	 * (If it was just turned off, we could recompute the record without full pages,
! 	 * but we choose not to bother.)
! 	 */
! 	if ((Insert->fullPageWrites || Insert->forcePageWrites) && !doPageWrites)
  	{
! 		/* Oops, must redo it with full-page data. */
! 		LWLockRelease(WALInsertLock);
! 		END_CRIT_SECTION();
! 		rdt_lastnormal->next = NULL;
! 		info = info_orig;
! 		goto begin;
  	}
  
  	/*
! 	 * If there isn't enough space on the current XLOG page for a record
! 	 * header, advance to the next page (leaving the unused space as zeroes).
  	 */
! 	updrqst = false;
! 	freespace = INSERT_FREESPACE(Insert);
! 	if (freespace < SizeOfXLogRecord)
  	{
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		freespace = INSERT_FREESPACE(Insert);
! 	}
  
! 	/* Compute record's XLOG location */
! 	curridx = Insert->curridx;
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
! 	 * segment, we need not insert it (and don't want to because we'd like
! 	 * consecutive switch requests to be no-ops).  Instead, make sure
! 	 * everything is written and flushed through the end of the prior segment,
! 	 * and return the prior segment's end address.
  	 */
! 	if (isLogSwitch &&
! 		(RecPtr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
  	{
! 		/* We can release insert lock immediately */
! 		LWLockRelease(WALInsertLock);
! 
! 		RecPtr.xrecoff -= SizeOfXLogLongPHD;
! 		if (RecPtr.xrecoff == 0)
! 		{
! 			/* crossing a logid boundary */
! 			RecPtr.xlogid -= 1;
! 			RecPtr.xrecoff = XLogFileSize;
! 		}
! 
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 		LogwrtResult = XLogCtl->LogwrtResult;
! 		if (!XLByteLE(RecPtr, LogwrtResult.Flush))
! 		{
! 			XLogwrtRqst FlushRqst;
! 
! 			FlushRqst.Write = RecPtr;
! 			FlushRqst.Flush = RecPtr;
! 			XLogWrite(FlushRqst, false, false);
! 		}
! 		LWLockRelease(WALWriteLock);
  
! 		END_CRIT_SECTION();
  
! 		return RecPtr;
  	}
  
! 	/* Insert record header */
! 
! 	record = (XLogRecord *) Insert->currpos;
! 	record->xl_prev = Insert->PrevRecord;
! 	record->xl_xid = GetCurrentTransactionIdIfAny();
! 	record->xl_tot_len = SizeOfXLogRecord + write_len;
! 	record->xl_len = len;		/* doesn't include backup blocks */
! 	record->xl_info = info;
! 	record->xl_rmid = rmid;
! 
! 	/* Now we can finish computing the record's CRC */
! 	COMP_CRC32(rdata_crc, (char *) record + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	record->xl_crc = rdata_crc;
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
--- 1033,1138 ----
  	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
  		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
! 	/* Construct record header. */
! 	MemSet(&rechdr, 0, sizeof(rechdr));
! 	/* rechdr.xl_prev is set later */
! 	rechdr.xl_xid = GetCurrentTransactionIdIfAny();
! 	rechdr.xl_tot_len = SizeOfXLogRecord + write_len;
! 	rechdr.xl_len = len;		/* doesn't include backup blocks */
! 	rechdr.xl_info = info;
! 	rechdr.xl_rmid = rmid;
  
! 	START_CRIT_SECTION();
  
  	/*
! 	 * Try to reserve space for the record from the WAL.
  	 */
! 	if (!ReserveXLogInsertLocation(write_len, doPageWrites, isLogSwitch,
! 								   &PrevRecord, &StartPos, &EndPos,
! 								   (XLogInsertSlot **) &myslot, &updrqst))
  	{
! 		/*
! 		 * Reservation failed. This could be because the record was an
! 		 * XLOG_SWITCH, and we're exactly at the start of a segment. In that
! 		 * case we need not insert it (and don't want to because we'd like
! 		 * consecutive switch requests to be no-ops).  Instead, make sure
! 		 * everything is written and flushed through the end of the prior
! 		 * segment, and return the prior segment's end address.
! 		 *
! 		 * The other reason for failure is that someone changed RedoRecPtr
! 		 * or forcePageWrites after we had constructed our WAL record. In
! 		 * that case we need to redo it with full-page data.
! 		 */
! 		END_CRIT_SECTION();
  
! 		if (isLogSwitch && !XLogRecPtrIsInvalid(EndPos))
  		{
! 			XLogFlush(EndPos);
! 			return EndPos;
! 		}
! 		else
! 		{
! 			rdt_lastnormal->next = NULL;
! 			info = info_orig;
! 			goto begin;
  		}
  	}
! 	else
  	{
! 		/*
! 		 * Reservation succeeded.  Finish the record header by setting
! 		 * prev-link (now that we know it), and finish computing the record's
! 		 * CRC (in CopyXLogRecordToWAL).  Then copy the record to the space
! 		 * we reserved.
! 		 */
! 		rechdr.xl_prev = PrevRecord;
! 		CopyXLogRecordToWAL(write_len, isLogSwitch, &rechdr,
! 							rdata, rdata_crc, myslot, StartPos, EndPos);
  	}
+ 	END_CRIT_SECTION();
  
  	/*
! 	 * Update shared LogwrtRqst.Write, if we crossed page boundary.
  	 */
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
  
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, EndPos))
! 			xlogctl->LogwrtRqst.Write = EndPos;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
! 	}
  
  	/*
! 	 * If this was an XLOG_SWITCH record, flush the record and the empty
! 	 * padding space that fills the rest of the segment, and perform
! 	 * end-of-segment actions (eg, notifying archiver).
  	 */
! 	if (isLogSwitch)
  	{
! 		TRACE_POSTGRESQL_XLOG_SWITCH();
  
! 		XLogFlush(EndPos);
  
! 		/*
! 		 * Even though we reserved the rest of the segment for us, which is
! 		 * reflected in EndPos, we return a pointer to just the end of the
! 		 * xlog-switch record.
! 		 */
! 		EndPos.xlogid = StartPos.xlogid;
! 		EndPos.xrecoff = StartPos.xrecoff + SizeOfXLogRecord;
  	}
  
! 	/*
! 	 * Update our global variables
! 	 */
! 	ProcLastRecPtr = StartPos;
! 	XactLastRecEnd = EndPos;
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
***************
*** 1038,1219 **** begin:;
  
  		initStringInfo(&buf);
  		appendStringInfo(&buf, "INSERT @ %X/%X: ",
! 						 RecPtr.xlogid, RecPtr.xrecoff);
! 		xlog_outrec(&buf, record);
  		if (rdata->data != NULL)
  		{
  			appendStringInfo(&buf, " - ");
! 			RmgrTable[record->xl_rmid].rm_desc(&buf, record->xl_info, rdata->data);
  		}
  		elog(LOG, "%s", buf.data);
  		pfree(buf.data);
  	}
  #endif
  
- 	/* Record begin of record in appropriate places */
- 	ProcLastRecPtr = RecPtr;
- 	Insert->PrevRecord = RecPtr;
- 
- 	Insert->currpos += SizeOfXLogRecord;
- 	freespace -= SizeOfXLogRecord;
- 
  	/*
! 	 * Append the data, including backup blocks if any
  	 */
! 	while (write_len)
! 	{
! 		while (rdata->data == NULL)
! 			rdata = rdata->next;
  
! 		if (freespace > 0)
  		{
! 			if (rdata->len > freespace)
  			{
! 				memcpy(Insert->currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				write_len -= freespace;
! 			}
! 			else
! 			{
! 				memcpy(Insert->currpos, rdata->data, rdata->len);
! 				freespace -= rdata->len;
! 				write_len -= rdata->len;
! 				Insert->currpos += rdata->len;
! 				rdata = rdata->next;
! 				continue;
  			}
  		}
  
! 		/* Use next buffer */
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		curridx = Insert->curridx;
! 		/* Insert cont-record header */
! 		Insert->currpage->xlp_info |= XLP_FIRST_IS_CONTRECORD;
! 		contrecord = (XLogContRecord *) Insert->currpos;
! 		contrecord->xl_rem_len = write_len;
! 		Insert->currpos += SizeOfXLogContRecord;
! 		freespace = INSERT_FREESPACE(Insert);
  	}
  
! 	/* Ensure next record will be properly aligned */
! 	Insert->currpos = (char *) Insert->currpage +
! 		MAXALIGN(Insert->currpos - (char *) Insert->currpage);
! 	freespace = INSERT_FREESPACE(Insert);
  
  	/*
! 	 * The recptr I return is the beginning of the *next* record. This will be
! 	 * stored as LSN for changed data pages...
  	 */
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, we must now write and flush all the
! 	 * existing data, and then forcibly advance to the start of the next
! 	 * segment.  It's not good to do this I/O while holding the insert lock,
! 	 * but there seems too much risk of confusion if we try to release the
! 	 * lock sooner.  Fortunately xlog switch needn't be a high-performance
! 	 * operation anyway...
  	 */
! 	if (isLogSwitch)
! 	{
! 		XLogwrtRqst FlushRqst;
! 		XLogRecPtr	OldSegEnd;
  
! 		TRACE_POSTGRESQL_XLOG_SWITCH();
  
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  
  		/*
! 		 * Flush through the end of the page containing XLOG_SWITCH, and
! 		 * perform end-of-segment actions (eg, notifying archiver).
  		 */
! 		WriteRqst = XLogCtl->xlblocks[curridx];
! 		FlushRqst.Write = WriteRqst;
! 		FlushRqst.Flush = WriteRqst;
! 		XLogWrite(FlushRqst, false, true);
! 
! 		/* Set up the next buffer as first page of next segment */
! 		/* Note: AdvanceXLInsertBuffer cannot need to do I/O here */
! 		(void) AdvanceXLInsertBuffer(true);
! 
! 		/* There should be no unwritten data */
! 		curridx = Insert->curridx;
! 		Assert(curridx == XLogCtl->Write.curridx);
! 
! 		/* Compute end address of old segment */
! 		OldSegEnd = XLogCtl->xlblocks[curridx];
! 		OldSegEnd.xrecoff -= XLOG_BLCKSZ;
! 		if (OldSegEnd.xrecoff == 0)
! 		{
! 			/* crossing a logid boundary */
! 			OldSegEnd.xlogid -= 1;
! 			OldSegEnd.xrecoff = XLogFileSize;
! 		}
  
! 		/* Make it look like we've written and synced all of old segment */
! 		LogwrtResult.Write = OldSegEnd;
! 		LogwrtResult.Flush = OldSegEnd;
  
  		/*
! 		 * Update shared-memory status --- this code should match XLogWrite
  		 */
  		{
! 			/* use volatile pointer to prevent code rearrangement */
! 			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			SpinLockAcquire(&xlogctl->info_lck);
! 			xlogctl->LogwrtResult = LogwrtResult;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, LogwrtResult.Write))
! 				xlogctl->LogwrtRqst.Write = LogwrtResult.Write;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Flush, LogwrtResult.Flush))
! 				xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
! 			SpinLockRelease(&xlogctl->info_lck);
! 		}
  
! 		LWLockRelease(WALWriteLock);
  
! 		updrqst = false;		/* done already */
  	}
  	else
  	{
! 		/* normal case, ie not xlog switch */
  
! 		/* Need to update shared LogwrtRqst if some block was filled up */
! 		if (freespace < SizeOfXLogRecord)
  		{
! 			/* curridx is filled and available for writing out */
  			updrqst = true;
  		}
! 		else
  		{
! 			/* if updrqst already set, write through end of previous buf */
! 			curridx = PrevBufIdx(curridx);
  		}
- 		WriteRqst = XLogCtl->xlblocks[curridx];
  	}
  
! 	LWLockRelease(WALInsertLock);
  
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
  
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, WriteRqst))
! 			xlogctl->LogwrtRqst.Write = WriteRqst;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
  	}
  
! 	XactLastRecEnd = RecPtr;
  
! 	END_CRIT_SECTION();
  
! 	return RecPtr;
  }
  
  /*
--- 1141,1898 ----
  
  		initStringInfo(&buf);
  		appendStringInfo(&buf, "INSERT @ %X/%X: ",
! 						 EndPos.xlogid, EndPos.xrecoff);
! 		xlog_outrec(&buf, &rechdr);
  		if (rdata->data != NULL)
  		{
  			appendStringInfo(&buf, " - ");
! 			RmgrTable[rmid].rm_desc(&buf, rechdr.xl_info, rdata->data);
  		}
  		elog(LOG, "%s", buf.data);
  		pfree(buf.data);
  	}
  #endif
  
  	/*
! 	 * The recptr I return is the beginning of the *next* record. This will
! 	 * be stored as LSN for changed data pages...
  	 */
! 	return EndPos;
! }
! 
! /*
!  * Subroutine of XLogInsert.  Copies a WAL record to an already-reserved
!  * area in the WAL.
!  */
! static void
! CopyXLogRecordToWAL(int write_len, bool isLogSwitch, XLogRecord *rechdr,
! 					XLogRecData *rdata, pg_crc32 rdata_crc,
! 					XLogInsertSlot *myslot_p,
! 					XLogRecPtr StartPos, XLogRecPtr EndPos)
! {
! 	volatile XLogInsertSlot *myslot = myslot_p;
! 	char	   *currpos;
! 	XLogRecord *record;
! 	int			freespace;
! 	int			written;
! 	XLogRecPtr	CurrPos;
! 
! 	/* Get the right WAL page to start inserting to */
! 	CurrPos = StartPos;
! 	currpos = GetXLogBuffer(CurrPos);
! 
! 	/* Copy the record header in place, and finish calculating CRC */
! 	record = (XLogRecord *) currpos;
! 	memcpy(record, rechdr, sizeof(XLogRecord));
! 	COMP_CRC32(rdata_crc, currpos + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	record->xl_crc = rdata_crc;
! 
! 	currpos += SizeOfXLogRecord;
! 	XLByteAdvance(CurrPos, SizeOfXLogRecord);
  
! 	freespace = INSERT_FREESPACE(CurrPos);
! 
! 	if (!isLogSwitch)
! 	{
! 		/* Copy record data */
! 		written = 0;
! 		while (rdata != NULL)
  		{
! 			while (rdata->len > freespace)
  			{
! 				/*
! 				 * Write what fits on this page, then write the continuation
! 				 * record, and continue on the next page.
! 				 */
! 				XLogContRecord *contrecord;
! 
! 				memcpy(currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				written += freespace;
! 				XLByteAdvance(CurrPos, freespace);
! 
! 				/*
! 				 * CurrPos now points to the page boundary, ie. the first byte
! 				 * of the next page. Advertise that position in our insertion
! 				 * slot before calling GetXLogBuffer(), because GetXLogBuffer()
! 				 * might need to wait for some insertions to finish so that it
! 				 * can write out a buffer to make room for the new page.
! 				 * Updating the slot before waiting for a new buffer ensures
! 				 * that we don't deadlock with ourselves if we run out of
! 				 * clean buffers.
! 				 *
! 				 * Note that we must not advance CurrPos past the page header
! 				 * yet, otherwise someone might try to flush up to that point,
! 				 * which would fail if the next page was not initialized yet.
! 				 */
! 				UpdateSlotCurrPos(myslot, CurrPos);
! 
! 				/*
! 				 * Get pointer to beginning of next page, and set the
! 				 * XLP_FIRST_IS_CONTRECORD flag in the page header.
! 				 *
! 				 * It's safe to set the contrecord flag without a lock on the
! 				 * page. All the other flags are set in AdvanceXLInsertBuffer,
! 				 * and we're the only backend that needs to set the contrecord
! 				 * flag.
! 				 */
! 				currpos = GetXLogBuffer(CurrPos);
! 				((XLogPageHeader) currpos)->xlp_info |= XLP_FIRST_IS_CONTRECORD;
! 
! 				/* skip over the page header, and write continuation record */
! 				if (CurrPos.xrecoff % XLogSegSize == 0)
! 				{
! 					CurrPos.xrecoff += SizeOfXLogLongPHD;
! 					currpos += SizeOfXLogLongPHD;
! 				}
! 				else
! 				{
! 					CurrPos.xrecoff += SizeOfXLogShortPHD;
! 					currpos += SizeOfXLogShortPHD;
! 				}
! 				contrecord = (XLogContRecord *) currpos;
! 				contrecord->xl_rem_len = write_len - written;
! 
! 				currpos += SizeOfXLogContRecord;
! 				CurrPos.xrecoff += SizeOfXLogContRecord;
! 
! 				freespace = INSERT_FREESPACE(CurrPos);
  			}
+ 
+ 			memcpy(currpos, rdata->data, rdata->len);
+ 			currpos += rdata->len;
+ 			XLByteAdvance(CurrPos, rdata->len);
+ 			freespace -= rdata->len;
+ 			written += rdata->len;
+ 
+ 			rdata = rdata->next;
  		}
+ 		Assert(written == write_len);
  
! 		/* Align the end position, so that the next record starts aligned */
! 		CurrPos.xrecoff = MAXALIGN(CurrPos.xrecoff);
! 		if (CurrPos.xrecoff >= XLogFileSize)
! 		{
! 			/* crossed a logid boundary */
! 			CurrPos.xlogid += 1;
! 			CurrPos.xrecoff = 0;
! 		}
! 
! 		if (!XLByteEQ(CurrPos, EndPos))
! 			elog(PANIC, "space reserved for WAL record does not match what was written");
  	}
+ 	else
+ 	{
+ 		/* An xlog-switch record doesn't contain any data besides the header */
+ 		Assert(write_len == 0);
+ 
+ 		/*
+ 		 * An xlog-switch record consumes all the remaining space on the
+ 		 * WAL segment. We have already reserved it for us, but we still need
+ 		 * to make sure it's been allocated and zeroed in the WAL buffers so
+ 		 * that when the caller (or someone else) does XLogWrite(), it can
+ 		 * really write out all the zeros.
+ 		 *
+ 		 * We do this one page at a time, to make sure we don't deadlock
+ 		 * against ourselves if wal_buffers < XLOG_SEG_SIZE.
+ 		 */
+ 		Assert(EndPos.xrecoff % XLogSegSize == 0);
  
! 		/* Use up all the remaining space on the first page */
! 		XLByteAdvance(CurrPos, freespace);
! 
! 		while (XLByteLT(CurrPos, EndPos))
! 		{
! 			/*
! 			 * like in the non-xlog-switch codepath, let others know that
! 			 * we're done writing up to the end of this page
! 			 */
! 			UpdateSlotCurrPos(myslot, CurrPos);
! 			/* initialize the next page (if not initialized already */
! 			AdvanceXLInsertBuffer(CurrPos, false);
! 			XLByteAdvance(CurrPos, XLOG_BLCKSZ);
! 		}
! 	}
  
  	/*
! 	 * Done! Clear CurrPos in our slot to let others know that we're
! 	 * finished.
  	 */
! 	UpdateSlotCurrPos(myslot, InvalidXLogRecPtr);
  
  	/*
! 	 * When we run out of insertion slots, the next inserter has to grab the
! 	 * WALInsertTailLock to clean up some old slots.  That stalls all new
! 	 * insertions. The WAL writer process cleans up old slots periodically,
! 	 * but on a busy system that might not be enough. So we try to clean up
! 	 * old ones every time we've gone through 1/4 of all the slots.
  	 */
! 	if ((myslot_p - XLogCtl->XLogInsertSlots) % (NumXLogInsertSlots / 4) == 0)
! 		ReuseOldSlots();
! }
  
! /*
!  * Reserves the right amount of space for a record of given size from the WAL.
!  * *StartPos_p is set to the beginning of the reserved section, *EndPos_p to
!  * its end+1, and *PrevRecord_p to the beginning of the previous record to set
!  * to the prev-link of the record header.
!  *
!  * A log-switch record is handled slightly differently. The rest of the
!  * segment will be reserved for this insertion, as indicated by the returned
!  * *EndPos_p value. However, if we are already at the beginning of the current
!  * segment, the *EndPos_p is set to the current location without reserving
!  * any space, and the function returns false.
!  *
!  * *updrqst_p is set to true, if this record ends on different page than
!  * the previous one - the caller should update the shared LogwrtRqst value
!  * after it's done inserting the record in that case, so that the WAL page
!  * that filled up gets written out at the next convenient moment.
!  *
!  * While holding insertpos_lck, sets myslot->CurrPos to the starting position,
!  * (or the end of previous record, to be exact) to let others know that we're
!  * busy inserting to the reserved area. The caller must clear it when the
!  * insertion is finished.
!  *
!  * Returns true on success, or false if RedoRecPtr or forcePageWrites was
!  * changed. On failure, the shared state is not modified.
!  *
!  * This is the performance critical part of XLogInsert that must be serialized
!  * across backends. The rest can happen mostly in parallel.
!  *
!  * NB: The space calculation here must match the code in CopyXLogRecordToWAL,
!  * where we actually copy the record to the reserved space.
!  */
! static bool
! ReserveXLogInsertLocation(int size, bool didPageWrites,
! 						  bool isLogSwitch,
! 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
! 						  XLogRecPtr *EndPos_p,
! 						  XLogInsertSlot **myslot_p, bool *updrqst_p)
! {
! 	volatile XLogInsertSlot *myslot;
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			freespace;
! 	XLogRecPtr	ptr;
! 	XLogRecPtr	StartPos;
! 	XLogRecPtr	BeginCurrPos;
! 	int32		nextslot;
! 	int32		lastslot;
! 	bool		updrqst = false;
! 
! 	/* log-switch records should contain no data */
! 	Assert(!isLogSwitch || size == 0);
  
! 	size = SizeOfXLogRecord + size;
  
+ retry:
+ 	SpinLockAcquire(&Insert->insertpos_lck);
+ 
+ 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr) ||
+ 		(!didPageWrites && (Insert->forcePageWrites || Insert->fullPageWrites)))
+ 	{
  		/*
! 		 * Oops, a checkpoint just happened, or forcePageWrites was just
! 		 * turned on. Start XLogInsert() all over, because we might have to
! 		 * include more full-page images in the record.
  		 */
! 		RedoRecPtr = Insert->RedoRecPtr;
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		*EndPos_p = InvalidXLogRecPtr;
! 		return false;
! 	}
! 
! 	/*
! 	 * Reserve the next insertion slot for us.
! 	 *
! 	 * First check that the slot is not still in use. Modifications to
! 	 * lastslot are protected by WALInsertTailLock, but here we assume that
! 	 * reading an int32 is atomic. Another process might advance lastslot at
! 	 * the same time, but not past nextslot.
! 	 */
! 	lastslot = Insert->lastslot;
! 	nextslot = Insert->nextslot;
! 	if (NextSlotNo(nextslot) == lastslot)
! 	{
! 		/*
! 		 * Oops, we've "caught our tail" and the oldest slot is still in use.
! 		 * Have to wait for it to become vacant, and retry.
! 		 */
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		WaitXLogInsertionsToFinish(InvalidXLogRecPtr);
! 		goto retry;
! 	}
! 
! 	/*
! 	 * Got the slot. Now reserve the right amount of space from the WAL for
! 	 * our record.
! 	 */
! 	ptr = Insert->CurrPos;
! 	*PrevRecord_p = Insert->PrevRecord;
! 
! 	/*
! 	 * If there isn't enough space on the current XLOG page for a record
! 	 * header, advance to the next page (leaving the unused space as zeroes).
! 	 */
! 	freespace = INSERT_FREESPACE(ptr);
! 	if (freespace < SizeOfXLogRecord)
! 	{
! 		XLByteAdvance(ptr, freespace);
! 		BeginCurrPos = ptr;
! 
! 		if (ptr.xrecoff % XLogSegSize == 0)
! 			ptr.xrecoff += SizeOfXLogLongPHD;
! 		else
! 			ptr.xrecoff += SizeOfXLogShortPHD;
! 		freespace = INSERT_FREESPACE(ptr);
! 		updrqst = true;
! 	}
! 	else
! 		BeginCurrPos = ptr;
  
! 	/*
! 	 * We are now at the starting position of our record. Now figure out how
! 	 * the data will be split across the WAL pages, to calculate where the
! 	 * record ends.
! 	 */
! 	StartPos = ptr;
  
+ 	if (isLogSwitch)
+ 	{
  		/*
! 		 * If the record is an XLOG_SWITCH, and we are exactly at the start
! 		 * of a segment, we need not insert it (and don't want to because
! 		 * we'd like consecutive switch requests to be no-ops). Otherwise the
! 		 * XLOG_SWITCH record should consume all the remaining space on the
! 		 * current segment.
  		 */
+ 		if ((ptr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
  		{
! 			/* We can release insert lock immediately */
! 			SpinLockRelease(&Insert->insertpos_lck);
  
! 			ptr.xrecoff -= SizeOfXLogLongPHD;
! 			if (ptr.xrecoff == 0)
! 			{
! 				/* crossing a logid boundary */
! 				ptr.xlogid -= 1;
! 				ptr.xrecoff = XLogFileSize;
! 			}
  
! 			*EndPos_p = ptr;
! 			*StartPos_p = ptr;
! 			*myslot_p = NULL;
  
! 			return false;
! 		}
! 		else
! 		{
! 			if (ptr.xrecoff % XLOG_SEG_SIZE != 0)
! 			{
! 				int segleft = XLOG_SEG_SIZE - (ptr.xrecoff % XLOG_SEG_SIZE);
! 				XLByteAdvance(ptr, segleft);
! 			}
! 			updrqst = true;
! 		}
  	}
  	else
  	{
! 		/*
! 		 * A normal record, ie. not xlog-switch. Calculate how the record will
! 		 * be layed out across WAL pages. The straightforward way to do this
! 		 * would be a loop that fills in the WAL pages one at a time, tracking
! 		 * how much of the size is still left.  That's how the
! 		 * CopyXLogRecordToWAL() works when actually copying the data.
! 		 * However, we want to avoid looping to keep this spinlock-protected
! 		 * as short as possible, if the record spans many pages.
! 		 */
! 		int		sizeleft = size;
  
! 		if (sizeleft > freespace)
  		{
! 			int		pagesneeded;
! 			int		pagesleftonseg;
! 			int		fullpages;
! 
! 			/* First fill the first page with as much data as fits. */
! 			sizeleft -= freespace;
! 			XLByteAdvance(ptr, freespace);
! 
! 			/* We're now positioned at the beginning of the next page */
! 			Assert(ptr.xrecoff % XLOG_BLCKSZ == 0);
! 			do
! 			{
! 				/*
! 				 * If we're positioned at the beginning of a segment, take
! 				 * into account that the first page needs a long header.
! 				 */
! 				if (ptr.xrecoff % XLOG_SEG_SIZE == 0)
! 					sizeleft += (SizeOfXLogLongPHD - SizeOfXLogShortPHD);
! 
! 				/*
! 				 * Calculate the number of extra pages we need.  Each page
! 				 * will have a continuation record at the beginning.
! 				 *
! 				 * We do the calculation assuming that all the pages have a
! 				 * short header.  We don't know whether we have to cross to
! 				 * the next segment until we've calculated how many pages we
! 				 * need. If it turns out that we do, we'll fill up the current
! 				 * segment, and loop back to add the long page header to
! 				 * sizeleft, and continue calculation from there.
! 				 */
! #define SpaceOnXLogPage	(XLOG_BLCKSZ - SizeOfXLogShortPHD - SizeOfXLogContRecord)
! 				pagesneeded = (sizeleft + SpaceOnXLogPage - 1) / SpaceOnXLogPage;
! 
! 				pagesleftonseg = (XLOG_SEG_SIZE - (ptr.xrecoff % XLOG_SEG_SIZE)) / XLOG_BLCKSZ;
! 
! 				if (pagesneeded <= pagesleftonseg)
! 				{
! 					/*
! 					 * Fits in this segment. Skip over all the full pages, to
! 					 * the last page that will (possibly) be only partially
! 					 * filled.
! 					 */
! 					fullpages = pagesneeded - 1;
! 				}
! 				else
! 				{
! 					/*
! 					 * Doesn't fit in this segment. Fit as much as does, and
! 					 * continue from next segment.
! 					 */
! 					fullpages = pagesleftonseg;
! 				}
! 
! 				sizeleft -= fullpages * SpaceOnXLogPage;
! 				XLByteAdvance(ptr, fullpages * XLOG_BLCKSZ);
! 			} while (pagesneeded > pagesleftonseg);
! 
! 			/*
! 			 * We're now positioned at the beginning of the last page this
! 			 * record spans.  The rest should fit on this page.
! 			 *
! 			 * Note: We already took into account the long header above.
! 			 */
! 			ptr.xrecoff += SizeOfXLogShortPHD;
! 			ptr.xrecoff += SizeOfXLogContRecord;
! 
! 			Assert(sizeleft <= INSERT_FREESPACE(ptr));
! 
  			updrqst = true;
  		}
! 
! 		/* the rest fits on this page */
! 		ptr.xrecoff += sizeleft;
! 
! 		/* Align the end position, so that the next record starts aligned */
! 		ptr.xrecoff = MAXALIGN(ptr.xrecoff);
! 		if (ptr.xrecoff >= XLogFileSize)
  		{
! 			/* crossed a logid boundary */
! 			ptr.xlogid += 1;
! 			ptr.xrecoff = 0;
  		}
  	}
  
! 	/* Update the shared state, and our slot, before releasing the lock */
! 	myslot = &XLogCtl->XLogInsertSlots[nextslot];
! 	myslot->CurrPos = BeginCurrPos;
  
! 	Insert->CurrPos = ptr;
! 	Insert->PrevRecord = StartPos;
! 	Insert->nextslot = NextSlotNo(nextslot);
! 
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! #ifdef RESERVE_XLOGINSERT_LOCATION_DEBUG
! 	elog(LOG, "reserved xlog: prev %X/%X, start %X/%X, end %X/%X (len %d)",
! 		 PrevRecord_p->xlogid, PrevRecord_p->xrecoff,
! 		 StartPos.xlogid, StartPos.xrecoff,
! 		 ptr.xlogid, ptr.xrecoff,
! 		 size);
! #endif
! 
! 	*EndPos_p = ptr;
! 	*StartPos_p = StartPos;
! 	*myslot_p = (XLogInsertSlot *) myslot;
! 	*updrqst_p = updrqst;
! 
! 	return true;
! }
! 
! /*
!  * Update slot's CurrPos variable, and wake up anyone waiting on it.
!  */
! static void
! UpdateSlotCurrPos(volatile XLogInsertSlot *myslot, XLogRecPtr CurrPos)
! {
! 	PGPROC	   *head;
! 
! 	/*
! 	 * The write-barrier ensures that the changes we made to the WAL pages
! 	 * are visible to everyone before the update of CurrPos.
! 	 *
! 	 * XXX: I'm not sure if this is necessary. Doesn't the spinlock
! 	 * acquire/release act as an implicit barrier?
! 	 */
! 	pg_write_barrier();
! 
! 	SpinLockAcquire(&myslot->lck);
! 	myslot->CurrPos = CurrPos;
! 	head = myslot->head;
! 	myslot->head = myslot->tail = NULL;
! 	SpinLockRelease(&myslot->lck);
! 	while (head != NULL)
  	{
! 		PGPROC *proc = head;
! 		head = proc->lwWaitLink;
! 		proc->lwWaitLink = NULL;
! 		proc->lwWaiting = false;
! 		PGSemaphoreUnlock(&proc->sem);
! 	}
! }
  
! /*
!  * Get a pointer to the right location in the WAL buffer containing the
!  * given XLogRecPtr.
!  *
!  * If the page is not initialized yet, it is initialized. That might require
!  * evicting an old dirty buffer from the buffer cache, which means I/O.
!  *
!  * The caller must ensure that the page containing the requested location
!  * isn't evicted yet, and won't be evicted, by holding onto an
!  * XLOG insertion slot with CurrPos set to 'ptr'. Setting it to some value
!  * less than 'ptr' would suffice for GetXLogBuffer(), but risks deadlock:
!  * If we have to evict a buffer, we might have to wait for someone else to
!  * finish a write. And that someone else might not be able to finish the
!  * write, if our CurrPos points to a buffer that's still in the buffer cache.
!  */
! static char *
! GetXLogBuffer(XLogRecPtr ptr)
! {
! 	int			idx;
! 	XLogRecPtr	endptr;
! 	static uint32 cachedXlogid = 0;
! 	static uint32 cachedPage = 0;
! 	static char *cachedPos = NULL;
! 	XLogRecPtr	expectedEndPtr;
! 
! 	/*
! 	 * Fast path for the common case that we need to access again the same
! 	 * page as last time.
! 	 */
! 	if (ptr.xlogid == cachedXlogid && ptr.xrecoff / XLOG_BLCKSZ == cachedPage)
! 		return cachedPos + ptr.xrecoff % XLOG_BLCKSZ;
! 
! 	cachedXlogid = ptr.xlogid;
! 	cachedPage = ptr.xrecoff / XLOG_BLCKSZ;
! 
! 	/*
! 	 * The XLog buffer cache is organized so a page must always be loaded
! 	 * to a particular buffer.  That way we can easily calculate the buffer
! 	 * a given page must be loaded into, from the XLogRecPtr alone.
! 	 */
! 	idx = XLogRecPtrToBufIdx(ptr);
! 
! 	/*
! 	 * See what page is loaded in the buffer at the moment. It could be the
! 	 * page we're looking for, or something older. It can't be anything
! 	 * newer - that would imply the page we're looking for has already
! 	 * been written out to disk, which shouldn't happen as long as the caller
! 	 * has set its slot's CurrPos correctly.
! 	 *
! 	 * However, we don't hold a lock while we read the value. If someone has
! 	 * just initialized the page, it's possible that we get a "torn read" of
! 	 * the XLogRecPtr, and see a bogus value. That's ok, we'll grab the
! 	 * mapping lock (in AdvanceXLInsertBuffer) and retry if we see anything
! 	 * else than the page we're looking for. But it means that when we do this
! 	 * unlocked read, we might see a value that appears to be ahead of the
! 	 * page we're looking for. Don't PANIC on that, until we've verified the
! 	 * value while holding the lock.
! 	 */
! 	expectedEndPtr.xlogid = ptr.xlogid;
! 	expectedEndPtr.xrecoff = ptr.xrecoff - ptr.xrecoff % XLOG_BLCKSZ + XLOG_BLCKSZ;
! 
! 	endptr = XLogCtl->xlblocks[idx];
! 	if (!XLByteEQ(expectedEndPtr, endptr))
! 	{
! 		AdvanceXLInsertBuffer(ptr, false);
! 		endptr = XLogCtl->xlblocks[idx];
! 
! 		if (!XLByteEQ(expectedEndPtr, endptr))
! 			elog(PANIC, "could not find WAL buffer for %X/%X",
! 				 ptr.xlogid, ptr.xrecoff);
  	}
  
! 	/*
! 	 * Found the buffer holding this page. Return a pointer to the right
! 	 * offset within the page.
! 	 */
! 	cachedPos = XLogCtl->pages + idx * (Size) XLOG_BLCKSZ;
! 	return XLogCtl->pages + idx * (Size) XLOG_BLCKSZ +
! 		ptr.xrecoff % XLOG_BLCKSZ;
! }
  
! /*
!  * Try to mark old insertion slots as free for reuse.
!  */
! static void
! ReuseOldSlots(void)
! {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			lastslot;
! 	int			nextslot;
  
! 	/* Give up if someone else is already doing this */
! 	if (!LWLockConditionalAcquire(WALInsertTailLock, LW_EXCLUSIVE))
! 		return;
! 
! 	lastslot = Insert->lastslot;
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	nextslot = Insert->nextslot;
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! 	while (lastslot != nextslot)
! 	{
! 		/*
! 		 * Check if the oldest slot is still in use. We don't do any locking
! 		 * here, we just give up as soon as we find a slot that's still in
! 		 * use.
! 		 */
! 		volatile XLogInsertSlot *slot;
! 		slot = &XLogCtl->XLogInsertSlots[lastslot];
! 
! 		if (!XLByteEQ(slot->CurrPos, InvalidXLogRecPtr))
! 			break;
! 
! 		lastslot = NextSlotNo(lastslot);
! 	}
! 
! 	Insert->lastslot = lastslot;
! 	LWLockRelease(WALInsertTailLock);
! }
! 
! /*
!  * Wait for any insertions < upto to finish. If upto is invalid, we wait until
!  * at least one slot is available for insertion.
!  *
!  * Returns a value >= upto, which indicates the oldest in-progress insertion
!  * that we saw in the array, or InvalidXLogRecPtr if there are no insertions
!  * in-progress at exit.
!  */
! static XLogRecPtr
! WaitXLogInsertionsToFinish(XLogRecPtr upto)
! {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			lastslot;
! 	int			nextslot;
! 	XLogRecPtr	LastPos = InvalidXLogRecPtr;
! 	int			extraWaits = 0;
! 
! 	if (MyProc == NULL)
! 		elog(PANIC, "cannot wait without a PGPROC structure");
! 
! retry:
! 	/*
! 	 * Read lastslot and nextslot. lastslot cannot change while we hold the
! 	 * tail-lock. nextslot can advance while we run, but not beyond
! 	 * lastslot - 1. We still have to acquire insertpos_lck to make sure that
! 	 * we see the CurrPos of the latest slot correctly.
! 	 */
! 	LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
! 	lastslot = Insert->lastslot;
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	nextslot = Insert->nextslot;
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! 	while (lastslot != nextslot)
! 	{
! 		/*
! 		 * Examine the oldest slot still in use.
! 		 */
! 		volatile XLogInsertSlot *slot;
! 		XLogRecPtr	slotptr;
! 
! 		slot = &XLogCtl->XLogInsertSlots[lastslot];
! 
! 		/* First, a quick check without the lock. */
! 		if (XLByteEQ(slot->CurrPos, InvalidXLogRecPtr))
! 		{
! 			lastslot = NextSlotNo(lastslot);
! 			continue;
! 		}
! 
! 		SpinLockAcquire(&slot->lck);
! 		slotptr = slot->CurrPos;
! 
! 		if (XLByteEQ(slotptr, InvalidXLogRecPtr))
! 		{
! 			/*
! 			 * The insertion has already finished, we just need to advance
! 			 * lastslot to make the slot available for reuse.
! 			 */
! 			SpinLockRelease(&slot->lck);
! 			lastslot = NextSlotNo(lastslot);
! 			continue;
! 		}
! 		else
! 		{
! 			/*
! 			 * The insertion is still in-progress. If we just needed for
! 			 * any slot to become available and there is at least one slot
! 			 * free now, or if this slot's CurrPos >= upto, we can
! 			 * stop here. Otherwise we have to wait for it to finish.
! 			 */
! 			if ((XLogRecPtrIsInvalid(upto) && NextSlotNo(nextslot) != lastslot)
! 				|| (!XLogRecPtrIsInvalid(upto) && XLByteLE(upto, slotptr)))
! 			{
! 				SpinLockRelease(&slot->lck);
! 				LastPos = slotptr;
! 				break;
! 			}
! 			else
! 			{
! 				/* Wait for this insertion to finish. */
! 				MyProc->lwWaiting = true;
! 				MyProc->lwWaitMode = 0; /* doesn't matter */
! 				MyProc->lwWaitLink = NULL;
! 				if (slot->head == NULL)
! 					slot->head = MyProc;
! 				else
! 					slot->tail->lwWaitLink = MyProc;
! 				slot->tail = MyProc;
! 				SpinLockRelease(&slot->lck);
! 
! 				Insert->lastslot = lastslot;
! 				LWLockRelease(WALInsertTailLock);
! 				for (;;)
! 				{
! 					PGSemaphoreLock(&MyProc->sem, false);
! 					if (!MyProc->lwWaiting)
! 						break;
! 					extraWaits++;
! 				}
! 
! 				/*
! 				 * The insertion has now finished. Start all over. While we
! 				 * were not holding the tail-lock, someone might've filled up
! 				 * all slots again.
! 				 */
! 				goto retry;
! 			}
! 		}
! 	}
! 
! 	/* Update lastslot before we release the lock */
! 	Insert->lastslot = lastslot;
! 	LWLockRelease(WALInsertTailLock);
! 
! 	while (extraWaits-- > 0)
! 		PGSemaphoreUnlock(&MyProc->sem);
! 
! 	return LastPos;
  }
  
  /*
***************
*** 1440,1469 **** XLogArchiveCleanup(const char *xlog)
  }
  
  /*
!  * Advance the Insert state to the next buffer page, writing out the next
!  * buffer if it still contains unwritten data.
!  *
!  * If new_segment is TRUE then we set up the next buffer page as the first
!  * page of the next xlog segment file, possibly but not usually the next
!  * consecutive file page.
!  *
!  * The global LogwrtRqst.Write pointer needs to be advanced to include the
!  * just-filled page.  If we can do this for free (without an extra lock),
!  * we do so here.  Otherwise the caller must do it.  We return TRUE if the
!  * request update still needs to be done, FALSE if we did it internally.
!  *
!  * Must be called with WALInsertLock held.
   */
! static bool
! AdvanceXLInsertBuffer(bool new_segment)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			nextidx = NextBufIdx(Insert->curridx);
! 	bool		update_needed = true;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
! 	XLogRecPtr	NewPageEndPtr;
  	XLogPageHeader NewPage;
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
--- 2119,2151 ----
  }
  
  /*
!  * Initialize XLOG buffers, writing out old buffers if they still contain
!  * unwritten data, upto the page containing 'upto'. Or if 'opportunistic' is
!  * true, initialize as many pages as we can without having to write out
!  * unwritten data. Any new pages are initialized to zeros, with pages headers
!  * initialized properly.
   */
! static void
! AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			nextidx;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
! 	XLogRecPtr	NewPageEndPtr = InvalidXLogRecPtr;
  	XLogPageHeader NewPage;
+ 	int			npages = 0;
+ 
+ 	LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
+ 
+ 	/*
+ 	 * Now that we have the lock, check if someone initialized the page
+ 	 * already.
+ 	 */
+ /* XXX: fix indentation before commit */
+ while (!XLByteLT(upto, XLogCtl->xlblocks[XLogCtl->curridx]) || opportunistic)
+ {
+ 	nextidx = NextBufIdx(XLogCtl->curridx);
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
***************
*** 1473,1482 **** AdvanceXLInsertBuffer(bool new_segment)
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
  	if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  	{
! 		/* nope, got work to do... */
! 		XLogRecPtr	FinishedPageRqstPtr;
! 
! 		FinishedPageRqstPtr = XLogCtl->xlblocks[Insert->curridx];
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
--- 2155,2166 ----
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
  	if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  	{
! 		/*
! 		 * Nope, got work to do. If we just want to pre-initialize as much as
! 		 * we can without flushing, give up now.
! 		 */
! 		if (opportunistic)
! 			break;
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
***************
*** 1484,1504 **** AdvanceXLInsertBuffer(bool new_segment)
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, FinishedPageRqstPtr))
! 				xlogctl->LogwrtRqst.Write = FinishedPageRqstPtr;
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
- 		update_needed = false;	/* Did the shared-request update */
- 
  		/*
  		 * Now that we have an up-to-date LogwrtResult value, see if we still
  		 * need to write it or if someone else already did.
  		 */
  		if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/* Must acquire write lock */
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  			LogwrtResult = XLogCtl->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
--- 2168,2194 ----
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, OldPageRqstPtr))
! 				xlogctl->LogwrtRqst.Write = OldPageRqstPtr;
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
  		/*
  		 * Now that we have an up-to-date LogwrtResult value, see if we still
  		 * need to write it or if someone else already did.
  		 */
  		if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/*
! 			 * Must acquire write lock. Release WALBufMappingLock first, to
! 			 * make sure that all insertions that we need to wait for can
! 			 * finish (up to this same position). Otherwise we risk deadlock.
! 			 */
! 			LWLockRelease(WALBufMappingLock);
! 
! 			WaitXLogInsertionsToFinish(OldPageRqstPtr);
! 
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  			LogwrtResult = XLogCtl->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
***************
*** 1508,1525 **** AdvanceXLInsertBuffer(bool new_segment)
  			}
  			else
  			{
! 				/*
! 				 * Have to write buffers while holding insert lock. This is
! 				 * not good, so only write as much as we absolutely must.
! 				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false, false);
  				LWLockRelease(WALWriteLock);
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
  		}
  	}
  
--- 2198,2215 ----
  			}
  			else
  			{
! 				/* Have to write it ourselves */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false);
  				LWLockRelease(WALWriteLock);
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
+ 			/* Re-acquire WALBufMappingLock and retry */
+ 			LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
+ 			continue;
  		}
  	}
  
***************
*** 1527,1540 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[Insert->curridx];
! 
! 	if (new_segment)
! 	{
! 		/* force it to a segment start point */
! 		NewPageEndPtr.xrecoff += XLogSegSize - 1;
! 		NewPageEndPtr.xrecoff -= NewPageEndPtr.xrecoff % XLogSegSize;
! 	}
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
--- 2217,2223 ----
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[XLogCtl->curridx];
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
***************
*** 1544,1556 **** AdvanceXLInsertBuffer(bool new_segment)
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
! 	XLogCtl->xlblocks[nextidx] = NewPageEndPtr;
! 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
! 
! 	Insert->curridx = nextidx;
! 	Insert->currpage = NewPage;
  
! 	Insert->currpos = ((char *) NewPage) +SizeOfXLogShortPHD;
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
--- 2227,2236 ----
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
! 	Assert(NewPageEndPtr.xrecoff % XLOG_BLCKSZ == 0);
! 	Assert(XLogRecEndPtrToBufIdx(NewPageEndPtr) == nextidx);
  
! 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
***************
*** 1594,1604 **** AdvanceXLInsertBuffer(bool new_segment)
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
- 
- 		Insert->currpos = ((char *) NewPage) +SizeOfXLogLongPHD;
  	}
  
! 	return update_needed;
  }
  
  /*
--- 2274,2301 ----
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
  	}
  
! 	/*
! 	 * Make sure the initialization of the page becomes visible to others
! 	 * before the xlblocks update. GetXLogBuffer() reads xlblocks without
! 	 * holding a lock.
! 	 */
! 	pg_write_barrier();
! 
! 	*((volatile XLogRecPtr *) &XLogCtl->xlblocks[nextidx]) = NewPageEndPtr;
! 
! 	XLogCtl->curridx = nextidx;
! 
! 	npages++;
! }
! 	LWLockRelease(WALBufMappingLock);
! 
! #ifdef WAL_DEBUG
! 	if (npages > 0)
! 		elog(DEBUG1, "initialized %d pages, upto %X/%X",
! 			 npages, NewPageEndPtr.xlogid, NewPageEndPtr.xrecoff);
! #endif
  }
  
  /*
***************
*** 1643,1658 **** XLogCheckpointNeeded(uint32 logid, uint32 logseg)
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * If xlog_switch == TRUE, we are intending an xlog segment switch, so
!  * perform end-of-segment actions after writing the last page, even if
!  * it's not physically the end of its segment.  (NB: this will work properly
!  * only if caller specifies WriteRqst == page-end and flexible == false,
!  * and there is some data to write.)
!  *
!  * Must be called with WALWriteLock held.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
--- 2340,2351 ----
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * Must be called with WALWriteLock held. And you must've called
!  * WaitXLogInsertionsToFinish(WriteRqst) before grabbing the lock to make sure
!  * the data is ready to write.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
***************
*** 1701,1714 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  		 * if we're passed a bogus WriteRqst.Write that is past the end of the
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
! 		if (!XLByteLT(LogwrtResult.Write, XLogCtl->xlblocks[curridx]))
  			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
! 				 XLogCtl->xlblocks[curridx].xlogid,
! 				 XLogCtl->xlblocks[curridx].xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
! 		LogwrtResult.Write = XLogCtl->xlblocks[curridx];
  		ispartialpage = XLByteLT(WriteRqst.Write, LogwrtResult.Write);
  
  		if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
--- 2394,2407 ----
  		 * if we're passed a bogus WriteRqst.Write that is past the end of the
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
! 		XLogRecPtr EndPtr = XLogCtl->xlblocks[curridx];
! 		if (!XLByteLT(LogwrtResult.Write, EndPtr))
  			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
! 				 EndPtr.xlogid, EndPtr.xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
! 		LogwrtResult.Write = EndPtr;
  		ispartialpage = XLByteLT(WriteRqst.Write, LogwrtResult.Write);
  
  		if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
***************
*** 1805,1820 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
- 			 * We also do this if this is the last page written for an xlog
- 			 * switch.
- 			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg || (xlog_switch && last_iteration))
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
--- 2498,2510 ----
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg)
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
***************
*** 2066,2073 **** XLogFlush(XLogRecPtr record)
  	 */
  	for (;;)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
  		volatile XLogCtlData *xlogctl = XLogCtl;
  
  		/* read LogwrtResult and update local state */
  		SpinLockAcquire(&xlogctl->info_lck);
--- 2756,2767 ----
  	 */
  	for (;;)
  	{
! 		/* use volatile pointers to prevent code rearrangement */
  		volatile XLogCtlData *xlogctl = XLogCtl;
+ 		volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
+ 		uint32		freespace;
+ 		XLogRecPtr	insertpos,
+ 					inprogresspos;
  
  		/* read LogwrtResult and update local state */
  		SpinLockAcquire(&xlogctl->info_lck);
***************
*** 2081,2086 **** XLogFlush(XLogRecPtr record)
--- 2775,2812 ----
  			break;
  
  		/*
+ 		 * Get the current insert position.
+ 		 *
+ 		 * XXX: This used to do LWLockConditionalAcquire(WALInsertLock),
+ 		 * fall back to writing just up to 'record' if we couldn't get the
+ 		 * lock. I wonder if it would be a good idea to have a
+ 		 * SpinLockConditionalAcquire function and use that? On one hand,
+ 		 * it would be good to not cause more contention on the lock if it's
+ 		 * busy, but on the other hand, this spinlock is much more lightweight
+ 		 * than the WALInsertLock was, so maybe it's better to just grab the
+ 		 * spinlock. In fact, LWLockConditionalAcquire did a spinlock acquire
+ 		 * + release, anyway. Also note that if we stored the XLogRecPtr as
+ 		 * one 64-bit integer, we could just read it with no lock on platforms
+ 		 * where 64-bit integer accesses are atomic, which covers many common
+ 		 * platforms nowadays.
+ 		 */
+ 		SpinLockAcquire(&Insert->insertpos_lck);
+ 		insertpos = Insert->CurrPos;
+ 		SpinLockRelease(&Insert->insertpos_lck);
+ 
+ 		freespace = INSERT_FREESPACE(insertpos);
+ 		if (freespace < SizeOfXLogRecord)               /* buffer is full */
+ 			insertpos.xrecoff += freespace;
+ 
+ 		/*
+ 		 * Before actually performing the write, wait for all in-flight
+ 		 * insertions to the pages we're about to write to finish.
+ 		 */
+ 		inprogresspos = WaitXLogInsertionsToFinish(WriteRqstPtr);
+ 		if (!XLogRecPtrIsInvalid(inprogresspos))
+ 			insertpos = inprogresspos;
+ 
+ 		/*
  		 * Try to get the write lock. If we can't get it immediately, wait
  		 * until it's released, and recheck if we still need to do the flush
  		 * or if the backend that held the lock did it for us already. This
***************
*** 2100,2128 **** XLogFlush(XLogRecPtr record)
  		LogwrtResult = XLogCtl->LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			/* try to write/flush later additions to XLOG as well */
! 			if (LWLockConditionalAcquire(WALInsertLock, LW_EXCLUSIVE))
! 			{
! 				XLogCtlInsert *Insert = &XLogCtl->Insert;
! 				uint32		freespace = INSERT_FREESPACE(Insert);
  
! 				if (freespace < SizeOfXLogRecord)		/* buffer is full */
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 				else
! 				{
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 					WriteRqstPtr.xrecoff -= freespace;
! 				}
! 				LWLockRelease(WALInsertLock);
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = WriteRqstPtr;
! 			}
! 			else
! 			{
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = record;
! 			}
! 			XLogWrite(WriteRqst, false, false);
  		}
  		LWLockRelease(WALWriteLock);
  		/* done */
--- 2826,2835 ----
  		LogwrtResult = XLogCtl->LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			WriteRqst.Write = insertpos;
! 			WriteRqst.Flush = insertpos;
  
! 			XLogWrite(WriteRqst, false);
  		}
  		LWLockRelease(WALWriteLock);
  		/* done */
***************
*** 2237,2243 **** XLogBackgroundFlush(void)
  
  	START_CRIT_SECTION();
  
! 	/* now wait for the write lock */
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  	LogwrtResult = XLogCtl->LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
--- 2944,2951 ----
  
  	START_CRIT_SECTION();
  
! 	/* now wait for any in-progress insertions to finish and get write lock */
! 	WaitXLogInsertionsToFinish(WriteRqstPtr);
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  	LogwrtResult = XLogCtl->LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
***************
*** 2246,2256 **** XLogBackgroundFlush(void)
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible, false);
  	}
- 	LWLockRelease(WALWriteLock);
  
  	END_CRIT_SECTION();
  }
  
  /*
--- 2954,2971 ----
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible);
  	}
  
  	END_CRIT_SECTION();
+ 
+ 	LWLockRelease(WALWriteLock);
+ 
+ 	/*
+ 	 * Great, done. To take some work off the critical path, try to initialize
+ 	 * as many of the no-longer-needed WAL buffers for future use as we can.
+ 	 */
+ 	AdvanceXLInsertBuffer(InvalidXLogRecPtr, true);
  }
  
  /*
***************
*** 5059,5064 **** XLOGShmemInit(void)
--- 5774,5780 ----
  	bool		foundCFile,
  				foundXLog;
  	char	   *allocptr;
+ 	int			i;
  
  	ControlFile = (ControlFileData *)
  		ShmemInitStruct("Control File", sizeof(ControlFileData), &foundCFile);
***************
*** 5084,5089 **** XLOGShmemInit(void)
--- 5800,5816 ----
  	memset(XLogCtl->xlblocks, 0, sizeof(XLogRecPtr) * XLOGbuffers);
  	allocptr += sizeof(XLogRecPtr) * XLOGbuffers;
  
+ 	/* Initialize insertion slots */
+ 	for (i = 0; i < NumXLogInsertSlots; i++)
+ 	{
+ 		XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[i];
+ 		slot->CurrPos = InvalidXLogRecPtr;
+ 		slot->head = slot->tail = NULL;
+ 		SpinLockInit(&slot->lck);
+ 	}
+ 	XLogCtl->Insert.nextslot = 0;
+ 	XLogCtl->Insert.lastslot = 0;
+ 
  	/*
  	 * Align the start of the page buffers to an ALIGNOF_XLOG_BUFFER boundary.
  	 */
***************
*** 5098,5104 **** XLOGShmemInit(void)
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
! 	XLogCtl->Insert.currpage = (XLogPageHeader) (XLogCtl->pages);
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
--- 5825,5831 ----
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
! 	SpinLockInit(&XLogCtl->Insert.insertpos_lck);
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
***************
*** 5980,5985 **** StartupXLOG(void)
--- 6707,6713 ----
  	bool		backupEndRequired = false;
  	bool		backupFromStandby = false;
  	DBState		dbstate_at_startup;
+ 	int			firstIdx;
  
  	/*
  	 * Read control file and check XLOG status looks valid.
***************
*** 6232,6238 **** StartupXLOG(void)
  
  	lastFullPageWrites = checkPoint.fullPageWrites;
  
! 	RedoRecPtr = XLogCtl->Insert.RedoRecPtr = checkPoint.redo;
  
  	if (XLByteLT(RecPtr, checkPoint.redo))
  		ereport(PANIC,
--- 6960,6966 ----
  
  	lastFullPageWrites = checkPoint.fullPageWrites;
  
! 	RedoRecPtr = XLogCtl->RedoRecPtr = XLogCtl->Insert.RedoRecPtr = checkPoint.redo;
  
  	if (XLByteLT(RecPtr, checkPoint.redo))
  		ereport(PANIC,
***************
*** 6786,6793 **** StartupXLOG(void)
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 	XLogCtl->xlblocks[0].xlogid = openLogId;
! 	XLogCtl->xlblocks[0].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
--- 7514,7525 ----
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 
! 	firstIdx = XLogRecEndPtrToBufIdx(EndOfLog);
! 	XLogCtl->curridx = firstIdx;
! 
! 	XLogCtl->xlblocks[firstIdx].xlogid = openLogId;
! 	XLogCtl->xlblocks[firstIdx].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
***************
*** 6795,6804 **** StartupXLOG(void)
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[0].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) Insert->currpage, readBuf, XLOG_BLCKSZ);
! 	Insert->currpos = (char *) Insert->currpage +
! 		(EndOfLog.xrecoff + XLOG_BLCKSZ - XLogCtl->xlblocks[0].xrecoff);
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
--- 7527,7535 ----
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[firstIdx].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) &XLogCtl->pages[firstIdx * XLOG_BLCKSZ], readBuf, XLOG_BLCKSZ);
! 	Insert->CurrPos = EndOfLog;
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
***************
*** 6807,6818 **** StartupXLOG(void)
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(Insert->currpos, 0, freespace);
! 		XLogCtl->Write.curridx = 0;
  	}
  	else
  	{
--- 7538,7549 ----
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = INSERT_FREESPACE(EndOfLog);
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(&XLogCtl->pages[firstIdx * XLOG_BLCKSZ] + EndOfLog.xrecoff % XLOG_BLCKSZ, 0, freespace);
! 		XLogCtl->Write.curridx = firstIdx;
  	}
  	else
  	{
***************
*** 6824,6830 **** StartupXLOG(void)
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(0);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
--- 7555,7561 ----
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(firstIdx);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
***************
*** 7307,7327 **** InitXLOGAccess(void)
  }
  
  /*
!  * Once spawned, a backend may update its local RedoRecPtr from
!  * XLogCtl->Insert.RedoRecPtr; it must hold the insert lock or info_lck
!  * to do so.  This is done in XLogInsert() or GetRedoRecPtr().
   */
  XLogRecPtr
  GetRedoRecPtr(void)
  {
  	/* use volatile pointer to prevent code rearrangement */
  	volatile XLogCtlData *xlogctl = XLogCtl;
  
  	SpinLockAcquire(&xlogctl->info_lck);
! 	Assert(XLByteLE(RedoRecPtr, xlogctl->Insert.RedoRecPtr));
! 	RedoRecPtr = xlogctl->Insert.RedoRecPtr;
  	SpinLockRelease(&xlogctl->info_lck);
  
  	return RedoRecPtr;
  }
  
--- 8038,8066 ----
  }
  
  /*
!  * Return the current Redo pointer from shared memory.
!  *
!  * As a side-effect, the local RedoRecPtr copy is updated.
   */
  XLogRecPtr
  GetRedoRecPtr(void)
  {
  	/* use volatile pointer to prevent code rearrangement */
  	volatile XLogCtlData *xlogctl = XLogCtl;
+ 	XLogRecPtr ptr;
  
+ 	/*
+ 	 * The possibly not up-to-date copy in XlogCtl is enough. Even if we
+ 	 * grabbed insertpos_lck to read the master copy, someone might update
+ 	 * it just after we've released the lock.
+ 	 */
  	SpinLockAcquire(&xlogctl->info_lck);
! 	ptr = xlogctl->RedoRecPtr;
  	SpinLockRelease(&xlogctl->info_lck);
  
+ 	if (XLByteLT(RedoRecPtr, ptr))
+ 		RedoRecPtr = xlogctl->RedoRecPtr;
+ 
  	return RedoRecPtr;
  }
  
***************
*** 7330,7336 **** GetRedoRecPtr(void)
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire WALInsertLock which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
--- 8069,8075 ----
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire insertpos_lck which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
***************
*** 7592,7597 **** LogCheckpointEnd(bool restartpoint)
--- 8331,8338 ----
  void
  CreateCheckPoint(int flags)
  {
+ 	/* use volatile pointer to prevent code rearrangement */
+ 	volatile XLogCtlData *xlogctl = XLogCtl;
  	bool		shutdown;
  	CheckPoint	checkPoint;
  	XLogRecPtr	recptr;
***************
*** 7606,7611 **** CreateCheckPoint(int flags)
--- 8347,8353 ----
  	uint32		insert_logSeg;
  	TransactionId *inCommitXids;
  	int			nInCommit;
+ 	XLogRecPtr	curInsert;
  
  	/*
  	 * An end-of-recovery checkpoint is really a shutdown checkpoint, just
***************
*** 7674,7683 **** CreateCheckPoint(int flags)
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * We must hold WALInsertLock while examining insert state to determine
  	 * the checkpoint REDO pointer.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
--- 8416,8426 ----
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * We must hold insertpos_lck while examining insert state to determine
  	 * the checkpoint REDO pointer.
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	curInsert = Insert->CurrPos;
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
***************
*** 7689,7695 **** CreateCheckPoint(int flags)
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding the WALInsertLock we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
--- 8432,8438 ----
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding insertpos_lck we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
***************
*** 7698,7712 **** CreateCheckPoint(int flags)
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
- 		XLogRecPtr	curInsert;
- 
- 		INSERT_RECPTR(curInsert, Insert, Insert->curridx);
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			LWLockRelease(WALInsertLock);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
--- 8441,8452 ----
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
***************
*** 7733,7750 **** CreateCheckPoint(int flags)
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace < SizeOfXLogRecord)
  	{
! 		(void) AdvanceXLInsertBuffer(false);
! 		/* OK to ignore update return flag, since we will do flush anyway */
! 		freespace = INSERT_FREESPACE(Insert);
  	}
! 	INSERT_RECPTR(checkPoint.redo, Insert, Insert->curridx);
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
! 	 * must be done while holding the insert lock AND the info_lck.
  	 *
  	 * Note: if we fail to complete the checkpoint, RedoRecPtr will be left
  	 * pointing past where it really needs to point.  This is okay; the only
--- 8473,8492 ----
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(curInsert);
  	if (freespace < SizeOfXLogRecord)
  	{
! 		XLByteAdvance(curInsert, freespace);
! 		if (curInsert.xrecoff % XLogSegSize == 0)
! 			curInsert.xrecoff += SizeOfXLogLongPHD;
! 		else
! 			curInsert.xrecoff += SizeOfXLogShortPHD;
  	}
! 	checkPoint.redo = curInsert;
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
! 	 * must be done while holding the insert lock.
  	 *
  	 * Note: if we fail to complete the checkpoint, RedoRecPtr will be left
  	 * pointing past where it really needs to point.  This is okay; the only
***************
*** 7753,7772 **** CreateCheckPoint(int flags)
  	 * XLogInserts that happen while we are dumping buffers must assume that
  	 * their buffer changes are not included in the checkpoint.
  	 */
! 	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
! 
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		RedoRecPtr = xlogctl->Insert.RedoRecPtr = checkPoint.redo;
! 		SpinLockRelease(&xlogctl->info_lck);
! 	}
  
  	/*
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
--- 8495,8512 ----
  	 * XLogInserts that happen while we are dumping buffers must assume that
  	 * their buffer changes are not included in the checkpoint.
  	 */
! 	RedoRecPtr = xlogctl->Insert.RedoRecPtr = checkPoint.redo;
  
  	/*
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! 	/* Update the info_lck-protected copy of RedoRecPtr as well */
! 	SpinLockAcquire(&xlogctl->info_lck);
! 	xlogctl->RedoRecPtr = checkPoint.redo;
! 	SpinLockRelease(&xlogctl->info_lck);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
***************
*** 7786,7792 **** CreateCheckPoint(int flags)
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released WALInsertLock, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
--- 8526,8532 ----
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released insertpos_lck, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
***************
*** 8153,8167 **** CreateRestartPoint(int flags)
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * You need to hold WALInsertLock and info_lck to update it, although
! 	 * during recovery acquiring WALInsertLock is just pro forma, because
! 	 * there is no other processes updating Insert.RedoRecPtr.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
- 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * Prepare to accumulate statistics.
--- 8893,8910 ----
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * Like in CreatecheckPoint(), hold insertpos_lck to update it, although
! 	 * during recovery acquiring insertpos_lck is just pro forma, because no
! 	 * WAL insertions are happening.
  	 */
! 	SpinLockAcquire(&xlogctl->Insert.insertpos_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
+ 	SpinLockRelease(&xlogctl->Insert.insertpos_lck);
+ 
+ 	/* Also update the info_lck-protected copy */
+ 	SpinLockAcquire(&xlogctl->info_lck);
+ 	xlogctl->RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
  
  	/*
  	 * Prepare to accumulate statistics.
***************
*** 8448,8454 **** XLogReportParameters(void)
  void
  UpdateFullPageWrites(void)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  
  	/*
  	 * Do nothing if full_page_writes has not been changed.
--- 9191,9197 ----
  void
  UpdateFullPageWrites(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  
  	/*
  	 * Do nothing if full_page_writes has not been changed.
***************
*** 8471,8479 **** UpdateFullPageWrites(void)
  	 */
  	if (fullPageWrites)
  	{
! 		LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  		Insert->fullPageWrites = true;
! 		LWLockRelease(WALInsertLock);
  	}
  
  	/*
--- 9214,9222 ----
  	 */
  	if (fullPageWrites)
  	{
! 		SpinLockAcquire(&Insert->insertpos_lck);
  		Insert->fullPageWrites = true;
! 		SpinLockRelease(&Insert->insertpos_lck);
  	}
  
  	/*
***************
*** 8494,8502 **** UpdateFullPageWrites(void)
  
  	if (!fullPageWrites)
  	{
! 		LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  		Insert->fullPageWrites = false;
! 		LWLockRelease(WALInsertLock);
  	}
  	END_CRIT_SECTION();
  }
--- 9237,9245 ----
  
  	if (!fullPageWrites)
  	{
! 		SpinLockAcquire(&Insert->insertpos_lck);
  		Insert->fullPageWrites = false;
! 		SpinLockRelease(&Insert->insertpos_lck);
  	}
  	END_CRIT_SECTION();
  }
***************
*** 9024,9029 **** issue_xlog_fsync(int fd, uint32 log, uint32 seg)
--- 9767,9773 ----
  XLogRecPtr
  do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	bool		backup_started_in_recovery = false;
  	XLogRecPtr	checkpointloc;
***************
*** 9086,9111 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  	 * Note that forcePageWrites has no effect during an online backup from
  	 * the standby.
  	 *
! 	 * We must hold WALInsertLock to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
! 		if (XLogCtl->Insert.exclusiveBackup)
  		{
! 			LWLockRelease(WALInsertLock);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		XLogCtl->Insert.exclusiveBackup = true;
  	}
  	else
! 		XLogCtl->Insert.nonExclusiveBackups++;
! 	XLogCtl->Insert.forcePageWrites = true;
! 	LWLockRelease(WALInsertLock);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
--- 9830,9855 ----
  	 * Note that forcePageWrites has no effect during an online backup from
  	 * the standby.
  	 *
! 	 * We must hold insertpos_lck to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
! 		if (Insert->exclusiveBackup)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		Insert->exclusiveBackup = true;
  	}
  	else
! 		Insert->nonExclusiveBackups++;
! 	Insert->forcePageWrites = true;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
***************
*** 9218,9230 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			LWLockAcquire(WALInsertLock, LW_SHARED);
! 			if (XLByteLT(XLogCtl->Insert.lastBackupStart, startpoint))
  			{
! 				XLogCtl->Insert.lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			LWLockRelease(WALInsertLock);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
--- 9962,9974 ----
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			SpinLockAcquire(&Insert->insertpos_lck);
! 			if (XLByteLT(Insert->lastBackupStart, startpoint))
  			{
! 				Insert->lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			SpinLockRelease(&Insert->insertpos_lck);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
***************
*** 9308,9334 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
! 		Assert(XLogCtl->Insert.exclusiveBackup);
! 		XLogCtl->Insert.exclusiveBackup = false;
  	}
  	else
  	{
! 		Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 		XLogCtl->Insert.nonExclusiveBackups--;
  	}
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 10052,10079 ----
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
! 		Assert(Insert->exclusiveBackup);
! 		Insert->exclusiveBackup = false;
  	}
  	else
  	{
! 		Assert(Insert->nonExclusiveBackups > 0);
! 		Insert->nonExclusiveBackups--;
  	}
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9341,9346 **** pg_start_backup_callback(int code, Datum arg)
--- 10086,10092 ----
  XLogRecPtr
  do_pg_stop_backup(char *labelfile, bool waitforarchive)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	bool		backup_started_in_recovery = false;
  	XLogRecPtr	startpoint;
***************
*** 9394,9402 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
! 		XLogCtl->Insert.exclusiveBackup = false;
  	else
  	{
  		/*
--- 10140,10148 ----
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
! 		Insert->exclusiveBackup = false;
  	else
  	{
  		/*
***************
*** 9405,9420 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 		XLogCtl->Insert.nonExclusiveBackups--;
  	}
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  
  	if (exclusive)
  	{
--- 10151,10166 ----
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(Insert->nonExclusiveBackups > 0);
! 		Insert->nonExclusiveBackups--;
  	}
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	if (exclusive)
  	{
***************
*** 9692,9707 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  void
  do_pg_abort_backup(void)
  {
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 	Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 	XLogCtl->Insert.nonExclusiveBackups--;
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 10438,10455 ----
  void
  do_pg_abort_backup(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	Assert(Insert->nonExclusiveBackups > 0);
! 	Insert->nonExclusiveBackups--;
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9755,9766 **** GetStandbyFlushRecPtr(void)
  XLogRecPtr
  GetXLogInsertRecPtr(void)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	LWLockAcquire(WALInsertLock, LW_SHARED);
! 	INSERT_RECPTR(current_recptr, Insert, Insert->curridx);
! 	LWLockRelease(WALInsertLock);
  
  	return current_recptr;
  }
--- 10503,10514 ----
  XLogRecPtr
  GetXLogInsertRecPtr(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	current_recptr = Insert->CurrPos;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	return current_recptr;
  }
*** a/src/backend/storage/ipc/procarray.c
--- b/src/backend/storage/ipc/procarray.c
***************
*** 1753,1761 **** GetOldestActiveTransactionId(void)
   * the result is somewhat indeterminate, but we don't really care.  Even in
   * a multiprocessor with delayed writes to shared memory, it should be certain
   * that setting of inCommit will propagate to shared memory when the backend
!  * takes the WALInsertLock, so we cannot fail to see an xact as inCommit if
!  * it's already inserted its commit record.  Whether it takes a little while
!  * for clearing of inCommit to propagate is unimportant for correctness.
   */
  int
  GetTransactionsInCommit(TransactionId **xids_p)
--- 1753,1762 ----
   * the result is somewhat indeterminate, but we don't really care.  Even in
   * a multiprocessor with delayed writes to shared memory, it should be certain
   * that setting of inCommit will propagate to shared memory when the backend
!  * takes a lock to write the WAL record, so we cannot fail to see an xact as
!  * inCommit if it's already inserted its commit record.  Whether it takes a
!  * little while for clearing of inCommit to propagate is unimportant for
!  * correctness.
   */
  int
  GetTransactionsInCommit(TransactionId **xids_p)
*** a/src/backend/storage/lmgr/spin.c
--- b/src/backend/storage/lmgr/spin.c
***************
*** 56,61 **** SpinlockSemas(void)
--- 56,64 ----
  	 *
  	 * For now, though, we just need a few spinlocks (10 should be plenty)
  	 * plus one for each LWLock and one for each buffer header.
+ 	 *
+ 	 * XXX: remember to adjust this for the number of spinlocks needed by the
+ 	 * xlog.c changes before committing!
  	 */
  	return NumLWLocks() + NBuffers + 10;
  }
*** a/src/include/storage/lwlock.h
--- b/src/include/storage/lwlock.h
***************
*** 53,59 **** typedef enum LWLockId
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALInsertLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
--- 53,59 ----
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALBufMappingLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
***************
*** 79,84 **** typedef enum LWLockId
--- 79,85 ----
  	SerializablePredicateLockListLock,
  	OldSerXidLock,
  	SyncRepLock,
+ 	WALInsertTailLock,
  	/* Individual lock IDs end here */
  	FirstBufMappingLock,
  	FirstLockMgrLock = FirstBufMappingLock + NUM_BUFFER_PARTITIONS,

*** a/src/backend/access/transam/xlog.c
--- b/src/backend/access/transam/xlog.c
***************
*** 42,47 ****
--- 42,48 ----
  #include "postmaster/startup.h"
  #include "replication/walreceiver.h"
  #include "replication/walsender.h"
+ #include "storage/barrier.h"
  #include "storage/bufmgr.h"
  #include "storage/fd.h"
  #include "storage/ipc.h"
***************
*** 261,274 **** XLogRecPtr	XactLastRecEnd = {0, 0};
   * (which is almost but not quite the same as a pointer to the most recent
   * CHECKPOINT record).	We update this from the shared-memory copy,
   * XLogCtl->Insert.RedoRecPtr, whenever we can safely do so (ie, when we
!  * hold the Insert lock).  See XLogInsert for details.	We are also allowed
!  * to update from XLogCtl->Insert.RedoRecPtr if we hold the info_lck;
   * see GetRedoRecPtr.  A freshly spawned backend obtains the value during
   * InitXLOGAccess.
   */
  static XLogRecPtr RedoRecPtr;
  
  /*
   * RedoStartLSN points to the checkpoint's REDO location which is specified
   * in a backup label file, backup history file or control file. In standby
   * mode, XLOG streaming usually starts from the position where an invalid
--- 262,281 ----
   * (which is almost but not quite the same as a pointer to the most recent
   * CHECKPOINT record).	We update this from the shared-memory copy,
   * XLogCtl->Insert.RedoRecPtr, whenever we can safely do so (ie, when we
!  * hold the insertpos lock).  See XLogInsert for details.	We are also allowed
!  * to update from XLogCtl->RedoRecPtr if we hold the info_lck;
   * see GetRedoRecPtr.  A freshly spawned backend obtains the value during
   * InitXLOGAccess.
   */
  static XLogRecPtr RedoRecPtr;
  
  /*
+  * doPageWrites is this backend's local copy of the Insert->fullPageWrites ||
+  * Insert->forcePageWrites. It is refreshed at every insertion.
+  */
+ static bool doPageWrites;
+ 
+ /*
   * RedoStartLSN points to the checkpoint's REDO location which is specified
   * in a backup label file, backup history file or control file. In standby
   * mode, XLOG streaming usually starts from the position where an invalid
***************
*** 300,309 **** static XLogRecPtr RedoStartLSN = {0, 0};
   * (protected by info_lck), but we don't need to cache any copies of it.
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  The other locks are held longer (potentially
!  * over I/O operations), so we use LWLocks for them.  These locks are:
   *
!  * WALInsertLock: must be held to insert a record into the WAL buffers.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
--- 307,321 ----
   * (protected by info_lck), but we don't need to cache any copies of it.
   *
   * info_lck is only held long enough to read/update the protected variables,
!  * so it's a plain spinlock.  insertpos_lck protects the current logical
!  * insert location, ie. the head of reserved WAL space.  The other locks are
!  * held longer (potentially over I/O operations), so we use LWLocks for them.
!  * These locks are:
   *
!  * WALBufMappingLock: must be held to replace a page in the WAL buffer cache.
!  * This is only held while initializing and changing the mapping. If the
!  * contents of the buffer being replaced haven't been written yet, the mapping
!  * lock is released while the write is done, and reacquired afterwards.
   *
   * WALWriteLock: must be held to write WAL buffers to disk (XLogWrite or
   * XLogFlush).
***************
*** 315,320 **** static XLogRecPtr RedoStartLSN = {0, 0};
--- 327,399 ----
   * only one checkpointer at a time; currently, with all checkpoints done by
   * the checkpointer, this is just pro forma).
   *
+  *
+  * Inserting a new WAL record is a two-step process:
+  *
+  * 1. Reserve the right amount of space from the WAL, and the next insertion
+  *    slot to advertise that the insertion is in progress. The current head
+  *    of reserved space is kept in Insert->CurrPos, and is protected by
+  *    insertpos_lck. Try to keep this section as short as possible,
+  *    insertpos_lck can be heavily contended on a busy system
+  *
+  * 2. Copy the record to the reserved WAL space. This involves finding the
+  *    correct WAL buffer containing the reserved space, and copying the
+  *    record in place. This can be done concurrently in multiple processes.
+  *
+  * To allow as much parallelism as possible for step 2, we try hard to avoid
+  * lock contention in that code path. Each insertion is asssigned its own
+  * "XLog insertion slot", which is used to advertise the position the backend
+  * is writing to. The slot is marked as in-use in step 1, while holding
+  * insertpos_lck, by setting the position field in the slot. When the backend
+  * is finished with the insertion, it clears its slot. Each slot is protected
+  * by a separate spinlock, to keep contention minimal.
+  *
+  * The insertion slots also provide a mechanism to wait for an insertion to
+  * finish. This is important when an XLOG page is written out - any
+  * in-progress insertions must finish copying data to the page first, or the
+  * on-disk copy will be incomplete. Waiting is done by the
+  * WaitXLogInsertionsToFinish() function. It adds the current process to the
+  * waiting queue in the slot it needs to wait for, and when that insertion
+  * finishes (or proceeds to the next page, at least), the inserter wakes up
+  * the process.
+  *
+  * The insertion slots form a ring. Insert->nextslot points to the next free
+  * slot, and Insert->lastslot points to the last slot that's still in use.
+  * lastslot can lag behind reality by any number of slots, as long as nextslot
+  * doesn't catch up with it. lastslot is advanced by
+  * WaitXLogInsertionsToFinish(), and is protected by WALInsertTailLock.
+  * nextslot is advanced in ReserveXLogInsertLocation() and is protected by
+  * insertpos_lck. Both slot variables are 32-bit integers, so that they can
+  * be read atomically without holding a lock. nextslot == lastslot means that
+  * all the slots are empty.
+  *
+  * Whenever the ring fills up, ie. when nextslot wraps around and catches up
+  * with lastslot, ReserveXLogInsertLocation() has to wait for the oldest
+  * insertion to finish and advance lastslot, to make room for the new
+  * insertion. This is also handled by WaitXLogInsertionsToFinish().
+  *
+  *
+  * Deadlock analysis
+  * -----------------
+  *
+  * It's important to call WaitXLogInsertionsToFinish() *before* acquiring
+  * WALWriteLock. Otherwise you might get stuck waiting for an insertion to
+  * finish (or at least advance to next uninitialized page), while you're
+  * holding WALWriteLock. That would be bad, because the backend you're waiting
+  * for might need to acquire WALWriteLock, too, to evict an old buffer, so
+  * you'd get deadlock.
+  *
+  * WaitXLogInsertionsToFinish() will not get stuck indefinitely, as long as
+  * it's called with a location that's known to be already allocated in the WAL
+  * buffers. Calling it with the position of a record you've already inserted
+  * satisfies that condition, so the common pattern:
+  *
+  *   recptr = XLogInsert(...)
+  *   XLogFlush(recptr)
+  *
+  * is safe. It can't get stuck, because an insertion to a WAL page that's
+  * already initialized in cache can always proceed without waiting on a lock.
+  *
   *----------
   */
  
***************
*** 335,344 **** typedef struct XLogwrtResult
   */
  typedef struct XLogCtlInsert
  {
! 	XLogRecPtr	PrevRecord;		/* start of previously-inserted record */
! 	int			curridx;		/* current block index in cache */
! 	XLogPageHeader currpage;	/* points to header of block in cache */
! 	char	   *currpos;		/* current insertion point in cache */
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
--- 414,435 ----
   */
  typedef struct XLogCtlInsert
  {
! 	slock_t		insertpos_lck;	/* protects all the fields in this struct
! 								 * (except lastslot). */
! 
! 	int32		nextslot;		/* next insertion slot to use */
! 	int32		lastslot;		/* last in-use insertion slot (protected by
! 								 * WALInsertTailLock) */
! 
! 	/*
! 	 * CurrPos is the very tip of the reserved WAL space at the moment.
! 	 * The next record will be inserted there (or somewhere after it if
! 	 * there's not enough space on the current page).  PrevRecord points to
! 	 * the beginning of the last record already reserved.  It might not be
! 	 * fully copied into place yet, but we know its exact location already.
! 	 */
! 	XLogRecPtr	CurrPos;
! 	XLogRecPtr	PrevRecord;
  	XLogRecPtr	RedoRecPtr;		/* current redo point for insertions */
  	bool		forcePageWrites;	/* forcing full-page writes for PITR? */
  
***************
*** 364,369 **** typedef struct XLogCtlInsert
--- 455,471 ----
  } XLogCtlInsert;
  
  /*
+  * We force XLogCtlInsert to be aligned at a 64-byte boundary, to ensure
+  * that the inserpos_lck spinlock and the fields it protects are all on the
+  * same cache line (assuming the cache line size is at least 64 bytes).
+  * Testing shows that that makes a big difference in performance. If the
+  * struct grows larger than 64 bytes, this needs to be enlarged, too, but
+  * then it won't fit on a single cache line on systems with smaller cache
+  * line size anyway.
+  */
+ #define XLOGCTLINSERT_ALIGNMENT (64)
+ 
+ /*
   * Shared state data for XLogWrite/XLogFlush.
   */
  typedef struct XLogCtlWrite
***************
*** 372,387 **** typedef struct XLogCtlWrite
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/* Protected by WALInsertLock: */
  	XLogCtlInsert Insert;
  
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
  	uint32		ckptXidEpoch;	/* nextXID & epoch of latest checkpoint */
  	TransactionId ckptXid;
  	XLogRecPtr	asyncXactLSN;	/* LSN of newest async commit/abort */
--- 474,512 ----
  	pg_time_t	lastSegSwitchTime;		/* time of last xlog segment switch */
  } XLogCtlWrite;
  
+ 
+ /*
+  * Slots for in-progress WAL insertions.
+  */
+ typedef struct
+ {
+ 	slock_t		lck;
+ 	bool		finished;
+ 	XLogRecPtr	CurrPos;	/* current position this process is inserting to */
+ 	PGPROC	   *head;		/* head of list of waiting PGPROCs */
+ 	PGPROC	   *tail;		/* tail of list of waiting PGPROCs */
+ } XLogInsertSlot;
+ 
+ #define NumXLogInsertSlots	512
+ 
  /*
   * Total shared-memory state for XLOG.
   */
  typedef struct XLogCtlData
  {
! 	/*
! 	 * Note: Insert must be the first field in the struct or it won't be
! 	 * aligned to a cache-line boundary like we want it to be.
! 	 *
! 	 * Protected by insertpos_lck.
! 	 */
  	XLogCtlInsert Insert;
  
+ 	XLogInsertSlot XLogInsertSlots[NumXLogInsertSlots];
+ 
  	/* Protected by info_lck: */
  	XLogwrtRqst LogwrtRqst;
+ 	XLogRecPtr	RedoRecPtr;		/* a recent copy of Insert->RedoRecPtr */
  	uint32		ckptXidEpoch;	/* nextXID & epoch of latest checkpoint */
  	TransactionId ckptXid;
  	XLogRecPtr	asyncXactLSN;	/* LSN of newest async commit/abort */
***************
*** 398,406 **** typedef struct XLogCtlData
  	XLogwrtResult LogwrtResult;
  
  	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALInsertLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
--- 523,540 ----
  	XLogwrtResult LogwrtResult;
  
  	/*
+ 	 * To change curridx and the identity of a buffer, you need to hold
+ 	 * WALBufMappingLock.  To change the identity of a buffer that's still
+ 	 * dirty, the old page needs to be written out first, and for that you
+ 	 * need WALWriteLock, and you need to ensure that there's no in-progress
+ 	 * insertions to the page by calling WaitXLogInsertionsToFinish().
+ 	 */
+ 	int			curridx;		/* latest initialized block index in cache */
+ 
+ 	/*
  	 * These values do not change after startup, although the pointed-to pages
  	 * and xlblocks values certainly do.  Permission to read/write the pages
! 	 * and xlblocks values depends on WALBufMappingLock and WALWriteLock.
  	 */
  	char	   *pages;			/* buffers for unwritten XLOG pages */
  	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + XLOG_BLCKSZ */
***************
*** 478,505 **** static XLogCtlData *XLogCtl = NULL;
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Macros for managing XLogInsert state.  In most cases, the calling routine
!  * has local copies of XLogCtl->Insert and/or XLogCtl->Insert->curridx,
!  * so these are passed as parameters instead of being fetched via XLogCtl.
   */
  
! /* Free space remaining in the current xlog page buffer */
! #define INSERT_FREESPACE(Insert)  \
! 	(XLOG_BLCKSZ - ((Insert)->currpos - (char *) (Insert)->currpage))
  
! /* Construct XLogRecPtr value for current insertion point */
! #define INSERT_RECPTR(recptr,Insert,curridx)  \
! 	( \
! 	  (recptr).xlogid = XLogCtl->xlblocks[curridx].xlogid, \
! 	  (recptr).xrecoff = \
! 		XLogCtl->xlblocks[curridx].xrecoff - INSERT_FREESPACE(Insert) \
! 	)
  
! #define PrevBufIdx(idx)		\
! 		(((idx) == 0) ? XLogCtl->XLogCacheBlck : ((idx) - 1))
  
! #define NextBufIdx(idx)		\
! 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
--- 612,660 ----
  static ControlFileData *ControlFile = NULL;
  
  /*
!  * Calculate the amount of space left on the page after 'endptr'.
!  * Beware multiple evaluation!
   */
+ #define INSERT_FREESPACE(endptr)	\
+ 	(((endptr).xrecoff % XLOG_BLCKSZ == 0) ? 0 : (XLOG_BLCKSZ - (endptr).xrecoff % XLOG_BLCKSZ))
  
! /*
!  * Macros to advance to next buffer index and insertion slot.
!  */
! #define NextBufIdx(idx)		\
! 		(((idx) == XLogCtl->XLogCacheBlck) ? 0 : ((idx) + 1))
  
! #define NextSlotNo(idx)		(((idx) + 1) % NumXLogInsertSlots)
  
! /*
!  * The mapping from a slot number to an element in the XLogInsertSlots array
!  * is not a simple linear mapping as you would expect. We want to spread out
!  * the accesses to the slots, to reduce the contention on the cache lines of
!  * logically adjacent slots.
!  *
!  * To do that, we swap the four low-order bits with high order bits:
!  *
!  * 123456789 ->  1567892345
!  */
! static inline int
! SlotNoToIdx(int slotno)
! {
! 	return (slotno & 0xffffff00) | (slotno & 0xf0) >> 4 | (slotno & 0x0f) << 4;
! }
  
! 
! /*
!  * XLogRecPtrToBufIdx returns the index of the WAL buffer that holds, or
!  * would hold if it was in cache, the page containing 'recptr'.
!  *
!  * XLogRecEndPtrToBufIdx is the same, but a pointer to the first byte of a
!  * page is taken to mean the previous page.
!  */
! #define XLogRecPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogFileSize) + (recptr).xrecoff)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
! 
! #define XLogRecEndPtrToBufIdx(recptr)	\
! 	((((((uint64) (recptr).xlogid * (uint64) XLogFileSize) + (recptr).xrecoff - 1)) / XLOG_BLCKSZ) % (XLogCtl->XLogCacheBlck + 1))
  
  /*
   * Private, possibly out-of-date copy of shared LogwrtResult.
***************
*** 625,633 **** static void KeepLogSeg(XLogRecPtr recptr, uint32 *logId, uint32 *logSeg);
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static bool AdvanceXLInsertBuffer(bool new_segment);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
--- 780,788 ----
  
  static bool XLogCheckBuffer(XLogRecData *rdata, bool doPageWrites,
  				XLogRecPtr *lsn, BkpBlock *bkpb);
! static void AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic);
  static bool XLogCheckpointNeeded(uint32 logid, uint32 logseg);
! static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible);
  static bool InstallXLogFileSegment(uint32 *log, uint32 *seg, char *tmppath,
  					   bool find_free, int *max_advance,
  					   bool use_lock);
***************
*** 674,679 **** static bool read_backup_label(XLogRecPtr *checkPointLoc,
--- 829,849 ----
  static void rm_redo_error_callback(void *arg);
  static int	get_sync_bit(int method);
  
+ static void CopyXLogRecordToWAL(int write_len, bool isLogSwitch,
+ 				  XLogRecord *rechdr,
+ 				  XLogRecData *rdata, pg_crc32 rdata_crc,
+ 				  int slotno,
+ 				  XLogRecPtr StartPos, XLogRecPtr EndPos);
+ static bool ReserveXLogInsertLocation(int size,
+ 						  bool isLogSwitch,
+ 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
+ 						  XLogRecPtr *EndPos_p,
+ 						  int *myslotno_p, bool *updrqst_p);
+ static void UpdateSlotCurrPos(int myslotno, XLogRecPtr CurrPos, bool finished);
+ static void	ReuseOldSlots(void);
+ static XLogRecPtr WaitXLogInsertionsToFinish(XLogRecPtr upto);
+ static char *GetXLogBuffer(int slotno, XLogRecPtr ptr);
+ 
  
  /*
   * Insert an XLOG record having the specified RMID and info bytes,
***************
*** 693,705 **** static int	get_sync_bit(int method);
  XLogRecPtr
  XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  {
- 	XLogCtlInsert *Insert = &XLogCtl->Insert;
- 	XLogRecord *record;
- 	XLogContRecord *contrecord;
- 	XLogRecPtr	RecPtr;
- 	XLogRecPtr	WriteRqst;
- 	uint32		freespace;
- 	int			curridx;
  	XLogRecData *rdt;
  	XLogRecData *rdt_lastnormal;
  	Buffer		dtbuf[XLR_MAX_BKP_BLOCKS];
--- 863,868 ----
***************
*** 714,722 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  				write_len;
  	unsigned	i;
  	bool		updrqst;
- 	bool		doPageWrites;
  	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
  	uint8		info_orig = info;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
--- 877,889 ----
  				write_len;
  	unsigned	i;
  	bool		updrqst;
  	bool		isLogSwitch = (rmid == RM_XLOG_ID && info == XLOG_SWITCH);
  	uint8		info_orig = info;
+ 	XLogRecord	rechdr;
+ 	XLogRecPtr	PrevRecord;
+ 	XLogRecPtr	StartPos;
+ 	XLogRecPtr	EndPos;
+ 	int			myslotno;
  
  	/* cross-check on whether we should be here or not */
  	if (!XLogInsertAllowed())
***************
*** 734,742 **** XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
  	 */
  	if (IsBootstrapProcessingMode() && rmid != RM_XLOG_ID)
  	{
! 		RecPtr.xlogid = 0;
! 		RecPtr.xrecoff = SizeOfXLogLongPHD;		/* start of 1st chkpt record */
! 		return RecPtr;
  	}
  
  	/*
--- 901,909 ----
  	 */
  	if (IsBootstrapProcessingMode() && rmid != RM_XLOG_ID)
  	{
! 		EndPos.xlogid = 0;
! 		EndPos.xrecoff = SizeOfXLogLongPHD;		/* start of 1st chkpt record */
! 		return EndPos;
  	}
  
  	/*
***************
*** 760,773 **** begin:;
  		dtbuf_bkp[i] = false;
  	}
  
- 	/*
- 	 * Decide if we need to do full-page writes in this XLOG record: true if
- 	 * full_page_writes is on or we have a PITR request for it.  Since we
- 	 * don't yet have the insert lock, fullPageWrites and forcePageWrites
- 	 * could change under us, but we'll recheck them once we have the lock.
- 	 */
- 	doPageWrites = Insert->fullPageWrites || Insert->forcePageWrites;
- 
  	len = 0;
  	for (rdt = rdata;;)
  	{
--- 927,932 ----
***************
*** 903,1035 **** begin:;
  	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
  		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
! 	START_CRIT_SECTION();
  
! 	/* Now wait to get insert lock */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  
  	/*
! 	 * Check to see if my RedoRecPtr is out of date.  If so, may have to go
! 	 * back and recompute everything.  This can only happen just after a
! 	 * checkpoint, so it's better to be slow in this case and fast otherwise.
! 	 *
! 	 * If we aren't doing full-page writes then RedoRecPtr doesn't actually
! 	 * affect the contents of the XLOG record, so we'll update our local copy
! 	 * but not force a recomputation.
  	 */
! 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr))
  	{
! 		Assert(XLByteLT(RedoRecPtr, Insert->RedoRecPtr));
! 		RedoRecPtr = Insert->RedoRecPtr;
  
! 		if (doPageWrites)
  		{
! 			for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
! 			{
! 				if (dtbuf[i] == InvalidBuffer)
! 					continue;
! 				if (dtbuf_bkp[i] == false &&
! 					XLByteLE(dtbuf_lsn[i], RedoRecPtr))
! 				{
! 					/*
! 					 * Oops, this buffer now needs to be backed up, but we
! 					 * didn't think so above.  Start over.
! 					 */
! 					LWLockRelease(WALInsertLock);
! 					END_CRIT_SECTION();
! 					rdt_lastnormal->next = NULL;
! 					info = info_orig;
! 					goto begin;
! 				}
! 			}
  		}
  	}
! 
! 	/*
! 	 * Also check to see if fullPageWrites or forcePageWrites was just turned on;
! 	 * if we weren't already doing full-page writes then go back and recompute.
! 	 * (If it was just turned off, we could recompute the record without full pages,
! 	 * but we choose not to bother.)
! 	 */
! 	if ((Insert->fullPageWrites || Insert->forcePageWrites) && !doPageWrites)
  	{
! 		/* Oops, must redo it with full-page data. */
! 		LWLockRelease(WALInsertLock);
! 		END_CRIT_SECTION();
! 		rdt_lastnormal->next = NULL;
! 		info = info_orig;
! 		goto begin;
  	}
  
  	/*
! 	 * If there isn't enough space on the current XLOG page for a record
! 	 * header, advance to the next page (leaving the unused space as zeroes).
  	 */
! 	updrqst = false;
! 	freespace = INSERT_FREESPACE(Insert);
! 	if (freespace < SizeOfXLogRecord)
  	{
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		freespace = INSERT_FREESPACE(Insert);
! 	}
  
! 	/* Compute record's XLOG location */
! 	curridx = Insert->curridx;
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, and we are exactly at the start of a
! 	 * segment, we need not insert it (and don't want to because we'd like
! 	 * consecutive switch requests to be no-ops).  Instead, make sure
! 	 * everything is written and flushed through the end of the prior segment,
! 	 * and return the prior segment's end address.
  	 */
! 	if (isLogSwitch &&
! 		(RecPtr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
  	{
! 		/* We can release insert lock immediately */
! 		LWLockRelease(WALInsertLock);
! 
! 		RecPtr.xrecoff -= SizeOfXLogLongPHD;
! 		if (RecPtr.xrecoff == 0)
! 		{
! 			/* crossing a logid boundary */
! 			RecPtr.xlogid -= 1;
! 			RecPtr.xrecoff = XLogFileSize;
! 		}
! 
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
! 		LogwrtResult = XLogCtl->LogwrtResult;
! 		if (!XLByteLE(RecPtr, LogwrtResult.Flush))
! 		{
! 			XLogwrtRqst FlushRqst;
! 
! 			FlushRqst.Write = RecPtr;
! 			FlushRqst.Flush = RecPtr;
! 			XLogWrite(FlushRqst, false, false);
! 		}
! 		LWLockRelease(WALWriteLock);
  
! 		END_CRIT_SECTION();
  
! 		return RecPtr;
  	}
  
! 	/* Insert record header */
! 
! 	record = (XLogRecord *) Insert->currpos;
! 	record->xl_prev = Insert->PrevRecord;
! 	record->xl_xid = GetCurrentTransactionIdIfAny();
! 	record->xl_tot_len = SizeOfXLogRecord + write_len;
! 	record->xl_len = len;		/* doesn't include backup blocks */
! 	record->xl_info = info;
! 	record->xl_rmid = rmid;
! 
! 	/* Now we can finish computing the record's CRC */
! 	COMP_CRC32(rdata_crc, (char *) record + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	record->xl_crc = rdata_crc;
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
--- 1062,1167 ----
  	for (rdt = rdata; rdt != NULL; rdt = rdt->next)
  		COMP_CRC32(rdata_crc, rdt->data, rdt->len);
  
! 	/* Construct record header. */
! 	MemSet(&rechdr, 0, sizeof(rechdr));
! 	/* rechdr.xl_prev is set later */
! 	rechdr.xl_xid = GetCurrentTransactionIdIfAny();
! 	rechdr.xl_tot_len = SizeOfXLogRecord + write_len;
! 	rechdr.xl_len = len;		/* doesn't include backup blocks */
! 	rechdr.xl_info = info;
! 	rechdr.xl_rmid = rmid;
  
! 	START_CRIT_SECTION();
  
  	/*
! 	 * Try to reserve space for the record from the WAL.
  	 */
! 	if (!ReserveXLogInsertLocation(write_len, isLogSwitch,
! 								   &PrevRecord, &StartPos, &EndPos,
! 								   &myslotno, &updrqst))
  	{
! 		/*
! 		 * Reservation failed. This could be because the record was an
! 		 * XLOG_SWITCH, and we're exactly at the start of a segment. In that
! 		 * case we need not insert it (and don't want to because we'd like
! 		 * consecutive switch requests to be no-ops).  Instead, make sure
! 		 * everything is written and flushed through the end of the prior
! 		 * segment, and return the prior segment's end address.
! 		 *
! 		 * The other reason for failure is that someone changed RedoRecPtr
! 		 * or forcePageWrites after we had constructed our WAL record. In
! 		 * that case we need to redo it with full-page data.
! 		 */
! 		END_CRIT_SECTION();
  
! 		if (isLogSwitch && !XLogRecPtrIsInvalid(EndPos))
  		{
! 			XLogFlush(EndPos);
! 			return EndPos;
! 		}
! 		else
! 		{
! 			rdt_lastnormal->next = NULL;
! 			info = info_orig;
! 			goto begin;
  		}
  	}
! 	else
  	{
! 		/*
! 		 * Reservation succeeded.  Finish the record header by setting
! 		 * prev-link (now that we know it), and finish computing the record's
! 		 * CRC (in CopyXLogRecordToWAL).  Then copy the record to the space
! 		 * we reserved.
! 		 */
! 		rechdr.xl_prev = PrevRecord;
! 		CopyXLogRecordToWAL(write_len, isLogSwitch, &rechdr,
! 							rdata, rdata_crc, myslotno, StartPos, EndPos);
  	}
+ 	END_CRIT_SECTION();
  
  	/*
! 	 * Update shared LogwrtRqst.Write, if we crossed page boundary.
  	 */
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
  
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, EndPos))
! 			xlogctl->LogwrtRqst.Write = EndPos;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
! 	}
  
  	/*
! 	 * If this was an XLOG_SWITCH record, flush the record and the empty
! 	 * padding space that fills the rest of the segment, and perform
! 	 * end-of-segment actions (eg, notifying archiver).
  	 */
! 	if (isLogSwitch)
  	{
! 		TRACE_POSTGRESQL_XLOG_SWITCH();
  
! 		XLogFlush(EndPos);
  
! 		/*
! 		 * Even though we reserved the rest of the segment for us, which is
! 		 * reflected in EndPos, we return a pointer to just the end of the
! 		 * xlog-switch record.
! 		 */
! 		EndPos.xlogid = StartPos.xlogid;
! 		EndPos.xrecoff = StartPos.xrecoff + SizeOfXLogRecord;
  	}
  
! 	/*
! 	 * Update our global variables
! 	 */
! 	ProcLastRecPtr = StartPos;
! 	XactLastRecEnd = EndPos;
  
  #ifdef WAL_DEBUG
  	if (XLOG_DEBUG)
***************
*** 1038,1219 **** begin:;
  
  		initStringInfo(&buf);
  		appendStringInfo(&buf, "INSERT @ %X/%X: ",
! 						 RecPtr.xlogid, RecPtr.xrecoff);
! 		xlog_outrec(&buf, record);
  		if (rdata->data != NULL)
  		{
  			appendStringInfo(&buf, " - ");
! 			RmgrTable[record->xl_rmid].rm_desc(&buf, record->xl_info, rdata->data);
  		}
  		elog(LOG, "%s", buf.data);
  		pfree(buf.data);
  	}
  #endif
  
- 	/* Record begin of record in appropriate places */
- 	ProcLastRecPtr = RecPtr;
- 	Insert->PrevRecord = RecPtr;
- 
- 	Insert->currpos += SizeOfXLogRecord;
- 	freespace -= SizeOfXLogRecord;
- 
  	/*
! 	 * Append the data, including backup blocks if any
  	 */
! 	while (write_len)
! 	{
! 		while (rdata->data == NULL)
! 			rdata = rdata->next;
  
! 		if (freespace > 0)
  		{
! 			if (rdata->len > freespace)
  			{
! 				memcpy(Insert->currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				write_len -= freespace;
! 			}
! 			else
! 			{
! 				memcpy(Insert->currpos, rdata->data, rdata->len);
! 				freespace -= rdata->len;
! 				write_len -= rdata->len;
! 				Insert->currpos += rdata->len;
! 				rdata = rdata->next;
! 				continue;
  			}
  		}
  
! 		/* Use next buffer */
! 		updrqst = AdvanceXLInsertBuffer(false);
! 		curridx = Insert->curridx;
! 		/* Insert cont-record header */
! 		Insert->currpage->xlp_info |= XLP_FIRST_IS_CONTRECORD;
! 		contrecord = (XLogContRecord *) Insert->currpos;
! 		contrecord->xl_rem_len = write_len;
! 		Insert->currpos += SizeOfXLogContRecord;
! 		freespace = INSERT_FREESPACE(Insert);
  	}
  
! 	/* Ensure next record will be properly aligned */
! 	Insert->currpos = (char *) Insert->currpage +
! 		MAXALIGN(Insert->currpos - (char *) Insert->currpage);
! 	freespace = INSERT_FREESPACE(Insert);
  
  	/*
! 	 * The recptr I return is the beginning of the *next* record. This will be
! 	 * stored as LSN for changed data pages...
  	 */
! 	INSERT_RECPTR(RecPtr, Insert, curridx);
  
  	/*
! 	 * If the record is an XLOG_SWITCH, we must now write and flush all the
! 	 * existing data, and then forcibly advance to the start of the next
! 	 * segment.  It's not good to do this I/O while holding the insert lock,
! 	 * but there seems too much risk of confusion if we try to release the
! 	 * lock sooner.  Fortunately xlog switch needn't be a high-performance
! 	 * operation anyway...
  	 */
! 	if (isLogSwitch)
! 	{
! 		XLogwrtRqst FlushRqst;
! 		XLogRecPtr	OldSegEnd;
  
! 		TRACE_POSTGRESQL_XLOG_SWITCH();
  
! 		LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  
  		/*
! 		 * Flush through the end of the page containing XLOG_SWITCH, and
! 		 * perform end-of-segment actions (eg, notifying archiver).
  		 */
! 		WriteRqst = XLogCtl->xlblocks[curridx];
! 		FlushRqst.Write = WriteRqst;
! 		FlushRqst.Flush = WriteRqst;
! 		XLogWrite(FlushRqst, false, true);
! 
! 		/* Set up the next buffer as first page of next segment */
! 		/* Note: AdvanceXLInsertBuffer cannot need to do I/O here */
! 		(void) AdvanceXLInsertBuffer(true);
! 
! 		/* There should be no unwritten data */
! 		curridx = Insert->curridx;
! 		Assert(curridx == XLogCtl->Write.curridx);
! 
! 		/* Compute end address of old segment */
! 		OldSegEnd = XLogCtl->xlblocks[curridx];
! 		OldSegEnd.xrecoff -= XLOG_BLCKSZ;
! 		if (OldSegEnd.xrecoff == 0)
! 		{
! 			/* crossing a logid boundary */
! 			OldSegEnd.xlogid -= 1;
! 			OldSegEnd.xrecoff = XLogFileSize;
! 		}
  
! 		/* Make it look like we've written and synced all of old segment */
! 		LogwrtResult.Write = OldSegEnd;
! 		LogwrtResult.Flush = OldSegEnd;
  
  		/*
! 		 * Update shared-memory status --- this code should match XLogWrite
  		 */
  		{
! 			/* use volatile pointer to prevent code rearrangement */
! 			volatile XLogCtlData *xlogctl = XLogCtl;
  
! 			SpinLockAcquire(&xlogctl->info_lck);
! 			xlogctl->LogwrtResult = LogwrtResult;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, LogwrtResult.Write))
! 				xlogctl->LogwrtRqst.Write = LogwrtResult.Write;
! 			if (XLByteLT(xlogctl->LogwrtRqst.Flush, LogwrtResult.Flush))
! 				xlogctl->LogwrtRqst.Flush = LogwrtResult.Flush;
! 			SpinLockRelease(&xlogctl->info_lck);
! 		}
  
! 		LWLockRelease(WALWriteLock);
  
! 		updrqst = false;		/* done already */
  	}
  	else
  	{
! 		/* normal case, ie not xlog switch */
  
! 		/* Need to update shared LogwrtRqst if some block was filled up */
! 		if (freespace < SizeOfXLogRecord)
  		{
! 			/* curridx is filled and available for writing out */
  			updrqst = true;
  		}
! 		else
! 		{
! 			/* if updrqst already set, write through end of previous buf */
! 			curridx = PrevBufIdx(curridx);
! 		}
! 		WriteRqst = XLogCtl->xlblocks[curridx];
  	}
  
! 	LWLockRelease(WALInsertLock);
  
! 	if (updrqst)
  	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
  
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		/* advance global request to include new block(s) */
! 		if (XLByteLT(xlogctl->LogwrtRqst.Write, WriteRqst))
! 			xlogctl->LogwrtRqst.Write = WriteRqst;
! 		/* update local result copy while I have the chance */
! 		LogwrtResult = xlogctl->LogwrtResult;
! 		SpinLockRelease(&xlogctl->info_lck);
  	}
  
! 	XactLastRecEnd = RecPtr;
  
! 	END_CRIT_SECTION();
  
! 	return RecPtr;
  }
  
  /*
--- 1170,1954 ----
  
  		initStringInfo(&buf);
  		appendStringInfo(&buf, "INSERT @ %X/%X: ",
! 						 EndPos.xlogid, EndPos.xrecoff);
! 		xlog_outrec(&buf, &rechdr);
  		if (rdata->data != NULL)
  		{
  			appendStringInfo(&buf, " - ");
! 			RmgrTable[rmid].rm_desc(&buf, rechdr.xl_info, rdata->data);
  		}
  		elog(LOG, "%s", buf.data);
  		pfree(buf.data);
  	}
  #endif
  
  	/*
! 	 * The recptr I return is the beginning of the *next* record. This will
! 	 * be stored as LSN for changed data pages...
  	 */
! 	return EndPos;
! }
! 
! /*
!  * Subroutine of XLogInsert.  Copies a WAL record to an already-reserved
!  * area in the WAL.
!  */
! static void
! CopyXLogRecordToWAL(int write_len, bool isLogSwitch, XLogRecord *rechdr,
! 					XLogRecData *rdata, pg_crc32 rdata_crc,
! 					int myslotno,
! 					XLogRecPtr StartPos, XLogRecPtr EndPos)
! {
! 	char	   *currpos;
! 	XLogRecord *record;
! 	int			freespace;
! 	int			written;
! 	XLogRecPtr	CurrPos;
! 
! 	/* Get the right WAL page to start inserting to */
! 	CurrPos = StartPos;
! 	currpos = GetXLogBuffer(myslotno, CurrPos);
! 
! 	/* Copy the record header in place, and finish calculating CRC */
! 	record = (XLogRecord *) currpos;
! 	memcpy(record, rechdr, sizeof(XLogRecord));
! 	COMP_CRC32(rdata_crc, currpos + sizeof(pg_crc32),
! 			   SizeOfXLogRecord - sizeof(pg_crc32));
! 	FIN_CRC32(rdata_crc);
! 	record->xl_crc = rdata_crc;
! 
! 	currpos += SizeOfXLogRecord;
! 	XLByteAdvance(CurrPos, SizeOfXLogRecord);
  
! 	freespace = INSERT_FREESPACE(CurrPos);
! 
! 	if (!isLogSwitch)
! 	{
! 		/* Copy record data */
! 		written = 0;
! 		while (rdata != NULL)
  		{
! 			while (rdata->len > freespace)
  			{
! 				/*
! 				 * Write what fits on this page, then write the continuation
! 				 * record, and continue on the next page.
! 				 */
! 				XLogContRecord *contrecord;
! 
! 				memcpy(currpos, rdata->data, freespace);
  				rdata->data += freespace;
  				rdata->len -= freespace;
! 				written += freespace;
! 				XLByteAdvance(CurrPos, freespace);
! 
! 				/*
! 				 * Get pointer to beginning of next page, and set the
! 				 * XLP_FIRST_IS_CONTRECORD flag in the page header.
! 				 *
! 				 * It's safe to set the contrecord flag without a lock on the
! 				 * page. All the other flags are set in AdvanceXLInsertBuffer,
! 				 * and we're the only backend that needs to set the contrecord
! 				 * flag.
! 				 */
! 				currpos = GetXLogBuffer(myslotno, CurrPos);
! 				((XLogPageHeader) currpos)->xlp_info |= XLP_FIRST_IS_CONTRECORD;
! 
! 				/* skip over the page header, and write continuation record */
! 				if (CurrPos.xrecoff % XLogSegSize == 0)
! 				{
! 					CurrPos.xrecoff += SizeOfXLogLongPHD;
! 					currpos += SizeOfXLogLongPHD;
! 				}
! 				else
! 				{
! 					CurrPos.xrecoff += SizeOfXLogShortPHD;
! 					currpos += SizeOfXLogShortPHD;
! 				}
! 				contrecord = (XLogContRecord *) currpos;
! 				contrecord->xl_rem_len = write_len - written;
! 
! 				currpos += SizeOfXLogContRecord;
! 				CurrPos.xrecoff += SizeOfXLogContRecord;
! 
! 				freespace = INSERT_FREESPACE(CurrPos);
  			}
+ 
+ 			memcpy(currpos, rdata->data, rdata->len);
+ 			currpos += rdata->len;
+ 			XLByteAdvance(CurrPos, rdata->len);
+ 			freespace -= rdata->len;
+ 			written += rdata->len;
+ 
+ 			rdata = rdata->next;
  		}
+ 		Assert(written == write_len);
  
! 		/* Align the end position, so that the next record starts aligned */
! 		CurrPos.xrecoff = MAXALIGN(CurrPos.xrecoff);
! 		if (CurrPos.xrecoff >= XLogFileSize)
! 		{
! 			/* crossed a logid boundary */
! 			CurrPos.xlogid += 1;
! 			CurrPos.xrecoff = 0;
! 		}
! 
! 		if (!XLByteEQ(CurrPos, EndPos))
! 			elog(PANIC, "space reserved for WAL record does not match what was written");
  	}
+ 	else
+ 	{
+ 		/* An xlog-switch record doesn't contain any data besides the header */
+ 		Assert(write_len == 0);
+ 
+ 		/*
+ 		 * An xlog-switch record consumes all the remaining space on the
+ 		 * WAL segment. We have already reserved it for us, but we still need
+ 		 * to make sure it's been allocated and zeroed in the WAL buffers so
+ 		 * that when the caller (or someone else) does XLogWrite(), it can
+ 		 * really write out all the zeros.
+ 		 *
+ 		 * We do this one page at a time, to make sure we don't deadlock
+ 		 * against ourselves if wal_buffers < XLOG_SEG_SIZE.
+ 		 */
+ 		Assert(EndPos.xrecoff % XLogSegSize == 0);
+ 
+ 		/* Use up all the remaining space on the first page */
+ 		XLByteAdvance(CurrPos, freespace);
  
! 		while (XLByteLT(CurrPos, EndPos))
! 		{
! 			/*
! 			 * like in the non-xlog-switch codepath, let others know that
! 			 * we're done writing up to the end of this page
! 			 */
! 			UpdateSlotCurrPos(myslotno, CurrPos, false);
! 			/* initialize the next page (if not initialized already */
! 			AdvanceXLInsertBuffer(CurrPos, false);
! 			XLByteAdvance(CurrPos, XLOG_BLCKSZ);
! 		}
! 	}
  
  	/*
! 	 * Done! Clear CurrPos in our slot to let others know that we're
! 	 * finished.
  	 */
! 	UpdateSlotCurrPos(myslotno, InvalidXLogRecPtr, true);
  
  	/*
! 	 * When we run out of insertion slots, the next inserter has to grab the
! 	 * WALInsertTailLock to clean up some old slots.  That stalls all new
! 	 * insertions. The WAL writer process cleans up old slots periodically,
! 	 * but on a busy system that might not be enough. So we try to clean up
! 	 * old ones every time we've gone through 1/4 of all the slots.
  	 */
! 	if (myslotno % (NumXLogInsertSlots / 4) == 0)
! 		ReuseOldSlots();
! }
  
! /*
!  * Reserves the right amount of space for a record of given size from the WAL.
!  * *StartPos_p is set to the beginning of the reserved section, *EndPos_p to
!  * its end+1, and *PrevRecord_p to the beginning of the previous record to set
!  * to the prev-link of the record header.
!  *
!  * A log-switch record is handled slightly differently. The rest of the
!  * segment will be reserved for this insertion, as indicated by the returned
!  * *EndPos_p value. However, if we are already at the beginning of the current
!  * segment, the *EndPos_p is set to the current location without reserving
!  * any space, and the function returns false.
!  *
!  * *updrqst_p is set to true, if this record ends on different page than
!  * the previous one - the caller should update the shared LogwrtRqst value
!  * after it's done inserting the record in that case, so that the WAL page
!  * that filled up gets written out at the next convenient moment.
!  *
!  * While holding insertpos_lck, sets myslot->CurrPos to the starting position,
!  * (or the end of previous record, to be exact) to let others know that we're
!  * busy inserting to the reserved area. The caller must clear it when the
!  * insertion is finished.
!  *
!  * Returns true on success, or false if RedoRecPtr or forcePageWrites was
!  * changed. On failure, the shared state is not modified.
!  *
!  * This is the performance critical part of XLogInsert that must be serialized
!  * across backends. The rest can happen mostly in parallel.
!  *
!  * NB: The space calculation here must match the code in CopyXLogRecordToWAL,
!  * where we actually copy the record to the reserved space.
!  */
! static bool
! ReserveXLogInsertLocation(int size,
! 						  bool isLogSwitch,
! 						  XLogRecPtr *PrevRecord_p, XLogRecPtr *StartPos_p,
! 						  XLogRecPtr *EndPos_p,
! 						  int *myslotno_p, bool *updrqst_p)
! {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			freespace;
! 	XLogRecPtr	ptr;
! 	XLogRecPtr	StartPos;
! 	int32		nextslot;
! 	int32		lastslot;
! 	bool		updrqst = false;
! 	bool		didPageWrites = doPageWrites;
! 
! 	/* log-switch records should contain no data */
! 	Assert(!isLogSwitch || size == 0);
  
! 	size = SizeOfXLogRecord + size;
! 
! retry:
! 	SpinLockAcquire(&Insert->insertpos_lck);
  
+ 	doPageWrites = Insert->forcePageWrites || Insert->fullPageWrites;
+ 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr) ||
+ 		(!didPageWrites && doPageWrites))
+ 	{
  		/*
! 		 * Oops, a checkpoint just happened, or forcePageWrites was just
! 		 * turned on. Start XLogInsert() all over, because we might have to
! 		 * include more full-page images in the record.
  		 */
! 		RedoRecPtr = Insert->RedoRecPtr;
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		*EndPos_p = InvalidXLogRecPtr;
! 		return false;
! 	}
! 
! 	/*
! 	 * Reserve the next insertion slot for us.
! 	 *
! 	 * First check that the slot is not still in use. Modifications to
! 	 * lastslot are protected by WALInsertTailLock, but here we assume that
! 	 * reading an int32 is atomic. Another process might advance lastslot at
! 	 * the same time, but not past nextslot.
! 	 */
! 	lastslot = Insert->lastslot;
! 	nextslot = Insert->nextslot;
! 	if (NextSlotNo(nextslot) == lastslot)
! 	{
! 		/*
! 		 * Oops, we've "caught our tail" and the oldest slot is still in use.
! 		 * Have to wait for it to become vacant, and retry.
! 		 */
! 		SpinLockRelease(&Insert->insertpos_lck);
! 		WaitXLogInsertionsToFinish(InvalidXLogRecPtr);
! 		goto retry;
! 	}
! 
! 	/*
! 	 * Got the slot. Now reserve the right amount of space from the WAL for
! 	 * our record.
! 	 */
! 	ptr = Insert->CurrPos;
! 	*PrevRecord_p = Insert->PrevRecord;
! 
! 	/*
! 	 * If there isn't enough space on the current XLOG page for a record
! 	 * header, advance to the next page (leaving the unused space as zeroes).
! 	 */
! 	freespace = INSERT_FREESPACE(ptr);
! 	if (freespace < SizeOfXLogRecord)
! 	{
! 		XLByteAdvance(ptr, freespace);
  
! 		if (ptr.xrecoff % XLogSegSize == 0)
! 			ptr.xrecoff += SizeOfXLogLongPHD;
! 		else
! 			ptr.xrecoff += SizeOfXLogShortPHD;
! 		freespace = INSERT_FREESPACE(ptr);
! 		updrqst = true;
! 	}
  
+ 	/*
+ 	 * We are now at the starting position of our record. Now figure out how
+ 	 * the data will be split across the WAL pages, to calculate where the
+ 	 * record ends.
+ 	 */
+ 	StartPos = ptr;
+ 
+ 	if (isLogSwitch)
+ 	{
  		/*
! 		 * If the record is an XLOG_SWITCH, and we are exactly at the start
! 		 * of a segment, we need not insert it (and don't want to because
! 		 * we'd like consecutive switch requests to be no-ops). Otherwise the
! 		 * XLOG_SWITCH record should consume all the remaining space on the
! 		 * current segment.
  		 */
+ 		if ((ptr.xrecoff % XLogSegSize) == SizeOfXLogLongPHD)
  		{
! 			/* We can release insert lock immediately */
! 			SpinLockRelease(&Insert->insertpos_lck);
  
! 			ptr.xrecoff -= SizeOfXLogLongPHD;
! 			if (ptr.xrecoff == 0)
! 			{
! 				/* crossing a logid boundary */
! 				ptr.xlogid -= 1;
! 				ptr.xrecoff = XLogFileSize;
! 			}
  
! 			*EndPos_p = ptr;
! 			*StartPos_p = ptr;
! 			*myslotno_p = 0;
  
! 			return false;
! 		}
! 		else
! 		{
! 			if (ptr.xrecoff % XLOG_SEG_SIZE != 0)
! 			{
! 				int segleft = XLOG_SEG_SIZE - (ptr.xrecoff % XLOG_SEG_SIZE);
! 				ptr.xrecoff += segleft;
! 			}
! 			updrqst = true;
! 		}
  	}
  	else
  	{
! 		/*
! 		 * A normal record, ie. not xlog-switch.
! 		 *
! 		 * Calculate how the record will be laid out across WAL pages. The
! 		 * straightforward way to do this would be a loop that fills in the
! 		 * WAL pages one at a time, tracking how much of the size is still
! 		 * left.  That's how the CopyXLogRecordToWAL() works when actually
! 		 * copying the data. However, we want to avoid looping to keep this
! 		 * spinlock-protected block as short as possible, in case the record
! 		 * spans pages.
! 		 */
! 		int		sizeleft = size;
  
! 		if (sizeleft > freespace)
  		{
! 			int		pagesneeded;
! 			int		pagesleftonseg;
! 			int		fullpages;
! 
! 			/* First fill the first page with as much data as fits. */
! 			sizeleft -= freespace;
! 			ptr.xrecoff += freespace;
! 
! 			/* We're now positioned at the beginning of the next page */
! 			Assert(ptr.xrecoff % XLOG_BLCKSZ == 0);
! 			do
! 			{
! 				if (ptr.xrecoff >= XLogFileSize)
! 				{
! 					/* crossing a logid boundary */
! 					ptr.xlogid++;
! 					ptr.xrecoff = 0;
! 				}
! 
! 				/*
! 				 * If we're positioned at the beginning of a segment, take
! 				 * into account that the first page needs a long header.
! 				 */
! 				if (ptr.xrecoff % XLOG_SEG_SIZE == 0)
! 					sizeleft += (SizeOfXLogLongPHD - SizeOfXLogShortPHD);
! 
! 				/*
! 				 * Calculate the number of extra pages we need.  Each page
! 				 * will have a continuation record at the beginning.
! 				 *
! 				 * We do the calculation assuming that all the pages have a
! 				 * short header.  We don't know whether we have to cross to
! 				 * the next segment until we've calculated how many pages we
! 				 * need. If it turns out that we do, we'll fill up the current
! 				 * segment, and loop back to add the long page header to
! 				 * sizeleft, and continue calculation from there.
! 				 */
! #define SpaceOnXLogPage	(XLOG_BLCKSZ - SizeOfXLogShortPHD - SizeOfXLogContRecord)
! 				pagesneeded = (sizeleft + SpaceOnXLogPage - 1) / SpaceOnXLogPage;
! 
! 				pagesleftonseg = (XLOG_SEG_SIZE - (ptr.xrecoff % XLOG_SEG_SIZE)) / XLOG_BLCKSZ;
! 
! 				if (pagesneeded <= pagesleftonseg)
! 				{
! 					/*
! 					 * Fits in this segment. Skip over all the full pages, to
! 					 * the last page that will (possibly) be only partially
! 					 * filled.
! 					 */
! 					fullpages = pagesneeded - 1;
! 				}
! 				else
! 				{
! 					/*
! 					 * Doesn't fit in this segment. Fit as much as does, and
! 					 * continue from next segment.
! 					 */
! 					fullpages = pagesleftonseg;
! 				}
! 
! 				sizeleft -= fullpages * SpaceOnXLogPage;
! 				ptr.xrecoff += fullpages * XLOG_BLCKSZ;
! 			} while (pagesneeded > pagesleftonseg);
! 
! 			/*
! 			 * We're now positioned at the beginning of the last page this
! 			 * record spans.  The rest should fit on this page.
! 			 *
! 			 * Note: We already took into account the long header above.
! 			 */
! 			ptr.xrecoff += SizeOfXLogShortPHD;
! 			ptr.xrecoff += SizeOfXLogContRecord;
! 
! 			Assert(sizeleft <= INSERT_FREESPACE(ptr) && sizeleft > 0);
! 
  			updrqst = true;
  		}
! 
! 		/*
! 		 * The rest fits on this page. Note that we mustn't use XLByteAdvance
! 		 * here, because if this record just fills up a logical log file,
! 		 * we want ptr.xlogid to point to log file that was filled, not the
! 		 * next one. XLogWrite gets upset otherwise.
! 		 */
! 		ptr.xrecoff += sizeleft;
! 
! 		/* Align the end position, so that the next record starts aligned */
! 		ptr.xrecoff = MAXALIGN(ptr.xrecoff);
  	}
  
! 	/* Update the shared state before releasing the lock */
! 	Insert->CurrPos = ptr;
! 	Insert->PrevRecord = StartPos;
! 	Insert->nextslot = NextSlotNo(nextslot);
  
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! #ifdef RESERVE_XLOGINSERT_LOCATION_DEBUG
! 	elog(LOG, "reserved xlog: prev %X/%X, start %X/%X, end %X/%X (len %d)",
! 		 PrevRecord_p->xlogid, PrevRecord_p->xrecoff,
! 		 StartPos.xlogid, StartPos.xrecoff,
! 		 ptr.xlogid, ptr.xrecoff,
! 		 size);
! #endif
! 
! 	/*
! 	 * XLogWrite gets upset if given a pointer to the beginning of a logical
! 	 * log file. If the record ends exactly at the end of one, we must return
! 	 * the last byte on previous log file + 1 as our ending position, not
! 	 * the first byte on the next log file.
! 	 */
! 	Assert(ptr.xrecoff != 0);
! 
! 	*EndPos_p = ptr;
! 	*StartPos_p = StartPos;
! 	*myslotno_p = nextslot;
! 	*updrqst_p = updrqst;
! 
! 	return true;
! }
! 
! /*
!  * Update slot's CurrPos variable, and wake up anyone waiting on it.
!  */
! static void
! UpdateSlotCurrPos(int myslotno, XLogRecPtr CurrPos, bool finished)
! {
! 	volatile XLogInsertSlot *myslot = &XLogCtl->XLogInsertSlots[SlotNoToIdx(myslotno)];
! 	PGPROC	   *head;
! 
! 	/* Must not move backwards. */
! 	Assert(finished || XLByteLE(myslot->CurrPos, CurrPos));
! 
! 	/*
! 	 * The write-barrier ensures that the changes we made to the WAL pages
! 	 * are visible to everyone before the update of CurrPos.
! 	 *
! 	 * XXX: I'm not sure if this is necessary. Doesn't the spinlock
! 	 * acquire/release act as an implicit barrier?
! 	 */
! 	pg_write_barrier();
! 
! 	SpinLockAcquire(&myslot->lck);
! 	myslot->finished = finished;
! 	myslot->CurrPos = CurrPos;
! 	head = myslot->head;
! 	myslot->head = myslot->tail = NULL;
! 	SpinLockRelease(&myslot->lck);
! 	while (head != NULL)
  	{
! 		PGPROC *proc = head;
! 		head = proc->lwWaitLink;
! 		proc->lwWaitLink = NULL;
! 		proc->lwWaiting = false;
! 		PGSemaphoreUnlock(&proc->sem);
! 	}
! }
  
! /*
!  * Get a pointer to the right location in the WAL buffer containing the
!  * given XLogRecPtr.
!  *
!  * If the page is not initialized yet, it is initialized. That might require
!  * evicting an old dirty buffer from the buffer cache, which means I/O.
!  *
!  * The caller must ensure that the page containing the requested location
!  * isn't evicted yet, and won't be evicted, by holding onto an XLOG insertion
!  * slot with CurrPos set to something <= ptr. This function can update the
!  * advertised CurrPos up to 'ptr', so you are not allowed to access anything
!  * older than 'ptr' after calling this function.
!  */
! static char *
! GetXLogBuffer(int myslotno, XLogRecPtr ptr)
! {
! 	int			idx;
! 	XLogRecPtr	endptr;
! 	static uint32 cachedXlogid = 0;
! 	static uint32 cachedPage = 0;
! 	static char *cachedPos = NULL;
! 	XLogRecPtr	expectedEndPtr;
! 
! 	/*
! 	 * Fast path for the common case that we need to access again the same
! 	 * page as last time.
! 	 */
! 	if (ptr.xlogid == cachedXlogid && ptr.xrecoff / XLOG_BLCKSZ == cachedPage)
! 		return cachedPos + ptr.xrecoff % XLOG_BLCKSZ;
! 
! 	cachedXlogid = ptr.xlogid;
! 	cachedPage = ptr.xrecoff / XLOG_BLCKSZ;
! 
! 	/*
! 	 * The XLog buffer cache is organized so a page must always be loaded
! 	 * to a particular buffer.  That way we can easily calculate the buffer
! 	 * a given page must be loaded into, from the XLogRecPtr alone.
! 	 */
! 	idx = XLogRecPtrToBufIdx(ptr);
! 
! 	/*
! 	 * See what page is loaded in the buffer at the moment. It could be the
! 	 * page we're looking for, or something older. It can't be anything
! 	 * newer - that would imply the page we're looking for has already
! 	 * been written out to disk, which shouldn't happen as long as the caller
! 	 * has set its slot's CurrPos correctly.
! 	 *
! 	 * However, we don't hold a lock while we read the value. If someone has
! 	 * just initialized the page, it's possible that we get a "torn read" of
! 	 * the XLogRecPtr, and see a bogus value. That's ok, we'll grab the
! 	 * mapping lock (in AdvanceXLInsertBuffer) and retry if we see anything
! 	 * else than the page we're looking for. But it means that when we do this
! 	 * unlocked read, we might see a value that appears to be ahead of the
! 	 * page we're looking for. Don't PANIC on that, until we've verified the
! 	 * value while holding the lock.
! 	 */
! 	expectedEndPtr.xlogid = ptr.xlogid;
! 	expectedEndPtr.xrecoff = ptr.xrecoff - ptr.xrecoff % XLOG_BLCKSZ + XLOG_BLCKSZ;
! 
! 	endptr = XLogCtl->xlblocks[idx];
! 	if (!XLByteEQ(expectedEndPtr, endptr))
! 	{
! 		/*
! 		 * Before we try to initialize the buffer for this page, let others
! 		 * know how far we've inserted, by updating the CurrPos field in our
! 		 * slot. This is important because AdvanceXLInsertBuffer() might need
! 		 * to wait for some insertions to finish so that it can write out the
! 		 * old page from the buffer.  Updating our slot before waiting for a
! 		 * new buffer ensures that we don't deadlock with ourselves if we run
! 		 * out of clean buffers.
! 		 *
! 		 * Note that we must not advance CurrPos past the page header yet.
! 		 * Otherwise someone might try to flush up to that point, which would
! 		 * fail if the next page was not initialized yet.
! 		 */
! 		XLogRecPtr pagebeginptr = ptr;
! 		pagebeginptr.xrecoff -= ptr.xrecoff % XLOG_BLCKSZ;
! 		UpdateSlotCurrPos(myslotno, pagebeginptr, false);
! 
! 		AdvanceXLInsertBuffer(ptr, false);
! 		endptr = XLogCtl->xlblocks[idx];
! 
! 		if (!XLByteEQ(expectedEndPtr, endptr))
! 			elog(PANIC, "could not find WAL buffer for %X/%X",
! 				 ptr.xlogid, ptr.xrecoff);
  	}
  
! 	/*
! 	 * Found the buffer holding this page. Return a pointer to the right
! 	 * offset within the page.
! 	 */
! 	cachedPos = XLogCtl->pages + idx * (Size) XLOG_BLCKSZ;
! 	return XLogCtl->pages + idx * (Size) XLOG_BLCKSZ +
! 		ptr.xrecoff % XLOG_BLCKSZ;
! }
  
! /*
!  * Try to mark old insertion slots as free for reuse.
!  */
! static void
! ReuseOldSlots(void)
! {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			lastslot;
! 	int			nextslot;
  
! 	/* Give up if someone else is already doing this */
! 	if (!LWLockConditionalAcquire(WALInsertTailLock, LW_EXCLUSIVE))
! 		return;
! 
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	lastslot = Insert->lastslot;
! 	nextslot = Insert->nextslot;
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! 	while (lastslot != nextslot)
! 	{
! 		/*
! 		 * Check if the oldest slot is still in use. We don't do any locking
! 		 * here, we just give up as soon as we find a slot that's still in
! 		 * use.
! 		 */
! 		volatile XLogInsertSlot *slot;
! 		slot = &XLogCtl->XLogInsertSlots[SlotNoToIdx(lastslot)];
! 
! 		if (!slot->finished)
! 			break;
! 
! 		/* Reinitialize the slot for reuse */
! 		slot->finished = false;
! 
! 		lastslot = NextSlotNo(lastslot);
! 	}
! 
! 	/*
! 	 * Update lastslot before we release the lock. (We don't need to grab
! 	 * insertpos_lck here, on the assumption that writing an int32 is atomic)
! 	 */
! 	Insert->lastslot = lastslot;
! 	LWLockRelease(WALInsertTailLock);
! }
! 
! /*
!  * Wait for any insertions < upto to finish. If upto is invalid, we wait until
!  * at least one slot is available for insertion.
!  *
!  * Returns a value >= upto, which indicates the oldest in-progress insertion
!  * that we saw in the array (or if there are non in-progress, the next insert
!  * position).
!  */
! static XLogRecPtr
! WaitXLogInsertionsToFinish(XLogRecPtr upto)
! {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			lastslot;
! 	int			nextslot;
! 	XLogRecPtr	LastPos;
! 	int			extraWaits = 0;
! 
! 	if (MyProc == NULL)
! 		elog(PANIC, "cannot wait without a PGPROC structure");
! 
! retry:
! 	/* Only allow one backend to advance lastslot at a time */
! 	LWLockAcquire(WALInsertTailLock, LW_EXCLUSIVE);
! 
! 	/*
! 	 * Read lastslot, nextslot, and current end of reserved XLOG.
! 	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	LastPos = Insert->CurrPos;
! 	lastslot = Insert->lastslot;
! 	nextslot = Insert->nextslot;
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! 	while (lastslot != nextslot)
! 	{
! 		/*
! 		 * Examine the oldest slot still in use.
! 		 */
! 		volatile XLogInsertSlot *slot;
! 		XLogRecPtr	slotptr;
! 
! 		slot = &XLogCtl->XLogInsertSlots[SlotNoToIdx(lastslot)];
! 
! 		/* First, a quick check without the lock. */
! 		if (slot->finished)
! 		{
! 			lastslot = NextSlotNo(lastslot);
! 			/* Reinitialize the slot for reuse */
! 			slot->finished = false;
! 			continue;
! 		}
! 
! 		SpinLockAcquire(&slot->lck);
! 		slotptr = slot->CurrPos;
! 
! 		if (slot->finished)
! 		{
! 			/*
! 			 * The insertion has already finished, we just need to advance
! 			 * lastslot to make the slot available for reuse.
! 			 */
! 			/* Reinitialize the slot for reuse */
! 			slot->finished = false;
! 			SpinLockRelease(&slot->lck);
! 			lastslot = NextSlotNo(lastslot);
! 			continue;
! 		}
! 		else
! 		{
! 			/*
! 			 * The insertion is still in-progress. If we just needed for
! 			 * any slot to become available and there is at least one slot
! 			 * free now, or if this slot's CurrPos >= upto, we can
! 			 * stop here. Otherwise we have to wait for it to finish.
! 			 */
! 			if ((XLogRecPtrIsInvalid(upto) && NextSlotNo(nextslot) != lastslot)
! 				|| (!XLogRecPtrIsInvalid(upto) && XLByteLE(upto, slotptr)))
! 			{
! 				SpinLockRelease(&slot->lck);
! 				LastPos = slotptr;
! 				break;
! 			}
! 			else
! 			{
! 				/* Wait for this insertion to finish. */
! 				MyProc->lwWaiting = true;
! 				MyProc->lwWaitMode = 0; /* doesn't matter */
! 				MyProc->lwWaitLink = NULL;
! 				if (slot->head == NULL)
! 					slot->head = MyProc;
! 				else
! 					slot->tail->lwWaitLink = MyProc;
! 				slot->tail = MyProc;
! 				SpinLockRelease(&slot->lck);
! 
! 				Insert->lastslot = lastslot;
! 				LWLockRelease(WALInsertTailLock);
! 				for (;;)
! 				{
! 					PGSemaphoreLock(&MyProc->sem, false);
! 					if (!MyProc->lwWaiting)
! 						break;
! 					extraWaits++;
! 				}
! 
! 				/*
! 				 * The insertion has now finished. Start all over. While we
! 				 * were not holding the tail-lock, someone might've filled up
! 				 * all slots again.
! 				 */
! 				goto retry;
! 			}
! 		}
! 	}
! 
! 	/*
! 	 * Update lastslot before we release the lock. (We don't need to grab
! 	 * insertpos_lck here, on the assumption that writing an int32 is atomic)
! 	 */
! 	Insert->lastslot = lastslot;
! 	LWLockRelease(WALInsertTailLock);
! 
! 	while (extraWaits-- > 0)
! 		PGSemaphoreUnlock(&MyProc->sem);
! 
! 	return LastPos;
  }
  
  /*
***************
*** 1440,1469 **** XLogArchiveCleanup(const char *xlog)
  }
  
  /*
!  * Advance the Insert state to the next buffer page, writing out the next
!  * buffer if it still contains unwritten data.
!  *
!  * If new_segment is TRUE then we set up the next buffer page as the first
!  * page of the next xlog segment file, possibly but not usually the next
!  * consecutive file page.
!  *
!  * The global LogwrtRqst.Write pointer needs to be advanced to include the
!  * just-filled page.  If we can do this for free (without an extra lock),
!  * we do so here.  Otherwise the caller must do it.  We return TRUE if the
!  * request update still needs to be done, FALSE if we did it internally.
!  *
!  * Must be called with WALInsertLock held.
   */
! static bool
! AdvanceXLInsertBuffer(bool new_segment)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			nextidx = NextBufIdx(Insert->curridx);
! 	bool		update_needed = true;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
! 	XLogRecPtr	NewPageEndPtr;
  	XLogPageHeader NewPage;
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
--- 2175,2207 ----
  }
  
  /*
!  * Initialize XLOG buffers, writing out old buffers if they still contain
!  * unwritten data, upto the page containing 'upto'. Or if 'opportunistic' is
!  * true, initialize as many pages as we can without having to write out
!  * unwritten data. Any new pages are initialized to zeros, with pages headers
!  * initialized properly.
   */
! static void
! AdvanceXLInsertBuffer(XLogRecPtr upto, bool opportunistic)
  {
  	XLogCtlInsert *Insert = &XLogCtl->Insert;
! 	int			nextidx;
  	XLogRecPtr	OldPageRqstPtr;
  	XLogwrtRqst WriteRqst;
! 	XLogRecPtr	NewPageEndPtr = InvalidXLogRecPtr;
  	XLogPageHeader NewPage;
+ 	int			npages = 0;
+ 
+ 	LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
+ 
+ 	/*
+ 	 * Now that we have the lock, check if someone initialized the page
+ 	 * already.
+ 	 */
+ /* XXX: fix indentation before commit */
+ while (!XLByteLT(upto, XLogCtl->xlblocks[XLogCtl->curridx]) || opportunistic)
+ {
+ 	nextidx = NextBufIdx(XLogCtl->curridx);
  
  	/*
  	 * Get ending-offset of the buffer page we need to replace (this may be
***************
*** 1473,1482 **** AdvanceXLInsertBuffer(bool new_segment)
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
  	if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  	{
! 		/* nope, got work to do... */
! 		XLogRecPtr	FinishedPageRqstPtr;
! 
! 		FinishedPageRqstPtr = XLogCtl->xlblocks[Insert->curridx];
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
--- 2211,2222 ----
  	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
  	if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  	{
! 		/*
! 		 * Nope, got work to do. If we just want to pre-initialize as much as
! 		 * we can without flushing, give up now.
! 		 */
! 		if (opportunistic)
! 			break;
  
  		/* Before waiting, get info_lck and update LogwrtResult */
  		{
***************
*** 1484,1504 **** AdvanceXLInsertBuffer(bool new_segment)
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, FinishedPageRqstPtr))
! 				xlogctl->LogwrtRqst.Write = FinishedPageRqstPtr;
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
- 		update_needed = false;	/* Did the shared-request update */
- 
  		/*
  		 * Now that we have an up-to-date LogwrtResult value, see if we still
  		 * need to write it or if someone else already did.
  		 */
  		if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/* Must acquire write lock */
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  			LogwrtResult = XLogCtl->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
--- 2224,2250 ----
  			volatile XLogCtlData *xlogctl = XLogCtl;
  
  			SpinLockAcquire(&xlogctl->info_lck);
! 			if (XLByteLT(xlogctl->LogwrtRqst.Write, OldPageRqstPtr))
! 				xlogctl->LogwrtRqst.Write = OldPageRqstPtr;
  			LogwrtResult = xlogctl->LogwrtResult;
  			SpinLockRelease(&xlogctl->info_lck);
  		}
  
  		/*
  		 * Now that we have an up-to-date LogwrtResult value, see if we still
  		 * need to write it or if someone else already did.
  		 */
  		if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
  		{
! 			/*
! 			 * Must acquire write lock. Release WALBufMappingLock first, to
! 			 * make sure that all insertions that we need to wait for can
! 			 * finish (up to this same position). Otherwise we risk deadlock.
! 			 */
! 			LWLockRelease(WALBufMappingLock);
! 
! 			WaitXLogInsertionsToFinish(OldPageRqstPtr);
! 
  			LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  			LogwrtResult = XLogCtl->LogwrtResult;
  			if (XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
***************
*** 1508,1525 **** AdvanceXLInsertBuffer(bool new_segment)
  			}
  			else
  			{
! 				/*
! 				 * Have to write buffers while holding insert lock. This is
! 				 * not good, so only write as much as we absolutely must.
! 				 */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false, false);
  				LWLockRelease(WALWriteLock);
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
  		}
  	}
  
--- 2254,2271 ----
  			}
  			else
  			{
! 				/* Have to write it ourselves */
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_START();
  				WriteRqst.Write = OldPageRqstPtr;
  				WriteRqst.Flush.xlogid = 0;
  				WriteRqst.Flush.xrecoff = 0;
! 				XLogWrite(WriteRqst, false);
  				LWLockRelease(WALWriteLock);
  				TRACE_POSTGRESQL_WAL_BUFFER_WRITE_DIRTY_DONE();
  			}
+ 			/* Re-acquire WALBufMappingLock and retry */
+ 			LWLockAcquire(WALBufMappingLock, LW_EXCLUSIVE);
+ 			continue;
  		}
  	}
  
***************
*** 1527,1540 **** AdvanceXLInsertBuffer(bool new_segment)
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[Insert->curridx];
! 
! 	if (new_segment)
! 	{
! 		/* force it to a segment start point */
! 		NewPageEndPtr.xrecoff += XLogSegSize - 1;
! 		NewPageEndPtr.xrecoff -= NewPageEndPtr.xrecoff % XLogSegSize;
! 	}
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
--- 2273,2279 ----
  	 * Now the next buffer slot is free and we can set it up to be the next
  	 * output page.
  	 */
! 	NewPageEndPtr = XLogCtl->xlblocks[XLogCtl->curridx];
  
  	if (NewPageEndPtr.xrecoff >= XLogFileSize)
  	{
***************
*** 1544,1556 **** AdvanceXLInsertBuffer(bool new_segment)
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
! 	XLogCtl->xlblocks[nextidx] = NewPageEndPtr;
! 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
! 
! 	Insert->curridx = nextidx;
! 	Insert->currpage = NewPage;
  
! 	Insert->currpos = ((char *) NewPage) +SizeOfXLogShortPHD;
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
--- 2283,2292 ----
  	}
  	else
  		NewPageEndPtr.xrecoff += XLOG_BLCKSZ;
! 	Assert(NewPageEndPtr.xrecoff % XLOG_BLCKSZ == 0);
! 	Assert(XLogRecEndPtrToBufIdx(NewPageEndPtr) == nextidx);
  
! 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) XLOG_BLCKSZ);
  
  	/*
  	 * Be sure to re-zero the buffer so that bytes beyond what we've written
***************
*** 1594,1604 **** AdvanceXLInsertBuffer(bool new_segment)
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
- 
- 		Insert->currpos = ((char *) NewPage) +SizeOfXLogLongPHD;
  	}
  
! 	return update_needed;
  }
  
  /*
--- 2330,2357 ----
  		NewLongPage->xlp_seg_size = XLogSegSize;
  		NewLongPage->xlp_xlog_blcksz = XLOG_BLCKSZ;
  		NewPage   ->xlp_info |= XLP_LONG_HEADER;
  	}
  
! 	/*
! 	 * Make sure the initialization of the page becomes visible to others
! 	 * before the xlblocks update. GetXLogBuffer() reads xlblocks without
! 	 * holding a lock.
! 	 */
! 	pg_write_barrier();
! 
! 	*((volatile XLogRecPtr *) &XLogCtl->xlblocks[nextidx]) = NewPageEndPtr;
! 
! 	XLogCtl->curridx = nextidx;
! 
! 	npages++;
! }
! 	LWLockRelease(WALBufMappingLock);
! 
! #ifdef WAL_DEBUG
! 	if (npages > 0)
! 		elog(DEBUG1, "initialized %d pages, upto %X/%X",
! 			 npages, NewPageEndPtr.xlogid, NewPageEndPtr.xrecoff);
! #endif
  }
  
  /*
***************
*** 1643,1658 **** XLogCheckpointNeeded(uint32 logid, uint32 logseg)
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * If xlog_switch == TRUE, we are intending an xlog segment switch, so
!  * perform end-of-segment actions after writing the last page, even if
!  * it's not physically the end of its segment.  (NB: this will work properly
!  * only if caller specifies WriteRqst == page-end and flexible == false,
!  * and there is some data to write.)
!  *
!  * Must be called with WALWriteLock held.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
--- 2396,2407 ----
   * This option allows us to avoid uselessly issuing multiple writes when a
   * single one would do.
   *
!  * Must be called with WALWriteLock held. And you must've called
!  * WaitXLogInsertionsToFinish(WriteRqst) before grabbing the lock to make sure
!  * the data is ready to write.
   */
  static void
! XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
  {
  	XLogCtlWrite *Write = &XLogCtl->Write;
  	bool		ispartialpage;
***************
*** 1701,1714 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  		 * if we're passed a bogus WriteRqst.Write that is past the end of the
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
! 		if (!XLByteLT(LogwrtResult.Write, XLogCtl->xlblocks[curridx]))
  			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
! 				 XLogCtl->xlblocks[curridx].xlogid,
! 				 XLogCtl->xlblocks[curridx].xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
! 		LogwrtResult.Write = XLogCtl->xlblocks[curridx];
  		ispartialpage = XLByteLT(WriteRqst.Write, LogwrtResult.Write);
  
  		if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
--- 2450,2463 ----
  		 * if we're passed a bogus WriteRqst.Write that is past the end of the
  		 * last page that's been initialized by AdvanceXLInsertBuffer.
  		 */
! 		XLogRecPtr EndPtr = XLogCtl->xlblocks[curridx];
! 		if (!XLByteLT(LogwrtResult.Write, EndPtr))
  			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
  				 LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff,
! 				 EndPtr.xlogid, EndPtr.xrecoff);
  
  		/* Advance LogwrtResult.Write to end of current buffer page */
! 		LogwrtResult.Write = EndPtr;
  		ispartialpage = XLByteLT(WriteRqst.Write, LogwrtResult.Write);
  
  		if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
***************
*** 1805,1820 **** XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
- 			 * We also do this if this is the last page written for an xlog
- 			 * switch.
- 			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg || (xlog_switch && last_iteration))
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
--- 2554,2566 ----
  			 * later. Doing it here ensures that one and only one backend will
  			 * perform this fsync.
  			 *
  			 * This is also the right place to notify the Archiver that the
  			 * segment is ready to copy to archival storage, and to update the
  			 * timer for archive_timeout, and to signal for a checkpoint if
  			 * too many logfile segments have been used since the last
  			 * checkpoint.
  			 */
! 			if (finishing_seg)
  			{
  				issue_xlog_fsync(openLogFile, openLogId, openLogSeg);
  				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
***************
*** 2068,2073 **** XLogFlush(XLogRecPtr record)
--- 2814,2820 ----
  	{
  		/* use volatile pointer to prevent code rearrangement */
  		volatile XLogCtlData *xlogctl = XLogCtl;
+ 		XLogRecPtr	insertpos;
  
  		/* read LogwrtResult and update local state */
  		SpinLockAcquire(&xlogctl->info_lck);
***************
*** 2081,2086 **** XLogFlush(XLogRecPtr record)
--- 2828,2839 ----
  			break;
  
  		/*
+ 		 * Before actually performing the write, wait for all in-flight
+ 		 * insertions to the pages we're about to write to finish.
+ 		 */
+ 		insertpos = WaitXLogInsertionsToFinish(WriteRqstPtr);
+ 
+ 		/*
  		 * Try to get the write lock. If we can't get it immediately, wait
  		 * until it's released, and recheck if we still need to do the flush
  		 * or if the backend that held the lock did it for us already. This
***************
*** 2100,2128 **** XLogFlush(XLogRecPtr record)
  		LogwrtResult = XLogCtl->LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			/* try to write/flush later additions to XLOG as well */
! 			if (LWLockConditionalAcquire(WALInsertLock, LW_EXCLUSIVE))
! 			{
! 				XLogCtlInsert *Insert = &XLogCtl->Insert;
! 				uint32		freespace = INSERT_FREESPACE(Insert);
  
! 				if (freespace < SizeOfXLogRecord)		/* buffer is full */
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 				else
! 				{
! 					WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
! 					WriteRqstPtr.xrecoff -= freespace;
! 				}
! 				LWLockRelease(WALInsertLock);
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = WriteRqstPtr;
! 			}
! 			else
! 			{
! 				WriteRqst.Write = WriteRqstPtr;
! 				WriteRqst.Flush = record;
! 			}
! 			XLogWrite(WriteRqst, false, false);
  		}
  		LWLockRelease(WALWriteLock);
  		/* done */
--- 2853,2862 ----
  		LogwrtResult = XLogCtl->LogwrtResult;
  		if (!XLByteLE(record, LogwrtResult.Flush))
  		{
! 			WriteRqst.Write = insertpos;
! 			WriteRqst.Flush = insertpos;
  
! 			XLogWrite(WriteRqst, false);
  		}
  		LWLockRelease(WALWriteLock);
  		/* done */
***************
*** 2237,2243 **** XLogBackgroundFlush(void)
  
  	START_CRIT_SECTION();
  
! 	/* now wait for the write lock */
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  	LogwrtResult = XLogCtl->LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
--- 2971,2978 ----
  
  	START_CRIT_SECTION();
  
! 	/* now wait for any in-progress insertions to finish and get write lock */
! 	WaitXLogInsertionsToFinish(WriteRqstPtr);
  	LWLockAcquire(WALWriteLock, LW_EXCLUSIVE);
  	LogwrtResult = XLogCtl->LogwrtResult;
  	if (!XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
***************
*** 2246,2256 **** XLogBackgroundFlush(void)
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible, false);
  	}
- 	LWLockRelease(WALWriteLock);
  
  	END_CRIT_SECTION();
  }
  
  /*
--- 2981,2998 ----
  
  		WriteRqst.Write = WriteRqstPtr;
  		WriteRqst.Flush = WriteRqstPtr;
! 		XLogWrite(WriteRqst, flexible);
  	}
  
  	END_CRIT_SECTION();
+ 
+ 	LWLockRelease(WALWriteLock);
+ 
+ 	/*
+ 	 * Great, done. To take some work off the critical path, try to initialize
+ 	 * as many of the no-longer-needed WAL buffers for future use as we can.
+ 	 */
+ 	AdvanceXLInsertBuffer(InvalidXLogRecPtr, true);
  }
  
  /*
***************
*** 5037,5042 **** XLOGShmemSize(void)
--- 5779,5791 ----
  
  	/* XLogCtl */
  	size = sizeof(XLogCtlData);
+ 
+ 	/*
+ 	 * We force XLogCtl to be suitably aligned to put insertpos_lck and
+ 	 * the fields it protects on the same cache line
+ 	 */
+ 	size += XLOGCTLINSERT_ALIGNMENT;
+ 
  	/* xlblocks array */
  	size = add_size(size, mul_size(sizeof(XLogRecPtr), XLOGbuffers));
  	/* extra alignment padding for XLOG I/O buffers */
***************
*** 5059,5069 **** XLOGShmemInit(void)
  	bool		foundCFile,
  				foundXLog;
  	char	   *allocptr;
  
  	ControlFile = (ControlFileData *)
  		ShmemInitStruct("Control File", sizeof(ControlFileData), &foundCFile);
! 	XLogCtl = (XLogCtlData *)
! 		ShmemInitStruct("XLOG Ctl", XLOGShmemSize(), &foundXLog);
  
  	if (foundCFile || foundXLog)
  	{
--- 5808,5818 ----
  	bool		foundCFile,
  				foundXLog;
  	char	   *allocptr;
+ 	int			i;
  
  	ControlFile = (ControlFileData *)
  		ShmemInitStruct("Control File", sizeof(ControlFileData), &foundCFile);
! 	allocptr = ShmemInitStruct("XLOG Ctl", XLOGShmemSize(), &foundXLog);
  
  	if (foundCFile || foundXLog)
  	{
***************
*** 5072,5077 **** XLOGShmemInit(void)
--- 5821,5833 ----
  		return;
  	}
  
+ 	/*
+ 	 * Ensure desired alignment for XLogCtlInsert, so that insertpos_lck and
+ 	 * the fields it protects fall on the same cache line.
+ 	 */
+ 	allocptr += XLOGCTLINSERT_ALIGNMENT - ((uintptr_t) allocptr) % XLOGCTLINSERT_ALIGNMENT;
+ 	XLogCtl = (XLogCtlData *) allocptr;
+ 
  	memset(XLogCtl, 0, sizeof(XLogCtlData));
  
  	/*
***************
*** 5084,5089 **** XLOGShmemInit(void)
--- 5840,5857 ----
  	memset(XLogCtl->xlblocks, 0, sizeof(XLogRecPtr) * XLOGbuffers);
  	allocptr += sizeof(XLogRecPtr) * XLOGbuffers;
  
+ 	/* Initialize insertion slots */
+ 	for (i = 0; i < NumXLogInsertSlots; i++)
+ 	{
+ 		XLogInsertSlot *slot = &XLogCtl->XLogInsertSlots[i];
+ 		slot->CurrPos = InvalidXLogRecPtr;
+ 		slot->finished = false;
+ 		slot->head = slot->tail = NULL;
+ 		SpinLockInit(&slot->lck);
+ 	}
+ 	XLogCtl->Insert.nextslot = 0;
+ 	XLogCtl->Insert.lastslot = 0;
+ 
  	/*
  	 * Align the start of the page buffers to an ALIGNOF_XLOG_BUFFER boundary.
  	 */
***************
*** 5098,5104 **** XLOGShmemInit(void)
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
! 	XLogCtl->Insert.currpage = (XLogPageHeader) (XLogCtl->pages);
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
--- 5866,5872 ----
  	XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
  	XLogCtl->SharedRecoveryInProgress = true;
  	XLogCtl->SharedHotStandbyActive = false;
! 	SpinLockInit(&XLogCtl->Insert.insertpos_lck);
  	SpinLockInit(&XLogCtl->info_lck);
  	InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
  	InitSharedLatch(&XLogCtl->WALWriterLatch);
***************
*** 5980,5985 **** StartupXLOG(void)
--- 6748,6754 ----
  	bool		backupEndRequired = false;
  	bool		backupFromStandby = false;
  	DBState		dbstate_at_startup;
+ 	int			firstIdx;
  
  	/*
  	 * Read control file and check XLOG status looks valid.
***************
*** 6232,6238 **** StartupXLOG(void)
  
  	lastFullPageWrites = checkPoint.fullPageWrites;
  
! 	RedoRecPtr = XLogCtl->Insert.RedoRecPtr = checkPoint.redo;
  
  	if (XLByteLT(RecPtr, checkPoint.redo))
  		ereport(PANIC,
--- 7001,7007 ----
  
  	lastFullPageWrites = checkPoint.fullPageWrites;
  
! 	RedoRecPtr = XLogCtl->RedoRecPtr = XLogCtl->Insert.RedoRecPtr = checkPoint.redo;
  
  	if (XLByteLT(RecPtr, checkPoint.redo))
  		ereport(PANIC,
***************
*** 6786,6793 **** StartupXLOG(void)
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 	XLogCtl->xlblocks[0].xlogid = openLogId;
! 	XLogCtl->xlblocks[0].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
--- 7555,7566 ----
  	openLogOff = 0;
  	Insert = &XLogCtl->Insert;
  	Insert->PrevRecord = LastRec;
! 
! 	firstIdx = XLogRecEndPtrToBufIdx(EndOfLog);
! 	XLogCtl->curridx = firstIdx;
! 
! 	XLogCtl->xlblocks[firstIdx].xlogid = openLogId;
! 	XLogCtl->xlblocks[firstIdx].xrecoff =
  		((EndOfLog.xrecoff - 1) / XLOG_BLCKSZ + 1) * XLOG_BLCKSZ;
  
  	/*
***************
*** 6795,6804 **** StartupXLOG(void)
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[0].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) Insert->currpage, readBuf, XLOG_BLCKSZ);
! 	Insert->currpos = (char *) Insert->currpage +
! 		(EndOfLog.xrecoff + XLOG_BLCKSZ - XLogCtl->xlblocks[0].xrecoff);
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
--- 7568,7576 ----
  	 * record spans, not the one it starts in.	The last block is indeed the
  	 * one we want to use.
  	 */
! 	Assert(readOff == (XLogCtl->xlblocks[firstIdx].xrecoff - XLOG_BLCKSZ) % XLogSegSize);
! 	memcpy((char *) &XLogCtl->pages[firstIdx * XLOG_BLCKSZ], readBuf, XLOG_BLCKSZ);
! 	Insert->CurrPos = EndOfLog;
  
  	LogwrtResult.Write = LogwrtResult.Flush = EndOfLog;
  
***************
*** 6807,6818 **** StartupXLOG(void)
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(Insert->currpos, 0, freespace);
! 		XLogCtl->Write.curridx = 0;
  	}
  	else
  	{
--- 7579,7590 ----
  	XLogCtl->LogwrtRqst.Write = EndOfLog;
  	XLogCtl->LogwrtRqst.Flush = EndOfLog;
  
! 	freespace = INSERT_FREESPACE(EndOfLog);
  	if (freespace > 0)
  	{
  		/* Make sure rest of page is zero */
! 		MemSet(&XLogCtl->pages[firstIdx * XLOG_BLCKSZ] + EndOfLog.xrecoff % XLOG_BLCKSZ, 0, freespace);
! 		XLogCtl->Write.curridx = firstIdx;
  	}
  	else
  	{
***************
*** 6824,6830 **** StartupXLOG(void)
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(0);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
--- 7596,7602 ----
  		 * this is sufficient.	The first actual attempt to insert a log
  		 * record will advance the insert state.
  		 */
! 		XLogCtl->Write.curridx = NextBufIdx(firstIdx);
  	}
  
  	/* Pre-scan prepared transactions to find out the range of XIDs present */
***************
*** 6835,6841 **** StartupXLOG(void)
  	 * XLOG_FPW_CHANGE record before resource manager writes cleanup
  	 * WAL records or checkpoint record is written.
  	 */
! 	Insert->fullPageWrites = lastFullPageWrites;
  	LocalSetXLogInsertAllowed();
  	UpdateFullPageWrites();
  	LocalXLogInsertAllowed = -1;
--- 7607,7613 ----
  	 * XLOG_FPW_CHANGE record before resource manager writes cleanup
  	 * WAL records or checkpoint record is written.
  	 */
! 	Insert->fullPageWrites = doPageWrites = lastFullPageWrites;
  	LocalSetXLogInsertAllowed();
  	UpdateFullPageWrites();
  	LocalXLogInsertAllowed = -1;
***************
*** 7307,7327 **** InitXLOGAccess(void)
  }
  
  /*
!  * Once spawned, a backend may update its local RedoRecPtr from
!  * XLogCtl->Insert.RedoRecPtr; it must hold the insert lock or info_lck
!  * to do so.  This is done in XLogInsert() or GetRedoRecPtr().
   */
  XLogRecPtr
  GetRedoRecPtr(void)
  {
  	/* use volatile pointer to prevent code rearrangement */
  	volatile XLogCtlData *xlogctl = XLogCtl;
  
  	SpinLockAcquire(&xlogctl->info_lck);
! 	Assert(XLByteLE(RedoRecPtr, xlogctl->Insert.RedoRecPtr));
! 	RedoRecPtr = xlogctl->Insert.RedoRecPtr;
  	SpinLockRelease(&xlogctl->info_lck);
  
  	return RedoRecPtr;
  }
  
--- 8079,8107 ----
  }
  
  /*
!  * Return the current Redo pointer from shared memory.
!  *
!  * As a side-effect, the local RedoRecPtr copy is updated.
   */
  XLogRecPtr
  GetRedoRecPtr(void)
  {
  	/* use volatile pointer to prevent code rearrangement */
  	volatile XLogCtlData *xlogctl = XLogCtl;
+ 	XLogRecPtr ptr;
  
+ 	/*
+ 	 * The possibly not up-to-date copy in XlogCtl is enough. Even if we
+ 	 * grabbed insertpos_lck to read the master copy, someone might update
+ 	 * it just after we've released the lock.
+ 	 */
  	SpinLockAcquire(&xlogctl->info_lck);
! 	ptr = xlogctl->RedoRecPtr;
  	SpinLockRelease(&xlogctl->info_lck);
  
+ 	if (XLByteLT(RedoRecPtr, ptr))
+ 		RedoRecPtr = xlogctl->RedoRecPtr;
+ 
  	return RedoRecPtr;
  }
  
***************
*** 7330,7336 **** GetRedoRecPtr(void)
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire WALInsertLock which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
--- 8110,8116 ----
   *
   * NOTE: The value *actually* returned is the position of the last full
   * xlog page. It lags behind the real insert position by at most 1 page.
!  * For that, we don't need to acquire insertpos_lck which can be quite
   * heavily contended, and an approximation is enough for the current
   * usage of this function.
   */
***************
*** 7592,7597 **** LogCheckpointEnd(bool restartpoint)
--- 8372,8379 ----
  void
  CreateCheckPoint(int flags)
  {
+ 	/* use volatile pointer to prevent code rearrangement */
+ 	volatile XLogCtlData *xlogctl = XLogCtl;
  	bool		shutdown;
  	CheckPoint	checkPoint;
  	XLogRecPtr	recptr;
***************
*** 7606,7611 **** CreateCheckPoint(int flags)
--- 8388,8394 ----
  	uint32		insert_logSeg;
  	TransactionId *inCommitXids;
  	int			nInCommit;
+ 	XLogRecPtr	curInsert;
  
  	/*
  	 * An end-of-recovery checkpoint is really a shutdown checkpoint, just
***************
*** 7674,7683 **** CreateCheckPoint(int flags)
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * We must hold WALInsertLock while examining insert state to determine
  	 * the checkpoint REDO pointer.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
--- 8457,8467 ----
  		checkPoint.oldestActiveXid = InvalidTransactionId;
  
  	/*
! 	 * We must hold insertpos_lck while examining insert state to determine
  	 * the checkpoint REDO pointer.
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	curInsert = Insert->CurrPos;
  
  	/*
  	 * If this isn't a shutdown or forced checkpoint, and we have not switched
***************
*** 7689,7695 **** CreateCheckPoint(int flags)
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding the WALInsertLock we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
--- 8473,8479 ----
  	 * (Perhaps it'd make even more sense to checkpoint only when the previous
  	 * checkpoint record is in a different xlog page?)
  	 *
! 	 * While holding insertpos_lck we find the current WAL insertion point
  	 * and compare that with the starting point of the last checkpoint, which
  	 * is the redo pointer. We use the redo pointer because the start and end
  	 * points of a checkpoint can be hundreds of files apart on large systems
***************
*** 7698,7712 **** CreateCheckPoint(int flags)
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
- 		XLogRecPtr	curInsert;
- 
- 		INSERT_RECPTR(curInsert, Insert, Insert->curridx);
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			LWLockRelease(WALInsertLock);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
--- 8482,8493 ----
  	if ((flags & (CHECKPOINT_IS_SHUTDOWN | CHECKPOINT_END_OF_RECOVERY |
  				  CHECKPOINT_FORCE)) == 0)
  	{
  		XLByteToSeg(curInsert, insert_logId, insert_logSeg);
  		XLByteToSeg(ControlFile->checkPointCopy.redo, redo_logId, redo_logSeg);
  		if (insert_logId == redo_logId &&
  			insert_logSeg == redo_logSeg)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			LWLockRelease(CheckpointLock);
  			END_CRIT_SECTION();
  			return;
***************
*** 7733,7750 **** CreateCheckPoint(int flags)
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(Insert);
  	if (freespace < SizeOfXLogRecord)
  	{
! 		(void) AdvanceXLInsertBuffer(false);
! 		/* OK to ignore update return flag, since we will do flush anyway */
! 		freespace = INSERT_FREESPACE(Insert);
  	}
! 	INSERT_RECPTR(checkPoint.redo, Insert, Insert->curridx);
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
! 	 * must be done while holding the insert lock AND the info_lck.
  	 *
  	 * Note: if we fail to complete the checkpoint, RedoRecPtr will be left
  	 * pointing past where it really needs to point.  This is okay; the only
--- 8514,8533 ----
  	 * the buffer flush work.  Those XLOG records are logically after the
  	 * checkpoint, even though physically before it.  Got that?
  	 */
! 	freespace = INSERT_FREESPACE(curInsert);
  	if (freespace < SizeOfXLogRecord)
  	{
! 		XLByteAdvance(curInsert, freespace);
! 		if (curInsert.xrecoff % XLogSegSize == 0)
! 			curInsert.xrecoff += SizeOfXLogLongPHD;
! 		else
! 			curInsert.xrecoff += SizeOfXLogShortPHD;
  	}
! 	checkPoint.redo = curInsert;
  
  	/*
  	 * Here we update the shared RedoRecPtr for future XLogInsert calls; this
! 	 * must be done while holding the insert lock.
  	 *
  	 * Note: if we fail to complete the checkpoint, RedoRecPtr will be left
  	 * pointing past where it really needs to point.  This is okay; the only
***************
*** 7753,7772 **** CreateCheckPoint(int flags)
  	 * XLogInserts that happen while we are dumping buffers must assume that
  	 * their buffer changes are not included in the checkpoint.
  	 */
! 	{
! 		/* use volatile pointer to prevent code rearrangement */
! 		volatile XLogCtlData *xlogctl = XLogCtl;
! 
! 		SpinLockAcquire(&xlogctl->info_lck);
! 		RedoRecPtr = xlogctl->Insert.RedoRecPtr = checkPoint.redo;
! 		SpinLockRelease(&xlogctl->info_lck);
! 	}
  
  	/*
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
--- 8536,8553 ----
  	 * XLogInserts that happen while we are dumping buffers must assume that
  	 * their buffer changes are not included in the checkpoint.
  	 */
! 	RedoRecPtr = xlogctl->Insert.RedoRecPtr = checkPoint.redo;
  
  	/*
  	 * Now we can release WAL insert lock, allowing other xacts to proceed
  	 * while we are flushing disk buffers.
  	 */
! 	SpinLockRelease(&Insert->insertpos_lck);
! 
! 	/* Update the info_lck-protected copy of RedoRecPtr as well */
! 	SpinLockAcquire(&xlogctl->info_lck);
! 	xlogctl->RedoRecPtr = checkPoint.redo;
! 	SpinLockRelease(&xlogctl->info_lck);
  
  	/*
  	 * If enabled, log checkpoint start.  We postpone this until now so as not
***************
*** 7786,7792 **** CreateCheckPoint(int flags)
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released WALInsertLock, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
--- 8567,8573 ----
  	 * we wait till he's out of his commit critical section before proceeding.
  	 * See notes in RecordTransactionCommit().
  	 *
! 	 * Because we've already released insertpos_lck, this test is a bit fuzzy:
  	 * it is possible that we will wait for xacts we didn't really need to
  	 * wait for.  But the delay should be short and it seems better to make
  	 * checkpoint take a bit longer than to hold locks longer than necessary.
***************
*** 8153,8167 **** CreateRestartPoint(int flags)
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * You need to hold WALInsertLock and info_lck to update it, although
! 	 * during recovery acquiring WALInsertLock is just pro forma, because
! 	 * there is no other processes updating Insert.RedoRecPtr.
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 	SpinLockAcquire(&xlogctl->info_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
- 	LWLockRelease(WALInsertLock);
  
  	/*
  	 * Prepare to accumulate statistics.
--- 8934,8951 ----
  	 * the number of segments replayed since last restartpoint, and request a
  	 * restartpoint if it exceeds checkpoint_segments.
  	 *
! 	 * Like in CreatecheckPoint(), hold insertpos_lck to update it, although
! 	 * during recovery acquiring insertpos_lck is just pro forma, because no
! 	 * WAL insertions are happening.
  	 */
! 	SpinLockAcquire(&xlogctl->Insert.insertpos_lck);
  	xlogctl->Insert.RedoRecPtr = lastCheckPoint.redo;
+ 	SpinLockRelease(&xlogctl->Insert.insertpos_lck);
+ 
+ 	/* Also update the info_lck-protected copy */
+ 	SpinLockAcquire(&xlogctl->info_lck);
+ 	xlogctl->RedoRecPtr = lastCheckPoint.redo;
  	SpinLockRelease(&xlogctl->info_lck);
  
  	/*
  	 * Prepare to accumulate statistics.
***************
*** 8448,8454 **** XLogReportParameters(void)
  void
  UpdateFullPageWrites(void)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  
  	/*
  	 * Do nothing if full_page_writes has not been changed.
--- 9232,9238 ----
  void
  UpdateFullPageWrites(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  
  	/*
  	 * Do nothing if full_page_writes has not been changed.
***************
*** 8471,8479 **** UpdateFullPageWrites(void)
  	 */
  	if (fullPageWrites)
  	{
! 		LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  		Insert->fullPageWrites = true;
! 		LWLockRelease(WALInsertLock);
  	}
  
  	/*
--- 9255,9263 ----
  	 */
  	if (fullPageWrites)
  	{
! 		SpinLockAcquire(&Insert->insertpos_lck);
  		Insert->fullPageWrites = true;
! 		SpinLockRelease(&Insert->insertpos_lck);
  	}
  
  	/*
***************
*** 8494,8502 **** UpdateFullPageWrites(void)
  
  	if (!fullPageWrites)
  	{
! 		LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  		Insert->fullPageWrites = false;
! 		LWLockRelease(WALInsertLock);
  	}
  	END_CRIT_SECTION();
  }
--- 9278,9286 ----
  
  	if (!fullPageWrites)
  	{
! 		SpinLockAcquire(&Insert->insertpos_lck);
  		Insert->fullPageWrites = false;
! 		SpinLockRelease(&Insert->insertpos_lck);
  	}
  	END_CRIT_SECTION();
  }
***************
*** 9024,9029 **** issue_xlog_fsync(int fd, uint32 log, uint32 seg)
--- 9808,9814 ----
  XLogRecPtr
  do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	bool		backup_started_in_recovery = false;
  	XLogRecPtr	checkpointloc;
***************
*** 9086,9111 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  	 * Note that forcePageWrites has no effect during an online backup from
  	 * the standby.
  	 *
! 	 * We must hold WALInsertLock to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
! 		if (XLogCtl->Insert.exclusiveBackup)
  		{
! 			LWLockRelease(WALInsertLock);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		XLogCtl->Insert.exclusiveBackup = true;
  	}
  	else
! 		XLogCtl->Insert.nonExclusiveBackups++;
! 	XLogCtl->Insert.forcePageWrites = true;
! 	LWLockRelease(WALInsertLock);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
--- 9871,9896 ----
  	 * Note that forcePageWrites has no effect during an online backup from
  	 * the standby.
  	 *
! 	 * We must hold insertpos_lck to change the value of forcePageWrites, to
  	 * ensure adequate interlocking against XLogInsert().
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
! 		if (Insert->exclusiveBackup)
  		{
! 			SpinLockRelease(&Insert->insertpos_lck);
  			ereport(ERROR,
  					(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
  					 errmsg("a backup is already in progress"),
  					 errhint("Run pg_stop_backup() and try again.")));
  		}
! 		Insert->exclusiveBackup = true;
  	}
  	else
! 		Insert->nonExclusiveBackups++;
! 	Insert->forcePageWrites = true;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	/* Ensure we release forcePageWrites if fail below */
  	PG_ENSURE_ERROR_CLEANUP(pg_start_backup_callback, (Datum) BoolGetDatum(exclusive));
***************
*** 9218,9230 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			LWLockAcquire(WALInsertLock, LW_SHARED);
! 			if (XLByteLT(XLogCtl->Insert.lastBackupStart, startpoint))
  			{
! 				XLogCtl->Insert.lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			LWLockRelease(WALInsertLock);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
--- 10003,10015 ----
  			 * taking a checkpoint right after another is not that expensive
  			 * either because only few buffers have been dirtied yet.
  			 */
! 			SpinLockAcquire(&Insert->insertpos_lck);
! 			if (XLByteLT(Insert->lastBackupStart, startpoint))
  			{
! 				Insert->lastBackupStart = startpoint;
  				gotUniqueStartpoint = true;
  			}
! 			SpinLockRelease(&Insert->insertpos_lck);
  		} while (!gotUniqueStartpoint);
  
  		XLByteToSeg(startpoint, _logId, _logSeg);
***************
*** 9308,9334 **** do_pg_start_backup(const char *backupidstr, bool fast, char **labelfile)
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
  	{
! 		Assert(XLogCtl->Insert.exclusiveBackup);
! 		XLogCtl->Insert.exclusiveBackup = false;
  	}
  	else
  	{
! 		Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 		XLogCtl->Insert.nonExclusiveBackups--;
  	}
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 10093,10120 ----
  static void
  pg_start_backup_callback(int code, Datum arg)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = DatumGetBool(arg);
  
  	/* Update backup counters and forcePageWrites on failure */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
  	{
! 		Assert(Insert->exclusiveBackup);
! 		Insert->exclusiveBackup = false;
  	}
  	else
  	{
! 		Assert(Insert->nonExclusiveBackups > 0);
! 		Insert->nonExclusiveBackups--;
  	}
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9341,9346 **** pg_start_backup_callback(int code, Datum arg)
--- 10127,10133 ----
  XLogRecPtr
  do_pg_stop_backup(char *labelfile, bool waitforarchive)
  {
+ 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	bool		exclusive = (labelfile == NULL);
  	bool		backup_started_in_recovery = false;
  	XLogRecPtr	startpoint;
***************
*** 9394,9402 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
  	if (exclusive)
! 		XLogCtl->Insert.exclusiveBackup = false;
  	else
  	{
  		/*
--- 10181,10189 ----
  	/*
  	 * OK to update backup counters and forcePageWrites
  	 */
! 	SpinLockAcquire(&Insert->insertpos_lck);
  	if (exclusive)
! 		Insert->exclusiveBackup = false;
  	else
  	{
  		/*
***************
*** 9405,9420 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 		XLogCtl->Insert.nonExclusiveBackups--;
  	}
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  
  	if (exclusive)
  	{
--- 10192,10207 ----
  		 * backups, it is expected that each do_pg_start_backup() call is
  		 * matched by exactly one do_pg_stop_backup() call.
  		 */
! 		Assert(Insert->nonExclusiveBackups > 0);
! 		Insert->nonExclusiveBackups--;
  	}
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	if (exclusive)
  	{
***************
*** 9692,9707 **** do_pg_stop_backup(char *labelfile, bool waitforarchive)
  void
  do_pg_abort_backup(void)
  {
! 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
! 	Assert(XLogCtl->Insert.nonExclusiveBackups > 0);
! 	XLogCtl->Insert.nonExclusiveBackups--;
  
! 	if (!XLogCtl->Insert.exclusiveBackup &&
! 		XLogCtl->Insert.nonExclusiveBackups == 0)
  	{
! 		XLogCtl->Insert.forcePageWrites = false;
  	}
! 	LWLockRelease(WALInsertLock);
  }
  
  /*
--- 10479,10496 ----
  void
  do_pg_abort_backup(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
! 
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	Assert(Insert->nonExclusiveBackups > 0);
! 	Insert->nonExclusiveBackups--;
  
! 	if (!Insert->exclusiveBackup &&
! 		Insert->nonExclusiveBackups == 0)
  	{
! 		Insert->forcePageWrites = false;
  	}
! 	SpinLockRelease(&Insert->insertpos_lck);
  }
  
  /*
***************
*** 9755,9766 **** GetStandbyFlushRecPtr(void)
  XLogRecPtr
  GetXLogInsertRecPtr(void)
  {
! 	XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	LWLockAcquire(WALInsertLock, LW_SHARED);
! 	INSERT_RECPTR(current_recptr, Insert, Insert->curridx);
! 	LWLockRelease(WALInsertLock);
  
  	return current_recptr;
  }
--- 10544,10555 ----
  XLogRecPtr
  GetXLogInsertRecPtr(void)
  {
! 	volatile XLogCtlInsert *Insert = &XLogCtl->Insert;
  	XLogRecPtr	current_recptr;
  
! 	SpinLockAcquire(&Insert->insertpos_lck);
! 	current_recptr = Insert->CurrPos;
! 	SpinLockRelease(&Insert->insertpos_lck);
  
  	return current_recptr;
  }
*** a/src/backend/storage/ipc/procarray.c
--- b/src/backend/storage/ipc/procarray.c
***************
*** 1753,1761 **** GetOldestActiveTransactionId(void)
   * the result is somewhat indeterminate, but we don't really care.  Even in
   * a multiprocessor with delayed writes to shared memory, it should be certain
   * that setting of inCommit will propagate to shared memory when the backend
!  * takes the WALInsertLock, so we cannot fail to see an xact as inCommit if
!  * it's already inserted its commit record.  Whether it takes a little while
!  * for clearing of inCommit to propagate is unimportant for correctness.
   */
  int
  GetTransactionsInCommit(TransactionId **xids_p)
--- 1753,1762 ----
   * the result is somewhat indeterminate, but we don't really care.  Even in
   * a multiprocessor with delayed writes to shared memory, it should be certain
   * that setting of inCommit will propagate to shared memory when the backend
!  * takes a lock to write the WAL record, so we cannot fail to see an xact as
!  * inCommit if it's already inserted its commit record.  Whether it takes a
!  * little while for clearing of inCommit to propagate is unimportant for
!  * correctness.
   */
  int
  GetTransactionsInCommit(TransactionId **xids_p)
*** a/src/backend/storage/lmgr/spin.c
--- b/src/backend/storage/lmgr/spin.c
***************
*** 56,61 **** SpinlockSemas(void)
--- 56,64 ----
  	 *
  	 * For now, though, we just need a few spinlocks (10 should be plenty)
  	 * plus one for each LWLock and one for each buffer header.
+ 	 *
+ 	 * XXX: remember to adjust this for the number of spinlocks needed by the
+ 	 * xlog.c changes before committing!
  	 */
  	return NumLWLocks() + NBuffers + 10;
  }
*** a/src/include/storage/lwlock.h
--- b/src/include/storage/lwlock.h
***************
*** 53,59 **** typedef enum LWLockId
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALInsertLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
--- 53,59 ----
  	ProcArrayLock,
  	SInvalReadLock,
  	SInvalWriteLock,
! 	WALBufMappingLock,
  	WALWriteLock,
  	ControlFileLock,
  	CheckpointLock,
***************
*** 79,84 **** typedef enum LWLockId
--- 79,85 ----
  	SerializablePredicateLockListLock,
  	OldSerXidLock,
  	SyncRepLock,
+ 	WALInsertTailLock,
  	/* Individual lock IDs end here */
  	FirstBufMappingLock,
  	FirstLockMgrLock = FirstBufMappingLock + NUM_BUFFER_PARTITIONS,