From 2c0d3b38d31f65edd7c50910770ea5e502c08ea6 Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Wed, 18 Dec 2024 12:03:49 +0200 Subject: [PATCH v10 08/14] Remove code to deal with old 9.3 and 9.3 era broken clusters Now that pg_upgrade will rewrite the SLRUs, we know the correct oldest member offset. XXX: is that correct? --- src/backend/access/transam/multixact.c | 99 ++++---------------------- 1 file changed, 15 insertions(+), 84 deletions(-) diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c index 651766a4935..25fca431937 100644 --- a/src/backend/access/transam/multixact.c +++ b/src/backend/access/transam/multixact.c @@ -243,11 +243,9 @@ typedef struct MultiXactStateData /* * Oldest multixact offset that is potentially referenced by a multixact - * referenced by a relation. We don't always know this value, so there's - * a flag here to indicate whether or not we currently do. + * referenced by a relation. */ MultiXactOffset oldestOffset; - bool oldestOffsetKnown; /* support for anti-wraparound measures */ MultiXactId multiVacLimit; @@ -390,7 +388,7 @@ static bool MultiXactOffsetPrecedes(MultiXactOffset offset1, static void ExtendMultiXactOffset(MultiXactId multi); static void ExtendMultiXactMember(MultiXactOffset offset, int nmembers); static bool SetOffsetVacuumLimit(bool is_startup); -static bool find_multixact_start(MultiXactId multi, MultiXactOffset *result); +static MultiXactOffset find_multixact_start(MultiXactId multi); static void WriteMZeroPageXlogRec(int64 pageno, uint8 info); static void WriteMTruncateXlogRec(Oid oldestMultiDB, MultiXactId startTruncOff, @@ -2599,10 +2597,7 @@ SetOffsetVacuumLimit(bool is_startup) MultiXactId oldestMultiXactId; MultiXactId nextMXact; MultiXactOffset oldestOffset = 0; /* placate compiler */ - MultiXactOffset prevOldestOffset; MultiXactOffset nextOffset; - bool oldestOffsetKnown = false; - bool prevOldestOffsetKnown; /* * NB: Have to prevent concurrent truncation, we might otherwise try to @@ -2615,8 +2610,6 @@ SetOffsetVacuumLimit(bool is_startup) oldestMultiXactId = MultiXactState->oldestMultiXactId; nextMXact = MultiXactState->nextMXact; nextOffset = MultiXactState->nextOffset; - prevOldestOffsetKnown = MultiXactState->oldestOffsetKnown; - prevOldestOffset = MultiXactState->oldestOffset; Assert(MultiXactState->finishedStartup); LWLockRelease(MultiXactGenLock); @@ -2634,68 +2627,31 @@ SetOffsetVacuumLimit(bool is_startup) * offset. */ oldestOffset = nextOffset; - oldestOffsetKnown = true; } else - { - /* - * Figure out where the oldest existing multixact's offsets are - * stored. Due to bugs in early release of PostgreSQL 9.3.X and 9.4.X, - * the supposedly-earliest multixact might not really exist. We are - * careful not to fail in that case. - */ - oldestOffsetKnown = - find_multixact_start(oldestMultiXactId, &oldestOffset); - - if (!oldestOffsetKnown) - ereport(LOG, - (errmsg("MultiXact member wraparound protections are disabled because oldest checkpointed MultiXact %u does not exist on disk", - oldestMultiXactId))); - } + oldestOffset = find_multixact_start(oldestMultiXactId); LWLockRelease(MultiXactTruncationLock); - /* - * If we can, compute limits (and install them MultiXactState) to prevent - * overrun of old data in the members SLRU area. We can only do so if the - * oldest offset is known though. - */ - if (!oldestOffsetKnown && prevOldestOffsetKnown) - { - /* - * If we failed to get the oldest offset this time, but we have a - * value from a previous pass through this function, use the old - * values rather than automatically forcing an emergency autovacuum - * cycle again. - */ - oldestOffset = prevOldestOffset; - oldestOffsetKnown = true; - } - /* Install the computed values */ LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE); MultiXactState->oldestOffset = oldestOffset; - MultiXactState->oldestOffsetKnown = oldestOffsetKnown; LWLockRelease(MultiXactGenLock); /* - * Do we need autovacuum? If we're not sure, assume yes. + * Do we need autovacuum? */ - return !oldestOffsetKnown || - (nextOffset - oldestOffset > MULTIXACT_MEMBER_AUTOVAC_THRESHOLD); + return (nextOffset - oldestOffset > MULTIXACT_MEMBER_AUTOVAC_THRESHOLD); } /* * Find the starting offset of the given MultiXactId. * - * Returns false if the file containing the multi does not exist on disk. - * Otherwise, returns true and sets *result to the starting member offset. - * * This function does not prevent concurrent truncation, so if that's * required, the caller has to protect against that. */ -static bool -find_multixact_start(MultiXactId multi, MultiXactOffset *result) +static MultiXactOffset +find_multixact_start(MultiXactId multi) { MultiXactOffset offset; int64 pageno; @@ -2708,15 +2664,6 @@ find_multixact_start(MultiXactId multi, MultiXactOffset *result) pageno = MultiXactIdToOffsetPage(multi); entryno = MultiXactIdToOffsetEntry(multi); - /* - * Write out dirty data, so PhysicalPageExists can work correctly. - */ - SimpleLruWriteAll(MultiXactOffsetCtl, true); - SimpleLruWriteAll(MultiXactMemberCtl, true); - - if (!SimpleLruDoesPhysicalPageExist(MultiXactOffsetCtl, pageno)) - return false; - /* lock is acquired by SimpleLruReadPage_ReadOnly */ slotno = SimpleLruReadPage_ReadOnly(MultiXactOffsetCtl, pageno, multi); offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno]; @@ -2724,8 +2671,7 @@ find_multixact_start(MultiXactId multi, MultiXactOffset *result) offset = *offptr; LWLockRelease(SimpleLruGetBankLock(MultiXactOffsetCtl, pageno)); - *result = offset; - return true; + return offset; } typedef struct mxtruncinfo @@ -2759,11 +2705,12 @@ SlruScanDirCbFindEarliest(SlruCtl ctl, char *filename, int64 segpage, void *data * the full range at once. This means SimpleLruTruncate() can't trivially be * used - instead the to-be-deleted range is computed using the offsets * SLRU. C.f. TruncateMultiXact(). + * + * XXX could use SimpleLruTruncate() now */ static void PerformMembersTruncation(MultiXactOffset oldestOffset, MultiXactOffset newOldestOffset) { - const int64 maxsegment = MXOffsetToMemberSegment(MaxMultiXactOffset); int64 startsegment = MXOffsetToMemberSegment(oldestOffset); int64 endsegment = MXOffsetToMemberSegment(newOldestOffset); int64 segment = startsegment; @@ -2778,11 +2725,7 @@ PerformMembersTruncation(MultiXactOffset oldestOffset, MultiXactOffset newOldest (unsigned long long) segment); SlruDeleteSegment(MultiXactMemberCtl, segment); - /* move to next segment, handling wraparound correctly */ - if (segment == maxsegment) - segment = 0; - else - segment += 1; + segment += 1; } } @@ -2888,23 +2831,15 @@ TruncateMultiXact(MultiXactId newOldestMulti, Oid newOldestMultiDB) /* * First, compute the safe truncation point for MultiXactMember. This is * the starting offset of the oldest multixact. - * - * Hopefully, find_multixact_start will always work here, because we've - * already checked that it doesn't precede the earliest MultiXact on disk. - * But if it fails, don't truncate anything, and log a message. */ if (oldestMulti == nextMulti) { /* there are NO MultiXacts */ oldestOffset = nextOffset; } - else if (!find_multixact_start(oldestMulti, &oldestOffset)) + else { - ereport(LOG, - (errmsg("oldest MultiXact %u not found, earliest MultiXact %u, skipping truncation", - oldestMulti, earliest))); - LWLockRelease(MultiXactTruncationLock); - return; + oldestOffset = find_multixact_start(oldestMulti); } /* @@ -2916,13 +2851,9 @@ TruncateMultiXact(MultiXactId newOldestMulti, Oid newOldestMultiDB) /* there are NO MultiXacts */ newOldestOffset = nextOffset; } - else if (!find_multixact_start(newOldestMulti, &newOldestOffset)) + else { - ereport(LOG, - (errmsg("cannot truncate up to MultiXact %u because it does not exist on disk, skipping truncation", - newOldestMulti))); - LWLockRelease(MultiXactTruncationLock); - return; + newOldestOffset = find_multixact_start(newOldestMulti); } elog(DEBUG1, "performing multixact truncation: " -- 2.39.5