Debian Codegraph @

src/backend/access/transam/commit_ts.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * commit_ts.c
4 * PostgreSQL commit timestamp manager
5 *
6 * This module is a pg_xact-like system that stores the commit timestamp
7 * for each transaction.
8 *
9 * XLOG interactions: this module generates an XLOG record whenever a new
10 * CommitTs page is initialized to zeroes. Other writes of CommitTS come
11 * from recording of transaction commit in xact.c, which generates its own
12 * XLOG records for these events and will re-perform the status update on
13 * redo; so we need make no additional XLOG entry here.
14 *
15 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
16 * Portions Copyright (c) 1994, Regents of the University of California
17 *
18 * src/backend/access/transam/commit_ts.c
19 *
20 *-------------------------------------------------------------------------
21 */
22 #include "postgres.h"
23
24 #include "access/commit_ts.h"
25 #include "access/htup_details.h"
26 #include "access/slru.h"
27 #include "access/transam.h"
28 #include "access/xloginsert.h"
29 #include "access/xlogutils.h"
30 #include "funcapi.h"
31 #include "miscadmin.h"
32 #include "storage/shmem.h"
33 #include "utils/fmgrprotos.h"
34 #include "utils/guc_hooks.h"
35 #include "utils/timestamp.h"
36
37 /*
38 * Defines for CommitTs page sizes. A page is the same BLCKSZ as is used
39 * everywhere else in Postgres.
40 *
41 * Note: because TransactionIds are 32 bits and wrap around at 0xFFFFFFFF,
42 * CommitTs page numbering also wraps around at
43 * 0xFFFFFFFF/COMMIT_TS_XACTS_PER_PAGE, and CommitTs segment numbering at
44 * 0xFFFFFFFF/COMMIT_TS_XACTS_PER_PAGE/SLRU_PAGES_PER_SEGMENT. We need take no
45 * explicit notice of that fact in this module, except when comparing segment
46 * and page numbers in TruncateCommitTs (see CommitTsPagePrecedes).
47 */
48
49 /*
50 * We need 8+2 bytes per xact. Note that enlarging this struct might mean
51 * the largest possible file name is more than 5 chars long; see
52 * SlruScanDirectory.
53 */
54 typedef struct CommitTimestampEntry
55 {
56 TimestampTz time;
57 RepOriginId nodeid;
58 } CommitTimestampEntry;
59
60 #define SizeOfCommitTimestampEntry (offsetof(CommitTimestampEntry, nodeid) + \
61 sizeof(RepOriginId))
62
63 #define COMMIT_TS_XACTS_PER_PAGE \
64 (BLCKSZ / SizeOfCommitTimestampEntry)
65
66
67 /*
68 * Although we return an int64 the actual value can't currently exceed
69 * 0xFFFFFFFF/COMMIT_TS_XACTS_PER_PAGE.
70 */
71 static inline int64
72 TransactionIdToCTsPage(TransactionId xid)
73 {
74 return xid / (int64) COMMIT_TS_XACTS_PER_PAGE;
75 }
76
77 #define TransactionIdToCTsEntry(xid) \
78 ((xid) % (TransactionId) COMMIT_TS_XACTS_PER_PAGE)
79
80 /*
81 * Link to shared-memory data structures for CommitTs control
82 */
83 static SlruCtlData CommitTsCtlData;
84
85 #define CommitTsCtl (&CommitTsCtlData)
86
87 /*
88 * We keep a cache of the last value set in shared memory.
89 *
90 * This is also good place to keep the activation status. We keep this
91 * separate from the GUC so that the standby can activate the module if the
92 * primary has it active independently of the value of the GUC.
93 *
94 * This is protected by CommitTsLock. In some places, we use commitTsActive
95 * without acquiring the lock; where this happens, a comment explains the
96 * rationale for it.
97 */
98 typedef struct CommitTimestampShared
99 {
100 TransactionId xidLastCommit;
101 CommitTimestampEntry dataLastCommit;
102 bool commitTsActive;
103 } CommitTimestampShared;
104
105 static CommitTimestampShared *commitTsShared;
106
107
108 /* GUC variable */
109 bool track_commit_timestamp;
110
111 static void SetXidCommitTsInPage(TransactionId xid, int nsubxids,
112 TransactionId *subxids, TimestampTz ts,
113 RepOriginId nodeid, int64 pageno);
114 static void TransactionIdSetCommitTs(TransactionId xid, TimestampTz ts,
115 RepOriginId nodeid, int slotno);
116 static void error_commit_ts_disabled(void);
117 static int ZeroCommitTsPage(int64 pageno, bool writeXlog);
118 static bool CommitTsPagePrecedes(int64 page1, int64 page2);
119 static void ActivateCommitTs(void);
120 static void DeactivateCommitTs(void);
121 static void WriteZeroPageXlogRec(int64 pageno);
122 static void WriteTruncateXlogRec(int64 pageno, TransactionId oldestXid);
123
124 /*
125 * TransactionTreeSetCommitTsData
126 *
127 * Record the final commit timestamp of transaction entries in the commit log
128 * for a transaction and its subtransaction tree, as efficiently as possible.
129 *
130 * xid is the top level transaction id.
131 *
132 * subxids is an array of xids of length nsubxids, representing subtransactions
133 * in the tree of xid. In various cases nsubxids may be zero.
134 * The reason why tracking just the parent xid commit timestamp is not enough
135 * is that the subtrans SLRU does not stay valid across crashes (it's not
136 * permanent) so we need to keep the information about them here. If the
137 * subtrans implementation changes in the future, we might want to revisit the
138 * decision of storing timestamp info for each subxid.
139 */
140 void
141 TransactionTreeSetCommitTsData(TransactionId xid, int nsubxids,
142 TransactionId *subxids, TimestampTz timestamp,
143 RepOriginId nodeid)
144 {
145 int i;
146 TransactionId headxid;
147 TransactionId newestXact;
148
149 /*
150 * No-op if the module is not active.
151 *
152 * An unlocked read here is fine, because in a standby (the only place
153 * where the flag can change in flight) this routine is only called by the
154 * recovery process, which is also the only process which can change the
155 * flag.
156 */
157 if (!commitTsShared->commitTsActive)
158 return;
159
160 /*
161 * Figure out the latest Xid in this batch: either the last subxid if
162 * there's any, otherwise the parent xid.
163 */
164 if (nsubxids > 0)
165 newestXact = subxids[nsubxids - 1];
166 else
167 newestXact = xid;
168
169 /*
170 * We split the xids to set the timestamp to in groups belonging to the
171 * same SLRU page; the first element in each such set is its head. The
172 * first group has the main XID as the head; subsequent sets use the first
173 * subxid not on the previous page as head. This way, we only have to
174 * lock/modify each SLRU page once.
175 */
176 headxid = xid;
177 i = 0;
178 for (;;)
179 {
180 int64 pageno = TransactionIdToCTsPage(headxid);
181 int j;
182
183 for (j = i; j < nsubxids; j++)
184 {
185 if (TransactionIdToCTsPage(subxids[j]) != pageno)
186 break;
187 }
188 /* subxids[i..j] are on the same page as the head */
189
190 SetXidCommitTsInPage(headxid, j - i, subxids + i, timestamp, nodeid,
191 pageno);
192
193 /* if we wrote out all subxids, we're done. */
194 if (j >= nsubxids)
195 break;
196
197 /*
198 * Set the new head and skip over it, as well as over the subxids we
199 * just wrote.
200 */
201 headxid = subxids[j];
202 i = j + 1;
203 }
204
205 /* update the cached value in shared memory */
206 LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
207 commitTsShared->xidLastCommit = xid;
208 commitTsShared->dataLastCommit.time = timestamp;
209 commitTsShared->dataLastCommit.nodeid = nodeid;
210
211 /* and move forwards our endpoint, if needed */
212 if (TransactionIdPrecedes(TransamVariables->newestCommitTsXid, newestXact))
213 TransamVariables->newestCommitTsXid = newestXact;
214 LWLockRelease(CommitTsLock);
215 }
216
217 /*
218 * Record the commit timestamp of transaction entries in the commit log for all
219 * entries on a single page. Atomic only on this page.
220 */
221 static void
222 SetXidCommitTsInPage(TransactionId xid, int nsubxids,
223 TransactionId *subxids, TimestampTz ts,
224 RepOriginId nodeid, int64 pageno)
225 {
226 LWLock *lock = SimpleLruGetBankLock(CommitTsCtl, pageno);
227 int slotno;
228 int i;
229
230 LWLockAcquire(lock, LW_EXCLUSIVE);
231
232 slotno = SimpleLruReadPage(CommitTsCtl, pageno, true, xid);
233
234 TransactionIdSetCommitTs(xid, ts, nodeid, slotno);
235 for (i = 0; i < nsubxids; i++)
236 TransactionIdSetCommitTs(subxids[i], ts, nodeid, slotno);
237
238 CommitTsCtl->shared->page_dirty[slotno] = true;
239
240 LWLockRelease(lock);
241 }
242
243 /*
244 * Sets the commit timestamp of a single transaction.
245 *
246 * Caller must hold the correct SLRU bank lock, will be held at exit
247 */
248 static void
249 TransactionIdSetCommitTs(TransactionId xid, TimestampTz ts,
250 RepOriginId nodeid, int slotno)
251 {
252 int entryno = TransactionIdToCTsEntry(xid);
253 CommitTimestampEntry entry;
254
255 Assert(TransactionIdIsNormal(xid));
256
257 entry.time = ts;
258 entry.nodeid = nodeid;
259
260 memcpy(CommitTsCtl->shared->page_buffer[slotno] +
261 SizeOfCommitTimestampEntry * entryno,
262 &entry, SizeOfCommitTimestampEntry);
263 }
264
265 /*
266 * Interrogate the commit timestamp of a transaction.
267 *
268 * The return value indicates whether a commit timestamp record was found for
269 * the given xid. The timestamp value is returned in *ts (which may not be
270 * null), and the origin node for the Xid is returned in *nodeid, if it's not
271 * null.
272 */
273 bool
274 TransactionIdGetCommitTsData(TransactionId xid, TimestampTz *ts,
275 RepOriginId *nodeid)
276 {
277 int64 pageno = TransactionIdToCTsPage(xid);
278 int entryno = TransactionIdToCTsEntry(xid);
279 int slotno;
280 CommitTimestampEntry entry;
281 TransactionId oldestCommitTsXid;
282 TransactionId newestCommitTsXid;
283
284 if (!TransactionIdIsValid(xid))
285 ereport(ERROR,
286 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
287 errmsg("cannot retrieve commit timestamp for transaction %u", xid)));
288 else if (!TransactionIdIsNormal(xid))
289 {
290 /* frozen and bootstrap xids are always committed far in the past */
291 *ts = 0;
292 if (nodeid)
293 *nodeid = 0;
294 return false;
295 }
296
297 LWLockAcquire(CommitTsLock, LW_SHARED);
298
299 /* Error if module not enabled */
300 if (!commitTsShared->commitTsActive)
301 error_commit_ts_disabled();
302
303 /*
304 * If we're asked for the cached value, return that. Otherwise, fall
305 * through to read from SLRU.
306 */
307 if (commitTsShared->xidLastCommit == xid)
308 {
309 *ts = commitTsShared->dataLastCommit.time;
310 if (nodeid)
311 *nodeid = commitTsShared->dataLastCommit.nodeid;
312
313 LWLockRelease(CommitTsLock);
314 return *ts != 0;
315 }
316
317 oldestCommitTsXid = TransamVariables->oldestCommitTsXid;
318 newestCommitTsXid = TransamVariables->newestCommitTsXid;
319 /* neither is invalid, or both are */
320 Assert(TransactionIdIsValid(oldestCommitTsXid) == TransactionIdIsValid(newestCommitTsXid));
321 LWLockRelease(CommitTsLock);
322
323 /*
324 * Return empty if the requested value is outside our valid range.
325 */
326 if (!TransactionIdIsValid(oldestCommitTsXid) ||
327 TransactionIdPrecedes(xid, oldestCommitTsXid) ||
328 TransactionIdPrecedes(newestCommitTsXid, xid))
329 {
330 *ts = 0;
331 if (nodeid)
332 *nodeid = InvalidRepOriginId;
333 return false;
334 }
335
336 /* lock is acquired by SimpleLruReadPage_ReadOnly */
337 slotno = SimpleLruReadPage_ReadOnly(CommitTsCtl, pageno, xid);
338 memcpy(&entry,
339 CommitTsCtl->shared->page_buffer[slotno] +
340 SizeOfCommitTimestampEntry * entryno,
341 SizeOfCommitTimestampEntry);
342
343 *ts = entry.time;
344 if (nodeid)
345 *nodeid = entry.nodeid;
346
347 LWLockRelease(SimpleLruGetBankLock(CommitTsCtl, pageno));
348 return *ts != 0;
349 }
350
351 /*
352 * Return the Xid of the latest committed transaction. (As far as this module
353 * is concerned, anyway; it's up to the caller to ensure the value is useful
354 * for its purposes.)
355 *
356 * ts and nodeid are filled with the corresponding data; they can be passed
357 * as NULL if not wanted.
358 */
359 TransactionId
360 GetLatestCommitTsData(TimestampTz *ts, RepOriginId *nodeid)
361 {
362 TransactionId xid;
363
364 LWLockAcquire(CommitTsLock, LW_SHARED);
365
366 /* Error if module not enabled */
367 if (!commitTsShared->commitTsActive)
368 error_commit_ts_disabled();
369
370 xid = commitTsShared->xidLastCommit;
371 if (ts)
372 *ts = commitTsShared->dataLastCommit.time;
373 if (nodeid)
374 *nodeid = commitTsShared->dataLastCommit.nodeid;
375 LWLockRelease(CommitTsLock);
376
377 return xid;
378 }
379
380 static void
381 error_commit_ts_disabled(void)
382 {
383 ereport(ERROR,
384 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
385 errmsg("could not get commit timestamp data"),
386 RecoveryInProgress() ?
387 errhint("Make sure the configuration parameter \"%s\" is set on the primary server.",
388 "track_commit_timestamp") :
389 errhint("Make sure the configuration parameter \"%s\" is set.",
390 "track_commit_timestamp")));
391 }
392
393 /*
394 * SQL-callable wrapper to obtain commit time of a transaction
395 */
396 Datum
397 pg_xact_commit_timestamp(PG_FUNCTION_ARGS)
398 {
399 TransactionId xid = PG_GETARG_TRANSACTIONID(0);
400 TimestampTz ts;
401 bool found;
402
403 found = TransactionIdGetCommitTsData(xid, &ts, NULL);
404
405 if (!found)
406 PG_RETURN_NULL();
407
408 PG_RETURN_TIMESTAMPTZ(ts);
409 }
410
411
412 /*
413 * pg_last_committed_xact
414 *
415 * SQL-callable wrapper to obtain some information about the latest
416 * committed transaction: transaction ID, timestamp and replication
417 * origin.
418 */
419 Datum
420 pg_last_committed_xact(PG_FUNCTION_ARGS)
421 {
422 TransactionId xid;
423 RepOriginId nodeid;
424 TimestampTz ts;
425 Datum values[3];
426 bool nulls[3];
427 TupleDesc tupdesc;
428 HeapTuple htup;
429
430 /* and construct a tuple with our data */
431 xid = GetLatestCommitTsData(&ts, &nodeid);
432
433 if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
434 elog(ERROR, "return type must be a row type");
435
436 if (!TransactionIdIsNormal(xid))
437 {
438 memset(nulls, true, sizeof(nulls));
439 }
440 else
441 {
442 values[0] = TransactionIdGetDatum(xid);
443 nulls[0] = false;
444
445 values[1] = TimestampTzGetDatum(ts);
446 nulls[1] = false;
447
448 values[2] = ObjectIdGetDatum((Oid) nodeid);
449 nulls[2] = false;
450 }
451
452 htup = heap_form_tuple(tupdesc, values, nulls);
453
454 PG_RETURN_DATUM(HeapTupleGetDatum(htup));
455 }
456
457 /*
458 * pg_xact_commit_timestamp_origin
459 *
460 * SQL-callable wrapper to obtain commit timestamp and replication origin
461 * of a given transaction.
462 */
463 Datum
464 pg_xact_commit_timestamp_origin(PG_FUNCTION_ARGS)
465 {
466 TransactionId xid = PG_GETARG_TRANSACTIONID(0);
467 RepOriginId nodeid;
468 TimestampTz ts;
469 Datum values[2];
470 bool nulls[2];
471 TupleDesc tupdesc;
472 HeapTuple htup;
473 bool found;
474
475 found = TransactionIdGetCommitTsData(xid, &ts, &nodeid);
476
477 if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
478 elog(ERROR, "return type must be a row type");
479
480 if (!found)
481 {
482 memset(nulls, true, sizeof(nulls));
483 }
484 else
485 {
486 values[0] = TimestampTzGetDatum(ts);
487 nulls[0] = false;
488
489 values[1] = ObjectIdGetDatum((Oid) nodeid);
490 nulls[1] = false;
491 }
492
493 htup = heap_form_tuple(tupdesc, values, nulls);
494
495 PG_RETURN_DATUM(HeapTupleGetDatum(htup));
496 }
497
498 /*
499 * Number of shared CommitTS buffers.
500 *
501 * If asked to autotune, use 2MB for every 1GB of shared buffers, up to 8MB.
502 * Otherwise just cap the configured amount to be between 16 and the maximum
503 * allowed.
504 */
505 static int
506 CommitTsShmemBuffers(void)
507 {
508 /* auto-tune based on shared buffers */
509 if (commit_timestamp_buffers == 0)
510 return SimpleLruAutotuneBuffers(512, 1024);
511
512 return Min(Max(16, commit_timestamp_buffers), SLRU_MAX_ALLOWED_BUFFERS);
513 }
514
515 /*
516 * Shared memory sizing for CommitTs
517 */
518 Size
519 CommitTsShmemSize(void)
520 {
521 return SimpleLruShmemSize(CommitTsShmemBuffers(), 0) +
522 sizeof(CommitTimestampShared);
523 }
524
525 /*
526 * Initialize CommitTs at system startup (postmaster start or standalone
527 * backend)
528 */
529 void
530 CommitTsShmemInit(void)
531 {
532 bool found;
533
534 /* If auto-tuning is requested, now is the time to do it */
535 if (commit_timestamp_buffers == 0)
536 {
537 char buf[32];
538
539 snprintf(buf, sizeof(buf), "%d", CommitTsShmemBuffers());
540 SetConfigOption("commit_timestamp_buffers", buf, PGC_POSTMASTER,
541 PGC_S_DYNAMIC_DEFAULT);
542
543 /*
544 * We prefer to report this value's source as PGC_S_DYNAMIC_DEFAULT.
545 * However, if the DBA explicitly set commit_timestamp_buffers = 0 in
546 * the config file, then PGC_S_DYNAMIC_DEFAULT will fail to override
547 * that and we must force the matter with PGC_S_OVERRIDE.
548 */
549 if (commit_timestamp_buffers == 0) /* failed to apply it? */
550 SetConfigOption("commit_timestamp_buffers", buf, PGC_POSTMASTER,
551 PGC_S_OVERRIDE);
552 }
553 Assert(commit_timestamp_buffers != 0);
554
555 CommitTsCtl->PagePrecedes = CommitTsPagePrecedes;
556 SimpleLruInit(CommitTsCtl, "commit_timestamp", CommitTsShmemBuffers(), 0,
557 "pg_commit_ts", LWTRANCHE_COMMITTS_BUFFER,
558 LWTRANCHE_COMMITTS_SLRU,
559 SYNC_HANDLER_COMMIT_TS,
560 false);
561 SlruPagePrecedesUnitTests(CommitTsCtl, COMMIT_TS_XACTS_PER_PAGE);
562
563 commitTsShared = ShmemInitStruct("CommitTs shared",
564 sizeof(CommitTimestampShared),
565 &found);
566
567 if (!IsUnderPostmaster)
568 {
569 Assert(!found);
570
571 commitTsShared->xidLastCommit = InvalidTransactionId;
572 TIMESTAMP_NOBEGIN(commitTsShared->dataLastCommit.time);
573 commitTsShared->dataLastCommit.nodeid = InvalidRepOriginId;
574 commitTsShared->commitTsActive = false;
575 }
576 else
577 Assert(found);
578 }
579
580 /*
581 * GUC check_hook for commit_timestamp_buffers
582 */
583 bool
584 check_commit_ts_buffers(int *newval, void **extra, GucSource source)
585 {
586 return check_slru_buffers("commit_timestamp_buffers", newval);
587 }
588
589 /*
590 * This function must be called ONCE on system install.
591 *
592 * (The CommitTs directory is assumed to have been created by initdb, and
593 * CommitTsShmemInit must have been called already.)
594 */
595 void
596 BootStrapCommitTs(void)
597 {
598 /*
599 * Nothing to do here at present, unlike most other SLRU modules; segments
600 * are created when the server is started with this module enabled. See
601 * ActivateCommitTs.
602 */
603 }
604
605 /*
606 * Initialize (or reinitialize) a page of CommitTs to zeroes.
607 * If writeXlog is true, also emit an XLOG record saying we did this.
608 *
609 * The page is not actually written, just set up in shared memory.
610 * The slot number of the new page is returned.
611 *
612 * Control lock must be held at entry, and will be held at exit.
613 */
614 static int
615 ZeroCommitTsPage(int64 pageno, bool writeXlog)
616 {
617 int slotno;
618
619 slotno = SimpleLruZeroPage(CommitTsCtl, pageno);
620
621 if (writeXlog)
622 WriteZeroPageXlogRec(pageno);
623
624 return slotno;
625 }
626
627 /*
628 * This must be called ONCE during postmaster or standalone-backend startup,
629 * after StartupXLOG has initialized TransamVariables->nextXid.
630 */
631 void
632 StartupCommitTs(void)
633 {
634 ActivateCommitTs();
635 }
636
637 /*
638 * This must be called ONCE during postmaster or standalone-backend startup,
639 * after recovery has finished.
640 */
641 void
642 CompleteCommitTsInitialization(void)
643 {
644 /*
645 * If the feature is not enabled, turn it off for good. This also removes
646 * any leftover data.
647 *
648 * Conversely, we activate the module if the feature is enabled. This is
649 * necessary for primary and standby as the activation depends on the
650 * control file contents at the beginning of recovery or when a
651 * XLOG_PARAMETER_CHANGE is replayed.
652 */
653 if (!track_commit_timestamp)
654 DeactivateCommitTs();
655 else
656 ActivateCommitTs();
657 }
658
659 /*
660 * Activate or deactivate CommitTs' upon reception of a XLOG_PARAMETER_CHANGE
661 * XLog record during recovery.
662 */
663 void
664 CommitTsParameterChange(bool newvalue, bool oldvalue)
665 {
666 /*
667 * If the commit_ts module is disabled in this server and we get word from
668 * the primary server that it is enabled there, activate it so that we can
669 * replay future WAL records involving it; also mark it as active on
670 * pg_control. If the old value was already set, we already did this, so
671 * don't do anything.
672 *
673 * If the module is disabled in the primary, disable it here too, unless
674 * the module is enabled locally.
675 *
676 * Note this only runs in the recovery process, so an unlocked read is
677 * fine.
678 */
679 if (newvalue)
680 {
681 if (!commitTsShared->commitTsActive)
682 ActivateCommitTs();
683 }
684 else if (commitTsShared->commitTsActive)
685 DeactivateCommitTs();
686 }
687
688 /*
689 * Activate this module whenever necessary.
690 * This must happen during postmaster or standalone-backend startup,
691 * or during WAL replay anytime the track_commit_timestamp setting is
692 * changed in the primary.
693 *
694 * The reason why this SLRU needs separate activation/deactivation functions is
695 * that it can be enabled/disabled during start and the activation/deactivation
696 * on the primary is propagated to the standby via replay. Other SLRUs don't
697 * have this property and they can be just initialized during normal startup.
698 *
699 * This is in charge of creating the currently active segment, if it's not
700 * already there. The reason for this is that the server might have been
701 * running with this module disabled for a while and thus might have skipped
702 * the normal creation point.
703 */
704 static void
705 ActivateCommitTs(void)
706 {
707 TransactionId xid;
708 int64 pageno;
709
710 /*
711 * During bootstrap, we should not register commit timestamps so skip the
712 * activation in this case.
713 */
714 if (IsBootstrapProcessingMode())
715 return;
716
717 /* If we've done this already, there's nothing to do */
718 LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
719 if (commitTsShared->commitTsActive)
720 {
721 LWLockRelease(CommitTsLock);
722 return;
723 }
724 LWLockRelease(CommitTsLock);
725
726 xid = XidFromFullTransactionId(TransamVariables->nextXid);
727 pageno = TransactionIdToCTsPage(xid);
728
729 /*
730 * Re-Initialize our idea of the latest page number.
731 */
732 pg_atomic_write_u64(&CommitTsCtl->shared->latest_page_number, pageno);
733
734 /*
735 * If CommitTs is enabled, but it wasn't in the previous server run, we
736 * need to set the oldest and newest values to the next Xid; that way, we
737 * will not try to read data that might not have been set.
738 *
739 * XXX does this have a problem if a server is started with commitTs
740 * enabled, then started with commitTs disabled, then restarted with it
741 * enabled again? It doesn't look like it does, because there should be a
742 * checkpoint that sets the value to InvalidTransactionId at end of
743 * recovery; and so any chance of injecting new transactions without
744 * CommitTs values would occur after the oldestCommitTsXid has been set to
745 * Invalid temporarily.
746 */
747 LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
748 if (TransamVariables->oldestCommitTsXid == InvalidTransactionId)
749 {
750 TransamVariables->oldestCommitTsXid =
751 TransamVariables->newestCommitTsXid = ReadNextTransactionId();
752 }
753 LWLockRelease(CommitTsLock);
754
755 /* Create the current segment file, if necessary */
756 if (!SimpleLruDoesPhysicalPageExist(CommitTsCtl, pageno))
757 {
758 LWLock *lock = SimpleLruGetBankLock(CommitTsCtl, pageno);
759 int slotno;
760
761 LWLockAcquire(lock, LW_EXCLUSIVE);
762 slotno = ZeroCommitTsPage(pageno, false);
763 SimpleLruWritePage(CommitTsCtl, slotno);
764 Assert(!CommitTsCtl->shared->page_dirty[slotno]);
765 LWLockRelease(lock);
766 }
767
768 /* Change the activation status in shared memory. */
769 LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
770 commitTsShared->commitTsActive = true;
771 LWLockRelease(CommitTsLock);
772 }
773
774 /*
775 * Deactivate this module.
776 *
777 * This must be called when the track_commit_timestamp parameter is turned off.
778 * This happens during postmaster or standalone-backend startup, or during WAL
779 * replay.
780 *
781 * Resets CommitTs into invalid state to make sure we don't hand back
782 * possibly-invalid data; also removes segments of old data.
783 */
784 static void
785 DeactivateCommitTs(void)
786 {
787 /*
788 * Cleanup the status in the shared memory.
789 *
790 * We reset everything in the commitTsShared record to prevent user from
791 * getting confusing data about last committed transaction on the standby
792 * when the module was activated repeatedly on the primary.
793 */
794 LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
795
796 commitTsShared->commitTsActive = false;
797 commitTsShared->xidLastCommit = InvalidTransactionId;
798 TIMESTAMP_NOBEGIN(commitTsShared->dataLastCommit.time);
799 commitTsShared->dataLastCommit.nodeid = InvalidRepOriginId;
800
801 TransamVariables->oldestCommitTsXid = InvalidTransactionId;
802 TransamVariables->newestCommitTsXid = InvalidTransactionId;
803
804 /*
805 * Remove *all* files. This is necessary so that there are no leftover
806 * files; in the case where this feature is later enabled after running
807 * with it disabled for some time there may be a gap in the file sequence.
808 * (We can probably tolerate out-of-sequence files, as they are going to
809 * be overwritten anyway when we wrap around, but it seems better to be
810 * tidy.)
811 *
812 * Note that we do this with CommitTsLock acquired in exclusive mode. This
813 * is very heavy-handed, but since this routine can only be called in the
814 * replica and should happen very rarely, we don't worry too much about
815 * it. Note also that no process should be consulting this SLRU if we
816 * have just deactivated it.
817 */
818 (void) SlruScanDirectory(CommitTsCtl, SlruScanDirCbDeleteAll, NULL);
819
820 LWLockRelease(CommitTsLock);
821 }
822
823 /*
824 * Perform a checkpoint --- either during shutdown, or on-the-fly
825 */
826 void
827 CheckPointCommitTs(void)
828 {
829 /*
830 * Write dirty CommitTs pages to disk. This may result in sync requests
831 * queued for later handling by ProcessSyncRequests(), as part of the
832 * checkpoint.
833 */
834 SimpleLruWriteAll(CommitTsCtl, true);
835 }
836
837 /*
838 * Make sure that CommitTs has room for a newly-allocated XID.
839 *
840 * NB: this is called while holding XidGenLock. We want it to be very fast
841 * most of the time; even when it's not so fast, no actual I/O need happen
842 * unless we're forced to write out a dirty CommitTs or xlog page to make room
843 * in shared memory.
844 *
845 * NB: the current implementation relies on track_commit_timestamp being
846 * PGC_POSTMASTER.
847 */
848 void
849 ExtendCommitTs(TransactionId newestXact)
850 {
851 int64 pageno;
852 LWLock *lock;
853
854 /*
855 * Nothing to do if module not enabled. Note we do an unlocked read of
856 * the flag here, which is okay because this routine is only called from
857 * GetNewTransactionId, which is never called in a standby.
858 */
859 Assert(!InRecovery);
860 if (!commitTsShared->commitTsActive)
861 return;
862
863 /*
864 * No work except at first XID of a page. But beware: just after
865 * wraparound, the first XID of page zero is FirstNormalTransactionId.
866 */
867 if (TransactionIdToCTsEntry(newestXact) != 0 &&
868 !TransactionIdEquals(newestXact, FirstNormalTransactionId))
869 return;
870
871 pageno = TransactionIdToCTsPage(newestXact);
872
873 lock = SimpleLruGetBankLock(CommitTsCtl, pageno);
874
875 LWLockAcquire(lock, LW_EXCLUSIVE);
876
877 /* Zero the page and make an XLOG entry about it */
878 ZeroCommitTsPage(pageno, !InRecovery);
879
880 LWLockRelease(lock);
881 }
882
883 /*
884 * Remove all CommitTs segments before the one holding the passed
885 * transaction ID.
886 *
887 * Note that we don't need to flush XLOG here.
888 */
889 void
890 TruncateCommitTs(TransactionId oldestXact)
891 {
892 int64 cutoffPage;
893
894 /*
895 * The cutoff point is the start of the segment containing oldestXact. We
896 * pass the *page* containing oldestXact to SimpleLruTruncate.
897 */
898 cutoffPage = TransactionIdToCTsPage(oldestXact);
899
900 /* Check to see if there's any files that could be removed */
901 if (!SlruScanDirectory(CommitTsCtl, SlruScanDirCbReportPresence,
902 &cutoffPage))
903 return; /* nothing to remove */
904
905 /* Write XLOG record */
906 WriteTruncateXlogRec(cutoffPage, oldestXact);
907
908 /* Now we can remove the old CommitTs segment(s) */
909 SimpleLruTruncate(CommitTsCtl, cutoffPage);
910 }
911
912 /*
913 * Set the limit values between which commit TS can be consulted.
914 */
915 void
916 SetCommitTsLimit(TransactionId oldestXact, TransactionId newestXact)
917 {
918 /*
919 * Be careful not to overwrite values that are either further into the
920 * "future" or signal a disabled committs.
921 */
922 LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
923 if (TransamVariables->oldestCommitTsXid != InvalidTransactionId)
924 {
925 if (TransactionIdPrecedes(TransamVariables->oldestCommitTsXid, oldestXact))
926 TransamVariables->oldestCommitTsXid = oldestXact;
927 if (TransactionIdPrecedes(newestXact, TransamVariables->newestCommitTsXid))
928 TransamVariables->newestCommitTsXid = newestXact;
929 }
930 else
931 {
932 Assert(TransamVariables->newestCommitTsXid == InvalidTransactionId);
933 TransamVariables->oldestCommitTsXid = oldestXact;
934 TransamVariables->newestCommitTsXid = newestXact;
935 }
936 LWLockRelease(CommitTsLock);
937 }
938
939 /*
940 * Move forwards the oldest commitTS value that can be consulted
941 */
942 void
943 AdvanceOldestCommitTsXid(TransactionId oldestXact)
944 {
945 LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
946 if (TransamVariables->oldestCommitTsXid != InvalidTransactionId &&
947 TransactionIdPrecedes(TransamVariables->oldestCommitTsXid, oldestXact))
948 TransamVariables->oldestCommitTsXid = oldestXact;
949 LWLockRelease(CommitTsLock);
950 }
951
952
953 /*
954 * Decide whether a commitTS page number is "older" for truncation purposes.
955 * Analogous to CLOGPagePrecedes().
956 *
957 * At default BLCKSZ, (1 << 31) % COMMIT_TS_XACTS_PER_PAGE == 128. This
958 * introduces differences compared to CLOG and the other SLRUs having (1 <<
959 * 31) % per_page == 0. This function never tests exactly
960 * TransactionIdPrecedes(x-2^31, x). When the system reaches xidStopLimit,
961 * there are two possible counts of page boundaries between oldestXact and the
962 * latest XID assigned, depending on whether oldestXact is within the first
963 * 128 entries of its page. Since this function doesn't know the location of
964 * oldestXact within page2, it returns false for one page that actually is
965 * expendable. This is a wider (yet still negligible) version of the
966 * truncation opportunity that CLOGPagePrecedes() cannot recognize.
967 *
968 * For the sake of a worked example, number entries with decimal values such
969 * that page1==1 entries range from 1.0 to 1.999. Let N+0.15 be the number of
970 * pages that 2^31 entries will span (N is an integer). If oldestXact=N+2.1,
971 * then the final safe XID assignment leaves newestXact=1.95. We keep page 2,
972 * because entry=2.85 is the border that toggles whether entries precede the
973 * last entry of the oldestXact page. While page 2 is expendable at
974 * oldestXact=N+2.1, it would be precious at oldestXact=N+2.9.
975 */
976 static bool
977 CommitTsPagePrecedes(int64 page1, int64 page2)
978 {
979 TransactionId xid1;
980 TransactionId xid2;
981
982 xid1 = ((TransactionId) page1) * COMMIT_TS_XACTS_PER_PAGE;
983 xid1 += FirstNormalTransactionId + 1;
984 xid2 = ((TransactionId) page2) * COMMIT_TS_XACTS_PER_PAGE;
985 xid2 += FirstNormalTransactionId + 1;
986
987 return (TransactionIdPrecedes(xid1, xid2) &&
988 TransactionIdPrecedes(xid1, xid2 + COMMIT_TS_XACTS_PER_PAGE - 1));
989 }
990
991
992 /*
993 * Write a ZEROPAGE xlog record
994 */
995 static void
996 WriteZeroPageXlogRec(int64 pageno)
997 {
998 XLogBeginInsert();
999 XLogRegisterData(&pageno, sizeof(pageno));
1000 (void) XLogInsert(RM_COMMIT_TS_ID, COMMIT_TS_ZEROPAGE);
1001 }
1002
1003 /*
1004 * Write a TRUNCATE xlog record
1005 */
1006 static void
1007 WriteTruncateXlogRec(int64 pageno, TransactionId oldestXid)
1008 {
1009 xl_commit_ts_truncate xlrec;
1010
1011 xlrec.pageno = pageno;
1012 xlrec.oldestXid = oldestXid;
1013
1014 XLogBeginInsert();
1015 XLogRegisterData(&xlrec, SizeOfCommitTsTruncate);
1016 (void) XLogInsert(RM_COMMIT_TS_ID, COMMIT_TS_TRUNCATE);
1017 }
1018
1019 /*
1020 * CommitTS resource manager's routines
1021 */
1022 void
1023 commit_ts_redo(XLogReaderState *record)
1024 {
1025 uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
1026
1027 /* Backup blocks are not used in commit_ts records */
1028 Assert(!XLogRecHasAnyBlockRefs(record));
1029
1030 if (info == COMMIT_TS_ZEROPAGE)
1031 {
1032 int64 pageno;
1033 int slotno;
1034 LWLock *lock;
1035
1036 memcpy(&pageno, XLogRecGetData(record), sizeof(pageno));
1037
1038 lock = SimpleLruGetBankLock(CommitTsCtl, pageno);
1039 LWLockAcquire(lock, LW_EXCLUSIVE);
1040
1041 slotno = ZeroCommitTsPage(pageno, false);
1042 SimpleLruWritePage(CommitTsCtl, slotno);
1043 Assert(!CommitTsCtl->shared->page_dirty[slotno]);
1044
1045 LWLockRelease(lock);
1046 }
1047 else if (info == COMMIT_TS_TRUNCATE)
1048 {
1049 xl_commit_ts_truncate *trunc = (xl_commit_ts_truncate *) XLogRecGetData(record);
1050
1051 AdvanceOldestCommitTsXid(trunc->oldestXid);
1052
1053 /*
1054 * During XLOG replay, latest_page_number isn't set up yet; insert a
1055 * suitable value to bypass the sanity test in SimpleLruTruncate.
1056 */
1057 pg_atomic_write_u64(&CommitTsCtl->shared->latest_page_number,
1058 trunc->pageno);
1059
1060 SimpleLruTruncate(CommitTsCtl, trunc->pageno);
1061 }
1062 else
1063 elog(PANIC, "commit_ts_redo: unknown op code %u", info);
1064 }
1065
1066 /*
1067 * Entrypoint for sync.c to sync commit_ts files.
1068 */
1069 int
1070 committssyncfiletag(const FileTag *ftag, char *path)
1071 {
1072 return SlruSyncFileTag(CommitTsCtl, ftag, path);
1073 }