From 23e23dd4c0b1c4c69021a4f2bf95586f39d8bd1f Mon Sep 17 00:00:00 2001 From: Mikhail Litsarev Date: Mon, 6 May 2024 15:23:52 +0300 Subject: [PATCH] Replace recovery boolean flags with a bits32 set. Replace local and shared-memory flags (Local/Shared)HotStandbyActive, (Local/Shared)PromoteIsTriggered with corresponding (Local/Shared)RecoveryDataFlags. Introduce XLR_STANDBY_MODE_REQUESTED state which indicates that a node is in a standby mode at start, while recovery mode is on (standby.signal file was found at start up). --- src/backend/access/transam/xlogrecovery.c | 89 ++++++++++++++--------- src/include/access/xlogrecovery.h | 21 ++++++ 2 files changed, 76 insertions(+), 34 deletions(-) diff --git a/src/backend/access/transam/xlogrecovery.c b/src/backend/access/transam/xlogrecovery.c index b45b8331720..de92f48e4ae 100644 --- a/src/backend/access/transam/xlogrecovery.c +++ b/src/backend/access/transam/xlogrecovery.c @@ -170,16 +170,22 @@ static XLogRecPtr RedoStartLSN = InvalidXLogRecPtr; static TimeLineID RedoStartTLI = 0; /* - * Local copy of SharedHotStandbyActive variable. False actually means "not - * known, need to check the shared state". - */ -static bool LocalHotStandbyActive = false; - -/* - * Local copy of SharedPromoteIsTriggered variable. False actually means "not - * known, need to check the shared state". + * This bit array is introduced to keep the local copies of RecoveryDataFlags + * in corresponding SharedRecoveryDataFlags bitset. + * + * Currently it provides the following states: + * + * -- Local copy of XLR_HOT_STANDBY_ACTIVE flag. False actually means "not + * known, need to check the shared state. + * + * -- Local copy of XLR_PROMOTE_IS_TRIGGERED flag. False actually means "not + * known, need to check the shared state". + * + * -- XLR_STANDBY_MODE_REQUESTED is not mirrored here. + * + * This bitset can be extended in future. */ -static bool LocalPromoteIsTriggered = false; +static bits32 LocalRecoveryDataFlags; /* Has the recovery code requested a walreceiver wakeup? */ static bool doRequestWalReceiverReply; @@ -297,23 +303,26 @@ bool reachedConsistency = false; static char *replay_image_masked = NULL; static char *primary_image_masked = NULL; - /* * Shared-memory state for WAL recovery. */ typedef struct XLogRecoveryCtlData { /* - * SharedHotStandbyActive indicates if we allow hot standby queries to be - * run. Protected by info_lck. - */ - bool SharedHotStandbyActive; - - /* - * SharedPromoteIsTriggered indicates if a standby promotion has been - * triggered. Protected by info_lck. + * This bit array is introduced to keep the following states: + * + * -- XLR_HOT_STANDBY_ACTIVE indicates if we allow hot standby queries + * to be run. Protected by info_lck. + * + * -- XLR_PROMOTE_IS_TRIGGERED indicates if a standby promotion + * has been triggered. Protected by info_lck. + * + * -- XLR_STANDBY_MODE_REQUESTED indicates if we're in a standby mode + * at start, while recovery mode is on. No info_lck protection. + * + * and can be extended in future. */ - bool SharedPromoteIsTriggered; + bits32 SharedRecoveryDataFlags; /* * recoveryWakeupLatch is used to wake up the startup process to continue @@ -1082,10 +1091,17 @@ readRecoverySignalFile(void) StandbyModeRequested = false; ArchiveRecoveryRequested = false; + /* + * There is no need to use Spinlock here because only the startup + * process modifies the SharedRecoveryDataFlags bit here and + * no other processes are reading it at that time. + */ + XLogRecoveryCtl->SharedRecoveryDataFlags &= ~XLR_STANDBY_MODE_REQUESTED; if (standby_signal_file_found) { StandbyModeRequested = true; ArchiveRecoveryRequested = true; + XLogRecoveryCtl->SharedRecoveryDataFlags |= XLR_STANDBY_MODE_REQUESTED; } else if (recovery_signal_file_found) { @@ -2254,15 +2270,15 @@ CheckRecoveryConsistency(void) * enabling connections. */ if (standbyState == STANDBY_SNAPSHOT_READY && - !LocalHotStandbyActive && + !(LocalRecoveryDataFlags & XLR_HOT_STANDBY_ACTIVE) && reachedConsistency && IsUnderPostmaster) { SpinLockAcquire(&XLogRecoveryCtl->info_lck); - XLogRecoveryCtl->SharedHotStandbyActive = true; + XLogRecoveryCtl->SharedRecoveryDataFlags |= XLR_HOT_STANDBY_ACTIVE; SpinLockRelease(&XLogRecoveryCtl->info_lck); - LocalHotStandbyActive = true; + LocalRecoveryDataFlags |= XLR_HOT_STANDBY_ACTIVE; SendPostmasterSignal(PMSIGNAL_BEGIN_HOT_STANDBY); } @@ -2925,11 +2941,11 @@ static void recoveryPausesHere(bool endOfRecovery) { /* Don't pause unless users can connect! */ - if (!LocalHotStandbyActive) + if (!(LocalRecoveryDataFlags & XLR_HOT_STANDBY_ACTIVE)) return; /* Don't pause after standby promotion has been triggered */ - if (LocalPromoteIsTriggered) + if (LocalRecoveryDataFlags & XLR_PROMOTE_IS_TRIGGERED) return; if (endOfRecovery) @@ -4398,21 +4414,23 @@ PromoteIsTriggered(void) * triggered. We can't trigger a promotion again, so there's no need to * keep checking after the shared variable has once been seen true. */ - if (LocalPromoteIsTriggered) + if (LocalRecoveryDataFlags & XLR_PROMOTE_IS_TRIGGERED) return true; SpinLockAcquire(&XLogRecoveryCtl->info_lck); - LocalPromoteIsTriggered = XLogRecoveryCtl->SharedPromoteIsTriggered; + LocalRecoveryDataFlags &= ~XLR_PROMOTE_IS_TRIGGERED; + LocalRecoveryDataFlags |= + (XLogRecoveryCtl->SharedRecoveryDataFlags & XLR_PROMOTE_IS_TRIGGERED); SpinLockRelease(&XLogRecoveryCtl->info_lck); - return LocalPromoteIsTriggered; + return (LocalRecoveryDataFlags & XLR_PROMOTE_IS_TRIGGERED); } static void SetPromoteIsTriggered(void) { SpinLockAcquire(&XLogRecoveryCtl->info_lck); - XLogRecoveryCtl->SharedPromoteIsTriggered = true; + XLogRecoveryCtl->SharedRecoveryDataFlags |= XLR_PROMOTE_IS_TRIGGERED; SpinLockRelease(&XLogRecoveryCtl->info_lck); /* @@ -4423,7 +4441,7 @@ SetPromoteIsTriggered(void) */ SetRecoveryPause(false); - LocalPromoteIsTriggered = true; + LocalRecoveryDataFlags |= XLR_PROMOTE_IS_TRIGGERED; } /* @@ -4432,7 +4450,7 @@ SetPromoteIsTriggered(void) static bool CheckForStandbyTrigger(void) { - if (LocalPromoteIsTriggered) + if (LocalRecoveryDataFlags & XLR_PROMOTE_IS_TRIGGERED) return true; if (IsPromoteSignaled() && CheckPromoteSignal()) @@ -4506,16 +4524,18 @@ HotStandbyActive(void) * can't de-activate Hot Standby, so there's no need to keep checking * after the shared variable has once been seen true. */ - if (LocalHotStandbyActive) + if (LocalRecoveryDataFlags & XLR_HOT_STANDBY_ACTIVE) return true; else { /* spinlock is essential on machines with weak memory ordering! */ SpinLockAcquire(&XLogRecoveryCtl->info_lck); - LocalHotStandbyActive = XLogRecoveryCtl->SharedHotStandbyActive; + LocalRecoveryDataFlags &= ~XLR_HOT_STANDBY_ACTIVE; + LocalRecoveryDataFlags |= + (XLogRecoveryCtl->SharedRecoveryDataFlags & XLR_HOT_STANDBY_ACTIVE); SpinLockRelease(&XLogRecoveryCtl->info_lck); - return LocalHotStandbyActive; + return LocalRecoveryDataFlags & XLR_HOT_STANDBY_ACTIVE; } } @@ -4527,7 +4547,8 @@ static bool HotStandbyActiveInReplay(void) { Assert(AmStartupProcess() || !IsPostmasterEnvironment); - return LocalHotStandbyActive; + + return (LocalRecoveryDataFlags & XLR_HOT_STANDBY_ACTIVE); } /* diff --git a/src/include/access/xlogrecovery.h b/src/include/access/xlogrecovery.h index c423464e8bc..2cb56fc365f 100644 --- a/src/include/access/xlogrecovery.h +++ b/src/include/access/xlogrecovery.h @@ -16,6 +16,27 @@ #include "lib/stringinfo.h" #include "utils/timestamp.h" +/* + * The flag indicates if we allow hot standby queries to be run. + * Protected by info_lck. + */ +#define XLR_HOT_STANDBY_ACTIVE 0x01 +/* + * The flag indicates if a standby promotion has been triggered. + * Protected by info_lck. + */ +#define XLR_PROMOTE_IS_TRIGGERED 0x02 +/* + * The flag indicates if we're in a standby mode at start, + * while recovery mode is on. + * It is introduced to distinguish a replica from a regular instance + * in a Point In Time Recovery (PITR) mode. + * + * It is selected if standby.signal file is found at startup process + * It is skipped otherwise. + */ +#define XLR_STANDBY_MODE_REQUESTED 0x04 + /* * Recovery target type. * Only set during a Point in Time recovery, not when in standby mode. -- 2.34.1