void SimpleLruInit(SlruCtl ctl, const char *name, int nslots, int nlsns, const char *subdir, int buffer_tranche_id, int bank_tranche_id, SyncRequestHandler sync_handler, bool long_segment_names)

Definition: slru.c:252

SlruPagePrecedesUnitTests

#define SlruPagePrecedesUnitTests(ctl, per_page)

Definition: slru.h:200

MultiXactStateData::perBackendXactIds

MultiXactId perBackendXactIds[FLEXIBLE_ARRAY_MEMBER]

Definition: multixact.c:327

SYNC_HANDLER_MULTIXACT_MEMBER

@ SYNC_HANDLER_MULTIXACT_MEMBER

Definition: sync.h:41

SYNC_HANDLER_MULTIXACT_OFFSET

@ SYNC_HANDLER_MULTIXACT_OFFSET

Definition: sync.h:40

References Assert(), ConditionVariableInit(), DEBUG2, debug_elog2, IsUnderPostmaster, MaxOldestSlot, MemSet, multixact_member_buffers, multixact_offset_buffers, MULTIXACT_OFFSETS_PER_PAGE, MultiXactMemberCtl, MultiXactMemberPagePrecedes(), MultiXactOffsetCtl, MultiXactOffsetPagePrecedes(), MultiXactState, MultiXactStateData::nextoff_cv, OldestMemberMXactId, OldestVisibleMXactId, MultiXactStateData::perBackendXactIds, SHARED_MULTIXACT_STATE_SIZE, ShmemInitStruct(), SimpleLruInit(), SlruPagePrecedesUnitTests, SYNC_HANDLER_MULTIXACT_MEMBER, and SYNC_HANDLER_MULTIXACT_OFFSET.

Referenced by CreateOrAttachShmemStructs().

◆ MultiXactShmemSize()

Size MultiXactShmemSize ( void )

Definition at line 1938 of file multixact.c.

1939{

1940 Size size;

1941

1942 /* We need 2*MaxOldestSlot perBackendXactIds[] entries */

1943#define SHARED_MULTIXACT_STATE_SIZE \

1944 add_size(offsetof(MultiXactStateData, perBackendXactIds), \

1945 mul_size(sizeof(MultiXactId) * 2, MaxOldestSlot))

1946

1947 size = SHARED_MULTIXACT_STATE_SIZE;

1948 size = add_size(size, SimpleLruShmemSize(multixact_offset_buffers, 0));

1949 size = add_size(size, SimpleLruShmemSize(multixact_member_buffers, 0));

1950

1951 return size;

1952}

Size

size_t Size

Definition: c.h:610

add_size

Size add_size(Size s1, Size s2)

Definition: shmem.c:493

SimpleLruShmemSize

Size SimpleLruShmemSize(int nslots, int nlsns)

Definition: slru.c:198

References add_size(), multixact_member_buffers, multixact_offset_buffers, SHARED_MULTIXACT_STATE_SIZE, and SimpleLruShmemSize().

Referenced by CalculateShmemSize().

◆ mxid_to_string()

char * mxid_to_string ( MultiXactId multi,

int nmembers,

MultiXactMember * members

)

Definition at line 1768 of file multixact.c.

1769{

1770 static char *str = NULL;

1771 StringInfoData buf;

1772 int i;

1773

1774 if (str != NULL)

1775 pfree(str);

1776

1777 initStringInfo(&buf);

1778

1779 appendStringInfo(&buf, "%u %d[%u (%s)", multi, nmembers, members[0].xid,

1780 mxstatus_to_string(members[0].status));

1781

1782 for (i = 1; i < nmembers; i++)

1783 appendStringInfo(&buf, ", %u (%s)", members[i].xid,

1784 mxstatus_to_string(members[i].status));

1785

1786 appendStringInfoChar(&buf, ']');

1787 str = MemoryContextStrdup(TopMemoryContext, buf.data);

1788 pfree(buf.data);

1789 return str;

1790}

str

const char * str

Definition: hashfn_unstable.h:254

MemoryContextStrdup

char * MemoryContextStrdup(MemoryContext context, const char *string)

Definition: mcxt.c:1746

TopMemoryContext

MemoryContext TopMemoryContext

Definition: mcxt.c:166

appendStringInfoChar

void appendStringInfoChar(StringInfo str, char ch)

Definition: stringinfo.c:242

initStringInfo

void initStringInfo(StringInfo str)

Definition: stringinfo.c:97

StringInfoData

Definition: stringinfo.h:47

References appendStringInfo(), appendStringInfoChar(), buf, i, initStringInfo(), MemoryContextStrdup(), mxstatus_to_string(), pfree(), str, and TopMemoryContext.

Referenced by GetMultiXactIdMembers(), MultiXactIdCreate(), MultiXactIdCreateFromMembers(), mXactCacheGetById(), mXactCacheGetBySet(), and mXactCachePut().

◆ mxstatus_to_string()

char * mxstatus_to_string ( MultiXactStatus status )

Definition at line 1745 of file multixact.c.

1746{

1747 switch (status)

1748 {

1749 case MultiXactStatusForKeyShare:

1750 return "keysh";

1751 case MultiXactStatusForShare:

1752 return "sh";

1753 case MultiXactStatusForNoKeyUpdate:

1754 return "fornokeyupd";

1755 case MultiXactStatusForUpdate:

1756 return "forupd";

1757 case MultiXactStatusNoKeyUpdate:

1758 return "nokeyupd";

1759 case MultiXactStatusUpdate:

1760 return "upd";

1761 default:

1762 elog(ERROR, "unrecognized multixact status %d", status);

1763 return "";

1764 }

1765}

References elog, ERROR, MultiXactStatusForKeyShare, MultiXactStatusForNoKeyUpdate, MultiXactStatusForShare, MultiXactStatusForUpdate, MultiXactStatusNoKeyUpdate, and MultiXactStatusUpdate.

Referenced by MultiXactIdExpand(), mxid_to_string(), and pg_get_multixact_members().

◆ PostPrepare_MultiXact()

void PostPrepare_MultiXact ( FullTransactionId fxid )

Definition at line 1841 of file multixact.c.

1842{

1843 MultiXactId myOldestMember;

1844

1845 /*

1846 * Transfer our OldestMemberMXactId value to the slot reserved for the

1847 * prepared transaction.

1848 */

1849 myOldestMember = OldestMemberMXactId[MyProcNumber];

1850 if (MultiXactIdIsValid(myOldestMember))

1851 {

1852 ProcNumber dummyProcNumber = TwoPhaseGetDummyProcNumber(fxid, false);

1853

1854 /*

1855 * Even though storing MultiXactId is atomic, acquire lock to make

1856 * sure others see both changes, not just the reset of the slot of the

1857 * current backend. Using a volatile pointer might suffice, but this

1858 * isn't a hot spot.

1859 */

1860 LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);

1861

1862 OldestMemberMXactId[dummyProcNumber] = myOldestMember;

1863 OldestMemberMXactId[MyProcNumber] = InvalidMultiXactId;

1864

1865 LWLockRelease(MultiXactGenLock);

1866 }

1867

1868 /*

1869 * We don't need to transfer OldestVisibleMXactId value, because the

1870 * transaction is not going to be looking at any more multixacts once it's

1871 * prepared.

1872 *

1873 * We assume that storing a MultiXactId is atomic and so we need not take

1874 * MultiXactGenLock to do this.

1875 */

1876 OldestVisibleMXactId[MyProcNumber] = InvalidMultiXactId;

1877

1878 /*

1879 * Discard the local MultiXactId cache like in AtEOXact_MultiXact.

1880 */

1881 MXactContext = NULL;

1882 dclist_init(&MXactCache);

1883}

References dclist_init(), InvalidMultiXactId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MultiXactIdIsValid, MXactCache, MXactContext, MyProcNumber, OldestMemberMXactId, OldestVisibleMXactId, and TwoPhaseGetDummyProcNumber().

Referenced by PrepareTransaction().

◆ ReadMultiXactIdRange()

void ReadMultiXactIdRange ( MultiXactId * oldest,

MultiXactId * next

)

Definition at line 782 of file multixact.c.

783{

784 LWLockAcquire(MultiXactGenLock, LW_SHARED);

785 *oldest = MultiXactState->oldestMultiXactId;

786 *next = MultiXactState->nextMXact;

787 LWLockRelease(MultiXactGenLock);

788

789 if (*oldest < FirstMultiXactId)

790 *oldest = FirstMultiXactId;

791 if (*next < FirstMultiXactId)

792 *next = FirstMultiXactId;

793}

Definition: blutils.c:224

References FirstMultiXactId, LW_SHARED, LWLockAcquire(), LWLockRelease(), MultiXactState, next, MultiXactStateData::nextMXact, and MultiXactStateData::oldestMultiXactId.

Referenced by update_cached_mxid_range().

◆ ReadNextMultiXactId()

MultiXactId ReadNextMultiXactId ( void )

Definition at line 762 of file multixact.c.

763{

764 MultiXactId mxid;

765

766 /* XXX we could presumably do this without a lock. */

767 LWLockAcquire(MultiXactGenLock, LW_SHARED);

768 mxid = MultiXactState->nextMXact;

769 LWLockRelease(MultiXactGenLock);

770

771 if (mxid < FirstMultiXactId)

772 mxid = FirstMultiXactId;

773

774 return mxid;

775}

References FirstMultiXactId, LW_SHARED, LWLockAcquire(), LWLockRelease(), MultiXactState, and MultiXactStateData::nextMXact.

Referenced by ATRewriteTables(), AutoVacWorkerMain(), do_start_worker(), mxid_age(), refresh_by_heap_swap(), vac_update_datfrozenxid(), vac_update_relstats(), vacuum_get_cutoffs(), and vacuum_xid_failsafe_check().

◆ SetMultiXactIdLimit()

void SetMultiXactIdLimit ( MultiXactId oldest_datminmxid,

Oid oldest_datoid,

bool is_startup

)

Definition at line 2292 of file multixact.c.

2294{

2295 MultiXactId multiVacLimit;

2296 MultiXactId multiWarnLimit;

2297 MultiXactId multiStopLimit;

2298 MultiXactId multiWrapLimit;

2299 MultiXactId curMulti;

2300 bool needs_offset_vacuum;

2301

2302 Assert(MultiXactIdIsValid(oldest_datminmxid));

2303

2304 /*

2305 * We pretend that a wrap will happen halfway through the multixact ID

2306 * space, but that's not really true, because multixacts wrap differently

2307 * from transaction IDs. Note that, separately from any concern about

2308 * multixact IDs wrapping, we must ensure that multixact members do not

2309 * wrap. Limits for that are set in SetOffsetVacuumLimit, not here.

2310 */

2311 multiWrapLimit = oldest_datminmxid + (MaxMultiXactId >> 1);

2312 if (multiWrapLimit < FirstMultiXactId)

2313 multiWrapLimit += FirstMultiXactId;

2314

2315 /*

2316 * We'll refuse to continue assigning MultiXactIds once we get within 3M

2317 * multi of data loss. See SetTransactionIdLimit.

2318 */

2319 multiStopLimit = multiWrapLimit - 3000000;

2320 if (multiStopLimit < FirstMultiXactId)

2321 multiStopLimit -= FirstMultiXactId;

2322

2323 /*

2324 * We'll start complaining loudly when we get within 40M multis of data

2325 * loss. This is kind of arbitrary, but if you let your gas gauge get

2326 * down to 2% of full, would you be looking for the next gas station? We

2327 * need to be fairly liberal about this number because there are lots of

2328 * scenarios where most transactions are done by automatic clients that

2329 * won't pay attention to warnings. (No, we're not gonna make this

2330 * configurable. If you know enough to configure it, you know enough to

2331 * not get in this kind of trouble in the first place.)

2332 */

2333 multiWarnLimit = multiWrapLimit - 40000000;

2334 if (multiWarnLimit < FirstMultiXactId)

2335 multiWarnLimit -= FirstMultiXactId;

2336

2337 /*

2338 * We'll start trying to force autovacuums when oldest_datminmxid gets to

2339 * be more than autovacuum_multixact_freeze_max_age mxids old.

2340 *

2341 * Note: autovacuum_multixact_freeze_max_age is a PGC_POSTMASTER parameter

2342 * so that we don't have to worry about dealing with on-the-fly changes in

2343 * its value. See SetTransactionIdLimit.

2344 */

2345 multiVacLimit = oldest_datminmxid + autovacuum_multixact_freeze_max_age;

2346 if (multiVacLimit < FirstMultiXactId)

2347 multiVacLimit += FirstMultiXactId;

2348

2349 /* Grab lock for just long enough to set the new limit values */

2350 LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);

2351 MultiXactState->oldestMultiXactId = oldest_datminmxid;

2352 MultiXactState->oldestMultiXactDB = oldest_datoid;

2353 MultiXactState->multiVacLimit = multiVacLimit;

2354 MultiXactState->multiWarnLimit = multiWarnLimit;

2355 MultiXactState->multiStopLimit = multiStopLimit;

2356 MultiXactState->multiWrapLimit = multiWrapLimit;

2357 curMulti = MultiXactState->nextMXact;

2358 LWLockRelease(MultiXactGenLock);

2359

2360 /* Log the info */

2361 ereport(DEBUG1,

2362 (errmsg_internal("MultiXactId wrap limit is %u, limited by database with OID %u",

2363 multiWrapLimit, oldest_datoid)));

2364

2365 /*

2366 * Computing the actual limits is only possible once the data directory is

2367 * in a consistent state. There's no need to compute the limits while

2368 * still replaying WAL - no decisions about new multis are made even

2369 * though multixact creations might be replayed. So we'll only do further

2370 * checks after TrimMultiXact() has been called.

2371 */

2372 if (!MultiXactState->finishedStartup)

2373 return;

2374

2375 Assert(!InRecovery);

2376

2377 /* Set limits for offset vacuum. */

2378 needs_offset_vacuum = SetOffsetVacuumLimit(is_startup);

2379

2380 /*

2381 * If past the autovacuum force point, immediately signal an autovac

2382 * request. The reason for this is that autovac only processes one

2383 * database per invocation. Once it's finished cleaning up the oldest

2384 * database, it'll call here, and we'll signal the postmaster to start

2385 * another iteration immediately if there are still any old databases.

2386 */

2387 if ((MultiXactIdPrecedes(multiVacLimit, curMulti) ||

2388 needs_offset_vacuum) && IsUnderPostmaster)

2389 SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);

2390

2391 /* Give an immediate warning if past the wrap warn point */

2392 if (MultiXactIdPrecedes(multiWarnLimit, curMulti))

2393 {

2394 char *oldest_datname;

2395

2396 /*

2397 * We can be called when not inside a transaction, for example during

2398 * StartupXLOG(). In such a case we cannot do database access, so we

2399 * must just report the oldest DB's OID.

2400 *

2401 * Note: it's also possible that get_database_name fails and returns

2402 * NULL, for example because the database just got dropped. We'll

2403 * still warn, even though the warning might now be unnecessary.

2404 */

2405 if (IsTransactionState())

2406 oldest_datname = get_database_name(oldest_datoid);

2407 else

2408 oldest_datname = NULL;

2409

2410 if (oldest_datname)

2411 ereport(WARNING,

2412 (errmsg_plural("database \"%s\" must be vacuumed before %u more MultiXactId is used",

2413 "database \"%s\" must be vacuumed before %u more MultiXactIds are used",

2414 multiWrapLimit - curMulti,

2415 oldest_datname,

2416 multiWrapLimit - curMulti),

2417 errhint("To avoid MultiXactId assignment failures, execute a database-wide VACUUM in that database.\n"

2418 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));

2419 else

2420 ereport(WARNING,

2421 (errmsg_plural("database with OID %u must be vacuumed before %u more MultiXactId is used",

2422 "database with OID %u must be vacuumed before %u more MultiXactIds are used",

2423 multiWrapLimit - curMulti,

2424 oldest_datoid,

2425 multiWrapLimit - curMulti),

2426 errhint("To avoid MultiXactId assignment failures, execute a database-wide VACUUM in that database.\n"

2427 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));

2428 }

2429}

errmsg_plural

int errmsg_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)

Definition: elog.c:1184

errmsg_internal

int errmsg_internal(const char *fmt,...)

Definition: elog.c:1161

errhint

int errhint(const char *fmt,...)

Definition: elog.c:1321

WARNING

#define WARNING

Definition: elog.h:36

get_database_name

char * get_database_name(Oid dbid)

Definition: lsyscache.c:1259

SetOffsetVacuumLimit

static bool SetOffsetVacuumLimit(bool is_startup)

Definition: multixact.c:2647

MaxMultiXactId

#define MaxMultiXactId

Definition: multixact.h:27

SendPostmasterSignal

void SendPostmasterSignal(PMSignalReason reason)

Definition: pmsignal.c:165

PMSIGNAL_START_AUTOVAC_LAUNCHER

@ PMSIGNAL_START_AUTOVAC_LAUNCHER

Definition: pmsignal.h:39

MultiXactStateData::multiWrapLimit

MultiXactId multiWrapLimit

Definition: multixact.c:269

MultiXactStateData::multiStopLimit

MultiXactId multiStopLimit

Definition: multixact.c:268

MultiXactStateData::multiWarnLimit

MultiXactId multiWarnLimit

Definition: multixact.c:267

MultiXactStateData::multiVacLimit

MultiXactId multiVacLimit

Definition: multixact.c:266

MultiXactStateData::finishedStartup

bool finishedStartup

Definition: multixact.c:247

IsTransactionState

bool IsTransactionState(void)

Definition: xact.c:387

Referenced by BootStrapXLOG(), multixact_redo(), MultiXactAdvanceOldest(), StartupXLOG(), TrimMultiXact(), and vac_truncate_clog().

◆ StartupMultiXact()

void StartupMultiXact ( void )

Definition at line 2083 of file multixact.c.

2084{

2085 MultiXactId multi = MultiXactState->nextMXact;

2086 MultiXactOffset offset = MultiXactState->nextOffset;

2087 int64 pageno;

2088

2089 /*

2090 * Initialize offset's idea of the latest page number.

2091 */

2092 pageno = MultiXactIdToOffsetPage(multi);

2093 pg_atomic_write_u64(&MultiXactOffsetCtl->shared->latest_page_number,

2094 pageno);

2095

2096 /*

2097 * Initialize member's idea of the latest page number.

2098 */

2099 pageno = MXOffsetToMemberPage(offset);

2100 pg_atomic_write_u64(&MultiXactMemberCtl->shared->latest_page_number,

2101 pageno);

2102}

References MultiXactIdToOffsetPage(), MultiXactMemberCtl, MultiXactOffsetCtl, MultiXactState, MXOffsetToMemberPage(), MultiXactStateData::nextMXact, MultiXactStateData::nextOffset, and pg_atomic_write_u64().

Referenced by StartupXLOG().

◆ TrimMultiXact()

void TrimMultiXact ( void )

Definition at line 2108 of file multixact.c.

2109{

2110 MultiXactId nextMXact;

2111 MultiXactOffset offset;

2112 MultiXactId oldestMXact;

2113 Oid oldestMXactDB;

2114 int64 pageno;

2115 int entryno;

2116 int flagsoff;

2117

2118 LWLockAcquire(MultiXactGenLock, LW_SHARED);

2119 nextMXact = MultiXactState->nextMXact;

2120 offset = MultiXactState->nextOffset;

2121 oldestMXact = MultiXactState->oldestMultiXactId;

2122 oldestMXactDB = MultiXactState->oldestMultiXactDB;

2123 LWLockRelease(MultiXactGenLock);

2124

2125 /* Clean up offsets state */

2126

2127 /*

2128 * (Re-)Initialize our idea of the latest page number for offsets.

2129 */

2130 pageno = MultiXactIdToOffsetPage(nextMXact);

2131 pg_atomic_write_u64(&MultiXactOffsetCtl->shared->latest_page_number,

2132 pageno);

2133

2134 /*

2135 * Zero out the remainder of the current offsets page. See notes in

2136 * TrimCLOG() for background. Unlike CLOG, some WAL record covers every

2137 * pg_multixact SLRU mutation. Since, also unlike CLOG, we ignore the WAL

2138 * rule "write xlog before data," nextMXact successors may carry obsolete,

2139 * nonzero offset values. Zero those so case 2 of GetMultiXactIdMembers()

2140 * operates normally.

2141 */

2142 entryno = MultiXactIdToOffsetEntry(nextMXact);

2143 if (entryno != 0)

2144 {

2145 int slotno;

2146 MultiXactOffset *offptr;

2147 LWLock *lock = SimpleLruGetBankLock(MultiXactOffsetCtl, pageno);

2148

2149 LWLockAcquire(lock, LW_EXCLUSIVE);

2150 slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, nextMXact);

2151 offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];

2152 offptr += entryno;

2153

2154 MemSet(offptr, 0, BLCKSZ - (entryno * sizeof(MultiXactOffset)));

2155

2156 MultiXactOffsetCtl->shared->page_dirty[slotno] = true;

2157 LWLockRelease(lock);

2158 }

2159

2160 /*

2161 * And the same for members.

2162 *

2163 * (Re-)Initialize our idea of the latest page number for members.

2164 */

2165 pageno = MXOffsetToMemberPage(offset);

2166 pg_atomic_write_u64(&MultiXactMemberCtl->shared->latest_page_number,

2167 pageno);

2168

2169 /*

2170 * Zero out the remainder of the current members page. See notes in

2171 * TrimCLOG() for motivation.

2172 */

2173 flagsoff = MXOffsetToFlagsOffset(offset);

2174 if (flagsoff != 0)

2175 {

2176 int slotno;

2177 TransactionId *xidptr;

2178 int memberoff;

2179 LWLock *lock = SimpleLruGetBankLock(MultiXactMemberCtl, pageno);

2180

2181 LWLockAcquire(lock, LW_EXCLUSIVE);

2182 memberoff = MXOffsetToMemberOffset(offset);

2183 slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, offset);

2184 xidptr = (TransactionId *)

2185 (MultiXactMemberCtl->shared->page_buffer[slotno] + memberoff);

2186

2187 MemSet(xidptr, 0, BLCKSZ - memberoff);

2188

2189 /*

2190 * Note: we don't need to zero out the flag bits in the remaining

2191 * members of the current group, because they are always reset before

2192 * writing.

2193 */

2194

2195 MultiXactMemberCtl->shared->page_dirty[slotno] = true;

2196 LWLockRelease(lock);

2197 }

2198

2199 /* signal that we're officially up */

2200 LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);

2201 MultiXactState->finishedStartup = true;

2202 LWLockRelease(MultiXactGenLock);

2203

2204 /* Now compute how far away the next members wraparound is. */

2205 SetMultiXactIdLimit(oldestMXact, oldestMXactDB, true);

2206}

Oid

unsigned int Oid

Definition: postgres_ext.h:32

References MultiXactStateData::finishedStartup, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), MemSet, MultiXactIdToOffsetEntry(), MultiXactIdToOffsetPage(), MultiXactMemberCtl, MultiXactOffsetCtl, MultiXactState, MXOffsetToFlagsOffset(), MXOffsetToMemberOffset(), MXOffsetToMemberPage(), MultiXactStateData::nextMXact, MultiXactStateData::nextOffset, MultiXactStateData::oldestMultiXactDB, MultiXactStateData::oldestMultiXactId, pg_atomic_write_u64(), SetMultiXactIdLimit(), SimpleLruGetBankLock(), and SimpleLruReadPage().

Referenced by StartupXLOG().

◆ TruncateMultiXact()

void TruncateMultiXact ( MultiXactId newOldestMulti,

Oid newOldestMultiDB

)

Definition at line 3050 of file multixact.c.

3051{

3052 MultiXactId oldestMulti;

3053 MultiXactId nextMulti;

3054 MultiXactOffset newOldestOffset;

3055 MultiXactOffset oldestOffset;

3056 MultiXactOffset nextOffset;

3057 mxtruncinfo trunc;

3058 MultiXactId earliest;

3059

3060 Assert(!RecoveryInProgress());

3061 Assert(MultiXactState->finishedStartup);

3062

3063 /*

3064 * We can only allow one truncation to happen at once. Otherwise parts of

3065 * members might vanish while we're doing lookups or similar. There's no

3066 * need to have an interlock with creating new multis or such, since those

3067 * are constrained by the limits (which only grow, never shrink).

3068 */

3069 LWLockAcquire(MultiXactTruncationLock, LW_EXCLUSIVE);

3070

3071 LWLockAcquire(MultiXactGenLock, LW_SHARED);

3072 nextMulti = MultiXactState->nextMXact;

3073 nextOffset = MultiXactState->nextOffset;

3074 oldestMulti = MultiXactState->oldestMultiXactId;

3075 LWLockRelease(MultiXactGenLock);

3076 Assert(MultiXactIdIsValid(oldestMulti));

3077

3078 /*

3079 * Make sure to only attempt truncation if there's values to truncate

3080 * away. In normal processing values shouldn't go backwards, but there's

3081 * some corner cases (due to bugs) where that's possible.

3082 */

3083 if (MultiXactIdPrecedesOrEquals(newOldestMulti, oldestMulti))

3084 {

3085 LWLockRelease(MultiXactTruncationLock);

3086 return;

3087 }

3088

3089 /*

3090 * Note we can't just plow ahead with the truncation; it's possible that

3091 * there are no segments to truncate, which is a problem because we are

3092 * going to attempt to read the offsets page to determine where to

3093 * truncate the members SLRU. So we first scan the directory to determine

3094 * the earliest offsets page number that we can read without error.

3095 *

3096 * When nextMXact is less than one segment away from multiWrapLimit,

3097 * SlruScanDirCbFindEarliest can find some early segment other than the

3098 * actual earliest. (MultiXactOffsetPagePrecedes(EARLIEST, LATEST)

3099 * returns false, because not all pairs of entries have the same answer.)

3100 * That can also arise when an earlier truncation attempt failed unlink()

3101 * or returned early from this function. The only consequence is

3102 * returning early, which wastes space that we could have liberated.

3103 *

3104 * NB: It's also possible that the page that oldestMulti is on has already

3105 * been truncated away, and we crashed before updating oldestMulti.

3106 */

3107 trunc.earliestExistingPage = -1;

3108 SlruScanDirectory(MultiXactOffsetCtl, SlruScanDirCbFindEarliest, &trunc);

3109 earliest = trunc.earliestExistingPage * MULTIXACT_OFFSETS_PER_PAGE;

3110 if (earliest < FirstMultiXactId)

3111 earliest = FirstMultiXactId;

3112

3113 /* If there's nothing to remove, we can bail out early. */

3114 if (MultiXactIdPrecedes(oldestMulti, earliest))

3115 {

3116 LWLockRelease(MultiXactTruncationLock);

3117 return;

3118 }

3119

3120 /*

3121 * First, compute the safe truncation point for MultiXactMember. This is

3122 * the starting offset of the oldest multixact.

3123 *

3124 * Hopefully, find_multixact_start will always work here, because we've

3125 * already checked that it doesn't precede the earliest MultiXact on disk.

3126 * But if it fails, don't truncate anything, and log a message.

3127 */

3128 if (oldestMulti == nextMulti)

3129 {

3130 /* there are NO MultiXacts */

3131 oldestOffset = nextOffset;

3132 }

3133 else if (!find_multixact_start(oldestMulti, &oldestOffset))

3134 {

3135 ereport(LOG,

3136 (errmsg("oldest MultiXact %u not found, earliest MultiXact %u, skipping truncation",

3137 oldestMulti, earliest)));

3138 LWLockRelease(MultiXactTruncationLock);

3139 return;

3140 }

3141

3142 /*

3143 * Secondly compute up to where to truncate. Lookup the corresponding

3144 * member offset for newOldestMulti for that.

3145 */

3146 if (newOldestMulti == nextMulti)

3147 {

3148 /* there are NO MultiXacts */

3149 newOldestOffset = nextOffset;

3150 }

3151 else if (!find_multixact_start(newOldestMulti, &newOldestOffset))

3152 {

3153 ereport(LOG,

3154 (errmsg("cannot truncate up to MultiXact %u because it does not exist on disk, skipping truncation",

3155 newOldestMulti)));

3156 LWLockRelease(MultiXactTruncationLock);

3157 return;

3158 }

3159

3160 elog(DEBUG1, "performing multixact truncation: "

3161 "offsets [%u, %u), offsets segments [%" PRIx64 ", %" PRIx64 "), "

3162 "members [%u, %u), members segments [%" PRIx64 ", %" PRIx64 ")",

3163 oldestMulti, newOldestMulti,

3164 MultiXactIdToOffsetSegment(oldestMulti),

3165 MultiXactIdToOffsetSegment(newOldestMulti),

3166 oldestOffset, newOldestOffset,

3167 MXOffsetToMemberSegment(oldestOffset),

3168 MXOffsetToMemberSegment(newOldestOffset));

3169

3170 /*

3171 * Do truncation, and the WAL logging of the truncation, in a critical

3172 * section. That way offsets/members cannot get out of sync anymore, i.e.

3173 * once consistent the newOldestMulti will always exist in members, even

3174 * if we crashed in the wrong moment.

3175 */

3176 START_CRIT_SECTION();

3177

3178 /*

3179 * Prevent checkpoints from being scheduled concurrently. This is critical

3180 * because otherwise a truncation record might not be replayed after a

3181 * crash/basebackup, even though the state of the data directory would

3182 * require it.

3183 */

3184 Assert((MyProc->delayChkptFlags & DELAY_CHKPT_START) == 0);

3185 MyProc->delayChkptFlags |= DELAY_CHKPT_START;

3186

3187 /* WAL log truncation */

3188 WriteMTruncateXlogRec(newOldestMultiDB,

3189 oldestMulti, newOldestMulti,

3190 oldestOffset, newOldestOffset);

3191

3192 /*

3193 * Update in-memory limits before performing the truncation, while inside

3194 * the critical section: Have to do it before truncation, to prevent

3195 * concurrent lookups of those values. Has to be inside the critical

3196 * section as otherwise a future call to this function would error out,

3197 * while looking up the oldest member in offsets, if our caller crashes

3198 * before updating the limits.

3199 */

3200 LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);

3201 MultiXactState->oldestMultiXactId = newOldestMulti;

3202 MultiXactState->oldestMultiXactDB = newOldestMultiDB;

3203 LWLockRelease(MultiXactGenLock);

3204

3205 /* First truncate members */

3206 PerformMembersTruncation(oldestOffset, newOldestOffset);

3207

3208 /* Then offsets */

3209 PerformOffsetsTruncation(oldestMulti, newOldestMulti);

3210

3211 MyProc->delayChkptFlags &= ~DELAY_CHKPT_START;

3212

3213 END_CRIT_SECTION();

3214 LWLockRelease(MultiXactTruncationLock);

3215}

LOG

#define LOG

Definition: elog.h:31

START_CRIT_SECTION

#define START_CRIT_SECTION()

Definition: miscadmin.h:149

WriteMTruncateXlogRec

static void WriteMTruncateXlogRec(Oid oldestMultiDB, MultiXactId startTruncOff, MultiXactId endTruncOff, MultiXactOffset startTruncMemb, MultiXactOffset endTruncMemb)

Definition: multixact.c:3305

find_multixact_start

static bool find_multixact_start(MultiXactId multi, MultiXactOffset *result)

Definition: multixact.c:2822

SlruScanDirCbFindEarliest

static bool SlruScanDirCbFindEarliest(SlruCtl ctl, char *filename, int64 segpage, void *data)

Definition: multixact.c:2973

MultiXactIdPrecedesOrEquals

bool MultiXactIdPrecedesOrEquals(MultiXactId multi1, MultiXactId multi2)

Definition: multixact.c:3279

DELAY_CHKPT_START

#define DELAY_CHKPT_START