Loading...
Searching...
No Matches
#include "postgres.h"#include "access/clog.h"#include "access/slru.h"#include "access/transam.h"#include "access/xlog.h"#include "access/xloginsert.h"#include "access/xlogutils.h"#include "miscadmin.h"#include "pg_trace.h"#include "pgstat.h"#include "storage/proc.h"#include "storage/subsystems.h"#include "storage/sync.h"#include "utils/guc_hooks.h"#include "utils/wait_event.h"
Include dependency graph for clog.c:
Go to the source code of this file.
Macros | |
| #define | CLOG_BITS_PER_XACT 2 |
| #define | CLOG_XACTS_PER_BYTE 4 |
| #define | CLOG_XACTS_PER_PAGE (BLCKSZ * CLOG_XACTS_PER_BYTE) |
| #define | CLOG_XACT_BITMASK ((1 << CLOG_BITS_PER_XACT) - 1) |
| #define | CLOG_MAX_ALLOWED_BUFFERS |
| #define | TransactionIdToPgIndex(xid) ((xid) % (TransactionId) CLOG_XACTS_PER_PAGE) |
| #define | TransactionIdToByte(xid) (TransactionIdToPgIndex(xid) / CLOG_XACTS_PER_BYTE) |
| #define | TransactionIdToBIndex(xid) ((xid) % (TransactionId) CLOG_XACTS_PER_BYTE) |
| #define | CLOG_XACTS_PER_LSN_GROUP 32 /* keep this a power of 2 */ |
| #define | CLOG_LSNS_PER_PAGE (CLOG_XACTS_PER_PAGE / CLOG_XACTS_PER_LSN_GROUP) |
| #define | GetLSNIndex(slotno, xid) |
| #define | THRESHOLD_SUBTRANS_CLOG_OPT 5 |
| #define | XactCtl (&XactSlruDesc) |
Variables | |
| const ShmemCallbacks | CLOGShmemCallbacks |
| static SlruDesc | XactSlruDesc |
Macro Definition Documentation
◆ CLOG_BITS_PER_XACT
◆ CLOG_LSNS_PER_PAGE
| #define CLOG_LSNS_PER_PAGE (CLOG_XACTS_PER_PAGE / CLOG_XACTS_PER_LSN_GROUP) |
◆ CLOG_MAX_ALLOWED_BUFFERS
| #define CLOG_MAX_ALLOWED_BUFFERS |
Value:
Definition at line 74 of file clog.c.
84{
86}
87
88#define TransactionIdToPgIndex(xid) ((xid) % (TransactionId) CLOG_XACTS_PER_PAGE)
89#define TransactionIdToByte(xid) (TransactionIdToPgIndex(xid) / CLOG_XACTS_PER_BYTE)
90#define TransactionIdToBIndex(xid) ((xid) % (TransactionId) CLOG_XACTS_PER_BYTE)
91
92/* We store the latest async LSN for each group of transactions */
93#define CLOG_XACTS_PER_LSN_GROUP 32 /* keep this a power of 2 */
94#define CLOG_LSNS_PER_PAGE (CLOG_XACTS_PER_PAGE / CLOG_XACTS_PER_LSN_GROUP)
95
96#define GetLSNIndex(slotno, xid) ((slotno) * CLOG_LSNS_PER_PAGE + \
97 ((xid) % (TransactionId) CLOG_XACTS_PER_PAGE) / CLOG_XACTS_PER_LSN_GROUP)
98
99/*
100 * The number of subtransactions below which we consider to apply clog group
101 * update optimization. Testing reveals that the number higher than this can
102 * hurt performance.
103 */
104#define THRESHOLD_SUBTRANS_CLOG_OPT 5
105
106/*
107 * Link to shared-memory data structures for CLOG control
108 */
113
116 .init_fn = CLOGShmemInit,
117};
118
120
121#define XactCtl (&XactSlruDesc)
122
123
125 Oid oldestXactDb);
139
140
141/*
142 * TransactionIdSetTreeStatus
143 *
144 * Record the final state of transaction entries in the commit log for
145 * a transaction and its subtransaction tree. Take care to ensure this is
146 * efficient, and as atomic as possible.
147 *
148 * xid is a single xid to set status for. This will typically be
149 * the top level transactionid for a top level commit or abort. It can
150 * also be a subtransaction when we record transaction aborts.
151 *
152 * subxids is an array of xids of length nsubxids, representing subtransactions
153 * in the tree of xid. In various cases nsubxids may be zero.
154 *
155 * lsn must be the WAL location of the commit record when recording an async
156 * commit. For a synchronous commit it can be InvalidXLogRecPtr, since the
157 * caller guarantees the commit record is already flushed in that case. It
158 * should be InvalidXLogRecPtr for abort cases, too.
159 *
160 * In the commit case, atomicity is limited by whether all the subxids are in
161 * the same CLOG page as xid. If they all are, then the lock will be grabbed
162 * only once, and the status will be set to committed directly. Otherwise
163 * we must
164 * 1. set sub-committed all subxids that are not on the same page as the
165 * main xid
166 * 2. atomically set committed the main xid and the subxids on the same page
167 * 3. go over the first bunch again and set them committed
168 * Note that as far as concurrent checkers are concerned, main transaction
169 * commit as a whole is still atomic.
170 *
171 * Example:
172 * TransactionId t commits and has subxids t1, t2, t3, t4
173 * t is on page p1, t1 is also on p1, t2 and t3 are on p2, t4 is on p3
174 * 1. update pages2-3:
175 * page2: set t2,t3 as sub-committed
176 * page3: set t4 as sub-committed
177 * 2. update page1:
178 * page1: set t,t1 as committed
179 * 3. update pages2-3:
180 * page2: set t2,t3 as committed
181 * page3: set t4 as committed
182 *
183 * NB: this is a low-level routine and is NOT the preferred entry point
184 * for most uses; functions in transam.c are the intended callers.
185 *
186 * XXX Think about issuing POSIX_FADV_WILLNEED on pages that we will need,
187 * but aren't yet in cache, as well as hinting pages not to fall out of
188 * cache yet.
189 */
190void
193{
196
198 status == TRANSACTION_STATUS_ABORTED);
199
200 /*
201 * See how many subxids, if any, are on the same page as the parent, if
202 * any.
203 */
205 {
207 break;
208 }
209
210 /*
211 * Do all items fit on a single page?
212 */
214 {
215 /*
216 * Set the parent and all subtransactions in a single call
217 */
219 pageno, true);
220 }
221 else
222 {
224
225 /*
226 * If this is a commit then we care about doing this correctly (i.e.
227 * using the subcommitted intermediate status). By here, we know
228 * we're updating more than one page of clog, so we must mark entries
229 * that are *not* on the first page so that they show as subcommitted
230 * before we then return to update the status to fully committed.
231 *
232 * To avoid touching the first page twice, skip marking subcommitted
233 * for the subxids on that first page.
234 */
237 subxids + nsubxids_on_first_page,
238 TRANSACTION_STATUS_SUB_COMMITTED, lsn);
239
240 /*
241 * Now set the parent and subtransactions on same page as the parent,
242 * if any
243 */
244 pageno = TransactionIdToPage(xid);
246 lsn, pageno, false);
247
248 /*
249 * Now work through the rest of the subxids one clog page at a time,
250 * starting from the second page onwards, like we did above.
251 */
253 subxids + nsubxids_on_first_page,
254 status, lsn);
255 }
256}
257
258/*
259 * Helper for TransactionIdSetTreeStatus: set the status for a bunch of
260 * transactions, chunking in the separate CLOG pages involved. We never
261 * pass the whole transaction tree to this function, only subtransactions
262 * that are on different pages to the top level transaction id.
263 */
264static void
267{
269 int offset = 0;
271
273
275 {
278
279 do
280 {
283 break;
284 num_on_page++;
285 i++;
287
289 num_on_page, subxids + offset,
290 status, lsn, pageno, false);
291 offset = i;
292 pageno = nextpageno;
293 }
294}
295
296/*
297 * Record the final state of transaction entries in the commit log for all
298 * entries on a single page. Atomic only on this page.
299 */
300static void
305{
306 LWLock *lock;
307
308 /* Can't use group update when PGPROC overflows. */
310 "group clog threshold less than PGPROC cached subxids");
311
312 /* Get the SLRU bank lock for the page we are going to access. */
314
315 /*
316 * When there is contention on the SLRU bank lock we need, we try to group
317 * multiple updates; a single leader process will perform transaction
318 * status updates for multiple backends so that the number of times the
319 * bank lock needs to be acquired is reduced.
320 *
321 * For this optimization to be safe, the XID and subxids in MyProc must be
322 * the same as the ones for which we're setting the status. Check that
323 * this is the case.
324 *
325 * For this optimization to be efficient, we shouldn't have too many
326 * sub-XIDs and all of the XIDs for which we're adjusting clog should be
327 * on the same page. Check those conditions, too.
328 */
332 (nsubxids == 0 ||
335 {
336 /*
337 * If we can immediately acquire the lock, we update the status of our
338 * own XID and release the lock. If not, try use group XID update. If
339 * that doesn't work out, fall back to waiting for the lock to perform
340 * an update for this transaction only.
341 */
343 {
344 /* Got the lock without waiting! Do the update. */
346 lsn, pageno);
347 LWLockRelease(lock);
348 return;
349 }
351 {
352 /* Group update mechanism has done the work. */
353 return;
354 }
355
356 /* Fall through only if update isn't done yet. */
357 }
358
359 /* Group update not applicable, or couldn't accept this page number. */
362 lsn, pageno);
363 LWLockRelease(lock);
364}
365
366/*
367 * Record the final state of transaction entry in the commit log
368 *
369 * We don't do any locking here; caller must handle that.
370 */
371static void
375{
378
380 status == TRANSACTION_STATUS_ABORTED ||
383 LW_EXCLUSIVE));
384
385 /*
386 * If we're doing an async commit (ie, lsn is valid), then we must wait
387 * for any active write on the page slot to complete. Otherwise our
388 * update could reach disk in that write, which will not do since we
389 * mustn't let it reach disk until we've done the appropriate WAL flush.
390 * But when lsn is invalid, it's OK to scribble on a page while it is
391 * write-busy, since we don't care if the update reaches disk sooner than
392 * we think.
393 */
395
396 /*
397 * Set the main transaction id, if any.
398 *
399 * If we update more than one xid on this page while it is being written
400 * out, we might find that some of the bits go to disk and others don't.
401 * If we are updating commits on the page with the top-level xid that
402 * could break atomicity, so we subcommit the subxids first before we mark
403 * the top-level commit.
404 */
406 {
407 /* Subtransactions first, if needed ... */
409 {
411 {
415 lsn, slotno);
416 }
417 }
418
419 /* ... then the main transaction */
421 }
422
423 /* Set the subtransactions */
425 {
428 }
429
431}
432
433/*
434 * Subroutine for TransactionIdSetPageStatus, q.v.
435 *
436 * When we cannot immediately acquire the SLRU bank lock in exclusive mode at
437 * commit time, add ourselves to a list of processes that need their XIDs
438 * status update. The first process to add itself to the list will acquire
439 * the lock in exclusive mode and set transaction status as required on behalf
440 * of all group members. This avoids a great deal of contention when many
441 * processes are trying to commit at once, since the lock need not be
442 * repeatedly handed off from one committing process to the next.
443 *
444 * Returns true when transaction status has been updated in clog; returns
445 * false if we decided against applying the optimization because the page
446 * number we need to update differs from those processes already waiting.
447 */
448static bool
451{
458
459 /* We should definitely have an XID whose status needs to be updated. */
461
462 /*
463 * Prepare to add ourselves to the list of processes needing a group XID
464 * status update.
465 */
467 proc->clogGroupMemberXid = xid;
468 proc->clogGroupMemberXidStatus = status;
469 proc->clogGroupMemberPage = pageno;
470 proc->clogGroupMemberLsn = lsn;
471
472 /*
473 * We put ourselves in the queue by writing MyProcNumber to
474 * ProcGlobal->clogGroupFirst. However, if there's already a process
475 * listed there, we compare our pageno with that of that process; if it
476 * differs, we cannot participate in the group, so we return for caller to
477 * update pg_xact in the normal way.
478 *
479 * If we're not the first process in the list, we must follow the leader.
480 * We do this by storing the data we want updated in our PGPROC entry
481 * where the leader can find it, then going to sleep.
482 *
483 * If no process is already in the list, we're the leader; our first step
484 * is to lock the SLRU bank to which our page belongs, then we close out
485 * the group by resetting the list pointer from ProcGlobal->clogGroupFirst
486 * (this lets other processes set up other groups later); finally we do
487 * the SLRU updates, release the SLRU bank lock, and wake up the sleeping
488 * processes.
489 *
490 * If another group starts to update a page in a different SLRU bank, they
491 * can proceed concurrently, since the bank lock they're going to use is
492 * different from ours. If another group starts to update a page in the
493 * same bank as ours, they wait until we release the lock.
494 */
496
497 while (true)
498 {
499 /*
500 * Add the proc to list, if the clog page where we need to update the
501 * current transaction status is same as group leader's clog page.
502 *
503 * There is a race condition here, which is that after doing the below
504 * check and before adding this proc's clog update to a group, the
505 * group leader might have already finished the group update for this
506 * page and becomes group leader of another group, updating a
507 * different page. This will lead to a situation where a single group
508 * can have different clog page updates. This isn't likely and will
509 * still work, just less efficiently -- we handle this case by
510 * switching to a different bank lock in the loop below.
511 */
514 {
515 /*
516 * Ensure that this proc is not a member of any clog group that
517 * needs an XID status update.
518 */
521 return false;
522 }
523
525
527 &nextidx,
529 break;
530 }
531
532 /*
533 * If the list was not empty, the leader will update the status of our
534 * XID. It is impossible to have followers without a leader because the
535 * first process that has added itself to the list will always have
536 * nextidx as INVALID_PROC_NUMBER.
537 */
539 {
541
542 /* Sleep until the leader updates our XID status. */
544 for (;;)
545 {
546 /* acts as a read barrier */
549 break;
550 extraWaits++;
551 }
552 pgstat_report_wait_end();
553
555
556 /* Fix semaphore count for any absorbed wakeups */
559 return true;
560 }
561
562 /*
563 * By here, we know we're the leader process. Acquire the SLRU bank lock
564 * that corresponds to the page we originally wanted to modify.
565 */
569
570 /*
571 * Now that we've got the lock, clear the list of processes waiting for
572 * group XID status update, saving a pointer to the head of the list.
573 * (Trying to pop elements one at a time could lead to an ABA problem.)
574 *
575 * At this point, any processes trying to do this would create a separate
576 * group.
577 */
579 INVALID_PROC_NUMBER);
580
581 /* Remember head of list so we can perform wakeups after dropping lock. */
583
584 /* Walk the list and update the status of all XIDs. */
586 {
589
590 /*
591 * If the page to update belongs to a different bank than the previous
592 * one, exchange bank lock to the new one. This should be quite rare,
593 * as described above.
594 *
595 * (We could try to optimize this by waking up the processes for which
596 * we have already updated the status while we exchange the lock, but
597 * the code doesn't do that at present. I think it'd require
598 * additional bookkeeping, making the common path slower in order to
599 * improve an infrequent case.)
600 */
602 {
604
606 {
609 }
610 prevlock = lock;
612 }
613
614 /*
615 * Transactions with more than THRESHOLD_SUBTRANS_CLOG_OPT sub-XIDs
616 * should not use group XID status update mechanism.
617 */
619
621 nextproc->subxidStatus.count,
622 nextproc->subxids.xids,
623 nextproc->clogGroupMemberXidStatus,
624 nextproc->clogGroupMemberLsn,
625 nextproc->clogGroupMemberPage);
626
627 /* Move to next proc in list. */
629 }
630
631 /* We're done with the lock now. */
634
635 /*
636 * Now that we've released the lock, go back and wake everybody up. We
637 * don't do this under the lock so as to keep lock hold times to a
638 * minimum.
639 *
640 * (Perhaps we could do this in two passes, the first setting
641 * clogGroupNext to invalid while saving the semaphores to an array, then
642 * a single write barrier, then another pass unlocking the semaphores.)
643 */
645 {
647
650
651 /* ensure all previous writes are visible before follower continues. */
652 pg_write_barrier();
653
655
658 }
659
660 return true;
661}
662
663/*
664 * Sets the commit status of a single transaction.
665 *
666 * Caller must hold the corresponding SLRU bank lock, will be held at exit.
667 */
668static void
670{
676
680 LW_EXCLUSIVE));
681
684
685 /*
686 * When replaying transactions during recovery we still need to perform
687 * the two phases of subcommit and then commit. However, some transactions
688 * are already correctly marked, so we just treat those as a no-op which
689 * allows us to keep the following Assert as restrictive as possible.
690 */
693 return;
694
695 /*
696 * Current state change should be from 0 or subcommitted to target state
697 * or we should already be there when replaying changes during recovery.
698 */
701 status != TRANSACTION_STATUS_IN_PROGRESS) ||
702 curval == status);
703
704 /* note this assumes exclusive access to the clog page */
709
710 /*
711 * Update the group LSN if the transaction completion LSN is higher.
712 *
713 * Note: lsn will be invalid when supplied during InRecovery processing,
714 * so we don't need to do anything special to avoid LSN updates during
715 * recovery. After recovery completes the next clog change will set the
716 * LSN correctly.
717 */
719 {
721
724 }
725}
726
727/*
728 * Interrogate the state of a transaction in the commit log.
729 *
730 * Aside from the actual commit status, this function returns (into *lsn)
731 * an LSN that is late enough to be able to guarantee that if we flush up to
732 * that LSN then we will have flushed the transaction's commit record to disk.
733 * The result is not necessarily the exact LSN of the transaction's commit
734 * record! For example, for long-past transactions (those whose clog pages
735 * already migrated to disk), we'll return InvalidXLogRecPtr. Also, because
736 * we group transactions on the same clog page to conserve storage, we might
737 * return the LSN of a later transaction that falls into the same group.
738 *
739 * NB: this is a low-level routine and is NOT the preferred entry point
740 * for most uses; TransactionLogFetch() in transam.c is the intended caller.
741 */
742XidStatus
744{
751 XidStatus status;
752
753 /* lock is acquired by SimpleLruReadPage_ReadOnly */
754
757
759
762
764
765 return status;
766}
767
768/*
769 * Number of shared CLOG buffers.
770 *
771 * If asked to autotune, use 2MB for every 1GB of shared buffers, up to 8MB.
772 * Otherwise just cap the configured amount to be between 16 and the maximum
773 * allowed.
774 */
775static int
777{
778 /* auto-tune based on shared buffers */
781
783}
784
785/*
786 * Register shared memory for CLOG
787 */
788static void
790{
791 /* If auto-tuning is requested, now is the time to do it */
793 {
795
798 PGC_S_DYNAMIC_DEFAULT);
799
800 /*
801 * We prefer to report this value's source as PGC_S_DYNAMIC_DEFAULT.
802 * However, if the DBA explicitly set transaction_buffers = 0 in the
803 * config file, then PGC_S_DYNAMIC_DEFAULT will fail to override that
804 * and we must force the matter with PGC_S_OVERRIDE.
805 */
808 PGC_S_OVERRIDE);
809 }
813 .Dir = "pg_xact",
814 .long_segment_names = false,
815
816 .nslots = CLOGShmemBuffers(),
817 .nlsns = CLOG_LSNS_PER_PAGE,
818
819 .sync_handler = SYNC_HANDLER_CLOG,
820 .PagePrecedes = CLOGPagePrecedes,
821 .errdetail_for_io_error = clog_errdetail_for_io_error,
822
823 .buffer_tranche_id = LWTRANCHE_XACT_BUFFER,
824 .bank_tranche_id = LWTRANCHE_XACT_SLRU,
825 );
826}
827
828static void
830{
832}
833
834/*
835 * GUC check_hook for transaction_buffers
836 */
837bool
839{
841}
842
843/*
844 * This func must be called ONCE on system install. It creates
845 * the initial CLOG segment. (The CLOG directory is assumed to
846 * have been created by initdb, and CLOGShmemInit must have been
847 * called already.)
848 */
849void
851{
852 /* Zero the initial page and flush it to disk */
854}
855
856/*
857 * This must be called ONCE during postmaster or standalone-backend startup,
858 * after StartupXLOG has initialized TransamVariables->nextXid.
859 */
860void
862{
865
866 /*
867 * Initialize our idea of the latest page number.
868 */
870}
871
872/*
873 * This must be called ONCE at the end of startup/recovery.
874 */
875void
877{
881
883
884 /*
885 * Zero out the remainder of the current clog page. Under normal
886 * circumstances it should be zeroes already, but it seems at least
887 * theoretically possible that XLOG replay will have settled on a nextXID
888 * value that is less than the last XID actually used and marked by the
889 * previous database lifecycle (since subtransaction commit writes clog
890 * but makes no WAL entry). Let's just be safe. (We need not worry about
891 * pages beyond the current one, since those will be zeroed when first
892 * used. For the same reason, there is no need to do anything when
893 * nextXid is exactly at a page boundary; and it's likely that the
894 * "current" page doesn't exist yet in that case.)
895 */
897 {
902
905
906 /* Zero so-far-unused positions in the current byte */
908 /* Zero the rest of the page */
910
912 }
913
914 LWLockRelease(lock);
915}
916
917/*
918 * Perform a checkpoint --- either during shutdown, or on-the-fly
919 */
920void
922{
923 /*
924 * Write dirty CLOG pages to disk. This may result in sync requests
925 * queued for later handling by ProcessSyncRequests(), as part of the
926 * checkpoint.
927 */
931}
932
933
934/*
935 * Make sure that CLOG has room for a newly-allocated XID.
936 *
937 * NB: this is called while holding XidGenLock. We want it to be very fast
938 * most of the time; even when it's not so fast, no actual I/O need happen
939 * unless we're forced to write out a dirty clog or xlog page to make room
940 * in shared memory.
941 */
942void
944{
945 int64 pageno;
946 LWLock *lock;
947
948 /*
949 * No work except at first XID of a page. But beware: just after
950 * wraparound, the first XID of page zero is FirstNormalTransactionId.
951 */
954 return;
955
958
960
961 /* Zero the page and make a WAL entry about it */
964
965 LWLockRelease(lock);
966}
967
968
969/*
970 * Remove all CLOG segments before the one holding the passed transaction ID
971 *
972 * Before removing any CLOG data, we must flush XLOG to disk, to ensure that
973 * any recently-emitted records with freeze plans have reached disk; otherwise
974 * a crash and restart might leave us with some unfrozen tuples referencing
975 * removed CLOG data. We choose to emit a special TRUNCATE XLOG record too.
976 * Replaying the deletion from XLOG is not critical, since the files could
977 * just as well be removed later, but doing so prevents a long-running hot
978 * standby server from acquiring an unreasonably bloated CLOG directory.
979 *
980 * Since CLOG segments hold a large number of transactions, the opportunity to
981 * actually remove a segment is fairly rare, and so it seems best not to do
982 * the XLOG flush unless we have confirmed that there is a removable segment.
983 */
984void
986{
988
989 /*
990 * The cutoff point is the start of the segment containing oldestXact. We
991 * pass the *page* containing oldestXact to SimpleLruTruncate.
992 */
994
995 /* Check to see if there's any files that could be removed */
997 return; /* nothing to remove */
998
999 /*
1000 * Advance oldestClogXid before truncating clog, so concurrent xact status
1001 * lookups can ensure they don't attempt to access truncated-away clog.
1002 *
1003 * It's only necessary to do this if we will actually truncate away clog
1004 * pages.
1005 */
1006 AdvanceOldestClogXid(oldestXact);
1007
1008 /*
1009 * Write XLOG record and flush XLOG to disk. We record the oldest xid
1010 * we're keeping information about here so we can ensure that it's always
1011 * ahead of clog truncation in case we crash, and so a standby finds out
1012 * the new valid xid before the next checkpoint.
1013 */
1015
1016 /* Now we can remove the old CLOG segment(s) */
1018}
1019
1020
1021/*
1022 * Decide whether a CLOG page number is "older" for truncation purposes.
1023 *
1024 * We need to use comparison of TransactionIds here in order to do the right
1025 * thing with wraparound XID arithmetic. However, TransactionIdPrecedes()
1026 * would get weird about permanent xact IDs. So, offset both such that xid1,
1027 * xid2, and xid2 + CLOG_XACTS_PER_PAGE - 1 are all normal XIDs; this offset
1028 * is relevant to page 0 and to the page preceding page 0.
1029 *
1030 * The page containing oldestXact-2^31 is the important edge case. The
1031 * portion of that page equaling or following oldestXact-2^31 is expendable,
1032 * but the portion preceding oldestXact-2^31 is not. When oldestXact-2^31 is
1033 * the first XID of a page and segment, the entire page and segment is
1034 * expendable, and we could truncate the segment. Recognizing that case would
1035 * require making oldestXact, not just the page containing oldestXact,
1036 * available to this callback. The benefit would be rare and small, so we
1037 * don't optimize that edge case.
1038 */
1039static bool
1041{
1044
1049
1052}
1053
1054static int
1056{
1058
1060}
1061
1062
1063/*
1064 * Write a TRUNCATE xlog record
1065 *
1066 * We must flush the xlog record to disk before returning --- see notes
1067 * in TruncateCLOG().
1068 */
1069static void
1071{
1074
1076 xlrec.oldestXact = oldestXact;
1077 xlrec.oldestXactDb = oldestXactDb;
1078
1079 XLogBeginInsert();
1083}
1084
1085/*
1086 * CLOG resource manager's routines
1087 */
1088void
1090{
1092
1093 /* Backup blocks are not used in clog records */
1095
1097 {
1098 int64 pageno;
1099
1102 }
1104 {
1106
1108
1110
1112 }
1113 else
1115}
1116
1117/*
1118 * Entrypoint for sync.c to sync clog files.
1119 */
1120int
1122{
1124}
static bool pg_atomic_compare_exchange_u32(volatile pg_atomic_uint32 *ptr, uint32 *expected, uint32 newval)
Definition atomics.h:349
static void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition atomics.h:485
static void pg_atomic_write_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
Definition atomics.h:274
static uint32 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)
Definition atomics.h:237
static uint32 pg_atomic_exchange_u32(volatile pg_atomic_uint32 *ptr, uint32 newval)
Definition atomics.h:330
memcpy(sums, checksumBaseOffsets, sizeof(checksumBaseOffsets))
static void TransactionIdSetStatusBit(TransactionId xid, XidStatus status, XLogRecPtr lsn, int slotno)
Definition clog.c:670
XidStatus TransactionIdGetStatus(TransactionId xid, XLogRecPtr *lsn)
Definition clog.c:744
void TransactionIdSetTreeStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn)
Definition clog.c:192
bool check_transaction_buffers(int *newval, void **extra, GucSource source)
Definition clog.c:839
static void TransactionIdSetPageStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn, int64 pageno, bool all_xact_same_page)
Definition clog.c:302
static int clog_errdetail_for_io_error(const void *opaque_data)
Definition clog.c:1056
static void set_status_by_pages(int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn)
Definition clog.c:266
static bool TransactionGroupUpdateXidStatus(TransactionId xid, XidStatus status, XLogRecPtr lsn, int64 pageno)
Definition clog.c:450
static void TransactionIdSetPageStatusInternal(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn, int64 pageno)
Definition clog.c:373
static void WriteTruncateXlogRec(int64 pageno, TransactionId oldestXact, Oid oldestXactDb)
Definition clog.c:1071
int errdetail(const char *fmt,...) pg_attribute_printf(1
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
Definition guc.c:4228
#define newval
bool LWLockHeldByMeInMode(LWLock *lock, LWLockMode mode)
Definition lwlock.c:1929
bool LWLockConditionalAcquire(LWLock *lock, LWLockMode mode)
Definition lwlock.c:1321
bool SlruScanDirectory(SlruDesc *ctl, SlruScanCallback callback, void *data)
Definition slru.c:1844
int SimpleLruReadPage_ReadOnly(SlruDesc *ctl, int64 pageno, const void *opaque_data)
Definition slru.c:654
bool SlruScanDirCbReportPresence(SlruDesc *ctl, char *filename, int64 segpage, void *data)
Definition slru.c:1765
void SimpleLruZeroAndWritePage(SlruDesc *ctl, int64 pageno)
Definition slru.c:466
int SimpleLruReadPage(SlruDesc *ctl, int64 pageno, bool write_ok, const void *opaque_data)
Definition slru.c:550
int SlruSyncFileTag(SlruDesc *ctl, const FileTag *ftag, char *path)
Definition slru.c:1884
static LWLock * SimpleLruGetBankLock(SlruDesc *ctl, int64 pageno)
Definition slru.h:207
Definition lwlock.h:42
Definition proc.h:179
Definition proc.h:439
Definition shmem.h:123
Definition slru.h:191
Definition xlogreader.h:175
Definition clog.h:33
static bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition transam.h:263
void AdvanceOldestClogXid(TransactionId oldest_datfrozenxid)
Definition varsup.c:350
static void pgstat_report_wait_start(uint32 wait_event_info)
Definition wait_event.h:67
XLogRecPtr XLogSimpleInsertInt64(RmgrId rmid, uint8 info, int64 value)
Definition xloginsert.c:547
◆ CLOG_XACT_BITMASK
| #define CLOG_XACT_BITMASK ((1 << CLOG_BITS_PER_XACT) - 1) |
◆ CLOG_XACTS_PER_BYTE
◆ CLOG_XACTS_PER_LSN_GROUP
◆ CLOG_XACTS_PER_PAGE
| #define CLOG_XACTS_PER_PAGE (BLCKSZ * CLOG_XACTS_PER_BYTE) |
◆ GetLSNIndex
Value:
((slotno) * CLOG_LSNS_PER_PAGE + \
◆ THRESHOLD_SUBTRANS_CLOG_OPT
◆ TransactionIdToBIndex
| #define TransactionIdToBIndex | ( | xid | ) | ((xid) % (TransactionId) CLOG_XACTS_PER_BYTE) |
◆ TransactionIdToByte
| #define TransactionIdToByte | ( | xid | ) | (TransactionIdToPgIndex(xid) / CLOG_XACTS_PER_BYTE) |
◆ TransactionIdToPgIndex
| #define TransactionIdToPgIndex | ( | xid | ) | ((xid) % (TransactionId) CLOG_XACTS_PER_PAGE) |
◆ XactCtl
| #define XactCtl (&XactSlruDesc) |
Function Documentation
◆ BootStrapCLOG()
Definition at line 851 of file clog.c.
852{
853 /* Zero the initial page and flush it to disk */
855}
References SimpleLruZeroAndWritePage(), and XactCtl.
Referenced by BootStrapXLOG().
◆ check_transaction_buffers()
Definition at line 839 of file clog.c.
References check_slru_buffers(), and newval.
◆ CheckPointCLOG()
Definition at line 922 of file clog.c.
923{
924 /*
925 * Write dirty CLOG pages to disk. This may result in sync requests
926 * queued for later handling by ProcessSyncRequests(), as part of the
927 * checkpoint.
928 */
932}
References fb(), SimpleLruWriteAll(), and XactCtl.
Referenced by CheckPointGuts().
◆ clog_errdetail_for_io_error()
Definition at line 1056 of file clog.c.
1057{
1059
1061}
References errdetail(), and fb().
Referenced by CLOGShmemRequest().
◆ clog_redo()
| void clog_redo | ( | XLogReaderState * | record | ) |
Definition at line 1090 of file clog.c.
1091{
1093
1094 /* Backup blocks are not used in clog records */
1096
1098 {
1099 int64 pageno;
1100
1103 }
1105 {
1107
1109
1111
1113 }
1114 else
1116}
References AdvanceOldestClogXid(), Assert, CLOG_TRUNCATE, CLOG_ZEROPAGE, elog, fb(), memcpy(), PANIC, SimpleLruTruncate(), SimpleLruZeroAndWritePage(), XactCtl, XLogRecGetData, XLogRecGetInfo, and XLogRecHasAnyBlockRefs.
◆ CLOGPagePrecedes()
Definition at line 1041 of file clog.c.
1042{
1045
1050
1053}
References CLOG_XACTS_PER_PAGE, fb(), FirstNormalTransactionId, and TransactionIdPrecedes().
Referenced by CLOGShmemRequest().
◆ CLOGShmemBuffers()
Definition at line 777 of file clog.c.
778{
779 /* auto-tune based on shared buffers */
782
784}
References CLOG_MAX_ALLOWED_BUFFERS, Max, Min, SimpleLruAutotuneBuffers(), and transaction_buffers.
Referenced by CLOGShmemRequest().
◆ CLOGShmemInit()
Definition at line 830 of file clog.c.
References CLOG_XACTS_PER_PAGE, SlruPagePrecedesUnitTests, and XactCtl.
◆ CLOGShmemRequest()
Definition at line 790 of file clog.c.
791{
792 /* If auto-tuning is requested, now is the time to do it */
794 {
796
799 PGC_S_DYNAMIC_DEFAULT);
800
801 /*
802 * We prefer to report this value's source as PGC_S_DYNAMIC_DEFAULT.
803 * However, if the DBA explicitly set transaction_buffers = 0 in the
804 * config file, then PGC_S_DYNAMIC_DEFAULT will fail to override that
805 * and we must force the matter with PGC_S_OVERRIDE.
806 */
809 PGC_S_OVERRIDE);
810 }
814 .Dir = "pg_xact",
815 .long_segment_names = false,
816
817 .nslots = CLOGShmemBuffers(),
818 .nlsns = CLOG_LSNS_PER_PAGE,
819
820 .sync_handler = SYNC_HANDLER_CLOG,
821 .PagePrecedes = CLOGPagePrecedes,
822 .errdetail_for_io_error = clog_errdetail_for_io_error,
823
824 .buffer_tranche_id = LWTRANCHE_XACT_BUFFER,
825 .bank_tranche_id = LWTRANCHE_XACT_SLRU,
826 );
827}
References Assert, buf, clog_errdetail_for_io_error(), CLOG_LSNS_PER_PAGE, CLOGPagePrecedes(), CLOGShmemBuffers(), fb(), name, PGC_POSTMASTER, PGC_S_DYNAMIC_DEFAULT, PGC_S_OVERRIDE, SetConfigOption(), SimpleLruRequest, snprintf, SYNC_HANDLER_CLOG, transaction_buffers, and XactSlruDesc.
◆ clogsyncfiletag()
Definition at line 1122 of file clog.c.
References SlruSyncFileTag(), and XactCtl.
◆ ExtendCLOG()
| void ExtendCLOG | ( | TransactionId | newestXact | ) |
Definition at line 944 of file clog.c.
945{
946 int64 pageno;
947 LWLock *lock;
948
949 /*
950 * No work except at first XID of a page. But beware: just after
951 * wraparound, the first XID of page zero is FirstNormalTransactionId.
952 */
955 return;
956
959
961
962 /* Zero the page and make a WAL entry about it */
965
966 LWLockRelease(lock);
967}
References CLOG_ZEROPAGE, fb(), FirstNormalTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SimpleLruGetBankLock(), SimpleLruZeroPage(), TransactionIdEquals, TransactionIdToPage(), TransactionIdToPgIndex, XactCtl, and XLogSimpleInsertInt64().
Referenced by GetNewTransactionId().
◆ set_status_by_pages()
|
static |
Definition at line 266 of file clog.c.
268{
270 int offset = 0;
272
274
276 {
279
280 do
281 {
284 break;
285 num_on_page++;
286 i++;
288
290 num_on_page, subxids + offset,
291 status, lsn, pageno, false);
292 offset = i;
293 pageno = nextpageno;
294 }
295}
References Assert, fb(), i, InvalidTransactionId, TransactionIdSetPageStatus(), and TransactionIdToPage().
Referenced by TransactionIdSetTreeStatus().
◆ StartupCLOG()
Definition at line 862 of file clog.c.
863{
866
867 /*
868 * Initialize our idea of the latest page number.
869 */
871}
References TransamVariablesData::nextXid, pg_atomic_write_u64(), TransactionIdToPage(), TransamVariables, XactCtl, and XidFromFullTransactionId.
Referenced by StartupXLOG().
◆ TransactionGroupUpdateXidStatus()
|
static |
Definition at line 450 of file clog.c.
452{
459
460 /* We should definitely have an XID whose status needs to be updated. */
462
463 /*
464 * Prepare to add ourselves to the list of processes needing a group XID
465 * status update.
466 */
468 proc->clogGroupMemberXid = xid;
469 proc->clogGroupMemberXidStatus = status;
470 proc->clogGroupMemberPage = pageno;
471 proc->clogGroupMemberLsn = lsn;
472
473 /*
474 * We put ourselves in the queue by writing MyProcNumber to
475 * ProcGlobal->clogGroupFirst. However, if there's already a process
476 * listed there, we compare our pageno with that of that process; if it
477 * differs, we cannot participate in the group, so we return for caller to
478 * update pg_xact in the normal way.
479 *
480 * If we're not the first process in the list, we must follow the leader.
481 * We do this by storing the data we want updated in our PGPROC entry
482 * where the leader can find it, then going to sleep.
483 *
484 * If no process is already in the list, we're the leader; our first step
485 * is to lock the SLRU bank to which our page belongs, then we close out
486 * the group by resetting the list pointer from ProcGlobal->clogGroupFirst
487 * (this lets other processes set up other groups later); finally we do
488 * the SLRU updates, release the SLRU bank lock, and wake up the sleeping
489 * processes.
490 *
491 * If another group starts to update a page in a different SLRU bank, they
492 * can proceed concurrently, since the bank lock they're going to use is
493 * different from ours. If another group starts to update a page in the
494 * same bank as ours, they wait until we release the lock.
495 */
497
498 while (true)
499 {
500 /*
501 * Add the proc to list, if the clog page where we need to update the
502 * current transaction status is same as group leader's clog page.
503 *
504 * There is a race condition here, which is that after doing the below
505 * check and before adding this proc's clog update to a group, the
506 * group leader might have already finished the group update for this
507 * page and becomes group leader of another group, updating a
508 * different page. This will lead to a situation where a single group
509 * can have different clog page updates. This isn't likely and will
510 * still work, just less efficiently -- we handle this case by
511 * switching to a different bank lock in the loop below.
512 */
515 {
516 /*
517 * Ensure that this proc is not a member of any clog group that
518 * needs an XID status update.
519 */
522 return false;
523 }
524
526
528 &nextidx,
530 break;
531 }
532
533 /*
534 * If the list was not empty, the leader will update the status of our
535 * XID. It is impossible to have followers without a leader because the
536 * first process that has added itself to the list will always have
537 * nextidx as INVALID_PROC_NUMBER.
538 */
540 {
542
543 /* Sleep until the leader updates our XID status. */
545 for (;;)
546 {
547 /* acts as a read barrier */
550 break;
551 extraWaits++;
552 }
553 pgstat_report_wait_end();
554
556
557 /* Fix semaphore count for any absorbed wakeups */
560 return true;
561 }
562
563 /*
564 * By here, we know we're the leader process. Acquire the SLRU bank lock
565 * that corresponds to the page we originally wanted to modify.
566 */
570
571 /*
572 * Now that we've got the lock, clear the list of processes waiting for
573 * group XID status update, saving a pointer to the head of the list.
574 * (Trying to pop elements one at a time could lead to an ABA problem.)
575 *
576 * At this point, any processes trying to do this would create a separate
577 * group.
578 */
580 INVALID_PROC_NUMBER);
581
582 /* Remember head of list so we can perform wakeups after dropping lock. */
584
585 /* Walk the list and update the status of all XIDs. */
587 {
590
591 /*
592 * If the page to update belongs to a different bank than the previous
593 * one, exchange bank lock to the new one. This should be quite rare,
594 * as described above.
595 *
596 * (We could try to optimize this by waking up the processes for which
597 * we have already updated the status while we exchange the lock, but
598 * the code doesn't do that at present. I think it'd require
599 * additional bookkeeping, making the common path slower in order to
600 * improve an infrequent case.)
601 */
603 {
605
607 {
610 }
611 prevlock = lock;
613 }
614
615 /*
616 * Transactions with more than THRESHOLD_SUBTRANS_CLOG_OPT sub-XIDs
617 * should not use group XID status update mechanism.
618 */
620
622 nextproc->subxidStatus.count,
623 nextproc->subxids.xids,
624 nextproc->clogGroupMemberXidStatus,
625 nextproc->clogGroupMemberLsn,
626 nextproc->clogGroupMemberPage);
627
628 /* Move to next proc in list. */
630 }
631
632 /* We're done with the lock now. */
635
636 /*
637 * Now that we've released the lock, go back and wake everybody up. We
638 * don't do this under the lock so as to keep lock hold times to a
639 * minimum.
640 *
641 * (Perhaps we could do this in two passes, the first setting
642 * clogGroupNext to invalid while saving the semaphores to an array, then
643 * a single write barrier, then another pass unlocking the semaphores.)
644 */
646 {
648
651
652 /* ensure all previous writes are visible before follower continues. */
653 pg_write_barrier();
654
656
659 }
660
661 return true;
662}
References Assert, PGPROC::clogGroupMember, PGPROC::clogGroupMemberLsn, PGPROC::clogGroupMemberPage, PGPROC::clogGroupMemberXid, PGPROC::clogGroupMemberXidStatus, PGPROC::clogGroupNext, fb(), GetPGProcByNumber, INVALID_PROC_NUMBER, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyProc, MyProcNumber, pg_atomic_compare_exchange_u32(), pg_atomic_exchange_u32(), pg_atomic_read_u32(), pg_atomic_write_u32(), pg_write_barrier, PGSemaphoreLock(), PGSemaphoreUnlock(), pgstat_report_wait_end(), pgstat_report_wait_start(), ProcGlobal, PGPROC::sem, SimpleLruGetBankLock(), THRESHOLD_SUBTRANS_CLOG_OPT, TransactionIdIsValid, TransactionIdSetPageStatusInternal(), and XactCtl.
Referenced by TransactionIdSetPageStatus().
◆ TransactionIdGetStatus()
| XidStatus TransactionIdGetStatus | ( | TransactionId | xid, |
| XLogRecPtr * | lsn | ||
| ) |
Definition at line 744 of file clog.c.
745{
752 XidStatus status;
753
754 /* lock is acquired by SimpleLruReadPage_ReadOnly */
755
758
760
763
765
766 return status;
767}
References CLOG_BITS_PER_XACT, CLOG_XACT_BITMASK, fb(), GetLSNIndex, LWLockRelease(), SimpleLruGetBankLock(), SimpleLruReadPage_ReadOnly(), TransactionIdToBIndex, TransactionIdToByte, TransactionIdToPage(), and XactCtl.
Referenced by TransactionIdGetCommitLSN(), and TransactionLogFetch().
◆ TransactionIdSetPageStatus()
|
static |
Definition at line 302 of file clog.c.
306{
307 LWLock *lock;
308
309 /* Can't use group update when PGPROC overflows. */
311 "group clog threshold less than PGPROC cached subxids");
312
313 /* Get the SLRU bank lock for the page we are going to access. */
315
316 /*
317 * When there is contention on the SLRU bank lock we need, we try to group
318 * multiple updates; a single leader process will perform transaction
319 * status updates for multiple backends so that the number of times the
320 * bank lock needs to be acquired is reduced.
321 *
322 * For this optimization to be safe, the XID and subxids in MyProc must be
323 * the same as the ones for which we're setting the status. Check that
324 * this is the case.
325 *
326 * For this optimization to be efficient, we shouldn't have too many
327 * sub-XIDs and all of the XIDs for which we're adjusting clog should be
328 * on the same page. Check those conditions, too.
329 */
333 (nsubxids == 0 ||
336 {
337 /*
338 * If we can immediately acquire the lock, we update the status of our
339 * own XID and release the lock. If not, try use group XID update. If
340 * that doesn't work out, fall back to waiting for the lock to perform
341 * an update for this transaction only.
342 */
344 {
345 /* Got the lock without waiting! Do the update. */
347 lsn, pageno);
348 LWLockRelease(lock);
349 return;
350 }
352 {
353 /* Group update mechanism has done the work. */
354 return;
355 }
356
357 /* Fall through only if update isn't done yet. */
358 }
359
360 /* Group update not applicable, or couldn't accept this page number. */
363 lsn, pageno);
364 LWLockRelease(lock);
365}
References XidCacheStatus::count, fb(), LW_EXCLUSIVE, LWLockAcquire(), LWLockConditionalAcquire(), LWLockRelease(), MyProc, PGPROC_MAX_CACHED_SUBXIDS, SimpleLruGetBankLock(), StaticAssertDecl, PGPROC::subxids, PGPROC::subxidStatus, THRESHOLD_SUBTRANS_CLOG_OPT, TransactionGroupUpdateXidStatus(), TransactionIdSetPageStatusInternal(), XactCtl, PGPROC::xid, and XidCache::xids.
Referenced by set_status_by_pages(), and TransactionIdSetTreeStatus().
◆ TransactionIdSetPageStatusInternal()
|
static |
Definition at line 373 of file clog.c.
376{
379
381 status == TRANSACTION_STATUS_ABORTED ||
384 LW_EXCLUSIVE));
385
386 /*
387 * If we're doing an async commit (ie, lsn is valid), then we must wait
388 * for any active write on the page slot to complete. Otherwise our
389 * update could reach disk in that write, which will not do since we
390 * mustn't let it reach disk until we've done the appropriate WAL flush.
391 * But when lsn is invalid, it's OK to scribble on a page while it is
392 * write-busy, since we don't care if the update reaches disk sooner than
393 * we think.
394 */
396
397 /*
398 * Set the main transaction id, if any.
399 *
400 * If we update more than one xid on this page while it is being written
401 * out, we might find that some of the bits go to disk and others don't.
402 * If we are updating commits on the page with the top-level xid that
403 * could break atomicity, so we subcommit the subxids first before we mark
404 * the top-level commit.
405 */
407 {
408 /* Subtransactions first, if needed ... */
410 {
412 {
416 lsn, slotno);
417 }
418 }
419
420 /* ... then the main transaction */
422 }
423
424 /* Set the subtransactions */
426 {
429 }
430
432}
References Assert, fb(), i, LW_EXCLUSIVE, LWLockHeldByMeInMode(), SimpleLruGetBankLock(), SimpleLruReadPage(), TRANSACTION_STATUS_ABORTED, TRANSACTION_STATUS_COMMITTED, TRANSACTION_STATUS_SUB_COMMITTED, TransactionIdIsValid, TransactionIdSetStatusBit(), TransactionIdToPage(), XactCtl, and XLogRecPtrIsValid.
Referenced by TransactionGroupUpdateXidStatus(), and TransactionIdSetPageStatus().
◆ TransactionIdSetStatusBit()
|
static |
Definition at line 670 of file clog.c.
671{
677
681 LW_EXCLUSIVE));
682
685
686 /*
687 * When replaying transactions during recovery we still need to perform
688 * the two phases of subcommit and then commit. However, some transactions
689 * are already correctly marked, so we just treat those as a no-op which
690 * allows us to keep the following Assert as restrictive as possible.
691 */
694 return;
695
696 /*
697 * Current state change should be from 0 or subcommitted to target state
698 * or we should already be there when replaying changes during recovery.
699 */
702 status != TRANSACTION_STATUS_IN_PROGRESS) ||
703 curval == status);
704
705 /* note this assumes exclusive access to the clog page */
710
711 /*
712 * Update the group LSN if the transaction completion LSN is higher.
713 *
714 * Note: lsn will be invalid when supplied during InRecovery processing,
715 * so we don't need to do anything special to avoid LSN updates during
716 * recovery. After recovery completes the next clog change will set the
717 * LSN correctly.
718 */
720 {
722
725 }
726}
References Assert, CLOG_BITS_PER_XACT, CLOG_XACT_BITMASK, fb(), GetLSNIndex, InRecovery, LW_EXCLUSIVE, LWLockHeldByMeInMode(), SimpleLruGetBankLock(), TRANSACTION_STATUS_COMMITTED, TRANSACTION_STATUS_IN_PROGRESS, TRANSACTION_STATUS_SUB_COMMITTED, TransactionIdToBIndex, TransactionIdToByte, TransactionIdToPage(), XactCtl, and XLogRecPtrIsValid.
Referenced by TransactionIdSetPageStatusInternal().
◆ TransactionIdSetTreeStatus()
| void TransactionIdSetTreeStatus | ( | TransactionId | xid, |
| int | nsubxids, | ||
| TransactionId * | subxids, | ||
| XidStatus | status, | ||
| XLogRecPtr | lsn | ||
| ) |
Definition at line 192 of file clog.c.
194{
197
199 status == TRANSACTION_STATUS_ABORTED);
200
201 /*
202 * See how many subxids, if any, are on the same page as the parent, if
203 * any.
204 */
206 {
208 break;
209 }
210
211 /*
212 * Do all items fit on a single page?
213 */
215 {
216 /*
217 * Set the parent and all subtransactions in a single call
218 */
220 pageno, true);
221 }
222 else
223 {
225
226 /*
227 * If this is a commit then we care about doing this correctly (i.e.
228 * using the subcommitted intermediate status). By here, we know
229 * we're updating more than one page of clog, so we must mark entries
230 * that are *not* on the first page so that they show as subcommitted
231 * before we then return to update the status to fully committed.
232 *
233 * To avoid touching the first page twice, skip marking subcommitted
234 * for the subxids on that first page.
235 */
238 subxids + nsubxids_on_first_page,
239 TRANSACTION_STATUS_SUB_COMMITTED, lsn);
240
241 /*
242 * Now set the parent and subtransactions on same page as the parent,
243 * if any
244 */
245 pageno = TransactionIdToPage(xid);
247 lsn, pageno, false);
248
249 /*
250 * Now work through the rest of the subxids one clog page at a time,
251 * starting from the second page onwards, like we did above.
252 */
254 subxids + nsubxids_on_first_page,
255 status, lsn);
256 }
257}
References Assert, fb(), i, set_status_by_pages(), TRANSACTION_STATUS_ABORTED, TRANSACTION_STATUS_COMMITTED, TRANSACTION_STATUS_SUB_COMMITTED, TransactionIdSetPageStatus(), and TransactionIdToPage().
Referenced by TransactionIdAbortTree(), TransactionIdAsyncCommitTree(), and TransactionIdCommitTree().
◆ TransactionIdToPage()
|
inlinestatic |
Definition at line 84 of file clog.c.
References CLOG_XACTS_PER_PAGE.
Referenced by ExtendCLOG(), set_status_by_pages(), StartupCLOG(), TransactionIdGetStatus(), TransactionIdSetPageStatusInternal(), TransactionIdSetStatusBit(), TransactionIdSetTreeStatus(), TrimCLOG(), and TruncateCLOG().
◆ TrimCLOG()
Definition at line 877 of file clog.c.
878{
882
884
885 /*
886 * Zero out the remainder of the current clog page. Under normal
887 * circumstances it should be zeroes already, but it seems at least
888 * theoretically possible that XLOG replay will have settled on a nextXID
889 * value that is less than the last XID actually used and marked by the
890 * previous database lifecycle (since subtransaction commit writes clog
891 * but makes no WAL entry). Let's just be safe. (We need not worry about
892 * pages beyond the current one, since those will be zeroed when first
893 * used. For the same reason, there is no need to do anything when
894 * nextXid is exactly at a page boundary; and it's likely that the
895 * "current" page doesn't exist yet in that case.)
896 */
898 {
903
906
907 /* Zero so-far-unused positions in the current byte */
909 /* Zero the rest of the page */
911
913 }
914
915 LWLockRelease(lock);
916}
References CLOG_BITS_PER_XACT, fb(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MemSet, TransamVariablesData::nextXid, SimpleLruGetBankLock(), SimpleLruReadPage(), TransactionIdToBIndex, TransactionIdToByte, TransactionIdToPage(), TransactionIdToPgIndex, TransamVariables, XactCtl, and XidFromFullTransactionId.
Referenced by StartupXLOG().
◆ TruncateCLOG()
| void TruncateCLOG | ( | TransactionId | oldestXact, |
| Oid | oldestxid_datoid | ||
| ) |
Definition at line 986 of file clog.c.
987{
989
990 /*
991 * The cutoff point is the start of the segment containing oldestXact. We
992 * pass the *page* containing oldestXact to SimpleLruTruncate.
993 */
995
996 /* Check to see if there's any files that could be removed */
998 return; /* nothing to remove */
999
1000 /*
1001 * Advance oldestClogXid before truncating clog, so concurrent xact status
1002 * lookups can ensure they don't attempt to access truncated-away clog.
1003 *
1004 * It's only necessary to do this if we will actually truncate away clog
1005 * pages.
1006 */
1007 AdvanceOldestClogXid(oldestXact);
1008
1009 /*
1010 * Write XLOG record and flush XLOG to disk. We record the oldest xid
1011 * we're keeping information about here so we can ensure that it's always
1012 * ahead of clog truncation in case we crash, and so a standby finds out
1013 * the new valid xid before the next checkpoint.
1014 */
1016
1017 /* Now we can remove the old CLOG segment(s) */
1019}
References AdvanceOldestClogXid(), fb(), SimpleLruTruncate(), SlruScanDirCbReportPresence(), SlruScanDirectory(), TransactionIdToPage(), WriteTruncateXlogRec(), and XactCtl.
Referenced by vac_truncate_clog().
◆ WriteTruncateXlogRec()
|
static |
Definition at line 1071 of file clog.c.
1072{
1075
1077 xlrec.oldestXact = oldestXact;
1078 xlrec.oldestXactDb = oldestXactDb;
1079
1080 XLogBeginInsert();
1084}
References CLOG_TRUNCATE, fb(), xl_clog_truncate::pageno, XLogBeginInsert(), XLogFlush(), XLogInsert(), and XLogRegisterData().
Referenced by TruncateCLOG().
Variable Documentation
◆ CLOGShmemCallbacks
| const ShmemCallbacks CLOGShmemCallbacks |
Initial value:
◆ XactSlruDesc
|
static |
Definition at line 120 of file clog.c.
Referenced by CLOGShmemRequest().
