ExtendBufferedWhat -> BufferManagerRelation.

Commit 31966b15 invented a way for functions dealing with relation
extension to accept a Relation in online code and an SMgrRelation in
recovery code.  It seems highly likely that future bufmgr.c interfaces
will face the same problem, and need to do something similar.
Generalize the names so that each interface doesn't have to re-invent
the wheel.

Back-patch to 16.  Since extension AM authors might start using the
constructor macros once 16 ships, we agreed to do the rename in 16
rather than waiting for 17.

Reviewed-by: Peter Geoghegan <pg@bowt.ie>
Reviewed-by: Andres Freund <andres@anarazel.de>
Discussion: https://postgr.es/m/CA%2BhUKG%2B6tLD2BhpRWycEoti6LVLyQq457UL4ticP5xd8LqHySA%40mail.gmail.com

1 files changed, 56 insertions, 56 deletions

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index bd203c21913..4343178ff96 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -451,7 +451,7 @@ static Buffer ReadBuffer_common(SMgrRelation smgr, char relpersistence,
 								ForkNumber forkNum, BlockNumber blockNum,
 								ReadBufferMode mode, BufferAccessStrategy strategy,
 								bool *hit);
-static BlockNumber ExtendBufferedRelCommon(ExtendBufferedWhat eb,
+static BlockNumber ExtendBufferedRelCommon(BufferManagerRelation bmr,
 										   ForkNumber fork,
 										   BufferAccessStrategy strategy,
 										   uint32 flags,
@@ -459,7 +459,7 @@ static BlockNumber ExtendBufferedRelCommon(ExtendBufferedWhat eb,
 										   BlockNumber extend_upto,
 										   Buffer *buffers,
 										   uint32 *extended_by);
-static BlockNumber ExtendBufferedRelShared(ExtendBufferedWhat eb,
+static BlockNumber ExtendBufferedRelShared(BufferManagerRelation bmr,
 										   ForkNumber fork,
 										   BufferAccessStrategy strategy,
 										   uint32 flags,
@@ -809,7 +809,7 @@ ReadBufferWithoutRelcache(RelFileLocator rlocator, ForkNumber forkNum,
  * Convenience wrapper around ExtendBufferedRelBy() extending by one block.
  */
 Buffer
-ExtendBufferedRel(ExtendBufferedWhat eb,
+ExtendBufferedRel(BufferManagerRelation bmr,
 				  ForkNumber forkNum,
 				  BufferAccessStrategy strategy,
 				  uint32 flags)
@@ -817,7 +817,7 @@ ExtendBufferedRel(ExtendBufferedWhat eb,
 	Buffer		buf;
 	uint32		extend_by = 1;
 
-	ExtendBufferedRelBy(eb, forkNum, strategy, flags, extend_by,
+	ExtendBufferedRelBy(bmr, forkNum, strategy, flags, extend_by,
 						&buf, &extend_by);
 
 	return buf;
@@ -841,7 +841,7 @@ ExtendBufferedRel(ExtendBufferedWhat eb,
  * be empty.
  */
 BlockNumber
-ExtendBufferedRelBy(ExtendBufferedWhat eb,
+ExtendBufferedRelBy(BufferManagerRelation bmr,
 					ForkNumber fork,
 					BufferAccessStrategy strategy,
 					uint32 flags,
@@ -849,17 +849,17 @@ ExtendBufferedRelBy(ExtendBufferedWhat eb,
 					Buffer *buffers,
 					uint32 *extended_by)
 {
-	Assert((eb.rel != NULL) != (eb.smgr != NULL));
-	Assert(eb.smgr == NULL || eb.relpersistence != 0);
+	Assert((bmr.rel != NULL) != (bmr.smgr != NULL));
+	Assert(bmr.smgr == NULL || bmr.relpersistence != 0);
 	Assert(extend_by > 0);
 
-	if (eb.smgr == NULL)
+	if (bmr.smgr == NULL)
 	{
-		eb.smgr = RelationGetSmgr(eb.rel);
-		eb.relpersistence = eb.rel->rd_rel->relpersistence;
+		bmr.smgr = RelationGetSmgr(bmr.rel);
+		bmr.relpersistence = bmr.rel->rd_rel->relpersistence;
 	}
 
-	return ExtendBufferedRelCommon(eb, fork, strategy, flags,
+	return ExtendBufferedRelCommon(bmr, fork, strategy, flags,
 								   extend_by, InvalidBlockNumber,
 								   buffers, extended_by);
 }
@@ -873,7 +873,7 @@ ExtendBufferedRelBy(ExtendBufferedWhat eb,
  * crash recovery).
  */
 Buffer
-ExtendBufferedRelTo(ExtendBufferedWhat eb,
+ExtendBufferedRelTo(BufferManagerRelation bmr,
 					ForkNumber fork,
 					BufferAccessStrategy strategy,
 					uint32 flags,
@@ -885,14 +885,14 @@ ExtendBufferedRelTo(ExtendBufferedWhat eb,
 	Buffer		buffer = InvalidBuffer;
 	Buffer		buffers[64];
 
-	Assert((eb.rel != NULL) != (eb.smgr != NULL));
-	Assert(eb.smgr == NULL || eb.relpersistence != 0);
+	Assert((bmr.rel != NULL) != (bmr.smgr != NULL));
+	Assert(bmr.smgr == NULL || bmr.relpersistence != 0);
 	Assert(extend_to != InvalidBlockNumber && extend_to > 0);
 
-	if (eb.smgr == NULL)
+	if (bmr.smgr == NULL)
 	{
-		eb.smgr = RelationGetSmgr(eb.rel);
-		eb.relpersistence = eb.rel->rd_rel->relpersistence;
+		bmr.smgr = RelationGetSmgr(bmr.rel);
+		bmr.relpersistence = bmr.rel->rd_rel->relpersistence;
 	}
 
 	/*
@@ -901,21 +901,21 @@ ExtendBufferedRelTo(ExtendBufferedWhat eb,
 	 * an smgrexists call.
 	 */
 	if ((flags & EB_CREATE_FORK_IF_NEEDED) &&
-		(eb.smgr->smgr_cached_nblocks[fork] == 0 ||
-		 eb.smgr->smgr_cached_nblocks[fork] == InvalidBlockNumber) &&
-		!smgrexists(eb.smgr, fork))
+		(bmr.smgr->smgr_cached_nblocks[fork] == 0 ||
+		 bmr.smgr->smgr_cached_nblocks[fork] == InvalidBlockNumber) &&
+		!smgrexists(bmr.smgr, fork))
 	{
-		LockRelationForExtension(eb.rel, ExclusiveLock);
+		LockRelationForExtension(bmr.rel, ExclusiveLock);
 
 		/* could have been closed while waiting for lock */
-		if (eb.rel)
-			eb.smgr = RelationGetSmgr(eb.rel);
+		if (bmr.rel)
+			bmr.smgr = RelationGetSmgr(bmr.rel);
 
 		/* recheck, fork might have been created concurrently */
-		if (!smgrexists(eb.smgr, fork))
-			smgrcreate(eb.smgr, fork, flags & EB_PERFORMING_RECOVERY);
+		if (!smgrexists(bmr.smgr, fork))
+			smgrcreate(bmr.smgr, fork, flags & EB_PERFORMING_RECOVERY);
 
-		UnlockRelationForExtension(eb.rel, ExclusiveLock);
+		UnlockRelationForExtension(bmr.rel, ExclusiveLock);
 	}
 
 	/*
@@ -923,13 +923,13 @@ ExtendBufferedRelTo(ExtendBufferedWhat eb,
 	 * kernel.
 	 */
 	if (flags & EB_CLEAR_SIZE_CACHE)
-		eb.smgr->smgr_cached_nblocks[fork] = InvalidBlockNumber;
+		bmr.smgr->smgr_cached_nblocks[fork] = InvalidBlockNumber;
 
 	/*
 	 * Estimate how many pages we'll need to extend by. This avoids acquiring
 	 * unnecessarily many victim buffers.
 	 */
-	current_size = smgrnblocks(eb.smgr, fork);
+	current_size = smgrnblocks(bmr.smgr, fork);
 
 	/*
 	 * Since no-one else can be looking at the page contents yet, there is no
@@ -948,7 +948,7 @@ ExtendBufferedRelTo(ExtendBufferedWhat eb,
 		if ((uint64) current_size + num_pages > extend_to)
 			num_pages = extend_to - current_size;
 
-		first_block = ExtendBufferedRelCommon(eb, fork, strategy, flags,
+		first_block = ExtendBufferedRelCommon(bmr, fork, strategy, flags,
 											  num_pages, extend_to,
 											  buffers, &extended_by);
 
@@ -975,7 +975,7 @@ ExtendBufferedRelTo(ExtendBufferedWhat eb,
 		bool		hit;
 
 		Assert(extended_by == 0);
-		buffer = ReadBuffer_common(eb.smgr, eb.relpersistence,
+		buffer = ReadBuffer_common(bmr.smgr, bmr.relpersistence,
 								   fork, extend_to - 1, mode, strategy,
 								   &hit);
 	}
@@ -1019,7 +1019,7 @@ ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 		if (mode == RBM_ZERO_AND_LOCK || mode == RBM_ZERO_AND_CLEANUP_LOCK)
 			flags |= EB_LOCK_FIRST;
 
-		return ExtendBufferedRel(EB_SMGR(smgr, relpersistence),
+		return ExtendBufferedRel(BMR_SMGR(smgr, relpersistence),
 								 forkNum, strategy, flags);
 	}
 
@@ -1779,7 +1779,7 @@ LimitAdditionalPins(uint32 *additional_pins)
  * avoid duplicating the tracing and relpersistence related logic.
  */
 static BlockNumber
-ExtendBufferedRelCommon(ExtendBufferedWhat eb,
+ExtendBufferedRelCommon(BufferManagerRelation bmr,
 						ForkNumber fork,
 						BufferAccessStrategy strategy,
 						uint32 flags,
@@ -1791,27 +1791,27 @@ ExtendBufferedRelCommon(ExtendBufferedWhat eb,
 	BlockNumber first_block;
 
 	TRACE_POSTGRESQL_BUFFER_EXTEND_START(fork,
-										 eb.smgr->smgr_rlocator.locator.spcOid,
-										 eb.smgr->smgr_rlocator.locator.dbOid,
-										 eb.smgr->smgr_rlocator.locator.relNumber,
-										 eb.smgr->smgr_rlocator.backend,
+										 bmr.smgr->smgr_rlocator.locator.spcOid,
+										 bmr.smgr->smgr_rlocator.locator.dbOid,
+										 bmr.smgr->smgr_rlocator.locator.relNumber,
+										 bmr.smgr->smgr_rlocator.backend,
 										 extend_by);
 
-	if (eb.relpersistence == RELPERSISTENCE_TEMP)
-		first_block = ExtendBufferedRelLocal(eb, fork, flags,
+	if (bmr.relpersistence == RELPERSISTENCE_TEMP)
+		first_block = ExtendBufferedRelLocal(bmr, fork, flags,
 											 extend_by, extend_upto,
 											 buffers, &extend_by);
 	else
-		first_block = ExtendBufferedRelShared(eb, fork, strategy, flags,
+		first_block = ExtendBufferedRelShared(bmr, fork, strategy, flags,
 											  extend_by, extend_upto,
 											  buffers, &extend_by);
 	*extended_by = extend_by;
 
 	TRACE_POSTGRESQL_BUFFER_EXTEND_DONE(fork,
-										eb.smgr->smgr_rlocator.locator.spcOid,
-										eb.smgr->smgr_rlocator.locator.dbOid,
-										eb.smgr->smgr_rlocator.locator.relNumber,
-										eb.smgr->smgr_rlocator.backend,
+										bmr.smgr->smgr_rlocator.locator.spcOid,
+										bmr.smgr->smgr_rlocator.locator.dbOid,
+										bmr.smgr->smgr_rlocator.locator.relNumber,
+										bmr.smgr->smgr_rlocator.backend,
 										*extended_by,
 										first_block);
 
@@ -1823,7 +1823,7 @@ ExtendBufferedRelCommon(ExtendBufferedWhat eb,
  * shared buffers.
  */
 static BlockNumber
-ExtendBufferedRelShared(ExtendBufferedWhat eb,
+ExtendBufferedRelShared(BufferManagerRelation bmr,
 						ForkNumber fork,
 						BufferAccessStrategy strategy,
 						uint32 flags,
@@ -1874,9 +1874,9 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
 	 */
 	if (!(flags & EB_SKIP_EXTENSION_LOCK))
 	{
-		LockRelationForExtension(eb.rel, ExclusiveLock);
-		if (eb.rel)
-			eb.smgr = RelationGetSmgr(eb.rel);
+		LockRelationForExtension(bmr.rel, ExclusiveLock);
+		if (bmr.rel)
+			bmr.smgr = RelationGetSmgr(bmr.rel);
 	}
 
 	/*
@@ -1884,9 +1884,9 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
 	 * kernel.
 	 */
 	if (flags & EB_CLEAR_SIZE_CACHE)
-		eb.smgr->smgr_cached_nblocks[fork] = InvalidBlockNumber;
+		bmr.smgr->smgr_cached_nblocks[fork] = InvalidBlockNumber;
 
-	first_block = smgrnblocks(eb.smgr, fork);
+	first_block = smgrnblocks(bmr.smgr, fork);
 
 	/*
 	 * Now that we have the accurate relation size, check if the caller wants
@@ -1918,7 +1918,7 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
 		if (extend_by == 0)
 		{
 			if (!(flags & EB_SKIP_EXTENSION_LOCK))
-				UnlockRelationForExtension(eb.rel, ExclusiveLock);
+				UnlockRelationForExtension(bmr.rel, ExclusiveLock);
 			*extended_by = extend_by;
 			return first_block;
 		}
@@ -1929,7 +1929,7 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
 		ereport(ERROR,
 				(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
 				 errmsg("cannot extend relation %s beyond %u blocks",
-						relpath(eb.smgr->smgr_rlocator, fork),
+						relpath(bmr.smgr->smgr_rlocator, fork),
 						MaxBlockNumber)));
 
 	/*
@@ -1947,7 +1947,7 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
 		LWLock	   *partition_lock;
 		int			existing_id;
 
-		InitBufferTag(&tag, &eb.smgr->smgr_rlocator.locator, fork, first_block + i);
+		InitBufferTag(&tag, &bmr.smgr->smgr_rlocator.locator, fork, first_block + i);
 		hash = BufTableHashCode(&tag);
 		partition_lock = BufMappingPartitionLock(hash);
 
@@ -1996,7 +1996,7 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
 			if (valid && !PageIsNew((Page) buf_block))
 				ereport(ERROR,
 						(errmsg("unexpected data beyond EOF in block %u of relation %s",
-								existing_hdr->tag.blockNum, relpath(eb.smgr->smgr_rlocator, fork)),
+								existing_hdr->tag.blockNum, relpath(bmr.smgr->smgr_rlocator, fork)),
 						 errhint("This has been seen to occur with buggy kernels; consider updating your system.")));
 
 			/*
@@ -2030,7 +2030,7 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
 			victim_buf_hdr->tag = tag;
 
 			buf_state |= BM_TAG_VALID | BUF_USAGECOUNT_ONE;
-			if (eb.relpersistence == RELPERSISTENCE_PERMANENT || fork == INIT_FORKNUM)
+			if (bmr.relpersistence == RELPERSISTENCE_PERMANENT || fork == INIT_FORKNUM)
 				buf_state |= BM_PERMANENT;
 
 			UnlockBufHdr(victim_buf_hdr, buf_state);
@@ -2054,7 +2054,7 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
 	 *
 	 * We don't need to set checksum for all-zero pages.
 	 */
-	smgrzeroextend(eb.smgr, fork, first_block, extend_by, false);
+	smgrzeroextend(bmr.smgr, fork, first_block, extend_by, false);
 
 	/*
 	 * Release the file-extension lock; it's now OK for someone else to extend
@@ -2064,7 +2064,7 @@ ExtendBufferedRelShared(ExtendBufferedWhat eb,
 	 * take noticeable time.
 	 */
 	if (!(flags & EB_SKIP_EXTENSION_LOCK))
-		UnlockRelationForExtension(eb.rel, ExclusiveLock);
+		UnlockRelationForExtension(bmr.rel, ExclusiveLock);
 
 	pgstat_count_io_op_time(IOOBJECT_RELATION, io_context, IOOP_EXTEND,
 							io_start, extend_by);