Massive commit to run PGINDENT on all *.c and *.h files.

1 files changed, 1421 insertions, 1274 deletions

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index 466728c4a46..2a53e6bd78c 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -1,44 +1,44 @@
 /*-------------------------------------------------------------------------
  *
  * bufmgr.c--
- *    buffer manager interface routines
+ *	  buffer manager interface routines
  *
  * Copyright (c) 1994, Regents of the University of California
  *
  *
  * IDENTIFICATION
- *    $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.19 1997/08/19 21:32:39 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.20 1997/09/07 04:48:19 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
 /*
  *
  * BufferAlloc() -- lookup a buffer in the buffer table.  If
- *	it isn't there add it, but do not read it into memory.
- *	This is used when we are about to reinitialize the
- *	buffer so don't care what the current disk contents are.
- *	BufferAlloc() pins the new buffer in memory.
+ *		it isn't there add it, but do not read it into memory.
+ *		This is used when we are about to reinitialize the
+ *		buffer so don't care what the current disk contents are.
+ *		BufferAlloc() pins the new buffer in memory.
  *
  * ReadBuffer() -- same as BufferAlloc() but reads the data
- *	on a buffer cache miss.
+ *		on a buffer cache miss.
  *
  * ReleaseBuffer() -- unpin the buffer
  *
  * WriteNoReleaseBuffer() -- mark the buffer contents as "dirty"
- *	but don't unpin.  The disk IO is delayed until buffer
- *	replacement if WriteMode is BUFFER_LATE_WRITE.
+ *		but don't unpin.  The disk IO is delayed until buffer
+ *		replacement if WriteMode is BUFFER_LATE_WRITE.
  *
- * WriteBuffer() -- WriteNoReleaseBuffer() + ReleaseBuffer() 
+ * WriteBuffer() -- WriteNoReleaseBuffer() + ReleaseBuffer()
  *
  * FlushBuffer() -- as above but never delayed write.
  *
  * BufferSync() -- flush all dirty buffers in the buffer pool.
- * 
+ *
  * InitBufferPool() -- Init the buffer module.
  *
- * See other files:  
- * 	freelist.c -- chooses victim for buffer replacement 
- *	buf_table.c -- manages the buffer lookup table
+ * See other files:
+ *		freelist.c -- chooses victim for buffer replacement
+ *		buf_table.c -- manages the buffer lookup table
  */
 #include <sys/types.h>
 #include <sys/file.h>
@@ -66,7 +66,7 @@
 #include "utils/palloc.h"
 #include "utils/memutils.h"
 #include "utils/relcache.h"
-#include "executor/execdebug.h"	/* for NDirectFileRead */
+#include "executor/execdebug.h" /* for NDirectFileRead */
 #include "catalog/catalog.h"
 
 extern SPINLOCK BufMgrLock;
@@ -77,76 +77,88 @@ extern long int LocalBufferHitCount;
 extern long int BufferFlushCount;
 extern long int LocalBufferFlushCount;
 
-static int WriteMode = BUFFER_LATE_WRITE;	/* Delayed write is default */
+static int		WriteMode = BUFFER_LATE_WRITE;	/* Delayed write is
+												 * default */
+
+static void		WaitIO(BufferDesc * buf, SPINLOCK spinlock);
 
-static void WaitIO(BufferDesc *buf, SPINLOCK spinlock);
 #ifndef HAS_TEST_AND_SET
-static void SignalIO(BufferDesc *buf);
-extern long *NWaitIOBackendP; /* defined in buf_init.c */
-#endif /* HAS_TEST_AND_SET */
-
-static Buffer ReadBufferWithBufferLock(Relation relation, BlockNumber blockNum,
-				       bool bufferLockHeld);
-static BufferDesc *BufferAlloc(Relation reln, BlockNumber blockNum,
-			       bool *foundPtr, bool bufferLockHeld);
-static int FlushBuffer (Buffer buffer, bool release);
-static void BufferSync(void);
-static int BufferReplace(BufferDesc *bufHdr, bool bufferLockHeld);
+static void		SignalIO(BufferDesc * buf);
+extern long    *NWaitIOBackendP;/* defined in buf_init.c */
+
+#endif							/* HAS_TEST_AND_SET */
+
+static Buffer
+ReadBufferWithBufferLock(Relation relation, BlockNumber blockNum,
+						 bool bufferLockHeld);
+static BufferDesc *
+BufferAlloc(Relation reln, BlockNumber blockNum,
+			bool * foundPtr, bool bufferLockHeld);
+static int		FlushBuffer(Buffer buffer, bool release);
+static void		BufferSync(void);
+static int		BufferReplace(BufferDesc * bufHdr, bool bufferLockHeld);
 
 /* ---------------------------------------------------
  * RelationGetBufferWithBuffer
- *	see if the given buffer is what we want
- *	if yes, we don't need to bother the buffer manager
+ *		see if the given buffer is what we want
+ *		if yes, we don't need to bother the buffer manager
  * ---------------------------------------------------
  */
 Buffer
 RelationGetBufferWithBuffer(Relation relation,
-			    BlockNumber blockNumber,
-			    Buffer buffer)
+							BlockNumber blockNumber,
+							Buffer buffer)
 {
-    BufferDesc *bufHdr;
-    LRelId lrelId;
-    
-    if (BufferIsValid(buffer)) {
-	if (!BufferIsLocal(buffer)) {
-	    bufHdr = &BufferDescriptors[buffer-1];
-	    lrelId = RelationGetLRelId(relation);
-	    SpinAcquire(BufMgrLock);
-	    if (bufHdr->tag.blockNum == blockNumber &&
-		bufHdr->tag.relId.relId == lrelId.relId &&
-		bufHdr->tag.relId.dbId == lrelId.dbId) {
-		SpinRelease(BufMgrLock);
-		return(buffer);
-	    }
-	    return(ReadBufferWithBufferLock(relation, blockNumber, true));
-	} else {
-	    bufHdr = &LocalBufferDescriptors[-buffer-1];
-	    if (bufHdr->tag.relId.relId == relation->rd_id &&
-		bufHdr->tag.blockNum == blockNumber) {
-		return(buffer);
-	    }
+	BufferDesc	   *bufHdr;
+	LRelId			lrelId;
+
+	if (BufferIsValid(buffer))
+	{
+		if (!BufferIsLocal(buffer))
+		{
+			bufHdr = &BufferDescriptors[buffer - 1];
+			lrelId = RelationGetLRelId(relation);
+			SpinAcquire(BufMgrLock);
+			if (bufHdr->tag.blockNum == blockNumber &&
+				bufHdr->tag.relId.relId == lrelId.relId &&
+				bufHdr->tag.relId.dbId == lrelId.dbId)
+			{
+				SpinRelease(BufMgrLock);
+				return (buffer);
+			}
+			return (ReadBufferWithBufferLock(relation, blockNumber, true));
+		}
+		else
+		{
+			bufHdr = &LocalBufferDescriptors[-buffer - 1];
+			if (bufHdr->tag.relId.relId == relation->rd_id &&
+				bufHdr->tag.blockNum == blockNumber)
+			{
+				return (buffer);
+			}
+		}
 	}
-    }
-    return(ReadBuffer(relation, blockNumber));
+	return (ReadBuffer(relation, blockNumber));
 }
 
 /*
  * ReadBuffer -- returns a buffer containing the requested
- *	block of the requested relation.  If the blknum
- *	requested is P_NEW, extend the relation file and
- *	allocate a new block.
+ *		block of the requested relation.  If the blknum
+ *		requested is P_NEW, extend the relation file and
+ *		allocate a new block.
  *
  * Returns: the buffer number for the buffer containing
- *	the block read or NULL on an error.
+ *		the block read or NULL on an error.
  *
  * Assume when this function is called, that reln has been
- *	opened already.
+ *		opened already.
  */
 
-extern int ShowPinTrace;
+extern int		ShowPinTrace;
 
 
-#undef ReadBuffer	/* conflicts with macro when BUFMGR_DEBUG defined */
+#undef ReadBuffer				/* conflicts with macro when BUFMGR_DEBUG
+								 * defined */
 
 /*
  * ReadBuffer --
@@ -155,7 +167,7 @@ extern int ShowPinTrace;
 Buffer
 ReadBuffer(Relation reln, BlockNumber blockNum)
 {
-    return ReadBufferWithBufferLock(reln, blockNum, false);
+	return ReadBufferWithBufferLock(reln, blockNum, false);
 }
 
 /*
@@ -164,156 +176,176 @@ ReadBuffer(Relation reln, BlockNumber blockNum)
  * XXX caller must have already acquired BufMgrLock
  */
 #ifdef NOT_USED
-static bool
+static			bool
 is_userbuffer(Buffer buffer)
 {
-    BufferDesc *buf = &BufferDescriptors[buffer-1];
-    
-    if (IsSystemRelationName(buf->sb_relname))
-	return false;
-    return true;
+	BufferDesc	   *buf = &BufferDescriptors[buffer - 1];
+
+	if (IsSystemRelationName(buf->sb_relname))
+		return false;
+	return true;
 }
+
 #endif
 
 #ifdef NOT_USED
 Buffer
 ReadBuffer_Debug(char *file,
-		 int line,
-		 Relation reln,
-		 BlockNumber blockNum)
+				 int line,
+				 Relation reln,
+				 BlockNumber blockNum)
 {
-    Buffer buffer;
-    
-    buffer = ReadBufferWithBufferLock(reln, blockNum, false);
-    if (ShowPinTrace && !BufferIsLocal(buffer) && is_userbuffer(buffer)) {
-	BufferDesc *buf = &BufferDescriptors[buffer-1];
-	
-	fprintf(stderr, "PIN(RD) %ld relname = %s, blockNum = %d, \
+	Buffer			buffer;
+
+	buffer = ReadBufferWithBufferLock(reln, blockNum, false);
+	if (ShowPinTrace && !BufferIsLocal(buffer) && is_userbuffer(buffer))
+	{
+		BufferDesc	   *buf = &BufferDescriptors[buffer - 1];
+
+		fprintf(stderr, "PIN(RD) %ld relname = %s, blockNum = %d, \
 refcount = %ld, file: %s, line: %d\n",
-		buffer, buf->sb_relname, buf->tag.blockNum,
-		PrivateRefCount[buffer - 1], file, line);
-    }
-    return buffer;
+				buffer, buf->sb_relname, buf->tag.blockNum,
+				PrivateRefCount[buffer - 1], file, line);
+	}
+	return buffer;
 }
+
 #endif
 
 /*
- * ReadBufferWithBufferLock -- does the work of 
- *	ReadBuffer() but with the possibility that
- *	the buffer lock has already been held. this
- *	is yet another effort to reduce the number of
- *	semops in the system.
+ * ReadBufferWithBufferLock -- does the work of
+ *		ReadBuffer() but with the possibility that
+ *		the buffer lock has already been held. this
+ *		is yet another effort to reduce the number of
+ *		semops in the system.
  */
-static Buffer
+static			Buffer
 ReadBufferWithBufferLock(Relation reln,
-			 BlockNumber blockNum,
-			 bool bufferLockHeld)
+						 BlockNumber blockNum,
+						 bool bufferLockHeld)
 {
-    BufferDesc *bufHdr;	  
-    int		extend;   /* extending the file by one block */
-    int		status;
-    bool	found;
-    bool	isLocalBuf;
-
-    extend = (blockNum == P_NEW);
-    isLocalBuf = reln->rd_islocal;
-
-    if (isLocalBuf) {
-	ReadLocalBufferCount++;
-	bufHdr = LocalBufferAlloc(reln, blockNum, &found);
-	if (found) LocalBufferHitCount++;
-    } else {
-	ReadBufferCount++;
-
-	/* lookup the buffer.  IO_IN_PROGRESS is set if the requested
-	 * block is not currently in memory.
-	 */
-	bufHdr = BufferAlloc(reln, blockNum, &found, bufferLockHeld);
-	if (found) BufferHitCount++;
-    }
-
-    if (!bufHdr) {
-	return(InvalidBuffer);
-    }
-    
-    /* if its already in the buffer pool, we're done */
-    if (found) {
+	BufferDesc	   *bufHdr;
+	int				extend;		/* extending the file by one block */
+	int				status;
+	bool			found;
+	bool			isLocalBuf;
+
+	extend = (blockNum == P_NEW);
+	isLocalBuf = reln->rd_islocal;
+
+	if (isLocalBuf)
+	{
+		ReadLocalBufferCount++;
+		bufHdr = LocalBufferAlloc(reln, blockNum, &found);
+		if (found)
+			LocalBufferHitCount++;
+	}
+	else
+	{
+		ReadBufferCount++;
+
+		/*
+		 * lookup the buffer.  IO_IN_PROGRESS is set if the requested
+		 * block is not currently in memory.
+		 */
+		bufHdr = BufferAlloc(reln, blockNum, &found, bufferLockHeld);
+		if (found)
+			BufferHitCount++;
+	}
+
+	if (!bufHdr)
+	{
+		return (InvalidBuffer);
+	}
+
+	/* if its already in the buffer pool, we're done */
+	if (found)
+	{
+
+		/*
+		 * This happens when a bogus buffer was returned previously and is
+		 * floating around in the buffer pool.	A routine calling this
+		 * would want this extended.
+		 */
+		if (extend)
+		{
+			/* new buffers are zero-filled */
+			memset((char *) MAKE_PTR(bufHdr->data), 0, BLCKSZ);
+			smgrextend(bufHdr->bufsmgr, reln,
+					   (char *) MAKE_PTR(bufHdr->data));
+		}
+		return (BufferDescriptorGetBuffer(bufHdr));
+
+	}
+
 	/*
-	 * This happens when a bogus buffer was returned previously and is
-	 * floating around in the buffer pool.  A routine calling this would
-	 * want this extended.
+	 * if we have gotten to this point, the reln pointer must be ok and
+	 * the relation file must be open.
 	 */
-	if (extend) {
-	    /* new buffers are zero-filled */
-	    memset((char *) MAKE_PTR(bufHdr->data), 0, BLCKSZ);
-	    smgrextend(bufHdr->bufsmgr, reln,
-			      (char *) MAKE_PTR(bufHdr->data));
+	if (extend)
+	{
+		/* new buffers are zero-filled */
+		memset((char *) MAKE_PTR(bufHdr->data), 0, BLCKSZ);
+		status = smgrextend(bufHdr->bufsmgr, reln,
+							(char *) MAKE_PTR(bufHdr->data));
 	}
-	return (BufferDescriptorGetBuffer(bufHdr));
-		
-    }
-    
-    /* 
-     * if we have gotten to this point, the reln pointer must be ok
-     * and the relation file must be open.
-     */
-    if (extend) {
-	/* new buffers are zero-filled */
-	memset((char *) MAKE_PTR(bufHdr->data), 0, BLCKSZ);
-	status = smgrextend(bufHdr->bufsmgr, reln,
-			    (char *) MAKE_PTR(bufHdr->data));
-    } else {
-	status = smgrread(bufHdr->bufsmgr, reln, blockNum,
-			  (char *) MAKE_PTR(bufHdr->data));
-    }
-
-    if (isLocalBuf)
-	return (BufferDescriptorGetBuffer(bufHdr));
+	else
+	{
+		status = smgrread(bufHdr->bufsmgr, reln, blockNum,
+						  (char *) MAKE_PTR(bufHdr->data));
+	}
+
+	if (isLocalBuf)
+		return (BufferDescriptorGetBuffer(bufHdr));
+
+	/* lock buffer manager again to update IO IN PROGRESS */
+	SpinAcquire(BufMgrLock);
+
+	if (status == SM_FAIL)
+	{
+		/* IO Failed.  cleanup the data structures and go home */
+
+		if (!BufTableDelete(bufHdr))
+		{
+			SpinRelease(BufMgrLock);
+			elog(FATAL, "BufRead: buffer table broken after IO error\n");
+		}
+		/* remember that BufferAlloc() pinned the buffer */
+		UnpinBuffer(bufHdr);
 
-    /* lock buffer manager again to update IO IN PROGRESS */
-    SpinAcquire(BufMgrLock);
-    
-    if (status == SM_FAIL) {
-	/* IO Failed.  cleanup the data structures and go home */
-	
-	if (! BufTableDelete(bufHdr)) {
-	    SpinRelease(BufMgrLock);
-	    elog(FATAL,"BufRead: buffer table broken after IO error\n");
+		/*
+		 * Have to reset the flag so that anyone waiting for the buffer
+		 * can tell that the contents are invalid.
+		 */
+		bufHdr->flags |= BM_IO_ERROR;
+		bufHdr->flags &= ~BM_IO_IN_PROGRESS;
 	}
-	/* remember that BufferAlloc() pinned the buffer */
-	UnpinBuffer(bufHdr);
-	
-	/* 
-	 * Have to reset the flag so that anyone waiting for
-	 * the buffer can tell that the contents are invalid.
-	 */
-	bufHdr->flags |= BM_IO_ERROR;
-	bufHdr->flags &= ~BM_IO_IN_PROGRESS;
-    } else {
-	/* IO Succeeded.  clear the flags, finish buffer update */
-	
-	bufHdr->flags &= ~(BM_IO_ERROR | BM_IO_IN_PROGRESS);
-    }
-    
-    /* If anyone was waiting for IO to complete, wake them up now */
+	else
+	{
+		/* IO Succeeded.  clear the flags, finish buffer update */
+
+		bufHdr->flags &= ~(BM_IO_ERROR | BM_IO_IN_PROGRESS);
+	}
+
+	/* If anyone was waiting for IO to complete, wake them up now */
 #ifdef HAS_TEST_AND_SET
-    S_UNLOCK(&(bufHdr->io_in_progress_lock));
+	S_UNLOCK(&(bufHdr->io_in_progress_lock));
 #else
-    if (bufHdr->refcount > 1)
-	SignalIO(bufHdr);
+	if (bufHdr->refcount > 1)
+		SignalIO(bufHdr);
 #endif
-    
-    SpinRelease(BufMgrLock);
-    
-    if (status == SM_FAIL)
-	return(InvalidBuffer);
-    
-    return(BufferDescriptorGetBuffer(bufHdr));
+
+	SpinRelease(BufMgrLock);
+
+	if (status == SM_FAIL)
+		return (InvalidBuffer);
+
+	return (BufferDescriptorGetBuffer(bufHdr));
 }
 
 /*
  * BufferAlloc -- Get a buffer from the buffer pool but dont
- *	read it.
+ *		read it.
  *
  * Returns: descriptor for buffer
  *
@@ -321,321 +353,339 @@ ReadBufferWithBufferLock(Relation reln,
  */
 static BufferDesc *
 BufferAlloc(Relation reln,
-	    BlockNumber blockNum,
-	    bool	*foundPtr,
-	    bool bufferLockHeld)
+			BlockNumber blockNum,
+			bool * foundPtr,
+			bool bufferLockHeld)
 {
-    BufferDesc 		*buf, *buf2;	  
-    BufferTag 		newTag;	 /* identity of requested block */
-    bool		inProgress; /* buffer undergoing IO */
-    bool		newblock = FALSE;
-    
-    /* create a new tag so we can lookup the buffer */
-    /* assume that the relation is already open */
-    if (blockNum == P_NEW) {
-	newblock = TRUE;
-	blockNum = smgrnblocks(reln->rd_rel->relsmgr, reln);
-    }
-    
-    INIT_BUFFERTAG(&newTag,reln,blockNum);
-    
-    if (!bufferLockHeld)
-	SpinAcquire(BufMgrLock);
-    
-    /* see if the block is in the buffer pool already */
-    buf = BufTableLookup(&newTag);
-    if (buf != NULL) {
-	/* Found it.  Now, (a) pin the buffer so no
-	 * one steals it from the buffer pool, 
-	 * (b) check IO_IN_PROGRESS, someone may be
-	 * faulting the buffer into the buffer pool.
-	 */
-	
-	PinBuffer(buf);
-	inProgress = (buf->flags & BM_IO_IN_PROGRESS);
-	
-	*foundPtr = TRUE;
-	if (inProgress) {
-	    WaitIO(buf, BufMgrLock);
-	    if (buf->flags & BM_IO_ERROR) {
-		/* wierd race condition: 
-		 *
-		 * We were waiting for someone else to read the buffer.  
-		 * While we were waiting, the reader boof'd in some
-		 *  way, so the contents of the buffer are still
-		 * invalid.  By saying that we didn't find it, we can
-		 * make the caller reinitialize the buffer.  If two
-		 * processes are waiting for this block, both will
-		 * read the block.  The second one to finish may overwrite 
-		 * any updates made by the first.  (Assume higher level
-		 * synchronization prevents this from happening).
-		 *
-		 * This is never going to happen, don't worry about it.
-		 */
-		*foundPtr = FALSE;
-	    }
+	BufferDesc	   *buf,
+				   *buf2;
+	BufferTag		newTag;		/* identity of requested block */
+	bool			inProgress; /* buffer undergoing IO */
+	bool			newblock = FALSE;
+
+	/* create a new tag so we can lookup the buffer */
+	/* assume that the relation is already open */
+	if (blockNum == P_NEW)
+	{
+		newblock = TRUE;
+		blockNum = smgrnblocks(reln->rd_rel->relsmgr, reln);
 	}
+
+	INIT_BUFFERTAG(&newTag, reln, blockNum);
+
+	if (!bufferLockHeld)
+		SpinAcquire(BufMgrLock);
+
+	/* see if the block is in the buffer pool already */
+	buf = BufTableLookup(&newTag);
+	if (buf != NULL)
+	{
+
+		/*
+		 * Found it.  Now, (a) pin the buffer so no one steals it from the
+		 * buffer pool, (b) check IO_IN_PROGRESS, someone may be faulting
+		 * the buffer into the buffer pool.
+		 */
+
+		PinBuffer(buf);
+		inProgress = (buf->flags & BM_IO_IN_PROGRESS);
+
+		*foundPtr = TRUE;
+		if (inProgress)
+		{
+			WaitIO(buf, BufMgrLock);
+			if (buf->flags & BM_IO_ERROR)
+			{
+
+				/*
+				 * wierd race condition:
+				 *
+				 * We were waiting for someone else to read the buffer. While
+				 * we were waiting, the reader boof'd in some way, so the
+				 * contents of the buffer are still invalid.  By saying
+				 * that we didn't find it, we can make the caller
+				 * reinitialize the buffer.  If two processes are waiting
+				 * for this block, both will read the block.  The second
+				 * one to finish may overwrite any updates made by the
+				 * first.  (Assume higher level synchronization prevents
+				 * this from happening).
+				 *
+				 * This is never going to happen, don't worry about it.
+				 */
+				*foundPtr = FALSE;
+			}
+		}
 #ifdef BMTRACE
-	_bm_trace((reln->rd_rel->relisshared ? 0 : MyDatabaseId), reln->rd_id, blockNum, BufferDescriptorGetBuffer(buf), BMT_ALLOCFND);
-#endif /* BMTRACE */
-	
-	SpinRelease(BufMgrLock);
-	
-	return(buf);
-    }
-    
-    *foundPtr = FALSE;
-    
-    /*
-     * Didn't find it in the buffer pool.  We'll have
-     * to initialize a new buffer.  First, grab one from
-     * the free list.  If it's dirty, flush it to disk.
-     * Remember to unlock BufMgr spinlock while doing the IOs.
-     */
-    inProgress = FALSE;
-    for (buf = (BufferDesc *) NULL; buf == (BufferDesc *) NULL; ) {
-	
-	/* GetFreeBuffer will abort if it can't find a free buffer */
-	buf = GetFreeBuffer();
-	
-	/* 
-	 * But it can return buf == NULL if we are in aborting 
-	 * transaction now and so elog(WARN,...) in GetFreeBuffer 
-	 * will not abort again.
-	 */
-	if ( buf == NULL )
-		return (NULL);
-	
+		_bm_trace((reln->rd_rel->relisshared ? 0 : MyDatabaseId), reln->rd_id, blockNum, BufferDescriptorGetBuffer(buf), BMT_ALLOCFND);
+#endif							/* BMTRACE */
+
+		SpinRelease(BufMgrLock);
+
+		return (buf);
+	}
+
+	*foundPtr = FALSE;
+
 	/*
-	 * There should be exactly one pin on the buffer after
-	 * it is allocated -- ours.  If it had a pin it wouldn't
-	 * have been on the free list.  No one else could have
-	 * pinned it between GetFreeBuffer and here because we
-	 * have the BufMgrLock.
+	 * Didn't find it in the buffer pool.  We'll have to initialize a new
+	 * buffer.	First, grab one from the free list.  If it's dirty, flush
+	 * it to disk. Remember to unlock BufMgr spinlock while doing the IOs.
 	 */
-	Assert(buf->refcount == 0);
-	buf->refcount = 1;	       
-	PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 1;
-	
-	if (buf->flags & BM_DIRTY) {
-	    bool smok;
-	    /*
-	     * Set BM_IO_IN_PROGRESS to keep anyone from doing anything
-	     * with the contents of the buffer while we write it out.
-	     * We don't really care if they try to read it, but if they
-	     * can complete a BufferAlloc on it they can then scribble
-	     * into it, and we'd really like to avoid that while we are
-	     * flushing the buffer.  Setting this flag should block them
-	     * in WaitIO until we're done.
-	     */
-	    inProgress = TRUE;
-	    buf->flags |= BM_IO_IN_PROGRESS; 
-#ifdef HAS_TEST_AND_SET
-	    /*
-	     * All code paths that acquire this lock pin the buffer
-	     * first; since no one had it pinned (it just came off the
-	     * free list), no one else can have this lock.
-	     */
-	    Assert(S_LOCK_FREE(&(buf->io_in_progress_lock)));
-	    S_LOCK(&(buf->io_in_progress_lock));
-#endif /* HAS_TEST_AND_SET */
-	    
-	    /*
-	     * Write the buffer out, being careful to release BufMgrLock
-	     * before starting the I/O.
-	     *
-	     * This #ifndef is here because a few extra semops REALLY kill
-	     * you on machines that don't have spinlocks.  If you don't
-	     * operate with much concurrency, well...
-	     */
-	    smok = BufferReplace(buf, true);
-#ifndef OPTIMIZE_SINGLE
-	    SpinAcquire(BufMgrLock); 
-#endif /* OPTIMIZE_SINGLE */
-
-	    if ( smok == FALSE )
-	    {
-		elog(NOTICE, "BufferAlloc: cannot write block %u for %s/%s",
-			 buf->tag.blockNum, buf->sb_dbname, buf->sb_relname);
-		inProgress = FALSE;
-		buf->flags |= BM_IO_ERROR;
-		buf->flags &= ~BM_IO_IN_PROGRESS;
-#ifdef HAS_TEST_AND_SET
-		S_UNLOCK(&(buf->io_in_progress_lock));
-#else /* !HAS_TEST_AND_SET */
-		if (buf->refcount > 1)
-		    SignalIO(buf);
-#endif /* !HAS_TEST_AND_SET */
-		PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 0;
-		buf->refcount--;
-		if ( buf->refcount == 0 )
-		{
-		    AddBufferToFreelist(buf);
-		    buf->flags |= BM_FREE;
-		}
-		buf = (BufferDesc *) NULL;
-	    }
-	    else
-	    {
+	inProgress = FALSE;
+	for (buf = (BufferDesc *) NULL; buf == (BufferDesc *) NULL;)
+	{
+
+		/* GetFreeBuffer will abort if it can't find a free buffer */
+		buf = GetFreeBuffer();
+
 		/*
-		 * BM_JUST_DIRTIED cleared by BufferReplace and shouldn't
-		 * be setted by anyone.     - vadim 01/17/97
+		 * But it can return buf == NULL if we are in aborting transaction
+		 * now and so elog(WARN,...) in GetFreeBuffer will not abort
+		 * again.
 		 */
-		if ( buf->flags & BM_JUST_DIRTIED )
-		{
-		    elog (FATAL, "BufferAlloc: content of block %u (%s) changed while flushing",
-			 buf->tag.blockNum, buf->sb_relname);
-		}
-		else
-		{
-		    buf->flags &= ~BM_DIRTY;
-		}
-	    }
-	    
-	    /*
-	     * Somebody could have pinned the buffer while we were
-	     * doing the I/O and had given up the BufMgrLock (though
-	     * they would be waiting for us to clear the BM_IO_IN_PROGRESS
-	     * flag).  That's why this is a loop -- if so, we need to clear
-	     * the I/O flags, remove our pin and start all over again.
-	     *
-	     * People may be making buffers free at any time, so there's
-	     * no reason to think that we have an immediate disaster on
-	     * our hands.
-	     */
-	    if ( buf && buf->refcount > 1 )
-	    {
-		inProgress = FALSE;
-		buf->flags &= ~BM_IO_IN_PROGRESS;
-#ifdef HAS_TEST_AND_SET
-		S_UNLOCK(&(buf->io_in_progress_lock));
-#else /* !HAS_TEST_AND_SET */
-		if (buf->refcount > 1)
-		    SignalIO(buf);
-#endif /* !HAS_TEST_AND_SET */
-		PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 0;
-		buf->refcount--;
-		buf = (BufferDesc *) NULL;
-	    }
-
-	    /*
-	     * Somebody could have allocated another buffer for the
-	     * same block we are about to read in. (While we flush out
-	     * the dirty buffer, we don't hold the lock and someone could
-	     * have allocated another buffer for the same block. The problem
-	     * is we haven't gotten around to insert the new tag into
-	     * the buffer table. So we need to check here.	-ay 3/95
-	     */
-	    buf2 = BufTableLookup(&newTag);
-	    if (buf2 != NULL) {
-		/* Found it. Someone has already done what we're about
-		 * to do. We'll just handle this as if it were found in
-		 * the buffer pool in the first place.
+		if (buf == NULL)
+			return (NULL);
+
+		/*
+		 * There should be exactly one pin on the buffer after it is
+		 * allocated -- ours.  If it had a pin it wouldn't have been on
+		 * the free list.  No one else could have pinned it between
+		 * GetFreeBuffer and here because we have the BufMgrLock.
 		 */
-		if ( buf != NULL )
+		Assert(buf->refcount == 0);
+		buf->refcount = 1;
+		PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 1;
+
+		if (buf->flags & BM_DIRTY)
 		{
+			bool			smok;
+
+			/*
+			 * Set BM_IO_IN_PROGRESS to keep anyone from doing anything
+			 * with the contents of the buffer while we write it out. We
+			 * don't really care if they try to read it, but if they can
+			 * complete a BufferAlloc on it they can then scribble into
+			 * it, and we'd really like to avoid that while we are
+			 * flushing the buffer.  Setting this flag should block them
+			 * in WaitIO until we're done.
+			 */
+			inProgress = TRUE;
+			buf->flags |= BM_IO_IN_PROGRESS;
 #ifdef HAS_TEST_AND_SET
-			S_UNLOCK(&(buf->io_in_progress_lock));
-#else /* !HAS_TEST_AND_SET */
-			if (buf->refcount > 1)
-			    SignalIO(buf);
-#endif /* !HAS_TEST_AND_SET */
-		
-		/* give up the buffer since we don't need it any more */
-			buf->refcount--;
-			PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 0;
-			AddBufferToFreelist(buf);
-			buf->flags |= BM_FREE;
-			buf->flags &= ~BM_IO_IN_PROGRESS;
-		}
 
-		PinBuffer(buf2);
-		inProgress = (buf2->flags & BM_IO_IN_PROGRESS);
-		
-		*foundPtr = TRUE;
-		if (inProgress) {
-		    WaitIO(buf2, BufMgrLock);
-		    if (buf2->flags & BM_IO_ERROR) {
-			*foundPtr = FALSE;
-		    }
+			/*
+			 * All code paths that acquire this lock pin the buffer first;
+			 * since no one had it pinned (it just came off the free
+			 * list), no one else can have this lock.
+			 */
+			Assert(S_LOCK_FREE(&(buf->io_in_progress_lock)));
+			S_LOCK(&(buf->io_in_progress_lock));
+#endif							/* HAS_TEST_AND_SET */
+
+			/*
+			 * Write the buffer out, being careful to release BufMgrLock
+			 * before starting the I/O.
+			 *
+			 * This #ifndef is here because a few extra semops REALLY kill
+			 * you on machines that don't have spinlocks.  If you don't
+			 * operate with much concurrency, well...
+			 */
+			smok = BufferReplace(buf, true);
+#ifndef OPTIMIZE_SINGLE
+			SpinAcquire(BufMgrLock);
+#endif							/* OPTIMIZE_SINGLE */
+
+			if (smok == FALSE)
+			{
+				elog(NOTICE, "BufferAlloc: cannot write block %u for %s/%s",
+					 buf->tag.blockNum, buf->sb_dbname, buf->sb_relname);
+				inProgress = FALSE;
+				buf->flags |= BM_IO_ERROR;
+				buf->flags &= ~BM_IO_IN_PROGRESS;
+#ifdef HAS_TEST_AND_SET
+				S_UNLOCK(&(buf->io_in_progress_lock));
+#else							/* !HAS_TEST_AND_SET */
+				if (buf->refcount > 1)
+					SignalIO(buf);
+#endif							/* !HAS_TEST_AND_SET */
+				PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 0;
+				buf->refcount--;
+				if (buf->refcount == 0)
+				{
+					AddBufferToFreelist(buf);
+					buf->flags |= BM_FREE;
+				}
+				buf = (BufferDesc *) NULL;
+			}
+			else
+			{
+
+				/*
+				 * BM_JUST_DIRTIED cleared by BufferReplace and shouldn't
+				 * be setted by anyone.		- vadim 01/17/97
+				 */
+				if (buf->flags & BM_JUST_DIRTIED)
+				{
+					elog(FATAL, "BufferAlloc: content of block %u (%s) changed while flushing",
+						 buf->tag.blockNum, buf->sb_relname);
+				}
+				else
+				{
+					buf->flags &= ~BM_DIRTY;
+				}
+			}
+
+			/*
+			 * Somebody could have pinned the buffer while we were doing
+			 * the I/O and had given up the BufMgrLock (though they would
+			 * be waiting for us to clear the BM_IO_IN_PROGRESS flag).
+			 * That's why this is a loop -- if so, we need to clear the
+			 * I/O flags, remove our pin and start all over again.
+			 *
+			 * People may be making buffers free at any time, so there's no
+			 * reason to think that we have an immediate disaster on our
+			 * hands.
+			 */
+			if (buf && buf->refcount > 1)
+			{
+				inProgress = FALSE;
+				buf->flags &= ~BM_IO_IN_PROGRESS;
+#ifdef HAS_TEST_AND_SET
+				S_UNLOCK(&(buf->io_in_progress_lock));
+#else							/* !HAS_TEST_AND_SET */
+				if (buf->refcount > 1)
+					SignalIO(buf);
+#endif							/* !HAS_TEST_AND_SET */
+				PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 0;
+				buf->refcount--;
+				buf = (BufferDesc *) NULL;
+			}
+
+			/*
+			 * Somebody could have allocated another buffer for the same
+			 * block we are about to read in. (While we flush out the
+			 * dirty buffer, we don't hold the lock and someone could have
+			 * allocated another buffer for the same block. The problem is
+			 * we haven't gotten around to insert the new tag into the
+			 * buffer table. So we need to check here.		-ay 3/95
+			 */
+			buf2 = BufTableLookup(&newTag);
+			if (buf2 != NULL)
+			{
+
+				/*
+				 * Found it. Someone has already done what we're about to
+				 * do. We'll just handle this as if it were found in the
+				 * buffer pool in the first place.
+				 */
+				if (buf != NULL)
+				{
+#ifdef HAS_TEST_AND_SET
+					S_UNLOCK(&(buf->io_in_progress_lock));
+#else							/* !HAS_TEST_AND_SET */
+					if (buf->refcount > 1)
+						SignalIO(buf);
+#endif							/* !HAS_TEST_AND_SET */
+
+					/* give up the buffer since we don't need it any more */
+					buf->refcount--;
+					PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 0;
+					AddBufferToFreelist(buf);
+					buf->flags |= BM_FREE;
+					buf->flags &= ~BM_IO_IN_PROGRESS;
+				}
+
+				PinBuffer(buf2);
+				inProgress = (buf2->flags & BM_IO_IN_PROGRESS);
+
+				*foundPtr = TRUE;
+				if (inProgress)
+				{
+					WaitIO(buf2, BufMgrLock);
+					if (buf2->flags & BM_IO_ERROR)
+					{
+						*foundPtr = FALSE;
+					}
+				}
+
+				SpinRelease(BufMgrLock);
+
+				return (buf2);
+			}
 		}
-		
+	}
+
+	/*
+	 * At this point we should have the sole pin on a non-dirty buffer and
+	 * we may or may not already have the BM_IO_IN_PROGRESS flag set.
+	 */
+
+	/*
+	 * Change the name of the buffer in the lookup table:
+	 *
+	 * Need to update the lookup table before the read starts. If someone
+	 * comes along looking for the buffer while we are reading it in, we
+	 * don't want them to allocate a new buffer.  For the same reason, we
+	 * didn't want to erase the buf table entry for the buffer we were
+	 * writing back until now, either.
+	 */
+
+	if (!BufTableDelete(buf))
+	{
 		SpinRelease(BufMgrLock);
-		
-		return(buf2);
-	    }
+		elog(FATAL, "buffer wasn't in the buffer table\n");
+
 	}
-    }
-    /*
-     * At this point we should have the sole pin on a non-dirty
-     * buffer and we may or may not already have the BM_IO_IN_PROGRESS
-     * flag set.
-     */
-    
-    /* 
-     * Change the name of the buffer in the lookup table:
-     *  
-     * Need to update the lookup table before the read starts.
-     * If someone comes along looking for the buffer while
-     * we are reading it in, we don't want them to allocate
-     * a new buffer.  For the same reason, we didn't want
-     * to erase the buf table entry for the buffer we were
-     * writing back until now, either.
-     */
-    
-    if (! BufTableDelete(buf)) {
-	SpinRelease(BufMgrLock);
-	elog(FATAL,"buffer wasn't in the buffer table\n");
-
-    }
-    
-    /* record the database name and relation name for this buffer */
-    strcpy (buf->sb_relname, reln->rd_rel->relname.data);
-    strcpy (buf->sb_dbname, GetDatabaseName());
-    
-    /* remember which storage manager is responsible for it */
-    buf->bufsmgr = reln->rd_rel->relsmgr;
-    
-    INIT_BUFFERTAG(&(buf->tag),reln,blockNum);
-    if (! BufTableInsert(buf)) {
-	SpinRelease(BufMgrLock);
-	elog(FATAL,"Buffer in lookup table twice \n");
-    } 
-    
-    /* Buffer contents are currently invalid.  Have
-     * to mark IO IN PROGRESS so no one fiddles with
-     * them until the read completes.  If this routine
-     * has been called simply to allocate a buffer, no
-     * io will be attempted, so the flag isnt set.
-     */
-    if (!inProgress) {
-	buf->flags |= BM_IO_IN_PROGRESS; 
+
+	/* record the database name and relation name for this buffer */
+	strcpy(buf->sb_relname, reln->rd_rel->relname.data);
+	strcpy(buf->sb_dbname, GetDatabaseName());
+
+	/* remember which storage manager is responsible for it */
+	buf->bufsmgr = reln->rd_rel->relsmgr;
+
+	INIT_BUFFERTAG(&(buf->tag), reln, blockNum);
+	if (!BufTableInsert(buf))
+	{
+		SpinRelease(BufMgrLock);
+		elog(FATAL, "Buffer in lookup table twice \n");
+	}
+
+	/*
+	 * Buffer contents are currently invalid.  Have to mark IO IN PROGRESS
+	 * so no one fiddles with them until the read completes.  If this
+	 * routine has been called simply to allocate a buffer, no io will be
+	 * attempted, so the flag isnt set.
+	 */
+	if (!inProgress)
+	{
+		buf->flags |= BM_IO_IN_PROGRESS;
 #ifdef HAS_TEST_AND_SET
-	Assert(S_LOCK_FREE(&(buf->io_in_progress_lock)));
-	S_LOCK(&(buf->io_in_progress_lock));
-#endif /* HAS_TEST_AND_SET */
-    }
-    
+		Assert(S_LOCK_FREE(&(buf->io_in_progress_lock)));
+		S_LOCK(&(buf->io_in_progress_lock));
+#endif							/* HAS_TEST_AND_SET */
+	}
+
 #ifdef BMTRACE
-    _bm_trace((reln->rd_rel->relisshared ? 0 : MyDatabaseId), reln->rd_id, blockNum, BufferDescriptorGetBuffer(buf), BMT_ALLOCNOTFND);
-#endif /* BMTRACE */
-    
-    SpinRelease(BufMgrLock);
-    
-    return (buf);
+	_bm_trace((reln->rd_rel->relisshared ? 0 : MyDatabaseId), reln->rd_id, blockNum, BufferDescriptorGetBuffer(buf), BMT_ALLOCNOTFND);
+#endif							/* BMTRACE */
+
+	SpinRelease(BufMgrLock);
+
+	return (buf);
 }
 
 /*
  * WriteBuffer--
  *
- *	Pushes buffer contents to disk if WriteMode is BUFFER_FLUSH_WRITE.
- *	Otherwise, marks contents as dirty.  
+ *		Pushes buffer contents to disk if WriteMode is BUFFER_FLUSH_WRITE.
+ *		Otherwise, marks contents as dirty.
  *
  * Assume that buffer is pinned.  Assume that reln is
- *	valid.
+ *		valid.
  *
  * Side Effects:
- *    	Pin count is decremented.
+ *		Pin count is decremented.
  */
 
 #undef WriteBuffer
@@ -643,92 +693,103 @@ BufferAlloc(Relation reln,
 int
 WriteBuffer(Buffer buffer)
 {
-    BufferDesc	*bufHdr;
+	BufferDesc	   *bufHdr;
 
-    if (WriteMode == BUFFER_FLUSH_WRITE) {
-	return (FlushBuffer (buffer, TRUE));
-    } else {
+	if (WriteMode == BUFFER_FLUSH_WRITE)
+	{
+		return (FlushBuffer(buffer, TRUE));
+	}
+	else
+	{
 
-	if (BufferIsLocal(buffer))
-	    return WriteLocalBuffer(buffer, TRUE);
-    
-	if (BAD_BUFFER_ID(buffer))
-	    return(FALSE);
+		if (BufferIsLocal(buffer))
+			return WriteLocalBuffer(buffer, TRUE);
 
-	bufHdr = &BufferDescriptors[buffer-1];
-	
-	SpinAcquire(BufMgrLock);
-	Assert(bufHdr->refcount > 0);
-	bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
-	UnpinBuffer(bufHdr);
-	SpinRelease(BufMgrLock);
-	CommitInfoNeedsSave[buffer - 1] = 0;
-    }
-    return(TRUE);
-} 
+		if (BAD_BUFFER_ID(buffer))
+			return (FALSE);
+
+		bufHdr = &BufferDescriptors[buffer - 1];
+
+		SpinAcquire(BufMgrLock);
+		Assert(bufHdr->refcount > 0);
+		bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
+		UnpinBuffer(bufHdr);
+		SpinRelease(BufMgrLock);
+		CommitInfoNeedsSave[buffer - 1] = 0;
+	}
+	return (TRUE);
+}
 
 #ifdef NOT_USED
 void
 WriteBuffer_Debug(char *file, int line, Buffer buffer)
 {
-    WriteBuffer(buffer);
-    if (ShowPinTrace && BufferIsLocal(buffer) && is_userbuffer(buffer)) {
-	BufferDesc *buf;
-	buf = &BufferDescriptors[buffer-1];
-	fprintf(stderr, "UNPIN(WR) %ld relname = %s, blockNum = %d, \
+	WriteBuffer(buffer);
+	if (ShowPinTrace && BufferIsLocal(buffer) && is_userbuffer(buffer))
+	{
+		BufferDesc	   *buf;
+
+		buf = &BufferDescriptors[buffer - 1];
+		fprintf(stderr, "UNPIN(WR) %ld relname = %s, blockNum = %d, \
 refcount = %ld, file: %s, line: %d\n",
-		buffer, buf->sb_relname, buf->tag.blockNum,
-		PrivateRefCount[buffer - 1], file, line);
-    }
+				buffer, buf->sb_relname, buf->tag.blockNum,
+				PrivateRefCount[buffer - 1], file, line);
+	}
 }
+
 #endif
 
 /*
  * DirtyBufferCopy() -- For a given dbid/relid/blockno, if the buffer is
- *			in the cache and is dirty, mark it clean and copy
- *			it to the requested location.  This is a logical
- *			write, and has been installed to support the cache
- *			management code for write-once storage managers.
+ *						in the cache and is dirty, mark it clean and copy
+ *						it to the requested location.  This is a logical
+ *						write, and has been installed to support the cache
+ *						management code for write-once storage managers.
  *
- *  DirtyBufferCopy() -- Copy a given dirty buffer to the requested
- *			 destination.
+ *	DirtyBufferCopy() -- Copy a given dirty buffer to the requested
+ *						 destination.
  *
- *	We treat this as a write.  If the requested buffer is in the pool
- *	and is dirty, we copy it to the location requested and mark it
- *	clean.  This routine supports the Sony jukebox storage manager,
- *	which agrees to take responsibility for the data once we mark
- *	it clean.
+ *		We treat this as a write.  If the requested buffer is in the pool
+ *		and is dirty, we copy it to the location requested and mark it
+ *		clean.	This routine supports the Sony jukebox storage manager,
+ *		which agrees to take responsibility for the data once we mark
+ *		it clean.
  *
- *  NOTE: used by sony jukebox code in postgres 4.2   - ay 2/95
+ *	NOTE: used by sony jukebox code in postgres 4.2   - ay 2/95
  */
 #ifdef NOT_USED
 void
 DirtyBufferCopy(Oid dbid, Oid relid, BlockNumber blkno, char *dest)
 {
-    BufferDesc *buf;
-    BufferTag btag;
-    
-    btag.relId.relId = relid;
-    btag.relId.dbId = dbid;
-    btag.blockNum = blkno;
-    
-    SpinAcquire(BufMgrLock);
-    buf = BufTableLookup(&btag);
-    
-    if (buf == (BufferDesc *) NULL
-	|| !(buf->flags & BM_DIRTY)
-	|| !(buf->flags & BM_VALID)) {
+	BufferDesc	   *buf;
+	BufferTag		btag;
+
+	btag.relId.relId = relid;
+	btag.relId.dbId = dbid;
+	btag.blockNum = blkno;
+
+	SpinAcquire(BufMgrLock);
+	buf = BufTableLookup(&btag);
+
+	if (buf == (BufferDesc *) NULL
+		|| !(buf->flags & BM_DIRTY)
+		|| !(buf->flags & BM_VALID))
+	{
+		SpinRelease(BufMgrLock);
+		return;
+	}
+
+	/*
+	 * hate to do this holding the lock, but release and reacquire is
+	 * slower
+	 */
+	memmove(dest, (char *) MAKE_PTR(buf->data), BLCKSZ);
+
+	buf->flags &= ~BM_DIRTY;
+
 	SpinRelease(BufMgrLock);
-	return;
-    }
-    
-    /* hate to do this holding the lock, but release and reacquire is slower */
-    memmove(dest, (char *) MAKE_PTR(buf->data), BLCKSZ);
-    
-    buf->flags &= ~BM_DIRTY;
-    
-    SpinRelease(BufMgrLock);
 }
+
 #endif
 
 /*
@@ -742,504 +803,541 @@ DirtyBufferCopy(Oid dbid, Oid relid, BlockNumber blkno, char *dest)
 static int
 FlushBuffer(Buffer buffer, bool release)
 {
-    BufferDesc	*bufHdr;
-    Oid bufdb;
-    Relation bufrel;
-    int	status;
-
-    if (BufferIsLocal(buffer))
-	return FlushLocalBuffer(buffer, release);
-	    
-    if (BAD_BUFFER_ID(buffer))
-	return (STATUS_ERROR);
-    
-    bufHdr = &BufferDescriptors[buffer-1];
-    bufdb = bufHdr->tag.relId.dbId;
-    
-    Assert (bufdb == MyDatabaseId || bufdb == (Oid) NULL);
-    bufrel = RelationIdCacheGetRelation (bufHdr->tag.relId.relId);
-    Assert (bufrel != (Relation) NULL);
-
-    /* To check if block content changed while flushing. - vadim 01/17/97 */
-    SpinAcquire(BufMgrLock); 
-    bufHdr->flags &= ~BM_JUST_DIRTIED; 
-    SpinRelease(BufMgrLock);
-
-    status = smgrflush(bufHdr->bufsmgr, bufrel, bufHdr->tag.blockNum,
-			   (char *) MAKE_PTR(bufHdr->data));
-    
-    if (status == SM_FAIL)
-    {
-	elog(WARN, "FlushBuffer: cannot flush block %u of the relation %s", 
-			bufHdr->tag.blockNum, bufHdr->sb_relname);
-	return (STATUS_ERROR);
-    }
-    BufferFlushCount++;
-    
-    SpinAcquire(BufMgrLock); 
-    /*
-     * If this buffer was marked by someone as DIRTY while
-     * we were flushing it out we must not clear DIRTY flag
-     *  - vadim 01/17/97
-     */
-    if ( bufHdr->flags & BM_JUST_DIRTIED )
-    {
-	elog (NOTICE, "FlusfBuffer: content of block %u (%s) changed while flushing",
-			bufHdr->tag.blockNum, bufHdr->sb_relname);
-    }
-    else
-    {
-    	bufHdr->flags &= ~BM_DIRTY;
-    }
-    if ( release )
-    	UnpinBuffer(bufHdr);
-    SpinRelease(BufMgrLock);
-    CommitInfoNeedsSave[buffer - 1] = 0;
-    
-    return(STATUS_OK);
+	BufferDesc	   *bufHdr;
+	Oid				bufdb;
+	Relation		bufrel;
+	int				status;
+
+	if (BufferIsLocal(buffer))
+		return FlushLocalBuffer(buffer, release);
+
+	if (BAD_BUFFER_ID(buffer))
+		return (STATUS_ERROR);
+
+	bufHdr = &BufferDescriptors[buffer - 1];
+	bufdb = bufHdr->tag.relId.dbId;
+
+	Assert(bufdb == MyDatabaseId || bufdb == (Oid) NULL);
+	bufrel = RelationIdCacheGetRelation(bufHdr->tag.relId.relId);
+	Assert(bufrel != (Relation) NULL);
+
+	/* To check if block content changed while flushing. - vadim 01/17/97 */
+	SpinAcquire(BufMgrLock);
+	bufHdr->flags &= ~BM_JUST_DIRTIED;
+	SpinRelease(BufMgrLock);
+
+	status = smgrflush(bufHdr->bufsmgr, bufrel, bufHdr->tag.blockNum,
+					   (char *) MAKE_PTR(bufHdr->data));
+
+	if (status == SM_FAIL)
+	{
+		elog(WARN, "FlushBuffer: cannot flush block %u of the relation %s",
+			 bufHdr->tag.blockNum, bufHdr->sb_relname);
+		return (STATUS_ERROR);
+	}
+	BufferFlushCount++;
+
+	SpinAcquire(BufMgrLock);
+
+	/*
+	 * If this buffer was marked by someone as DIRTY while we were
+	 * flushing it out we must not clear DIRTY flag - vadim 01/17/97
+	 */
+	if (bufHdr->flags & BM_JUST_DIRTIED)
+	{
+		elog(NOTICE, "FlusfBuffer: content of block %u (%s) changed while flushing",
+			 bufHdr->tag.blockNum, bufHdr->sb_relname);
+	}
+	else
+	{
+		bufHdr->flags &= ~BM_DIRTY;
+	}
+	if (release)
+		UnpinBuffer(bufHdr);
+	SpinRelease(BufMgrLock);
+	CommitInfoNeedsSave[buffer - 1] = 0;
+
+	return (STATUS_OK);
 }
 
 /*
  * WriteNoReleaseBuffer -- like WriteBuffer, but do not unpin the buffer
- * 			   when the operation is complete.
+ *						   when the operation is complete.
  *
- *	We know that the buffer is for a relation in our private cache,
- *	because this routine is called only to write out buffers that
- *	were changed by the executing backend.
+ *		We know that the buffer is for a relation in our private cache,
+ *		because this routine is called only to write out buffers that
+ *		were changed by the executing backend.
  */
 int
 WriteNoReleaseBuffer(Buffer buffer)
 {
-    BufferDesc	*bufHdr;
-    
-    if (WriteMode == BUFFER_FLUSH_WRITE) {
-	return (FlushBuffer (buffer, FALSE));
-    } else {
+	BufferDesc	   *bufHdr;
 
-	if (BufferIsLocal(buffer))
-	    return WriteLocalBuffer(buffer, FALSE);
-	    
-	if (BAD_BUFFER_ID(buffer))
-	    return (STATUS_ERROR);
+	if (WriteMode == BUFFER_FLUSH_WRITE)
+	{
+		return (FlushBuffer(buffer, FALSE));
+	}
+	else
+	{
 
-	bufHdr = &BufferDescriptors[buffer-1];
-	
-	SpinAcquire(BufMgrLock);
-	bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
-	SpinRelease(BufMgrLock);
-    	CommitInfoNeedsSave[buffer - 1] = 0;
-    }
-    return(STATUS_OK);
+		if (BufferIsLocal(buffer))
+			return WriteLocalBuffer(buffer, FALSE);
+
+		if (BAD_BUFFER_ID(buffer))
+			return (STATUS_ERROR);
+
+		bufHdr = &BufferDescriptors[buffer - 1];
+
+		SpinAcquire(BufMgrLock);
+		bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
+		SpinRelease(BufMgrLock);
+		CommitInfoNeedsSave[buffer - 1] = 0;
+	}
+	return (STATUS_OK);
 }
 
 
 #undef ReleaseAndReadBuffer
 /*
  * ReleaseAndReadBuffer -- combine ReleaseBuffer() and ReadBuffer()
- * 	so that only one semop needs to be called.
+ *		so that only one semop needs to be called.
  *
  */
 Buffer
 ReleaseAndReadBuffer(Buffer buffer,
-		     Relation relation,
-		     BlockNumber blockNum)
+					 Relation relation,
+					 BlockNumber blockNum)
 {
-    BufferDesc	*bufHdr;
-    Buffer retbuf;
-
-    if (BufferIsLocal(buffer)) {
-	Assert(LocalRefCount[-buffer - 1] > 0);
-	LocalRefCount[-buffer - 1]--;
-    } else {
-	if (BufferIsValid(buffer)) {
-	    bufHdr = &BufferDescriptors[buffer-1];
-	    Assert(PrivateRefCount[buffer - 1] > 0);
-	    PrivateRefCount[buffer - 1]--;
-	    if (PrivateRefCount[buffer - 1] == 0 &&
-		LastRefCount[buffer - 1] == 0) {
-		/* only release buffer if it is not pinned in previous ExecMain
-		   level */
-		SpinAcquire(BufMgrLock);
-		bufHdr->refcount--;
-		if (bufHdr->refcount == 0) {
-		    AddBufferToFreelist(bufHdr);
-		    bufHdr->flags |= BM_FREE;
-		}
-		if(CommitInfoNeedsSave[buffer - 1]) {
-		    bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
-		    CommitInfoNeedsSave[buffer - 1] = 0;
+	BufferDesc	   *bufHdr;
+	Buffer			retbuf;
+
+	if (BufferIsLocal(buffer))
+	{
+		Assert(LocalRefCount[-buffer - 1] > 0);
+		LocalRefCount[-buffer - 1]--;
+	}
+	else
+	{
+		if (BufferIsValid(buffer))
+		{
+			bufHdr = &BufferDescriptors[buffer - 1];
+			Assert(PrivateRefCount[buffer - 1] > 0);
+			PrivateRefCount[buffer - 1]--;
+			if (PrivateRefCount[buffer - 1] == 0 &&
+				LastRefCount[buffer - 1] == 0)
+			{
+
+				/*
+				 * only release buffer if it is not pinned in previous
+				 * ExecMain level
+				 */
+				SpinAcquire(BufMgrLock);
+				bufHdr->refcount--;
+				if (bufHdr->refcount == 0)
+				{
+					AddBufferToFreelist(bufHdr);
+					bufHdr->flags |= BM_FREE;
+				}
+				if (CommitInfoNeedsSave[buffer - 1])
+				{
+					bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
+					CommitInfoNeedsSave[buffer - 1] = 0;
+				}
+				retbuf = ReadBufferWithBufferLock(relation, blockNum, true);
+				return retbuf;
+			}
 		}
-		retbuf = ReadBufferWithBufferLock(relation, blockNum, true);
-		return retbuf;
-	    }
 	}
-    }
 
-    return (ReadBuffer(relation, blockNum));
+	return (ReadBuffer(relation, blockNum));
 }
 
 /*
  * BufferSync -- Flush all dirty buffers in the pool.
  *
- *	This is called at transaction commit time.  It does the wrong thing,
- *	right now.  We should flush only our own changes to stable storage,
- *	and we should obey the lock protocol on the buffer manager metadata
- *	as we do it.  Also, we need to be sure that no other transaction is
- *	modifying the page as we flush it.  This is only a problem for objects
- *	that use a non-two-phase locking protocol, like btree indices.  For
- *	those objects, we would like to set a write lock for the duration of
- *	our IO.  Another possibility is to code updates to btree pages
- *	carefully, so that writing them out out of order cannot cause
- *	any unrecoverable errors.
+ *		This is called at transaction commit time.	It does the wrong thing,
+ *		right now.	We should flush only our own changes to stable storage,
+ *		and we should obey the lock protocol on the buffer manager metadata
+ *		as we do it.  Also, we need to be sure that no other transaction is
+ *		modifying the page as we flush it.	This is only a problem for objects
+ *		that use a non-two-phase locking protocol, like btree indices.	For
+ *		those objects, we would like to set a write lock for the duration of
+ *		our IO.  Another possibility is to code updates to btree pages
+ *		carefully, so that writing them out out of order cannot cause
+ *		any unrecoverable errors.
  *
- *	I don't want to think hard about this right now, so I will try
- *	to come back to it later.
+ *		I don't want to think hard about this right now, so I will try
+ *		to come back to it later.
  */
 static void
 BufferSync()
-{ 
-    int i;
-    Oid bufdb;
-    Oid bufrel;
-    Relation reln;
-    BufferDesc *bufHdr;
-    int status;
-    
-    SpinAcquire(BufMgrLock);
-    for (i=0, bufHdr = BufferDescriptors; i < NBuffers; i++, bufHdr++) {
-	if ((bufHdr->flags & BM_VALID) && (bufHdr->flags & BM_DIRTY)) {
-	    bufdb = bufHdr->tag.relId.dbId;
-	    bufrel = bufHdr->tag.relId.relId;
-	    if (bufdb == MyDatabaseId || bufdb == (Oid) 0) {
-		reln = RelationIdCacheGetRelation(bufrel);
-		
-		/* 
-		 *  We have to pin buffer to keep anyone from stealing it
-		 *  from the buffer pool while we are flushing it or
-		 *  waiting in WaitIO. It's bad for GetFreeBuffer in
-		 *  BufferAlloc, but there is no other way to prevent
-		 *  writing into disk block data from some other buffer,
-		 *  getting smgr status of some other block and
-		 *  clearing BM_DIRTY of ...		- VAdim 09/16/96
-		 */
-		PinBuffer(bufHdr);
-		if (bufHdr->flags & BM_IO_IN_PROGRESS)
+{
+	int				i;
+	Oid				bufdb;
+	Oid				bufrel;
+	Relation		reln;
+	BufferDesc	   *bufHdr;
+	int				status;
+
+	SpinAcquire(BufMgrLock);
+	for (i = 0, bufHdr = BufferDescriptors; i < NBuffers; i++, bufHdr++)
+	{
+		if ((bufHdr->flags & BM_VALID) && (bufHdr->flags & BM_DIRTY))
 		{
-		    WaitIO(bufHdr, BufMgrLock);
-		    UnpinBuffer(bufHdr);
-		    if (bufHdr->flags & BM_IO_ERROR)
-		    {
-			elog(WARN, "BufferSync: write error %u for %s",
-				bufHdr->tag.blockNum, bufHdr->sb_relname);
-		    }
-		    if (reln != (Relation)NULL)
-			RelationDecrementReferenceCount(reln);
-		    continue;
-		}
-		
-		/*
-		 * To check if block content changed while flushing
-		 * (see below). - vadim 01/17/97
-		 */
-		bufHdr->flags &= ~BM_JUST_DIRTIED;
+			bufdb = bufHdr->tag.relId.dbId;
+			bufrel = bufHdr->tag.relId.relId;
+			if (bufdb == MyDatabaseId || bufdb == (Oid) 0)
+			{
+				reln = RelationIdCacheGetRelation(bufrel);
+
+				/*
+				 * We have to pin buffer to keep anyone from stealing it
+				 * from the buffer pool while we are flushing it or
+				 * waiting in WaitIO. It's bad for GetFreeBuffer in
+				 * BufferAlloc, but there is no other way to prevent
+				 * writing into disk block data from some other buffer,
+				 * getting smgr status of some other block and clearing
+				 * BM_DIRTY of ...			  - VAdim 09/16/96
+				 */
+				PinBuffer(bufHdr);
+				if (bufHdr->flags & BM_IO_IN_PROGRESS)
+				{
+					WaitIO(bufHdr, BufMgrLock);
+					UnpinBuffer(bufHdr);
+					if (bufHdr->flags & BM_IO_ERROR)
+					{
+						elog(WARN, "BufferSync: write error %u for %s",
+							 bufHdr->tag.blockNum, bufHdr->sb_relname);
+					}
+					if (reln != (Relation) NULL)
+						RelationDecrementReferenceCount(reln);
+					continue;
+				}
+
+				/*
+				 * To check if block content changed while flushing (see
+				 * below). - vadim 01/17/97
+				 */
+				bufHdr->flags &= ~BM_JUST_DIRTIED;
+
+				/*
+				 * If we didn't have the reldesc in our local cache, flush
+				 * this page out using the 'blind write' storage manager
+				 * routine.  If we did find it, use the standard
+				 * interface.
+				 */
 
-		/*
-		 *  If we didn't have the reldesc in our local cache, flush this
-		 *  page out using the 'blind write' storage manager routine.  If
-		 *  we did find it, use the standard interface.
-		 */
-		
 #ifndef OPTIMIZE_SINGLE
-		SpinRelease(BufMgrLock);
-#endif /* OPTIMIZE_SINGLE */
-		if (reln == (Relation) NULL) {
-		    status = smgrblindwrt(bufHdr->bufsmgr, bufHdr->sb_dbname,
-					  bufHdr->sb_relname, bufdb, bufrel,
-					  bufHdr->tag.blockNum,
-					  (char *) MAKE_PTR(bufHdr->data));
-		} else {
-		    status = smgrwrite(bufHdr->bufsmgr, reln,
-				       bufHdr->tag.blockNum,
-				       (char *) MAKE_PTR(bufHdr->data));
-		}
+				SpinRelease(BufMgrLock);
+#endif							/* OPTIMIZE_SINGLE */
+				if (reln == (Relation) NULL)
+				{
+					status = smgrblindwrt(bufHdr->bufsmgr, bufHdr->sb_dbname,
+									   bufHdr->sb_relname, bufdb, bufrel,
+										  bufHdr->tag.blockNum,
+										(char *) MAKE_PTR(bufHdr->data));
+				}
+				else
+				{
+					status = smgrwrite(bufHdr->bufsmgr, reln,
+									   bufHdr->tag.blockNum,
+									   (char *) MAKE_PTR(bufHdr->data));
+				}
 #ifndef OPTIMIZE_SINGLE
-		SpinAcquire(BufMgrLock);
-#endif /* OPTIMIZE_SINGLE */
-		
-		UnpinBuffer(bufHdr);
-		if (status == SM_FAIL) {
-		    bufHdr->flags |= BM_IO_ERROR;
-		    elog(WARN, "BufferSync: cannot write %u for %s",
-			 bufHdr->tag.blockNum, bufHdr->sb_relname);
-		}
-    		BufferFlushCount++;
-		/*
-		 * If this buffer was marked by someone as DIRTY while
-		 * we were flushing it out we must not clear DIRTY flag
-		 *  - vadim 01/17/97
-		 */
-		if ( bufHdr->flags & BM_JUST_DIRTIED )
-		{
-		    elog (NOTICE, "BufferSync: content of block %u (%s) changed while flushing",
-			 bufHdr->tag.blockNum, bufHdr->sb_relname);
-		}
-		else
-		{
-		    bufHdr->flags &= ~BM_DIRTY;
+				SpinAcquire(BufMgrLock);
+#endif							/* OPTIMIZE_SINGLE */
+
+				UnpinBuffer(bufHdr);
+				if (status == SM_FAIL)
+				{
+					bufHdr->flags |= BM_IO_ERROR;
+					elog(WARN, "BufferSync: cannot write %u for %s",
+						 bufHdr->tag.blockNum, bufHdr->sb_relname);
+				}
+				BufferFlushCount++;
+
+				/*
+				 * If this buffer was marked by someone as DIRTY while we
+				 * were flushing it out we must not clear DIRTY flag -
+				 * vadim 01/17/97
+				 */
+				if (bufHdr->flags & BM_JUST_DIRTIED)
+				{
+					elog(NOTICE, "BufferSync: content of block %u (%s) changed while flushing",
+						 bufHdr->tag.blockNum, bufHdr->sb_relname);
+				}
+				else
+				{
+					bufHdr->flags &= ~BM_DIRTY;
+				}
+				if (reln != (Relation) NULL)
+					RelationDecrementReferenceCount(reln);
+			}
 		}
-		if (reln != (Relation)NULL)
-		    RelationDecrementReferenceCount(reln);
-	    }
 	}
-    }
-    SpinRelease(BufMgrLock);
+	SpinRelease(BufMgrLock);
 
-    LocalBufferSync();
+	LocalBufferSync();
 }
 
 
 /*
  * WaitIO -- Block until the IO_IN_PROGRESS flag on 'buf'
- * 	is cleared.  Because IO_IN_PROGRESS conflicts are
- *	expected to be rare, there is only one BufferIO
- *	lock in the entire system.  All processes block
- *	on this semaphore when they try to use a buffer
- *	that someone else is faulting in.  Whenever a
- *	process finishes an IO and someone is waiting for
- *	the buffer, BufferIO is signaled (SignalIO).  All
- *	waiting processes then wake up and check to see
- *	if their buffer is now ready.  This implementation
- *	is simple, but efficient enough if WaitIO is
- *	rarely called by multiple processes simultaneously.
+ *		is cleared.  Because IO_IN_PROGRESS conflicts are
+ *		expected to be rare, there is only one BufferIO
+ *		lock in the entire system.	All processes block
+ *		on this semaphore when they try to use a buffer
+ *		that someone else is faulting in.  Whenever a
+ *		process finishes an IO and someone is waiting for
+ *		the buffer, BufferIO is signaled (SignalIO).  All
+ *		waiting processes then wake up and check to see
+ *		if their buffer is now ready.  This implementation
+ *		is simple, but efficient enough if WaitIO is
+ *		rarely called by multiple processes simultaneously.
  *
- *  ProcSleep atomically releases the spinlock and goes to
- *	sleep.
+ *	ProcSleep atomically releases the spinlock and goes to
+ *		sleep.
  *
- *  Note: there is an easy fix if the queue becomes long.
- *	save the id of the buffer we are waiting for in
- *	the queue structure.  That way signal can figure
- *	out which proc to wake up.
+ *	Note: there is an easy fix if the queue becomes long.
+ *		save the id of the buffer we are waiting for in
+ *		the queue structure.  That way signal can figure
+ *		out which proc to wake up.
  */
 #ifdef HAS_TEST_AND_SET
 static void
-WaitIO(BufferDesc *buf, SPINLOCK spinlock)
+WaitIO(BufferDesc * buf, SPINLOCK spinlock)
 {
-    SpinRelease(spinlock);
-    S_LOCK(&(buf->io_in_progress_lock));
-    S_UNLOCK(&(buf->io_in_progress_lock));
-    SpinAcquire(spinlock);
+	SpinRelease(spinlock);
+	S_LOCK(&(buf->io_in_progress_lock));
+	S_UNLOCK(&(buf->io_in_progress_lock));
+	SpinAcquire(spinlock);
 }
 
-#else /* HAS_TEST_AND_SET */
-IpcSemaphoreId        WaitIOSemId;
+#else							/* HAS_TEST_AND_SET */
+IpcSemaphoreId	WaitIOSemId;
 
 static void
-WaitIO(BufferDesc *buf, SPINLOCK spinlock)
+WaitIO(BufferDesc * buf, SPINLOCK spinlock)
 {
-    bool 	inProgress;
-    
-    for (;;) {
-	
-	/* wait until someone releases IO lock */
-	(*NWaitIOBackendP)++;
-	SpinRelease(spinlock);
-	IpcSemaphoreLock(WaitIOSemId, 0, 1);
-	SpinAcquire(spinlock);
-	inProgress = (buf->flags & BM_IO_IN_PROGRESS);
-	if (!inProgress) break;
-    }
+	bool			inProgress;
+
+	for (;;)
+	{
+
+		/* wait until someone releases IO lock */
+		(*NWaitIOBackendP)++;
+		SpinRelease(spinlock);
+		IpcSemaphoreLock(WaitIOSemId, 0, 1);
+		SpinAcquire(spinlock);
+		inProgress = (buf->flags & BM_IO_IN_PROGRESS);
+		if (!inProgress)
+			break;
+	}
 }
 
 /*
  * SignalIO --
  */
 static void
-SignalIO(BufferDesc *buf)
+SignalIO(BufferDesc * buf)
 {
-    /* somebody better be waiting. */
-    Assert( buf->refcount > 1);
-    IpcSemaphoreUnlock(WaitIOSemId, 0, *NWaitIOBackendP);
-    *NWaitIOBackendP = 0;
+	/* somebody better be waiting. */
+	Assert(buf->refcount > 1);
+	IpcSemaphoreUnlock(WaitIOSemId, 0, *NWaitIOBackendP);
+	*NWaitIOBackendP = 0;
 }
-#endif /* HAS_TEST_AND_SET */
 
-long NDirectFileRead;	/* some I/O's are direct file access.  bypass bufmgr */
-long NDirectFileWrite;   /* e.g., I/O in psort and hashjoin.		     */
+#endif							/* HAS_TEST_AND_SET */
+
+long			NDirectFileRead;/* some I/O's are direct file access.
+								 * bypass bufmgr */
+long			NDirectFileWrite;		/* e.g., I/O in psort and
+										 * hashjoin.				 */
 
 void
-PrintBufferUsage(FILE *statfp)
+PrintBufferUsage(FILE * statfp)
 {
-    float hitrate;
-    float localhitrate;
-    
-    if (ReadBufferCount==0)
-	hitrate = 0.0;
-    else
-	hitrate = (float)BufferHitCount * 100.0/ReadBufferCount;
-    
-    if (ReadLocalBufferCount==0)
-	localhitrate = 0.0;
-    else
-	localhitrate = (float)LocalBufferHitCount * 100.0/ReadLocalBufferCount;
-    
-    fprintf(statfp, "!\tShared blocks: %10ld read, %10ld written, buffer hit rate = %.2f%%\n", 
-	    ReadBufferCount - BufferHitCount, BufferFlushCount, hitrate);
-    fprintf(statfp, "!\tLocal  blocks: %10ld read, %10ld written, buffer hit rate = %.2f%%\n", 
-	    ReadLocalBufferCount - LocalBufferHitCount, LocalBufferFlushCount, localhitrate);
-    fprintf(statfp, "!\tDirect blocks: %10ld read, %10ld written\n", 
-	    NDirectFileRead, NDirectFileWrite);
+	float			hitrate;
+	float			localhitrate;
+
+	if (ReadBufferCount == 0)
+		hitrate = 0.0;
+	else
+		hitrate = (float) BufferHitCount *100.0 / ReadBufferCount;
+
+	if (ReadLocalBufferCount == 0)
+		localhitrate = 0.0;
+	else
+		localhitrate = (float) LocalBufferHitCount *100.0 / ReadLocalBufferCount;
+
+	fprintf(statfp, "!\tShared blocks: %10ld read, %10ld written, buffer hit rate = %.2f%%\n",
+			ReadBufferCount - BufferHitCount, BufferFlushCount, hitrate);
+	fprintf(statfp, "!\tLocal  blocks: %10ld read, %10ld written, buffer hit rate = %.2f%%\n",
+			ReadLocalBufferCount - LocalBufferHitCount, LocalBufferFlushCount, localhitrate);
+	fprintf(statfp, "!\tDirect blocks: %10ld read, %10ld written\n",
+			NDirectFileRead, NDirectFileWrite);
 }
 
 void
 ResetBufferUsage()
 {
-    BufferHitCount = 0;
-    ReadBufferCount = 0;
-    BufferFlushCount = 0;
-    LocalBufferHitCount = 0;
-    ReadLocalBufferCount = 0;
-    LocalBufferFlushCount = 0;
-    NDirectFileRead = 0;
-    NDirectFileWrite = 0;
+	BufferHitCount = 0;
+	ReadBufferCount = 0;
+	BufferFlushCount = 0;
+	LocalBufferHitCount = 0;
+	ReadLocalBufferCount = 0;
+	LocalBufferFlushCount = 0;
+	NDirectFileRead = 0;
+	NDirectFileWrite = 0;
 }
 
 /* ----------------------------------------------
- *	ResetBufferPool
+ *		ResetBufferPool
  *
- *	this routine is supposed to be called when a transaction aborts.
- *	it will release all the buffer pins held by the transaciton.
+ *		this routine is supposed to be called when a transaction aborts.
+ *		it will release all the buffer pins held by the transaciton.
  *
  * ----------------------------------------------
  */
 void
 ResetBufferPool()
 {
-    register int i;
-    for (i=1; i<=NBuffers; i++) {
-	CommitInfoNeedsSave[i - 1] = 0;
-	if (BufferIsValid(i)) {
-	    while(PrivateRefCount[i - 1] > 0) {
-		ReleaseBuffer(i);
-	    }
+	register int	i;
+
+	for (i = 1; i <= NBuffers; i++)
+	{
+		CommitInfoNeedsSave[i - 1] = 0;
+		if (BufferIsValid(i))
+		{
+			while (PrivateRefCount[i - 1] > 0)
+			{
+				ReleaseBuffer(i);
+			}
+		}
+		LastRefCount[i - 1] = 0;
 	}
-	LastRefCount[i - 1] = 0;
-    }
 
-    ResetLocalBufferPool();
+	ResetLocalBufferPool();
 }
 
 /* -----------------------------------------------
- *	BufferPoolCheckLeak
+ *		BufferPoolCheckLeak
  *
- *	check if there is buffer leak
+ *		check if there is buffer leak
  *
  * -----------------------------------------------
  */
 int
 BufferPoolCheckLeak()
 {
-    register int i;
-    int error = 0;
-    
-    for (i = 1; i <= NBuffers; i++) {
-	if (BufferIsValid(i)) {
-	    elog(NOTICE, 
-                 "buffer leak [%d] detected in BufferPoolCheckLeak()", i-1);
-            error = 1;
+	register int	i;
+	int				error = 0;
+
+	for (i = 1; i <= NBuffers; i++)
+	{
+		if (BufferIsValid(i))
+		{
+			elog(NOTICE,
+			"buffer leak [%d] detected in BufferPoolCheckLeak()", i - 1);
+			error = 1;
+		}
 	}
-    }
-    if(error) {
-      PrintBufferDescs();
-      return(1);
-    }
-    return(0);
+	if (error)
+	{
+		PrintBufferDescs();
+		return (1);
+	}
+	return (0);
 }
 
 /* ------------------------------------------------
- *	FlushBufferPool
+ *		FlushBufferPool
  *
- *	flush all dirty blocks in buffer pool to disk
+ *		flush all dirty blocks in buffer pool to disk
  *
  * ------------------------------------------------
  */
 void
 FlushBufferPool(int StableMainMemoryFlag)
 {
-    if (!StableMainMemoryFlag) {
-        BufferSync();
-	smgrcommit();
-    }
+	if (!StableMainMemoryFlag)
+	{
+		BufferSync();
+		smgrcommit();
+	}
 }
 
 /*
  * BufferIsValid --
- *	True iff the refcnt of the local buffer is > 0
+ *		True iff the refcnt of the local buffer is > 0
  * Note:
- *	BufferIsValid(InvalidBuffer) is False.
- *	BufferIsValid(UnknownBuffer) is False.
+ *		BufferIsValid(InvalidBuffer) is False.
+ *		BufferIsValid(UnknownBuffer) is False.
  */
 bool
 BufferIsValid(Buffer bufnum)
 {
-    if (BufferIsLocal(bufnum)) 
-	return (bufnum >= -NLocBuffer && LocalRefCount[-bufnum - 1] > 0);
-    
-    if (BAD_BUFFER_ID(bufnum))
-        return(false);
+	if (BufferIsLocal(bufnum))
+		return (bufnum >= -NLocBuffer && LocalRefCount[-bufnum - 1] > 0);
 
-    return ((bool)(PrivateRefCount[bufnum - 1] > 0));
+	if (BAD_BUFFER_ID(bufnum))
+		return (false);
+
+	return ((bool) (PrivateRefCount[bufnum - 1] > 0));
 }
 
 /*
  * BufferGetBlockNumber --
- *	Returns the block number associated with a buffer.
+ *		Returns the block number associated with a buffer.
  *
  * Note:
- *	Assumes that the buffer is valid.
+ *		Assumes that the buffer is valid.
  */
 BlockNumber
 BufferGetBlockNumber(Buffer buffer)
 {
-    Assert(BufferIsValid(buffer));
+	Assert(BufferIsValid(buffer));
 
-    /* XXX should be a critical section */
-    if (BufferIsLocal(buffer))
-	return (LocalBufferDescriptors[-buffer-1].tag.blockNum);
-    else
-	return (BufferDescriptors[buffer-1].tag.blockNum);
+	/* XXX should be a critical section */
+	if (BufferIsLocal(buffer))
+		return (LocalBufferDescriptors[-buffer - 1].tag.blockNum);
+	else
+		return (BufferDescriptors[buffer - 1].tag.blockNum);
 }
 
 /*
  * BufferGetRelation --
- *	Returns the relation desciptor associated with a buffer.
+ *		Returns the relation desciptor associated with a buffer.
  *
  * Note:
- *	Assumes buffer is valid.
+ *		Assumes buffer is valid.
  */
 Relation
 BufferGetRelation(Buffer buffer)
 {
-    Relation    relation;
-    Oid		relid;
-
-    Assert(BufferIsValid(buffer));
-    Assert(!BufferIsLocal(buffer));	/* not supported for local buffers */
-    
-    /* XXX should be a critical section */
-    relid = LRelIdGetRelationId(BufferDescriptors[buffer-1].tag.relId);
-    relation = RelationIdGetRelation(relid);
-    
-    RelationDecrementReferenceCount(relation);
-    
-    if (RelationHasReferenceCountZero(relation)) {
-	/*
-	  elog(NOTICE, "BufferGetRelation: 0->1");
-	  */
-	
-        RelationIncrementReferenceCount(relation);
-    }
-    
-    return (relation);
+	Relation		relation;
+	Oid				relid;
+
+	Assert(BufferIsValid(buffer));
+	Assert(!BufferIsLocal(buffer));		/* not supported for local buffers */
+
+	/* XXX should be a critical section */
+	relid = LRelIdGetRelationId(BufferDescriptors[buffer - 1].tag.relId);
+	relation = RelationIdGetRelation(relid);
+
+	RelationDecrementReferenceCount(relation);
+
+	if (RelationHasReferenceCountZero(relation))
+	{
+
+		/*
+		 * elog(NOTICE, "BufferGetRelation: 0->1");
+		 */
+
+		RelationIncrementReferenceCount(relation);
+	}
+
+	return (relation);
 }
 
 /*
@@ -1249,217 +1347,232 @@ BufferGetRelation(Buffer buffer)
  *
  */
 static int
-BufferReplace(BufferDesc *bufHdr, bool bufferLockHeld)
+BufferReplace(BufferDesc * bufHdr, bool bufferLockHeld)
 {
-    Relation 	reln;
-    Oid	bufdb, bufrel;
-    int		status;
-    
-    if (!bufferLockHeld)
-	SpinAcquire(BufMgrLock);
-    
-    /*
-     * first try to find the reldesc in the cache, if no luck,
-     * don't bother to build the reldesc from scratch, just do
-     * a blind write.
-     */
-    
-    bufdb = bufHdr->tag.relId.dbId;
-    bufrel = bufHdr->tag.relId.relId;
-    
-    if (bufdb == MyDatabaseId || bufdb == (Oid) NULL)
-	reln = RelationIdCacheGetRelation(bufrel);
-    else
-	reln = (Relation) NULL;
-
-    /* To check if block content changed while flushing. - vadim 01/17/97 */
-    bufHdr->flags &= ~BM_JUST_DIRTIED;
-    
-    SpinRelease(BufMgrLock); 
-    
-    if (reln != (Relation) NULL) {
-	status = smgrflush(bufHdr->bufsmgr, reln, bufHdr->tag.blockNum,
-			   (char *) MAKE_PTR(bufHdr->data));
-    } else {
-	
-	/* blind write always flushes */
-	status = smgrblindwrt(bufHdr->bufsmgr, bufHdr->sb_dbname,
-			      bufHdr->sb_relname, bufdb, bufrel,
-			      bufHdr->tag.blockNum,
-			      (char *) MAKE_PTR(bufHdr->data));
-    }
-    
-    if (status == SM_FAIL)
-	return (FALSE);
-    
-    BufferFlushCount++;
-
-    return (TRUE);
+	Relation		reln;
+	Oid				bufdb,
+					bufrel;
+	int				status;
+
+	if (!bufferLockHeld)
+		SpinAcquire(BufMgrLock);
+
+	/*
+	 * first try to find the reldesc in the cache, if no luck, don't
+	 * bother to build the reldesc from scratch, just do a blind write.
+	 */
+
+	bufdb = bufHdr->tag.relId.dbId;
+	bufrel = bufHdr->tag.relId.relId;
+
+	if (bufdb == MyDatabaseId || bufdb == (Oid) NULL)
+		reln = RelationIdCacheGetRelation(bufrel);
+	else
+		reln = (Relation) NULL;
+
+	/* To check if block content changed while flushing. - vadim 01/17/97 */
+	bufHdr->flags &= ~BM_JUST_DIRTIED;
+
+	SpinRelease(BufMgrLock);
+
+	if (reln != (Relation) NULL)
+	{
+		status = smgrflush(bufHdr->bufsmgr, reln, bufHdr->tag.blockNum,
+						   (char *) MAKE_PTR(bufHdr->data));
+	}
+	else
+	{
+
+		/* blind write always flushes */
+		status = smgrblindwrt(bufHdr->bufsmgr, bufHdr->sb_dbname,
+							  bufHdr->sb_relname, bufdb, bufrel,
+							  bufHdr->tag.blockNum,
+							  (char *) MAKE_PTR(bufHdr->data));
+	}
+
+	if (status == SM_FAIL)
+		return (FALSE);
+
+	BufferFlushCount++;
+
+	return (TRUE);
 }
 
 /*
  * RelationGetNumberOfBlocks --
- *	Returns the buffer descriptor associated with a page in a relation.
+ *		Returns the buffer descriptor associated with a page in a relation.
  *
  * Note:
- *      XXX may fail for huge relations.
- *      XXX should be elsewhere.
- *      XXX maybe should be hidden
+ *		XXX may fail for huge relations.
+ *		XXX should be elsewhere.
+ *		XXX maybe should be hidden
  */
 BlockNumber
 RelationGetNumberOfBlocks(Relation relation)
 {
-    return
-	((relation->rd_islocal) ? relation->rd_nblocks :
-	    smgrnblocks(relation->rd_rel->relsmgr, relation));
+	return
+		((relation->rd_islocal) ? relation->rd_nblocks :
+		 smgrnblocks(relation->rd_rel->relsmgr, relation));
 }
 
 /*
  * BufferGetBlock --
- *	Returns a reference to a disk page image associated with a buffer.
+ *		Returns a reference to a disk page image associated with a buffer.
  *
  * Note:
- *	Assumes buffer is valid.
+ *		Assumes buffer is valid.
  */
 Block
 BufferGetBlock(Buffer buffer)
 {
-    Assert(BufferIsValid(buffer));
+	Assert(BufferIsValid(buffer));
 
-    if (BufferIsLocal(buffer))
-	return((Block)MAKE_PTR(LocalBufferDescriptors[-buffer-1].data));
-    else
-	return((Block)MAKE_PTR(BufferDescriptors[buffer-1].data));
+	if (BufferIsLocal(buffer))
+		return ((Block) MAKE_PTR(LocalBufferDescriptors[-buffer - 1].data));
+	else
+		return ((Block) MAKE_PTR(BufferDescriptors[buffer - 1].data));
 }
 
 /* ---------------------------------------------------------------------
- *      ReleaseRelationBuffers
+ *		ReleaseRelationBuffers
  *
- *      this function unmarks all the dirty pages of a relation 
- *	in the buffer pool so that at the end of transaction
- *      these pages will not be flushed.
- *      XXX currently it sequentially searches the buffer pool, should be
- *      changed to more clever ways of searching.
+ *		this function unmarks all the dirty pages of a relation
+ *		in the buffer pool so that at the end of transaction
+ *		these pages will not be flushed.
+ *		XXX currently it sequentially searches the buffer pool, should be
+ *		changed to more clever ways of searching.
  * --------------------------------------------------------------------
  */
 void
-ReleaseRelationBuffers (Relation rdesc)
+ReleaseRelationBuffers(Relation rdesc)
 {
-    register int i;
-    int holding = 0;
-    BufferDesc *buf;
-    
-    if ( rdesc->rd_islocal )
-    {
-    	for (i = 0; i < NLocBuffer; i++)
-    	{
-	    buf = &LocalBufferDescriptors[i];
-	    if ((buf->flags & BM_DIRTY) &&
-		(buf->tag.relId.relId == rdesc->rd_id))
-	    {
-		buf->flags &= ~BM_DIRTY;
-	    }
-    	}
-    	return;
-    }
-
-    for (i=1; i<=NBuffers; i++) {
-	buf = &BufferDescriptors[i-1];
-	if (!holding) {
-	    SpinAcquire(BufMgrLock);
-	    holding = 1;
+	register int	i;
+	int				holding = 0;
+	BufferDesc	   *buf;
+
+	if (rdesc->rd_islocal)
+	{
+		for (i = 0; i < NLocBuffer; i++)
+		{
+			buf = &LocalBufferDescriptors[i];
+			if ((buf->flags & BM_DIRTY) &&
+				(buf->tag.relId.relId == rdesc->rd_id))
+			{
+				buf->flags &= ~BM_DIRTY;
+			}
+		}
+		return;
 	}
-        if ((buf->flags & BM_DIRTY) &&
-            (buf->tag.relId.dbId == MyDatabaseId) &&
-            (buf->tag.relId.relId == rdesc->rd_id)) {
-            buf->flags &= ~BM_DIRTY;
-            if (!(buf->flags & BM_FREE)) {
-		SpinRelease(BufMgrLock);
-		holding = 0;
-		ReleaseBuffer(i);
-	    }
+
+	for (i = 1; i <= NBuffers; i++)
+	{
+		buf = &BufferDescriptors[i - 1];
+		if (!holding)
+		{
+			SpinAcquire(BufMgrLock);
+			holding = 1;
+		}
+		if ((buf->flags & BM_DIRTY) &&
+			(buf->tag.relId.dbId == MyDatabaseId) &&
+			(buf->tag.relId.relId == rdesc->rd_id))
+		{
+			buf->flags &= ~BM_DIRTY;
+			if (!(buf->flags & BM_FREE))
+			{
+				SpinRelease(BufMgrLock);
+				holding = 0;
+				ReleaseBuffer(i);
+			}
+		}
 	}
-    }
-    if (holding)
-	SpinRelease(BufMgrLock);
+	if (holding)
+		SpinRelease(BufMgrLock);
 }
 
 /* ---------------------------------------------------------------------
- *      DropBuffers
+ *		DropBuffers
  *
- *	This function marks all the buffers in the buffer cache for a
- *	particular database as clean.  This is used when we destroy a
- *	database, to avoid trying to flush data to disk when the directory
- *	tree no longer exists.
+ *		This function marks all the buffers in the buffer cache for a
+ *		particular database as clean.  This is used when we destroy a
+ *		database, to avoid trying to flush data to disk when the directory
+ *		tree no longer exists.
  *
- *	This is an exceedingly non-public interface.
+ *		This is an exceedingly non-public interface.
  * --------------------------------------------------------------------
  */
 void
 DropBuffers(Oid dbid)
 {
-    register int i;
-    BufferDesc *buf;
-    
-    SpinAcquire(BufMgrLock);
-    for (i=1; i<=NBuffers; i++) {
-	buf = &BufferDescriptors[i-1];
-        if ((buf->tag.relId.dbId == dbid) && (buf->flags & BM_DIRTY)) {
-            buf->flags &= ~BM_DIRTY;
-        }
-    }
-    SpinRelease(BufMgrLock);
+	register int	i;
+	BufferDesc	   *buf;
+
+	SpinAcquire(BufMgrLock);
+	for (i = 1; i <= NBuffers; i++)
+	{
+		buf = &BufferDescriptors[i - 1];
+		if ((buf->tag.relId.dbId == dbid) && (buf->flags & BM_DIRTY))
+		{
+			buf->flags &= ~BM_DIRTY;
+		}
+	}
+	SpinRelease(BufMgrLock);
 }
 
 /* -----------------------------------------------------------------
- *	PrintBufferDescs
+ *		PrintBufferDescs
  *
- *	this function prints all the buffer descriptors, for debugging
- *	use only.
+ *		this function prints all the buffer descriptors, for debugging
+ *		use only.
  * -----------------------------------------------------------------
  */
 void
 PrintBufferDescs()
 {
-    int i;
-    BufferDesc *buf = BufferDescriptors;
+	int				i;
+	BufferDesc	   *buf = BufferDescriptors;
 
-    if (IsUnderPostmaster) {
-	SpinAcquire(BufMgrLock);
-	for (i = 0; i < NBuffers; ++i, ++buf) {
-	    elog(NOTICE, "[%02d] (freeNext=%d, freePrev=%d, relname=%s, \
+	if (IsUnderPostmaster)
+	{
+		SpinAcquire(BufMgrLock);
+		for (i = 0; i < NBuffers; ++i, ++buf)
+		{
+			elog(NOTICE, "[%02d] (freeNext=%d, freePrev=%d, relname=%s, \
 blockNum=%d, flags=0x%x, refcount=%d %d)",
-		 i, buf->freeNext, buf->freePrev,
-		 buf->sb_relname, buf->tag.blockNum, buf->flags,
-		 buf->refcount, PrivateRefCount[i]);
+				 i, buf->freeNext, buf->freePrev,
+				 buf->sb_relname, buf->tag.blockNum, buf->flags,
+				 buf->refcount, PrivateRefCount[i]);
+		}
+		SpinRelease(BufMgrLock);
 	}
-	SpinRelease(BufMgrLock);
-    } else {
-	/* interactive backend */
-	for (i = 0; i < NBuffers; ++i, ++buf) {
-	    printf("[%-2d] (%s, %d) flags=0x%x, refcnt=%d %ld)\n",
-		   i, buf->sb_relname, buf->tag.blockNum, 
-		   buf->flags, buf->refcount, PrivateRefCount[i]);
+	else
+	{
+		/* interactive backend */
+		for (i = 0; i < NBuffers; ++i, ++buf)
+		{
+			printf("[%-2d] (%s, %d) flags=0x%x, refcnt=%d %ld)\n",
+				   i, buf->sb_relname, buf->tag.blockNum,
+				   buf->flags, buf->refcount, PrivateRefCount[i]);
+		}
 	}
-    }
 }
 
 void
 PrintPinnedBufs()
 {
-    int i;
-    BufferDesc *buf = BufferDescriptors;
-    
-    SpinAcquire(BufMgrLock);
-    for (i = 0; i < NBuffers; ++i, ++buf) {
-	if (PrivateRefCount[i] > 0)
-	    elog(NOTICE, "[%02d] (freeNext=%d, freePrev=%d, relname=%s, \
+	int				i;
+	BufferDesc	   *buf = BufferDescriptors;
+
+	SpinAcquire(BufMgrLock);
+	for (i = 0; i < NBuffers; ++i, ++buf)
+	{
+		if (PrivateRefCount[i] > 0)
+			elog(NOTICE, "[%02d] (freeNext=%d, freePrev=%d, relname=%s, \
 blockNum=%d, flags=0x%x, refcount=%d %d)\n",
-		 i, buf->freeNext, buf->freePrev, buf->sb_relname,
-		 buf->tag.blockNum, buf->flags,
-		 buf->refcount, PrivateRefCount[i]);
-    }
-    SpinRelease(BufMgrLock);
+				 i, buf->freeNext, buf->freePrev, buf->sb_relname,
+				 buf->tag.blockNum, buf->flags,
+				 buf->refcount, PrivateRefCount[i]);
+	}
+	SpinRelease(BufMgrLock);
 }
 
 /*
@@ -1474,17 +1587,20 @@ blockNum=%d, flags=0x%x, refcount=%d %d)\n",
 void
 BufferPoolBlowaway()
 {
-    register int i;
-    
-    BufferSync();
-    for (i=1; i<=NBuffers; i++) {
-        if (BufferIsValid(i)) {
-            while(BufferIsValid(i))
-                ReleaseBuffer(i);
-        }
-        BufTableDelete(&BufferDescriptors[i-1]);
-    }
+	register int	i;
+
+	BufferSync();
+	for (i = 1; i <= NBuffers; i++)
+	{
+		if (BufferIsValid(i))
+		{
+			while (BufferIsValid(i))
+				ReleaseBuffer(i);
+		}
+		BufTableDelete(&BufferDescriptors[i - 1]);
+	}
 }
+
 #endif
 
 #undef IncrBufferRefCount
@@ -1493,297 +1609,328 @@ BufferPoolBlowaway()
 void
 IncrBufferRefCount(Buffer buffer)
 {
-    if (BufferIsLocal(buffer)) {
-	Assert(LocalRefCount[-buffer - 1] >= 0);
-	LocalRefCount[-buffer - 1]++;
-    } else {
-	Assert(!BAD_BUFFER_ID(buffer));
-	Assert(PrivateRefCount[buffer - 1] >= 0);
-	PrivateRefCount[buffer - 1]++;
-    }
+	if (BufferIsLocal(buffer))
+	{
+		Assert(LocalRefCount[-buffer - 1] >= 0);
+		LocalRefCount[-buffer - 1]++;
+	}
+	else
+	{
+		Assert(!BAD_BUFFER_ID(buffer));
+		Assert(PrivateRefCount[buffer - 1] >= 0);
+		PrivateRefCount[buffer - 1]++;
+	}
 }
 
 /*
  * ReleaseBuffer -- remove the pin on a buffer without
- * 	marking it dirty.
+ *		marking it dirty.
  *
  */
 int
 ReleaseBuffer(Buffer buffer)
 {
-    BufferDesc	*bufHdr;
-    
-    if (BufferIsLocal(buffer)) {
-	Assert(LocalRefCount[-buffer - 1] > 0);
-	LocalRefCount[-buffer - 1]--;
-	return (STATUS_OK);
-    }
-    
-    if (BAD_BUFFER_ID(buffer))
-	return(STATUS_ERROR);
-
-    bufHdr = &BufferDescriptors[buffer-1];
-    
-    Assert(PrivateRefCount[buffer - 1] > 0);
-    PrivateRefCount[buffer - 1]--;
-    if (PrivateRefCount[buffer - 1] == 0 && LastRefCount[buffer - 1] == 0) {
-	/* only release buffer if it is not pinned in previous ExecMain
-	   levels */
-	SpinAcquire(BufMgrLock);
-	bufHdr->refcount--;
-	if (bufHdr->refcount == 0) {
-	    AddBufferToFreelist(bufHdr);
-	    bufHdr->flags |= BM_FREE;
+	BufferDesc	   *bufHdr;
+
+	if (BufferIsLocal(buffer))
+	{
+		Assert(LocalRefCount[-buffer - 1] > 0);
+		LocalRefCount[-buffer - 1]--;
+		return (STATUS_OK);
 	}
-	if(CommitInfoNeedsSave[buffer - 1]) {
-	    bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
-	    CommitInfoNeedsSave[buffer - 1] = 0;
+
+	if (BAD_BUFFER_ID(buffer))
+		return (STATUS_ERROR);
+
+	bufHdr = &BufferDescriptors[buffer - 1];
+
+	Assert(PrivateRefCount[buffer - 1] > 0);
+	PrivateRefCount[buffer - 1]--;
+	if (PrivateRefCount[buffer - 1] == 0 && LastRefCount[buffer - 1] == 0)
+	{
+
+		/*
+		 * only release buffer if it is not pinned in previous ExecMain
+		 * levels
+		 */
+		SpinAcquire(BufMgrLock);
+		bufHdr->refcount--;
+		if (bufHdr->refcount == 0)
+		{
+			AddBufferToFreelist(bufHdr);
+			bufHdr->flags |= BM_FREE;
+		}
+		if (CommitInfoNeedsSave[buffer - 1])
+		{
+			bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
+			CommitInfoNeedsSave[buffer - 1] = 0;
+		}
+		SpinRelease(BufMgrLock);
 	}
-	SpinRelease(BufMgrLock);
-    }
-    
-    return(STATUS_OK);
+
+	return (STATUS_OK);
 }
 
 #ifdef NOT_USED
 void
 IncrBufferRefCount_Debug(char *file, int line, Buffer buffer)
 {
-    IncrBufferRefCount(buffer);
-    if (ShowPinTrace && !BufferIsLocal(buffer) && is_userbuffer(buffer)) {
-        BufferDesc *buf = &BufferDescriptors[buffer-1];
-	
-        fprintf(stderr, "PIN(Incr) %ld relname = %s, blockNum = %d, \
+	IncrBufferRefCount(buffer);
+	if (ShowPinTrace && !BufferIsLocal(buffer) && is_userbuffer(buffer))
+	{
+		BufferDesc	   *buf = &BufferDescriptors[buffer - 1];
+
+		fprintf(stderr, "PIN(Incr) %ld relname = %s, blockNum = %d, \
 refcount = %ld, file: %s, line: %d\n",
-		buffer, buf->sb_relname, buf->tag.blockNum,
-		PrivateRefCount[buffer - 1], file, line);
-    }
+				buffer, buf->sb_relname, buf->tag.blockNum,
+				PrivateRefCount[buffer - 1], file, line);
+	}
 }
+
 #endif
 
 #ifdef NOT_USED
 void
 ReleaseBuffer_Debug(char *file, int line, Buffer buffer)
 {
-    ReleaseBuffer(buffer);
-    if (ShowPinTrace && !BufferIsLocal(buffer) && is_userbuffer(buffer)) {
-        BufferDesc *buf = &BufferDescriptors[buffer-1];
-	
-        fprintf(stderr, "UNPIN(Rel) %ld relname = %s, blockNum = %d, \
+	ReleaseBuffer(buffer);
+	if (ShowPinTrace && !BufferIsLocal(buffer) && is_userbuffer(buffer))
+	{
+		BufferDesc	   *buf = &BufferDescriptors[buffer - 1];
+
+		fprintf(stderr, "UNPIN(Rel) %ld relname = %s, blockNum = %d, \
 refcount = %ld, file: %s, line: %d\n",
-		buffer, buf->sb_relname, buf->tag.blockNum,
-		PrivateRefCount[buffer - 1], file, line);
-    }
+				buffer, buf->sb_relname, buf->tag.blockNum,
+				PrivateRefCount[buffer - 1], file, line);
+	}
 }
+
 #endif
 
 #ifdef NOT_USED
 int
 ReleaseAndReadBuffer_Debug(char *file,
-			   int line,
-			   Buffer buffer,
-			   Relation relation,
-			   BlockNumber blockNum)
+						   int line,
+						   Buffer buffer,
+						   Relation relation,
+						   BlockNumber blockNum)
 {
-    bool bufferValid;
-    Buffer b;
-    
-    bufferValid = BufferIsValid(buffer);
-    b = ReleaseAndReadBuffer(buffer, relation, blockNum);
-    if (ShowPinTrace && bufferValid && BufferIsLocal(buffer)
-	&& is_userbuffer(buffer)) {
-	BufferDesc *buf = &BufferDescriptors[buffer-1];
-	
-        fprintf(stderr, "UNPIN(Rel&Rd) %ld relname = %s, blockNum = %d, \
+	bool			bufferValid;
+	Buffer			b;
+
+	bufferValid = BufferIsValid(buffer);
+	b = ReleaseAndReadBuffer(buffer, relation, blockNum);
+	if (ShowPinTrace && bufferValid && BufferIsLocal(buffer)
+		&& is_userbuffer(buffer))
+	{
+		BufferDesc	   *buf = &BufferDescriptors[buffer - 1];
+
+		fprintf(stderr, "UNPIN(Rel&Rd) %ld relname = %s, blockNum = %d, \
 refcount = %ld, file: %s, line: %d\n",
-		buffer, buf->sb_relname, buf->tag.blockNum,
-		PrivateRefCount[buffer - 1], file, line);
-    }
-    if (ShowPinTrace && BufferIsLocal(buffer) && is_userbuffer(buffer)) {
-	BufferDesc *buf = &BufferDescriptors[b-1];
-	
-        fprintf(stderr, "PIN(Rel&Rd) %ld relname = %s, blockNum = %d, \
+				buffer, buf->sb_relname, buf->tag.blockNum,
+				PrivateRefCount[buffer - 1], file, line);
+	}
+	if (ShowPinTrace && BufferIsLocal(buffer) && is_userbuffer(buffer))
+	{
+		BufferDesc	   *buf = &BufferDescriptors[b - 1];
+
+		fprintf(stderr, "PIN(Rel&Rd) %ld relname = %s, blockNum = %d, \
 refcount = %ld, file: %s, line: %d\n",
-		b, buf->sb_relname, buf->tag.blockNum,
-		PrivateRefCount[b - 1], file, line);
-    }
-    return b;
+				b, buf->sb_relname, buf->tag.blockNum,
+				PrivateRefCount[b - 1], file, line);
+	}
+	return b;
 }
+
 #endif
 
 #ifdef BMTRACE
 
 /*
- *  trace allocations and deallocations in a circular buffer in
- *  shared memory.  check the buffer before doing the allocation,
- *  and die if there's anything fishy.
+ *	trace allocations and deallocations in a circular buffer in
+ *	shared memory.	check the buffer before doing the allocation,
+ *	and die if there's anything fishy.
  */
 
 _bm_trace(Oid dbId, Oid relId, int blkNo, int bufNo, int allocType)
 {
-    static int mypid = 0;
-    long start, cur;
-    bmtrace *tb;
-    
-    if (mypid == 0)
-	mypid = getpid();
-    
-    start = *CurTraceBuf;
-    
-    if (start > 0)
-	cur = start - 1;
-    else
-	cur = BMT_LIMIT - 1;
-    
-    for (;;) {
-	tb = &TraceBuf[cur];
-	if (tb->bmt_op != BMT_NOTUSED) {
-	    if (tb->bmt_buf == bufNo) {
-		if ((tb->bmt_op == BMT_DEALLOC)
-		    || (tb->bmt_dbid == dbId && tb->bmt_relid == relId
-			&& tb->bmt_blkno == blkNo))
-		    goto okay;
-		
-		/* die holding the buffer lock */
-		_bm_die(dbId, relId, blkNo, bufNo, allocType, start, cur);
-	    }
-	}
-	
-	if (cur == start)
-	    goto okay;
-	
-	if (cur == 0)
-	    cur = BMT_LIMIT - 1;
+	static int		mypid = 0;
+	long			start,
+					cur;
+	bmtrace		   *tb;
+
+	if (mypid == 0)
+		mypid = getpid();
+
+	start = *CurTraceBuf;
+
+	if (start > 0)
+		cur = start - 1;
 	else
-	    cur--;
-    }
-    
- okay:
-    tb = &TraceBuf[start];
-    tb->bmt_pid = mypid;
-    tb->bmt_buf = bufNo;
-    tb->bmt_dbid = dbId;
-    tb->bmt_relid = relId;
-    tb->bmt_blkno = blkNo;
-    tb->bmt_op = allocType;
-    
-    *CurTraceBuf = (start + 1) % BMT_LIMIT;
+		cur = BMT_LIMIT - 1;
+
+	for (;;)
+	{
+		tb = &TraceBuf[cur];
+		if (tb->bmt_op != BMT_NOTUSED)
+		{
+			if (tb->bmt_buf == bufNo)
+			{
+				if ((tb->bmt_op == BMT_DEALLOC)
+					|| (tb->bmt_dbid == dbId && tb->bmt_relid == relId
+						&& tb->bmt_blkno == blkNo))
+					goto okay;
+
+				/* die holding the buffer lock */
+				_bm_die(dbId, relId, blkNo, bufNo, allocType, start, cur);
+			}
+		}
+
+		if (cur == start)
+			goto okay;
+
+		if (cur == 0)
+			cur = BMT_LIMIT - 1;
+		else
+			cur--;
+	}
+
+okay:
+	tb = &TraceBuf[start];
+	tb->bmt_pid = mypid;
+	tb->bmt_buf = bufNo;
+	tb->bmt_dbid = dbId;
+	tb->bmt_relid = relId;
+	tb->bmt_blkno = blkNo;
+	tb->bmt_op = allocType;
+
+	*CurTraceBuf = (start + 1) % BMT_LIMIT;
 }
 
 _bm_die(Oid dbId, Oid relId, int blkNo, int bufNo,
-	int allocType, long start, long cur)
+		int allocType, long start, long cur)
 {
-    FILE *fp;
-    bmtrace *tb;
-    int i;
-    
-    tb = &TraceBuf[cur];
-    
-    if ((fp = AllocateFile("/tmp/death_notice", "w")) == NULL)
-	elog(FATAL, "buffer alloc trace error and can't open log file");
-    
-    fprintf(fp, "buffer alloc trace detected the following error:\n\n");
-    fprintf(fp, "    buffer %d being %s inconsistently with a previous %s\n\n",
-	    bufNo, (allocType == BMT_DEALLOC ? "deallocated" : "allocated"),
-	    (tb->bmt_op == BMT_DEALLOC ? "deallocation" : "allocation"));
-    
-    fprintf(fp, "the trace buffer contains:\n");
-    
-    i = start;
-    for (;;) {
-	tb = &TraceBuf[i];
-	if (tb->bmt_op != BMT_NOTUSED) {
-	    fprintf(fp, "     [%3d]%spid %d buf %2d for <%d,%d,%d> ",
-		    i, (i == cur ? " ---> " : "\t"),
-		    tb->bmt_pid, tb->bmt_buf,
-		    tb->bmt_dbid, tb->bmt_relid, tb->bmt_blkno);
-	    
-	    switch (tb->bmt_op) {
-	    case BMT_ALLOCFND:
+	FILE		   *fp;
+	bmtrace		   *tb;
+	int				i;
+
+	tb = &TraceBuf[cur];
+
+	if ((fp = AllocateFile("/tmp/death_notice", "w")) == NULL)
+		elog(FATAL, "buffer alloc trace error and can't open log file");
+
+	fprintf(fp, "buffer alloc trace detected the following error:\n\n");
+	fprintf(fp, "    buffer %d being %s inconsistently with a previous %s\n\n",
+		 bufNo, (allocType == BMT_DEALLOC ? "deallocated" : "allocated"),
+			(tb->bmt_op == BMT_DEALLOC ? "deallocation" : "allocation"));
+
+	fprintf(fp, "the trace buffer contains:\n");
+
+	i = start;
+	for (;;)
+	{
+		tb = &TraceBuf[i];
+		if (tb->bmt_op != BMT_NOTUSED)
+		{
+			fprintf(fp, "     [%3d]%spid %d buf %2d for <%d,%d,%d> ",
+					i, (i == cur ? " ---> " : "\t"),
+					tb->bmt_pid, tb->bmt_buf,
+					tb->bmt_dbid, tb->bmt_relid, tb->bmt_blkno);
+
+			switch (tb->bmt_op)
+			{
+			case BMT_ALLOCFND:
+				fprintf(fp, "allocate (found)\n");
+				break;
+
+			case BMT_ALLOCNOTFND:
+				fprintf(fp, "allocate (not found)\n");
+				break;
+
+			case BMT_DEALLOC:
+				fprintf(fp, "deallocate\n");
+				break;
+
+			default:
+				fprintf(fp, "unknown op type %d\n", tb->bmt_op);
+				break;
+			}
+		}
+
+		i = (i + 1) % BMT_LIMIT;
+		if (i == start)
+			break;
+	}
+
+	fprintf(fp, "\noperation causing error:\n");
+	fprintf(fp, "\tpid %d buf %d for <%d,%d,%d> ",
+			getpid(), bufNo, dbId, relId, blkNo);
+
+	switch (allocType)
+	{
+	case BMT_ALLOCFND:
 		fprintf(fp, "allocate (found)\n");
 		break;
-		
-	    case BMT_ALLOCNOTFND:
+
+	case BMT_ALLOCNOTFND:
 		fprintf(fp, "allocate (not found)\n");
 		break;
-		
-	    case BMT_DEALLOC:
+
+	case BMT_DEALLOC:
 		fprintf(fp, "deallocate\n");
 		break;
-		
-	    default:
-		fprintf(fp, "unknown op type %d\n", tb->bmt_op);
+
+	default:
+		fprintf(fp, "unknown op type %d\n", allocType);
 		break;
-	    }
 	}
-	
-	i = (i + 1) % BMT_LIMIT;
-	if (i == start)
-	    break;
-    }
-    
-    fprintf(fp, "\noperation causing error:\n");
-    fprintf(fp, "\tpid %d buf %d for <%d,%d,%d> ",
-	    getpid(), bufNo, dbId, relId, blkNo);
-    
-    switch (allocType) {
-    case BMT_ALLOCFND:
-	fprintf(fp, "allocate (found)\n");
-	break;
-	
-    case BMT_ALLOCNOTFND:
-	fprintf(fp, "allocate (not found)\n");
-	break;
-	
-    case BMT_DEALLOC:
-	fprintf(fp, "deallocate\n");
-	break;
-	
-    default:
-	fprintf(fp, "unknown op type %d\n", allocType);
-	break;
-    }
-    
-    FreeFile(fp);
-    
-    kill(getpid(), SIGILL);
+
+	FreeFile(fp);
+
+	kill(getpid(), SIGILL);
 }
 
-#endif /* BMTRACE */
+#endif							/* BMTRACE */
 
 void
 BufferRefCountReset(int *refcountsave)
 {
-    int i;
-    for (i=0; i<NBuffers; i++) {
-	refcountsave[i] = PrivateRefCount[i];
-	LastRefCount[i] += PrivateRefCount[i];
-	PrivateRefCount[i] = 0;
-    }
+	int				i;
+
+	for (i = 0; i < NBuffers; i++)
+	{
+		refcountsave[i] = PrivateRefCount[i];
+		LastRefCount[i] += PrivateRefCount[i];
+		PrivateRefCount[i] = 0;
+	}
 }
 
 void
 BufferRefCountRestore(int *refcountsave)
 {
-    int i;
-    for (i=0; i<NBuffers; i++) {
-	PrivateRefCount[i] = refcountsave[i];
-	LastRefCount[i] -= refcountsave[i];
-	refcountsave[i] = 0;
-    }
+	int				i;
+
+	for (i = 0; i < NBuffers; i++)
+	{
+		PrivateRefCount[i] = refcountsave[i];
+		LastRefCount[i] -= refcountsave[i];
+		refcountsave[i] = 0;
+	}
 }
 
-int SetBufferWriteMode (int mode)
+int
+SetBufferWriteMode(int mode)
 {
-    int old;
-    
-    old = WriteMode;
-    WriteMode = mode;
-    return (old);
+	int				old;
+
+	old = WriteMode;
+	WriteMode = mode;
+	return (old);
 }
 
-void SetBufferCommitInfoNeedsSave(Buffer buffer)
+void
+SetBufferCommitInfoNeedsSave(Buffer buffer)
 {
-    if ( !BufferIsLocal(buffer) )
-    	CommitInfoNeedsSave[buffer - 1]++;
+	if (!BufferIsLocal(buffer))
+		CommitInfoNeedsSave[buffer - 1]++;
 }