diff --git a/src/backend/access/nbtree/nbtxlog.c b/src/backend/access/nbtree/nbtxlog.c index 5f9fc49..dc90c02 100644 --- a/src/backend/access/nbtree/nbtxlog.c +++ b/src/backend/access/nbtree/nbtxlog.c @@ -501,33 +501,9 @@ btree_xlog_vacuum(XLogRecPtr lsn, XLogRecord *record) * here during crash recovery. */ if (HotStandbyActiveInReplay()) - { - BlockNumber blkno; - - for (blkno = xlrec->lastBlockVacuumed + 1; blkno < xlrec->block; blkno++) - { - /* - * We use RBM_NORMAL_NO_LOG mode because it's not an error - * condition to see all-zero pages. The original btvacuumpage - * scan would have skipped over all-zero pages, noting them in FSM - * but not bothering to initialize them just yet; so we mustn't - * throw an error here. (We could skip acquiring the cleanup lock - * if PageIsNew, but it's probably not worth the cycles to test.) - * - * XXX we don't actually need to read the block, we just need to - * confirm it is unpinned. If we had a special call into the - * buffer manager we could optimise this so that if the block is - * not in shared_buffers we confirm it as unpinned. - */ - buffer = XLogReadBufferExtended(xlrec->node, MAIN_FORKNUM, blkno, - RBM_NORMAL_NO_LOG); - if (BufferIsValid(buffer)) - { - LockBufferForCleanup(buffer); - UnlockReleaseBuffer(buffer); - } - } - } + XLogLockBlockRangeForCleanup(xlrec->node, MAIN_FORKNUM, + xlrec->lastBlockVacuumed + 1, + xlrec->block); /* * If we have a full-page image, restore it (using a cleanup lock) and diff --git a/src/backend/access/transam/xlogutils.c b/src/backend/access/transam/xlogutils.c index b7829ff..302551f 100644 --- a/src/backend/access/transam/xlogutils.c +++ b/src/backend/access/transam/xlogutils.c @@ -287,10 +287,6 @@ XLogReadBuffer(RelFileNode rnode, BlockNumber blkno, bool init) * * In RBM_ZERO and RBM_ZERO_ON_ERROR modes, if the page doesn't exist, the * relation is extended with all-zeroes pages up to the given block number. - * - * In RBM_NORMAL_NO_LOG mode, we return InvalidBuffer if the page doesn't - * exist, and we don't check for all-zeroes. Thus, no log entry is made - * to imply that the page should be dropped or truncated later. */ Buffer XLogReadBufferExtended(RelFileNode rnode, ForkNumber forknum, @@ -331,8 +327,6 @@ XLogReadBufferExtended(RelFileNode rnode, ForkNumber forknum, log_invalid_page(rnode, forknum, blkno, false); return InvalidBuffer; } - if (mode == RBM_NORMAL_NO_LOG) - return InvalidBuffer; /* OK to extend the file */ /* we do this in recovery only - no rel-extension lock needed */ Assert(InRecovery); @@ -375,6 +369,73 @@ XLogReadBufferExtended(RelFileNode rnode, ForkNumber forknum, return buffer; } +/* + * XLogBlockRangeForCleanup is used in Hot Standby mode to emulate the + * locking effects imposed by VACUUM for nbtrees. + */ +void +XLogLockBlockRangeForCleanup(RelFileNode rnode, ForkNumber forkNum, + BlockNumber startBlkno, + BlockNumber uptoBlkno) +{ + BlockNumber blkno; + BlockNumber lastblock; + BlockNumber endingBlkno; + Buffer buffer; + BufferAccessStrategy bstrategy; + SMgrRelation smgr; + + Assert(startBlkno != P_NEW); + Assert(uptoBlkno != P_NEW); + + /* Open the relation at smgr level */ + smgr = smgropen(rnode, InvalidBackendId); + + /* + * Create the target file if it doesn't already exist. This lets us cope + * if the replay sequence contains writes to a relation that is later + * deleted. (The original coding of this routine would instead suppress + * the writes, but that seems like it risks losing valuable data if the + * filesystem loses an inode during a crash. Better to write the data + * until we are actually told to delete the file.) + */ + smgrcreate(smgr, forkNum, true); + + lastblock = smgrnblocks(smgr, forkNum); + + endingBlkno = uptoBlkno; + if (lastblock < endingBlkno) + endingBlkno = lastblock; + + /* + * We need to use a BufferAccessStrategy because we do not want to + * increment the buffer's usage_count as we read them. However, + * there is no ring buffer associated with this strategy, since we + * never actually read or write the contents, just lock them. + */ + bstrategy = GetAccessStrategy(BAS_DISCARD); + + for (blkno = startBlkno; blkno < endingBlkno; blkno++) + { + /* + * All we need to do here is prove that we can lock each block + * with a cleanup lock. It's not an error to see all-zero pages + * here because the original btvacuumpage would not have thrown + * an error either. + * + * We don't actually need to read the block, we just need to + * confirm it is unpinned. + */ + buffer = GetBufferWithoutRelcache(rnode, forkNum, blkno, bstrategy); + if (BufferIsValid(buffer)) + { + LockBufferForCleanup(buffer); + UnlockReleaseBuffer(buffer); + } + } + + FreeAccessStrategy(bstrategy); +} /* * Struct actually returned by XLogFakeRelcacheEntry, though the declared diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c index c070278..2c8d374 100644 --- a/src/backend/storage/buffer/bufmgr.c +++ b/src/backend/storage/buffer/bufmgr.c @@ -221,8 +221,6 @@ ReadBuffer(Relation reln, BlockNumber blockNum) * current physical EOF; that is likely to cause problems in md.c when * the page is modified and written out. P_NEW is OK, though. * - * RBM_NORMAL_NO_LOG mode is treated the same as RBM_NORMAL here. - * * If strategy is not NULL, a nondefault buffer access strategy is used. * See buffer/README for details. */ @@ -283,6 +281,54 @@ ReadBufferWithoutRelcache(RelFileNode rnode, ForkNumber forkNum, mode, strategy, &hit); } +/* + * GetBufferWithoutRelcache returns Buffer iff available in shared_buffers, + * otherwise returns InvalidBuffer. Buffer is pinned, if available. + * + * Special purpose routine only executed during recovery, so uses a cut-down + * execution path rather than complicate ReadBuffer/AllocBuffer. + */ +Buffer +GetBufferWithoutRelcache(RelFileNode rnode, ForkNumber forkNum, + BlockNumber blockNum, BufferAccessStrategy strategy) +{ + BufferTag bufTag; /* identity of requested block */ + uint32 bufHash; /* hash value for newTag */ + LWLock *bufPartitionLock; /* buffer partition lock for it */ + int buf_id; + volatile BufferDesc *buf; + SMgrRelation smgr = smgropen(rnode, InvalidBackendId); + bool valid = false; + + Assert(InRecovery); + + /* Make sure we will have room to remember the buffer pin */ + ResourceOwnerEnlargeBuffers(CurrentResourceOwner); + + /* create a tag so we can lookup the buffer */ + INIT_BUFFERTAG(bufTag, smgr->smgr_rnode.node, forkNum, blockNum); + + /* determine its hash code and partition lock ID */ + bufHash = BufTableHashCode(&bufTag); + bufPartitionLock = BufMappingPartitionLock(bufHash); + + /* see if the block is in the buffer pool already */ + LWLockAcquire(bufPartitionLock, LW_SHARED); + buf_id = BufTableLookup(&bufTag, bufHash); + if (buf_id >= 0) + { + /* Found it. Now, try to pin the buffer. */ + buf = &BufferDescriptors[buf_id]; + + valid = PinBuffer(buf, strategy); + } + LWLockRelease(bufPartitionLock); + + if (valid) + return BufferDescriptorGetBuffer(&BufferDescriptors[buf_id]); + + return InvalidBuffer; +} /* * ReadBuffer_common -- common logic for all ReadBuffer variants @@ -1076,12 +1122,7 @@ ReleaseAndReadBuffer(Buffer buffer, * PinBuffer -- make buffer unavailable for replacement. * * For the default access strategy, the buffer's usage_count is incremented - * when we first pin it; for other strategies we just make sure the usage_count - * isn't zero. (The idea of the latter is that we don't want synchronized - * heap scans to inflate the count, but we need it to not be zero to discourage - * other backends from stealing buffers from our ring. As long as we cycle - * through the ring faster than the global clock-sweep cycles, buffers in - * our ring won't be chosen as victims for replacement by other backends.) + * when we first pin it; otherwise we let the Strategy decide what to do. * * This should be applied only to shared buffers, never local ones. * @@ -1106,10 +1147,7 @@ PinBuffer(volatile BufferDesc *buf, BufferAccessStrategy strategy) buf->usage_count++; } else - { - if (buf->usage_count == 0) - buf->usage_count = 1; - } + StrategySetBufferUsage(strategy, buf); result = (buf->flags & BM_VALID) != 0; UnlockBufHdr(buf); } diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 4befab0..c7daf47 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -76,6 +76,11 @@ typedef struct BufferAccessStrategyData bool current_was_in_ring; /* + * How we handle usage_count for this strategy. + */ + bool increment_on_zero; + + /* * Array of buffer numbers. InvalidBuffer (that is, zero) indicates we * have not yet selected a buffer for this ring slot. For allocation * simplicity this is palloc'd together with the fixed fields of the @@ -408,6 +413,7 @@ GetAccessStrategy(BufferAccessStrategyType btype) { BufferAccessStrategy strategy; int ring_size; + bool increment_on_zero = true; /* * Select ring size to use. See buffer/README for rationales. @@ -430,6 +436,10 @@ GetAccessStrategy(BufferAccessStrategyType btype) case BAS_VACUUM: ring_size = 256 * 1024 / BLCKSZ; break; + case BAS_DISCARD: + ring_size = 0; /* We musn't ever call GetBufferFromRing() */ + increment_on_zero = false; + break; default: elog(ERROR, "unrecognized buffer access strategy: %d", @@ -437,8 +447,9 @@ GetAccessStrategy(BufferAccessStrategyType btype) return NULL; /* keep compiler quiet */ } - /* Make sure ring isn't an undue fraction of shared buffers */ - ring_size = Min(NBuffers / 8, ring_size); + if (ring_size > 0) + /* Make sure ring isn't an undue fraction of shared buffers */ + ring_size = Min(NBuffers / 8, ring_size); /* Allocate the object and initialize all elements to zeroes */ strategy = (BufferAccessStrategy) @@ -448,6 +459,7 @@ GetAccessStrategy(BufferAccessStrategyType btype) /* Set fields that don't start out zero */ strategy->btype = btype; strategy->ring_size = ring_size; + strategy->increment_on_zero = increment_on_zero; return strategy; } @@ -478,6 +490,8 @@ GetBufferFromRing(BufferAccessStrategy strategy) volatile BufferDesc *buf; Buffer bufnum; + Assert(strategy->ring_size > 0); + /* Advance to next ring slot */ if (++strategy->current >= strategy->ring_size) strategy->current = 0; @@ -563,3 +577,22 @@ StrategyRejectBuffer(BufferAccessStrategy strategy, volatile BufferDesc *buf) return true; } + +/* + * Set the usage_count according to the strategy + * + * We just make sure the usage_count isn't zero. (We don't want + * synchronized heap scans to inflate the count, but we need it to not + * be zero to discourage other backends from stealing buffers from our + * ring. As long as we cycle through the ring faster than the global + * clock-sweep cycles, buffers in our ring won't be chosen as victims + * for replacement by other backends.) + * + * Called while holding buffer header spinlock, so make it quick. + */ +void +StrategySetBufferUsage(BufferAccessStrategy strategy, volatile BufferDesc *buf) +{ + if (buf->usage_count == 0 && strategy->increment_on_zero) + buf->usage_count = 1; +} diff --git a/src/include/access/xlogutils.h b/src/include/access/xlogutils.h index 58f11d9..1ecbeb3 100644 --- a/src/include/access/xlogutils.h +++ b/src/include/access/xlogutils.h @@ -25,7 +25,9 @@ extern void XLogTruncateRelation(RelFileNode rnode, ForkNumber forkNum, extern Buffer XLogReadBuffer(RelFileNode rnode, BlockNumber blkno, bool init); extern Buffer XLogReadBufferExtended(RelFileNode rnode, ForkNumber forknum, BlockNumber blkno, ReadBufferMode mode); - +extern void XLogLockBlockRangeForCleanup(RelFileNode rnode, ForkNumber forkNum, + BlockNumber startBlkno, + BlockNumber uptoBlkno); extern Relation CreateFakeRelcacheEntry(RelFileNode rnode); extern void FreeFakeRelcacheEntry(Relation fakerel); diff --git a/src/include/storage/buf_internals.h b/src/include/storage/buf_internals.h index c019013..720db12 100644 --- a/src/include/storage/buf_internals.h +++ b/src/include/storage/buf_internals.h @@ -190,6 +190,8 @@ extern volatile BufferDesc *StrategyGetBuffer(BufferAccessStrategy strategy, extern void StrategyFreeBuffer(volatile BufferDesc *buf); extern bool StrategyRejectBuffer(BufferAccessStrategy strategy, volatile BufferDesc *buf); +extern void StrategySetBufferUsage(BufferAccessStrategy strategy, + volatile BufferDesc *buf); extern int StrategySyncStart(uint32 *complete_passes, uint32 *num_buf_alloc); extern void StrategyNotifyBgWriter(Latch *bgwriterLatch); diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h index 89447d0..bdba547 100644 --- a/src/include/storage/bufmgr.h +++ b/src/include/storage/bufmgr.h @@ -29,7 +29,8 @@ typedef enum BufferAccessStrategyType BAS_BULKREAD, /* Large read-only scan (hint bit updates are * ok) */ BAS_BULKWRITE, /* Large multi-block write (e.g. COPY IN) */ - BAS_VACUUM /* VACUUM */ + BAS_VACUUM, /* VACUUM */ + BAS_DISCARD /* DISCARD can only be used with GetBuffersWithoutRelcache() */ } BufferAccessStrategyType; /* Possible modes for ReadBufferExtended() */ @@ -38,9 +39,7 @@ typedef enum RBM_NORMAL, /* Normal read */ RBM_ZERO, /* Don't read from disk, caller will * initialize */ - RBM_ZERO_ON_ERROR, /* Read, but return an all-zeros page on error */ - RBM_NORMAL_NO_LOG /* Don't log page as invalid during WAL - * replay; otherwise same as RBM_NORMAL */ + RBM_ZERO_ON_ERROR /* Read, but return an all-zeros page on error */ } ReadBufferMode; /* in globals.c ... this duplicates miscadmin.h */ @@ -170,6 +169,9 @@ extern Buffer ReadBufferExtended(Relation reln, ForkNumber forkNum, extern Buffer ReadBufferWithoutRelcache(RelFileNode rnode, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, BufferAccessStrategy strategy); +extern Buffer GetBufferWithoutRelcache(RelFileNode rnode, ForkNumber forkNum, + BlockNumber blockNum, + BufferAccessStrategy strategy); extern void ReleaseBuffer(Buffer buffer); extern void UnlockReleaseBuffer(Buffer buffer); extern void MarkBufferDirty(Buffer buffer);