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 
Reviewed-by: Andres Freund 
Discussion: https://postgr.es/m/CA%2BhUKG%2B6tLD2BhpRWycEoti6LVLyQq457UL4ticP5xd8LqHySA%40mail.gmail.com

diff --git a/contrib/bloom/blutils.c b/contrib/bloom/blutils.c
index d935ed8fbdff4fbe79ee6bbff846dddd18970979..a017d58bbe4aa4ca2158fc623f422be849024aaa 100644 (file)
--- a/contrib/bloom/blutils.c
+++ b/contrib/bloom/blutils.c
@@ -386,7 +386,7 @@ BloomNewBuffer(Relation index)
    }
 
    /* Must extend the file */
-   buffer = ExtendBufferedRel(EB_REL(index), MAIN_FORKNUM, NULL,
+   buffer = ExtendBufferedRel(BMR_REL(index), MAIN_FORKNUM, NULL,
                               EB_LOCK_FIRST);
 
    return buffer;

diff --git a/src/backend/access/brin/brin.c b/src/backend/access/brin/brin.c
index 3c6a956eaa3f2c9dfb016e23a98b0667259bddb5..d4fec654bb67b6d6b0562c4d4f376a91e13a0163 100644 (file)
--- a/src/backend/access/brin/brin.c
+++ b/src/backend/access/brin/brin.c
@@ -848,7 +848,7 @@ brinbuild(Relation heap, Relation index, IndexInfo *indexInfo)
     * whole relation will be rolled back.
     */
 
-   meta = ExtendBufferedRel(EB_REL(index), MAIN_FORKNUM, NULL,
+   meta = ExtendBufferedRel(BMR_REL(index), MAIN_FORKNUM, NULL,
                             EB_LOCK_FIRST | EB_SKIP_EXTENSION_LOCK);
    Assert(BufferGetBlockNumber(meta) == BRIN_METAPAGE_BLKNO);
 
@@ -915,7 +915,7 @@ brinbuildempty(Relation index)
    Buffer      metabuf;
 
    /* An empty BRIN index has a metapage only. */
-   metabuf = ExtendBufferedRel(EB_REL(index), INIT_FORKNUM, NULL,
+   metabuf = ExtendBufferedRel(BMR_REL(index), INIT_FORKNUM, NULL,
                                EB_LOCK_FIRST | EB_SKIP_EXTENSION_LOCK);
 
    /* Initialize and xlog metabuffer. */

diff --git a/src/backend/access/brin/brin_revmap.c b/src/backend/access/brin/brin_revmap.c
index f4271ba31c91659cb1ba67b56650f1446daa12d2..84d627cb5c9b53c02e084277f6f2309d6fd55ec8 100644 (file)
--- a/src/backend/access/brin/brin_revmap.c
+++ b/src/backend/access/brin/brin_revmap.c
@@ -569,7 +569,7 @@ revmap_physical_extend(BrinRevmap *revmap)
    }
    else
    {
-       buf = ExtendBufferedRel(EB_REL(irel), MAIN_FORKNUM, NULL,
+       buf = ExtendBufferedRel(BMR_REL(irel), MAIN_FORKNUM, NULL,
                                EB_LOCK_FIRST);
        if (BufferGetBlockNumber(buf) != mapBlk)
        {

diff --git a/src/backend/access/gin/gininsert.c b/src/backend/access/gin/gininsert.c
index be1841de7bfc00034271c95c6d3ab21606682d98..56968b95acf8745dc5d390322b72b4b97ef72894 100644 (file)
--- a/src/backend/access/gin/gininsert.c
+++ b/src/backend/access/gin/gininsert.c
@@ -440,9 +440,9 @@ ginbuildempty(Relation index)
                MetaBuffer;
 
    /* An empty GIN index has two pages. */
-   MetaBuffer = ExtendBufferedRel(EB_REL(index), INIT_FORKNUM, NULL,
+   MetaBuffer = ExtendBufferedRel(BMR_REL(index), INIT_FORKNUM, NULL,
                                   EB_LOCK_FIRST | EB_SKIP_EXTENSION_LOCK);
-   RootBuffer = ExtendBufferedRel(EB_REL(index), INIT_FORKNUM, NULL,
+   RootBuffer = ExtendBufferedRel(BMR_REL(index), INIT_FORKNUM, NULL,
                                   EB_LOCK_FIRST | EB_SKIP_EXTENSION_LOCK);
 
    /* Initialize and xlog metabuffer and root buffer. */

diff --git a/src/backend/access/gin/ginutil.c b/src/backend/access/gin/ginutil.c
index 437f24753c03100beb7b3b07aaa3dc5a1de8f531..7a4cd93f30185cd1b607bfc33f7fdf52559c89ed 100644 (file)
--- a/src/backend/access/gin/ginutil.c
+++ b/src/backend/access/gin/ginutil.c
@@ -327,7 +327,7 @@ GinNewBuffer(Relation index)
    }
 
    /* Must extend the file */
-   buffer = ExtendBufferedRel(EB_REL(index), MAIN_FORKNUM, NULL,
+   buffer = ExtendBufferedRel(BMR_REL(index), MAIN_FORKNUM, NULL,
                               EB_LOCK_FIRST);
 
    return buffer;

diff --git a/src/backend/access/gist/gist.c b/src/backend/access/gist/gist.c
index 516465f8b7dbfef5f6d008ed3e89da29da139a86..b1f19f6a8e61a70bc9b68c8d4ca2161b33cfaf41 100644 (file)
--- a/src/backend/access/gist/gist.c
+++ b/src/backend/access/gist/gist.c
@@ -134,7 +134,7 @@ gistbuildempty(Relation index)
    Buffer      buffer;
 
    /* Initialize the root page */
-   buffer = ExtendBufferedRel(EB_REL(index), INIT_FORKNUM, NULL,
+   buffer = ExtendBufferedRel(BMR_REL(index), INIT_FORKNUM, NULL,
                               EB_SKIP_EXTENSION_LOCK | EB_LOCK_FIRST);
 
    /* Initialize and xlog buffer */

diff --git a/src/backend/access/gist/gistutil.c b/src/backend/access/gist/gistutil.c
index f9f51152b8e18cb8299a0f2800779eb145a63d85..b6bc8c2c56daeea08c1d39ea8aeed51c3508ba34 100644 (file)
--- a/src/backend/access/gist/gistutil.c
+++ b/src/backend/access/gist/gistutil.c
@@ -877,7 +877,7 @@ gistNewBuffer(Relation r, Relation heaprel)
    }
 
    /* Must extend the file */
-   buffer = ExtendBufferedRel(EB_REL(r), MAIN_FORKNUM, NULL,
+   buffer = ExtendBufferedRel(BMR_REL(r), MAIN_FORKNUM, NULL,
                               EB_LOCK_FIRST);
 
    return buffer;

diff --git a/src/backend/access/hash/hashpage.c b/src/backend/access/hash/hashpage.c
index af3a1542667525f6c6e45e5b23ae0960dec496c0..0c6e79f1bdcc59ada2d7fdfb53ddb8839724db19 100644 (file)
--- a/src/backend/access/hash/hashpage.c
+++ b/src/backend/access/hash/hashpage.c
@@ -209,7 +209,7 @@ _hash_getnewbuf(Relation rel, BlockNumber blkno, ForkNumber forkNum)
    /* smgr insists we explicitly extend the relation */
    if (blkno == nblocks)
    {
-       buf = ExtendBufferedRel(EB_REL(rel), forkNum, NULL,
+       buf = ExtendBufferedRel(BMR_REL(rel), forkNum, NULL,
                                EB_LOCK_FIRST | EB_SKIP_EXTENSION_LOCK);
        if (BufferGetBlockNumber(buf) != blkno)
            elog(ERROR, "unexpected hash relation size: %u, should be %u",

diff --git a/src/backend/access/heap/hio.c b/src/backend/access/heap/hio.c
index 21f808fecb5343f03d878a1121c66669c6bab0a6..caa62708aa5f243b70dab8737ef26acce46a9c05 100644 (file)
--- a/src/backend/access/heap/hio.c
+++ b/src/backend/access/heap/hio.c
@@ -339,7 +339,7 @@ RelationAddBlocks(Relation relation, BulkInsertState bistate,
     * [auto]vacuum trying to truncate later pages as REL_TRUNCATE_MINIMUM is
     * way larger.
     */
-   first_block = ExtendBufferedRelBy(EB_REL(relation), MAIN_FORKNUM,
+   first_block = ExtendBufferedRelBy(BMR_REL(relation), MAIN_FORKNUM,
                                      bistate ? bistate->strategy : NULL,
                                      EB_LOCK_FIRST,
                                      extend_by_pages,

diff --git a/src/backend/access/heap/visibilitymap.c b/src/backend/access/heap/visibilitymap.c
index 7d54ec9c0f71c8dc165587dd471a89529560dab8..2e18cd88bcf35781280c2301f9090f7f0e18817b 100644 (file)
--- a/src/backend/access/heap/visibilitymap.c
+++ b/src/backend/access/heap/visibilitymap.c
@@ -628,7 +628,7 @@ vm_extend(Relation rel, BlockNumber vm_nblocks)
 {
    Buffer      buf;
 
-   buf = ExtendBufferedRelTo(EB_REL(rel), VISIBILITYMAP_FORKNUM, NULL,
+   buf = ExtendBufferedRelTo(BMR_REL(rel), VISIBILITYMAP_FORKNUM, NULL,
                              EB_CREATE_FORK_IF_NEEDED |
                              EB_CLEAR_SIZE_CACHE,
                              vm_nblocks,

diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index d78971bfe8867f5757a547036b5ebb8893ddacfc..6558aea42bad0aa71b4973426db74dd344b4ba1f 100644 (file)
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -975,7 +975,7 @@ _bt_allocbuf(Relation rel, Relation heaprel)
     * otherwise would make, as we can't use _bt_lockbuf() without introducing
     * a race.
     */
-   buf = ExtendBufferedRel(EB_REL(rel), MAIN_FORKNUM, NULL, EB_LOCK_FIRST);
+   buf = ExtendBufferedRel(BMR_REL(rel), MAIN_FORKNUM, NULL, EB_LOCK_FIRST);
    if (!RelationUsesLocalBuffers(rel))
        VALGRIND_MAKE_MEM_DEFINED(BufferGetPage(buf), BLCKSZ);
 

diff --git a/src/backend/access/spgist/spgutils.c b/src/backend/access/spgist/spgutils.c
index 190e4f76a9eec89da79b6edb9a460703245d3313..8f32e46fb8313ea00d34e60a323a3affbdd05f2d 100644 (file)
--- a/src/backend/access/spgist/spgutils.c
+++ b/src/backend/access/spgist/spgutils.c
@@ -405,7 +405,7 @@ SpGistNewBuffer(Relation index)
        ReleaseBuffer(buffer);
    }
 
-   buffer = ExtendBufferedRel(EB_REL(index), MAIN_FORKNUM, NULL,
+   buffer = ExtendBufferedRel(BMR_REL(index), MAIN_FORKNUM, NULL,
                               EB_LOCK_FIRST);
 
    return buffer;

diff --git a/src/backend/access/transam/xlogutils.c b/src/backend/access/transam/xlogutils.c
index e174a2a8919b78babd7fa8f431b514724d9d547c..43f7b31205def82397814635e4bd18631a2b9528 100644 (file)
--- a/src/backend/access/transam/xlogutils.c
+++ b/src/backend/access/transam/xlogutils.c
@@ -524,7 +524,7 @@ XLogReadBufferExtended(RelFileLocator rlocator, ForkNumber forknum,
        /* OK to extend the file */
        /* we do this in recovery only - no rel-extension lock needed */
        Assert(InRecovery);
-       buffer = ExtendBufferedRelTo(EB_SMGR(smgr, RELPERSISTENCE_PERMANENT),
+       buffer = ExtendBufferedRelTo(BMR_SMGR(smgr, RELPERSISTENCE_PERMANENT),
                                     forknum,
                                     NULL,
                                     EB_PERFORMING_RECOVERY |

diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c
index fc4f77e787e7aecc578519df339669afc803d161..ef1b8a92f25ede875e9edb50f0a122e2f342c0f3 100644 (file)
--- a/src/backend/commands/sequence.c
+++ b/src/backend/commands/sequence.c
@@ -377,7 +377,7 @@ fill_seq_fork_with_data(Relation rel, HeapTuple tuple, ForkNumber forkNum)
 
    /* Initialize first page of relation with special magic number */
 
-   buf = ExtendBufferedRel(EB_REL(rel), forkNum, NULL,
+   buf = ExtendBufferedRel(BMR_REL(rel), forkNum, NULL,
                            EB_LOCK_FIRST | EB_SKIP_EXTENSION_LOCK);
    Assert(BufferGetBlockNumber(buf) == 0);
 

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index df22aaa1c52a43aab888cd62afef97e7b838de7f..3bd82dbfca692784f288a9e140f7773a96825632 100644 (file)
--- 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);

diff --git a/src/backend/storage/buffer/localbuf.c b/src/backend/storage/buffer/localbuf.c
index f684862d98c085f115b16ff64dd3fecd3c994238..1735ec71419972bd126b204d502aa39dc75d5d39 100644 (file)
--- a/src/backend/storage/buffer/localbuf.c
+++ b/src/backend/storage/buffer/localbuf.c
@@ -308,7 +308,7 @@ LimitAdditionalLocalPins(uint32 *additional_pins)
  * temporary buffers.
  */
 BlockNumber
-ExtendBufferedRelLocal(ExtendBufferedWhat eb,
+ExtendBufferedRelLocal(BufferManagerRelation bmr,
                       ForkNumber fork,
                       uint32 flags,
                       uint32 extend_by,
@@ -338,7 +338,7 @@ ExtendBufferedRelLocal(ExtendBufferedWhat eb,
        MemSet((char *) buf_block, 0, BLCKSZ);
    }
 
-   first_block = smgrnblocks(eb.smgr, fork);
+   first_block = smgrnblocks(bmr.smgr, fork);
 
    if (extend_upto != InvalidBlockNumber)
    {
@@ -357,7 +357,7 @@ ExtendBufferedRelLocal(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)));
 
    for (int i = 0; i < extend_by; i++)
@@ -371,7 +371,7 @@ ExtendBufferedRelLocal(ExtendBufferedWhat eb,
        victim_buf_id = -buffers[i] - 1;
        victim_buf_hdr = GetLocalBufferDescriptor(victim_buf_id);
 
-       InitBufferTag(&tag, &eb.smgr->smgr_rlocator.locator, fork, first_block + i);
+       InitBufferTag(&tag, &bmr.smgr->smgr_rlocator.locator, fork, first_block + i);
 
        hresult = (LocalBufferLookupEnt *)
            hash_search(LocalBufHash, (void *) &tag, HASH_ENTER, &found);
@@ -411,7 +411,7 @@ ExtendBufferedRelLocal(ExtendBufferedWhat eb,
    io_start = pgstat_prepare_io_time();
 
    /* actually extend relation */
-   smgrzeroextend(eb.smgr, fork, first_block, extend_by, false);
+   smgrzeroextend(bmr.smgr, fork, first_block, extend_by, false);
 
    pgstat_count_io_op_time(IOOBJECT_TEMP_RELATION, IOCONTEXT_NORMAL, IOOP_EXTEND,
                            io_start, extend_by);

diff --git a/src/backend/storage/freespace/freespace.c b/src/backend/storage/freespace/freespace.c
index 2face615d07fa6b69dc01d2a4b12a52afa147440..fb9440ff72f1d2eb59921049b062a77da6886938 100644 (file)
--- a/src/backend/storage/freespace/freespace.c
+++ b/src/backend/storage/freespace/freespace.c
@@ -612,7 +612,7 @@ fsm_readbuf(Relation rel, FSMAddress addr, bool extend)
 static Buffer
 fsm_extend(Relation rel, BlockNumber fsm_nblocks)
 {
-   return ExtendBufferedRelTo(EB_REL(rel), FSM_FORKNUM, NULL,
+   return ExtendBufferedRelTo(BMR_REL(rel), FSM_FORKNUM, NULL,
                               EB_CREATE_FORK_IF_NEEDED |
                               EB_CLEAR_SIZE_CACHE,
                               fsm_nblocks,

diff --git a/src/include/storage/buf_internals.h b/src/include/storage/buf_internals.h
index 30807d5d97ea54530ebeeb2608404418df046425..bc79a329a1afb67627b471ffdfb30390b2896556 100644 (file)
--- a/src/include/storage/buf_internals.h
+++ b/src/include/storage/buf_internals.h
@@ -423,7 +423,7 @@ extern PrefetchBufferResult PrefetchLocalBuffer(SMgrRelation smgr,
                                                BlockNumber blockNum);
 extern BufferDesc *LocalBufferAlloc(SMgrRelation smgr, ForkNumber forkNum,
                                    BlockNumber blockNum, bool *foundPtr);
-extern BlockNumber ExtendBufferedRelLocal(ExtendBufferedWhat eb,
+extern BlockNumber ExtendBufferedRelLocal(BufferManagerRelation bmr,
                                          ForkNumber fork,
                                          uint32 flags,
                                          uint32 extend_by,

diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index 0f5fb6be00e0623d3ee583f029907b2d3d1c4e55..b379c76e2732e669e9d321b70bd480c68850e8ec 100644 (file)
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -92,19 +92,19 @@ typedef enum ExtendBufferedFlags
 }          ExtendBufferedFlags;
 
 /*
- * To identify the relation - either relation or smgr + relpersistence has to
- * be specified. Used via the EB_REL()/EB_SMGR() macros below. This allows us
- * to use the same function for both crash recovery and normal operation.
+ * Some functions identify relations either by relation or smgr +
+ * relpersistence.  Used via the BMR_REL()/BMR_SMGR() macros below.  This
+ * allows us to use the same function for both recovery and normal operation.
  */
-typedef struct ExtendBufferedWhat
+typedef struct BufferManagerRelation
 {
    Relation    rel;
    struct SMgrRelationData *smgr;
    char        relpersistence;
-} ExtendBufferedWhat;
+} BufferManagerRelation;
 
-#define EB_REL(p_rel) ((ExtendBufferedWhat){.rel = p_rel})
-#define EB_SMGR(p_smgr, p_relpersistence) ((ExtendBufferedWhat){.smgr = p_smgr, .relpersistence = p_relpersistence})
+#define BMR_REL(p_rel) ((BufferManagerRelation){.rel = p_rel})
+#define BMR_SMGR(p_smgr, p_relpersistence) ((BufferManagerRelation){.smgr = p_smgr, .relpersistence = p_relpersistence})
 
 
 /* forward declared, to avoid having to expose buf_internals.h here */
@@ -185,18 +185,18 @@ extern void CheckBufferIsPinnedOnce(Buffer buffer);
 extern Buffer ReleaseAndReadBuffer(Buffer buffer, Relation relation,
                                   BlockNumber blockNum);
 
-extern Buffer ExtendBufferedRel(ExtendBufferedWhat eb,
+extern Buffer ExtendBufferedRel(BufferManagerRelation bmr,
                                ForkNumber forkNum,
                                BufferAccessStrategy strategy,
                                uint32 flags);
-extern BlockNumber ExtendBufferedRelBy(ExtendBufferedWhat eb,
+extern BlockNumber ExtendBufferedRelBy(BufferManagerRelation bmr,
                                       ForkNumber fork,
                                       BufferAccessStrategy strategy,
                                       uint32 flags,
                                       uint32 extend_by,
                                       Buffer *buffers,
                                       uint32 *extended_by);
-extern Buffer ExtendBufferedRelTo(ExtendBufferedWhat eb,
+extern Buffer ExtendBufferedRelTo(BufferManagerRelation bmr,
                                  ForkNumber fork,
                                  BufferAccessStrategy strategy,
                                  uint32 flags,

diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 0acdcde8e652ff35b56d7ce92a00a62fc18e8284..49a33c0387463cb828f073d87bdfa74519ef3cb8 100644 (file)
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -319,6 +319,7 @@ BufferDesc
 BufferDescPadded
 BufferHeapTupleTableSlot
 BufferLookupEnt
+BufferManagerRelation
 BufferStrategyControl
 BufferTag
 BufferUsage
@@ -713,7 +714,6 @@ ExprEvalStep
 ExprSetupInfo
 ExprState
 ExprStateEvalFunc
-ExtendBufferedWhat
 ExtensibleNode
 ExtensibleNodeEntry
 ExtensibleNodeMethods