diff --git a/src/backend/catalog/storage.c b/src/backend/catalog/storage.c index 9a5fde0..68decab 100644 --- a/src/backend/catalog/storage.c +++ b/src/backend/catalog/storage.c @@ -31,6 +31,9 @@ #include "storage/smgr.h" #include "utils/memutils.h" #include "utils/rel.h" +#include "storage/lmgr.h" +#include "storage/procarray.h" +#include "access/transam.h" /* * We keep a list of all relations (represented as RelFileNode values) @@ -498,50 +501,56 @@ smgr_redo(XLogReaderState *record) reln = smgropen(xlrec->rnode, InvalidBackendId); - /* - * Forcibly create relation if it doesn't exist (which suggests that - * it was dropped somewhere later in the WAL sequence). As in - * XLogReadBufferForRedo, we prefer to recreate the rel and replay the - * log as best we can until the drop is seen. - */ - smgrcreate(reln, MAIN_FORKNUM, true); - - /* - * Before we perform the truncation, update minimum recovery point to - * cover this WAL record. Once the relation is truncated, there's no - * going back. The buffer manager enforces the WAL-first rule for - * normal updates to relation files, so that the minimum recovery - * point is always updated before the corresponding change in the data - * file is flushed to disk. We have to do the same manually here. - * - * Doing this before the truncation means that if the truncation fails - * for some reason, you cannot start up the system even after restart, - * until you fix the underlying situation so that the truncation will - * succeed. Alternatively, we could update the minimum recovery point - * after truncation, but that would leave a small window where the - * WAL-first rule could be violated. - */ - XLogFlush(lsn); - - if ((xlrec->flags & SMGR_TRUNCATE_HEAP) != 0) + if (!ConditionalLockRelationOid(reln->smgr_rnode.node.relNode, AccessExclusiveLock)) { - smgrtruncate(reln, MAIN_FORKNUM, xlrec->blkno); + /* + * Forcibly create relation if it doesn't exist (which suggests that + * it was dropped somewhere later in the WAL sequence). As in + * XLogReadBufferForRedo, we prefer to recreate the rel and replay the + * log as best we can until the drop is seen. + */ + smgrcreate(reln, MAIN_FORKNUM, true); + + /* + * Before we perform the truncation, update minimum recovery point to + * cover this WAL record. Once the relation is truncated, there's no + * going back. The buffer manager enforces the WAL-first rule for + * normal updates to relation files, so that the minimum recovery + * point is always updated before the corresponding change in the data + * file is flushed to disk. We have to do the same manually here. + * + * Doing this before the truncation means that if the truncation fails + * for some reason, you cannot start up the system even after restart, + * until you fix the underlying situation so that the truncation will + * succeed. Alternatively, we could update the minimum recovery point + * after truncation, but that would leave a small window where the + * WAL-first rule could be violated. + */ + XLogFlush(lsn); - /* Also tell xlogutils.c about it */ - XLogTruncateRelation(xlrec->rnode, MAIN_FORKNUM, xlrec->blkno); - } + if ((xlrec->flags & SMGR_TRUNCATE_HEAP) != 0) + { + smgrtruncate(reln, MAIN_FORKNUM, xlrec->blkno); + + /* Also tell xlogutils.c about it */ + XLogTruncateRelation(xlrec->rnode, MAIN_FORKNUM, xlrec->blkno); + } - /* Truncate FSM and VM too */ - rel = CreateFakeRelcacheEntry(xlrec->rnode); + /* Truncate FSM and VM too */ + rel = CreateFakeRelcacheEntry(xlrec->rnode); - if ((xlrec->flags & SMGR_TRUNCATE_FSM) != 0 && - smgrexists(reln, FSM_FORKNUM)) - FreeSpaceMapTruncateRel(rel, xlrec->blkno); - if ((xlrec->flags & SMGR_TRUNCATE_VM) != 0 && - smgrexists(reln, VISIBILITYMAP_FORKNUM)) - visibilitymap_truncate(rel, xlrec->blkno); + if ((xlrec->flags & SMGR_TRUNCATE_FSM) != 0 && + smgrexists(reln, FSM_FORKNUM)) + FreeSpaceMapTruncateRel(rel, xlrec->blkno); + if ((xlrec->flags & SMGR_TRUNCATE_VM) != 0 && + smgrexists(reln, VISIBILITYMAP_FORKNUM)) + visibilitymap_truncate(rel, xlrec->blkno); - FreeFakeRelcacheEntry(rel); + FreeFakeRelcacheEntry(rel); + } else + { + XLogFlush(lsn); + } } else elog(PANIC, "smgr_redo: unknown op code %u", info); diff --git a/src/backend/commands/vacuumlazy.c b/src/backend/commands/vacuumlazy.c index 45b1859..487b079 100644 --- a/src/backend/commands/vacuumlazy.c +++ b/src/backend/commands/vacuumlazy.c @@ -61,6 +61,8 @@ #include "utils/pg_rusage.h" #include "utils/timestamp.h" #include "utils/tqual.h" +#include "catalog/storage_xlog.h" +#include "access/rmgr.h" /* @@ -281,6 +283,31 @@ lazy_vacuum_rel(Relation onerel, int options, VacuumParams *params, */ if (should_attempt_truncation(vacrelstats)) lazy_truncate_heap(onerel, vacrelstats); + else + { + if (RelationNeedsWAL(onerel)) + { + /* + * Make an XLOG entry reporting the file truncation. + */ + XLogRecPtr lsn; + xl_smgr_truncate xlrec; + + /* Get the current relation length */ + LockRelationForExtension(onerel, ExclusiveLock); + + xlrec.blkno = vacrelstats->rel_pages; + xlrec.rnode = onerel->rd_node; + + XLogBeginInsert(); + XLogRegisterData((char *) &xlrec, sizeof(xlrec)); + + lsn = XLogInsert(RM_SMGR_ID, + XLOG_SMGR_TRUNCATE | XLR_SPECIAL_REL_UPDATE); + UnlockRelationForExtension(onerel, ExclusiveLock); + XLogFlush(lsn); + } + } /* Report that we are now doing final cleanup */ pgstat_progress_update_param(PROGRESS_VACUUM_PHASE, diff --git a/src/backend/storage/ipc/standby.c b/src/backend/storage/ipc/standby.c index d491ece..6f952bf 100644 --- a/src/backend/storage/ipc/standby.c +++ b/src/backend/storage/ipc/standby.c @@ -624,7 +624,7 @@ StandbyAcquireAccessExclusiveLock(TransactionId xid, Oid dbOid, Oid relOid) SET_LOCKTAG_RELATION(locktag, newlock->dbOid, newlock->relOid); - LockAcquireExtended(&locktag, AccessExclusiveLock, true, false, false); + LockAcquireExtended(&locktag, AccessExclusiveLock, true, false, false, true); } static void diff --git a/src/backend/storage/lmgr/lmgr.c b/src/backend/storage/lmgr/lmgr.c index fe98898..e960b26 100644 --- a/src/backend/storage/lmgr/lmgr.c +++ b/src/backend/storage/lmgr/lmgr.c @@ -232,7 +231,7 @@ ConditionalLockRelation(Relation relation, LOCKMODE lockmode) relation->rd_lockInfo.lockRelId.dbId, relation->rd_lockInfo.lockRelId.relId); - res = LockAcquire(&tag, lockmode, false, true); + res = LockAcquireExtended(&tag, lockmode, false, true, true, false); if (res == LOCKACQUIRE_NOT_AVAIL) return false; diff --git a/src/backend/storage/lmgr/lock.c b/src/backend/storage/lmgr/lock.c index 2b26173..40d390a 100644 --- a/src/backend/storage/lmgr/lock.c +++ b/src/backend/storage/lmgr/lock.c @@ -49,6 +49,8 @@ #include "utils/ps_status.h" #include "utils/resowner_private.h" +#include +#include /* This configuration variable is used to set the lock table size */ int max_locks_per_xact; /* set by guc.c */ @@ -685,7 +686,7 @@ LockAcquire(const LOCKTAG *locktag, bool sessionLock, bool dontWait) { - return LockAcquireExtended(locktag, lockmode, sessionLock, dontWait, true); + return LockAcquireExtended(locktag, lockmode, sessionLock, dontWait, true, true); } /* @@ -702,7 +703,8 @@ LockAcquireExtended(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock, bool dontWait, - bool reportMemoryError) + bool reportMemoryError, + bool walStandby) { LOCKMETHODID lockmethodid = locktag->locktag_lockmethodid; LockMethod lockMethodTable; @@ -813,7 +816,8 @@ LockAcquireExtended(const LOCKTAG *locktag, if (lockmode >= AccessExclusiveLock && locktag->locktag_type == LOCKTAG_RELATION && !RecoveryInProgress() && - XLogStandbyInfoActive()) + XLogStandbyInfoActive() && + walStandby) { LogAccessExclusiveLockPrepare(); log_lock = true; diff --git a/src/include/storage/lock.h b/src/include/storage/lock.h index 765431e..258b707 100644 --- a/src/include/storage/lock.h +++ b/src/include/storage/lock.h @@ -528,7 +528,8 @@ extern LockAcquireResult LockAcquireExtended(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock, bool dontWait, - bool report_memory_error); + bool report_memory_error, + bool walStandby); extern void AbortStrongLockAcquire(void); extern bool LockRelease(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock);