PostgreSQL Source Code git master
Macros | Functions | Variables
clog.c File Reference
#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/sync.h"
#include "utils/guc_hooks.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   (&XactCtlData)
 

Functions

static int64  TransactionIdToPage (TransactionId xid)
 
static bool  CLOGPagePrecedes (int64 page1, int64 page2)
 
static void  WriteTruncateXlogRec (int64 pageno, TransactionId oldestXact, Oid oldestXactDb)
 
static void  TransactionIdSetPageStatus (TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn, int64 pageno, bool all_xact_same_page)
 
static void  TransactionIdSetStatusBit (TransactionId xid, XidStatus status, XLogRecPtr lsn, int slotno)
 
static void  set_status_by_pages (int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn)
 
static bool  TransactionGroupUpdateXidStatus (TransactionId xid, XidStatus status, XLogRecPtr lsn, int64 pageno)
 
static void  TransactionIdSetPageStatusInternal (TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn, int64 pageno)
 
void  TransactionIdSetTreeStatus (TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn)
 
XidStatus  TransactionIdGetStatus (TransactionId xid, XLogRecPtr *lsn)
 
static int  CLOGShmemBuffers (void)
 
Size  CLOGShmemSize (void)
 
void  CLOGShmemInit (void)
 
bool  check_transaction_buffers (int *newval, void **extra, GucSource source)
 
void  BootStrapCLOG (void)
 
void  StartupCLOG (void)
 
void  TrimCLOG (void)
 
void  CheckPointCLOG (void)
 
void  ExtendCLOG (TransactionId newestXact)
 
void  TruncateCLOG (TransactionId oldestXact, Oid oldestxid_datoid)
 
void  clog_redo (XLogReaderState *record)
 
int  clogsyncfiletag (const FileTag *ftag, char *path)
 

Variables

static SlruCtlData  XactCtlData
 

Macro Definition Documentation

◆ CLOG_BITS_PER_XACT

#define CLOG_BITS_PER_XACT   2

Definition at line 62 of file clog.c.

◆ CLOG_LSNS_PER_PAGE

#define CLOG_LSNS_PER_PAGE   (CLOG_XACTS_PER_PAGE / CLOG_XACTS_PER_LSN_GROUP)

Definition at line 93 of file clog.c.

◆ CLOG_MAX_ALLOWED_BUFFERS

#define CLOG_MAX_ALLOWED_BUFFERS
Value:
#define Min(x, y)
Definition: c.h:1003
#define CLOG_XACTS_PER_PAGE
Definition: clog.c:64
#define SLRU_MAX_ALLOWED_BUFFERS
Definition: slru.h:24
#define MaxTransactionId
Definition: transam.h:35

Definition at line 72 of file clog.c.

◆ CLOG_XACT_BITMASK

#define CLOG_XACT_BITMASK   ((1 << CLOG_BITS_PER_XACT) - 1)

Definition at line 65 of file clog.c.

◆ CLOG_XACTS_PER_BYTE

#define CLOG_XACTS_PER_BYTE   4

Definition at line 63 of file clog.c.

◆ CLOG_XACTS_PER_LSN_GROUP

#define CLOG_XACTS_PER_LSN_GROUP   32 /* keep this a power of 2 */

Definition at line 92 of file clog.c.

◆ CLOG_XACTS_PER_PAGE

#define CLOG_XACTS_PER_PAGE   (BLCKSZ * CLOG_XACTS_PER_BYTE)

Definition at line 64 of file clog.c.

◆ GetLSNIndex

#define GetLSNIndex (   slotno,
  xid 
)
Value:
((slotno) * CLOG_LSNS_PER_PAGE + \
uint32 TransactionId
Definition: c.h:657
#define CLOG_XACTS_PER_LSN_GROUP
Definition: clog.c:92
#define CLOG_LSNS_PER_PAGE
Definition: clog.c:93

Definition at line 95 of file clog.c.

◆ THRESHOLD_SUBTRANS_CLOG_OPT

#define THRESHOLD_SUBTRANS_CLOG_OPT   5

Definition at line 103 of file clog.c.

◆ TransactionIdToBIndex

#define TransactionIdToBIndex (   xid )    ((xid) % (TransactionId) CLOG_XACTS_PER_BYTE)

Definition at line 89 of file clog.c.

◆ TransactionIdToByte

#define TransactionIdToByte (   xid )    (TransactionIdToPgIndex(xid) / CLOG_XACTS_PER_BYTE)

Definition at line 88 of file clog.c.

◆ TransactionIdToPgIndex

#define TransactionIdToPgIndex (   xid )    ((xid) % (TransactionId) CLOG_XACTS_PER_PAGE)

Definition at line 87 of file clog.c.

◆ XactCtl

#define XactCtl   (&XactCtlData)

Definition at line 110 of file clog.c.

Function Documentation

◆ BootStrapCLOG()

void BootStrapCLOG ( void  )

Definition at line 831 of file clog.c.

832{
833 /* Zero the initial page and flush it to disk */
835}
#define XactCtl
Definition: clog.c:110
void SimpleLruZeroAndWritePage(SlruCtl ctl, int64 pageno)
Definition: slru.c:444

References SimpleLruZeroAndWritePage(), and XactCtl.

Referenced by BootStrapXLOG().

◆ check_transaction_buffers()

bool check_transaction_buffers ( int *  newval,
void **  extra,
GucSource  source 
)

Definition at line 819 of file clog.c.

820{
821 return check_slru_buffers("transaction_buffers", newval);
822}
#define newval
bool check_slru_buffers(const char *name, int *newval)
Definition: slru.c:355

References check_slru_buffers(), and newval.

◆ CheckPointCLOG()

void CheckPointCLOG ( void  )

Definition at line 902 of file clog.c.

903{
904 /*
905 * Write dirty CLOG pages to disk. This may result in sync requests
906 * queued for later handling by ProcessSyncRequests(), as part of the
907 * checkpoint.
908 */
909 TRACE_POSTGRESQL_CLOG_CHECKPOINT_START(true);
911 TRACE_POSTGRESQL_CLOG_CHECKPOINT_DONE(true);
912}
void SimpleLruWriteAll(SlruCtl ctl, bool allow_redirtied)
Definition: slru.c:1347

References SimpleLruWriteAll(), and XactCtl.

Referenced by CheckPointGuts().

◆ clog_redo()

void clog_redo ( XLogReaderState *  record )

Definition at line 1062 of file clog.c.

1063{
1064 uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
1065
1066 /* Backup blocks are not used in clog records */
1068
1069 if (info == CLOG_ZEROPAGE)
1070 {
1071 int64 pageno;
1072
1073 memcpy(&pageno, XLogRecGetData(record), sizeof(pageno));
1075 }
1076 else if (info == CLOG_TRUNCATE)
1077 {
1078 xl_clog_truncate xlrec;
1079
1080 memcpy(&xlrec, XLogRecGetData(record), sizeof(xl_clog_truncate));
1081
1083
1085 }
1086 else
1087 elog(PANIC, "clog_redo: unknown op code %u", info);
1088}
uint8_t uint8
Definition: c.h:536
int64_t int64
Definition: c.h:535
#define CLOG_ZEROPAGE
Definition: clog.h:55
#define CLOG_TRUNCATE
Definition: clog.h:56
#define PANIC
Definition: elog.h:42
#define elog(elevel,...)
Definition: elog.h:226
Assert(PointerIsAligned(start, uint64))
void SimpleLruTruncate(SlruCtl ctl, int64 cutoffPage)
Definition: slru.c:1433
Definition: clog.h:33
int64 pageno
Definition: clog.h:34
TransactionId oldestXact
Definition: clog.h:35
void AdvanceOldestClogXid(TransactionId oldest_datfrozenxid)
Definition: varsup.c:355
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:410
#define XLogRecGetData(decoder)
Definition: xlogreader.h:415
#define XLogRecHasAnyBlockRefs(decoder)
Definition: xlogreader.h:417

References AdvanceOldestClogXid(), Assert(), CLOG_TRUNCATE, CLOG_ZEROPAGE, elog, xl_clog_truncate::oldestXact, xl_clog_truncate::pageno, PANIC, SimpleLruTruncate(), SimpleLruZeroAndWritePage(), XactCtl, XLogRecGetData, XLogRecGetInfo, and XLogRecHasAnyBlockRefs.

◆ CLOGPagePrecedes()

static bool CLOGPagePrecedes ( int64  page1,
int64  page2 
)
static

Definition at line 1021 of file clog.c.

1022{
1023 TransactionId xid1;
1024 TransactionId xid2;
1025
1026 xid1 = ((TransactionId) page1) * CLOG_XACTS_PER_PAGE;
1027 xid1 += FirstNormalTransactionId + 1;
1028 xid2 = ((TransactionId) page2) * CLOG_XACTS_PER_PAGE;
1029 xid2 += FirstNormalTransactionId + 1;
1030
1031 return (TransactionIdPrecedes(xid1, xid2) &&
1032 TransactionIdPrecedes(xid1, xid2 + CLOG_XACTS_PER_PAGE - 1));
1033}
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:280
#define FirstNormalTransactionId
Definition: transam.h:34

References CLOG_XACTS_PER_PAGE, FirstNormalTransactionId, and TransactionIdPrecedes().

Referenced by CLOGShmemInit().

◆ CLOGShmemBuffers()

static int CLOGShmemBuffers ( void  )
static

Definition at line 766 of file clog.c.

767{
768 /* auto-tune based on shared buffers */
769 if (transaction_buffers == 0)
770 return SimpleLruAutotuneBuffers(512, 1024);
771
773}
#define Max(x, y)
Definition: c.h:997
#define CLOG_MAX_ALLOWED_BUFFERS
Definition: clog.c:72
int transaction_buffers
Definition: globals.c:167
int SimpleLruAutotuneBuffers(int divisor, int max)
Definition: slru.c:231

References CLOG_MAX_ALLOWED_BUFFERS, Max, Min, SimpleLruAutotuneBuffers(), and transaction_buffers.

Referenced by CLOGShmemInit(), and CLOGShmemSize().

◆ CLOGShmemInit()

void CLOGShmemInit ( void  )

Definition at line 785 of file clog.c.

786{
787 /* If auto-tuning is requested, now is the time to do it */
788 if (transaction_buffers == 0)
789 {
790 char buf[32];
791
792 snprintf(buf, sizeof(buf), "%d", CLOGShmemBuffers());
793 SetConfigOption("transaction_buffers", buf, PGC_POSTMASTER,
795
796 /*
797 * We prefer to report this value's source as PGC_S_DYNAMIC_DEFAULT.
798 * However, if the DBA explicitly set transaction_buffers = 0 in the
799 * config file, then PGC_S_DYNAMIC_DEFAULT will fail to override that
800 * and we must force the matter with PGC_S_OVERRIDE.
801 */
802 if (transaction_buffers == 0) /* failed to apply it? */
803 SetConfigOption("transaction_buffers", buf, PGC_POSTMASTER,
805 }
807
808 XactCtl->PagePrecedes = CLOGPagePrecedes;
810 "pg_xact", LWTRANCHE_XACT_BUFFER,
811 LWTRANCHE_XACT_SLRU, SYNC_HANDLER_CLOG, false);
813}
static int CLOGShmemBuffers(void)
Definition: clog.c:766
static bool CLOGPagePrecedes(int64 page1, int64 page2)
Definition: clog.c:1021
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
Definition: guc.c:4338
@ PGC_S_DYNAMIC_DEFAULT
Definition: guc.h:114
@ PGC_S_OVERRIDE
Definition: guc.h:123
@ PGC_POSTMASTER
Definition: guc.h:74
static char * buf
Definition: pg_test_fsync.c:72
#define snprintf
Definition: port.h:239
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
#define SlruPagePrecedesUnitTests(ctl, per_page)
Definition: slru.h:200
@ SYNC_HANDLER_CLOG
Definition: sync.h:38

References Assert(), buf, CLOG_LSNS_PER_PAGE, CLOG_XACTS_PER_PAGE, CLOGPagePrecedes(), CLOGShmemBuffers(), PGC_POSTMASTER, PGC_S_DYNAMIC_DEFAULT, PGC_S_OVERRIDE, SetConfigOption(), SimpleLruInit(), SlruPagePrecedesUnitTests, snprintf, SYNC_HANDLER_CLOG, transaction_buffers, and XactCtl.

Referenced by CreateOrAttachShmemStructs().

◆ CLOGShmemSize()

Size CLOGShmemSize ( void  )

Definition at line 779 of file clog.c.

780{
782}
Size SimpleLruShmemSize(int nslots, int nlsns)
Definition: slru.c:198

References CLOG_LSNS_PER_PAGE, CLOGShmemBuffers(), and SimpleLruShmemSize().

Referenced by CalculateShmemSize().

◆ clogsyncfiletag()

int clogsyncfiletag ( const FileTag *  ftag,
char *  path 
)

Definition at line 1094 of file clog.c.

1095{
1096 return SlruSyncFileTag(XactCtl, ftag, path);
1097}
int SlruSyncFileTag(SlruCtl ctl, const FileTag *ftag, char *path)
Definition: slru.c:1856

References SlruSyncFileTag(), and XactCtl.

◆ ExtendCLOG()

void ExtendCLOG ( TransactionId  newestXact )

Definition at line 924 of file clog.c.

925{
926 int64 pageno;
927 LWLock *lock;
928
929 /*
930 * No work except at first XID of a page. But beware: just after
931 * wraparound, the first XID of page zero is FirstNormalTransactionId.
932 */
933 if (TransactionIdToPgIndex(newestXact) != 0 &&
935 return;
936
937 pageno = TransactionIdToPage(newestXact);
938 lock = SimpleLruGetBankLock(XactCtl, pageno);
939
941
942 /* Zero the page and make a WAL entry about it */
943 SimpleLruZeroPage(XactCtl, pageno);
944 XLogSimpleInsertInt64(RM_CLOG_ID, CLOG_ZEROPAGE, pageno);
945
946 LWLockRelease(lock);
947}
static int64 TransactionIdToPage(TransactionId xid)
Definition: clog.c:82
#define TransactionIdToPgIndex(xid)
Definition: clog.c:87
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1174
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1894
@ LW_EXCLUSIVE
Definition: lwlock.h:112
int SimpleLruZeroPage(SlruCtl ctl, int64 pageno)
Definition: slru.c:375
static LWLock * SimpleLruGetBankLock(SlruCtl ctl, int64 pageno)
Definition: slru.h:175
Definition: lwlock.h:42
#define TransactionIdEquals(id1, id2)
Definition: transam.h:43
XLogRecPtr XLogSimpleInsertInt64(RmgrId rmid, uint8 info, int64 value)
Definition: xloginsert.c:537

References CLOG_ZEROPAGE, FirstNormalTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SimpleLruGetBankLock(), SimpleLruZeroPage(), TransactionIdEquals, TransactionIdToPage(), TransactionIdToPgIndex, XactCtl, and XLogSimpleInsertInt64().

Referenced by GetNewTransactionId().

◆ set_status_by_pages()

static void set_status_by_pages ( int  nsubxids,
TransactionId *  subxids,
XidStatus  status,
XLogRecPtr  lsn 
)
static

Definition at line 255 of file clog.c.

257{
258 int64 pageno = TransactionIdToPage(subxids[0]);
259 int offset = 0;
260 int i = 0;
261
262 Assert(nsubxids > 0); /* else the pageno fetch above is unsafe */
263
264 while (i < nsubxids)
265 {
266 int num_on_page = 0;
267 int64 nextpageno;
268
269 do
270 {
271 nextpageno = TransactionIdToPage(subxids[i]);
272 if (nextpageno != pageno)
273 break;
274 num_on_page++;
275 i++;
276 } while (i < nsubxids);
277
279 num_on_page, subxids + offset,
280 status, lsn, pageno, false);
281 offset = i;
282 pageno = nextpageno;
283 }
284}
static void TransactionIdSetPageStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn, int64 pageno, bool all_xact_same_page)
Definition: clog.c:291
i
int i
Definition: isn.c:77
#define InvalidTransactionId
Definition: transam.h:31

References Assert(), i, InvalidTransactionId, TransactionIdSetPageStatus(), and TransactionIdToPage().

Referenced by TransactionIdSetTreeStatus().

◆ StartupCLOG()

void StartupCLOG ( void  )

Definition at line 842 of file clog.c.

843{
845 int64 pageno = TransactionIdToPage(xid);
846
847 /*
848 * Initialize our idea of the latest page number.
849 */
850 pg_atomic_write_u64(&XactCtl->shared->latest_page_number, pageno);
851}
static void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:483
FullTransactionId nextXid
Definition: transam.h:220
#define XidFromFullTransactionId(x)
Definition: transam.h:48
TransamVariablesData * TransamVariables
Definition: varsup.c:34

References TransamVariablesData::nextXid, pg_atomic_write_u64(), TransactionIdToPage(), TransamVariables, XactCtl, and XidFromFullTransactionId.

Referenced by StartupXLOG().

◆ TransactionGroupUpdateXidStatus()

static bool TransactionGroupUpdateXidStatus ( TransactionId  xid,
XidStatus  status,
XLogRecPtr  lsn,
int64  pageno 
)
static

Definition at line 439 of file clog.c.

441{
442 volatile PROC_HDR *procglobal = ProcGlobal;
443 PGPROC *proc = MyProc;
444 uint32 nextidx;
445 uint32 wakeidx;
446 int64 prevpageno;
447 LWLock *prevlock = NULL;
448
449 /* We should definitely have an XID whose status needs to be updated. */
451
452 /*
453 * Prepare to add ourselves to the list of processes needing a group XID
454 * status update.
455 */
456 proc->clogGroupMember = true;
457 proc->clogGroupMemberXid = xid;
458 proc->clogGroupMemberXidStatus = status;
459 proc->clogGroupMemberPage = pageno;
460 proc->clogGroupMemberLsn = lsn;
461
462 /*
463 * We put ourselves in the queue by writing MyProcNumber to
464 * ProcGlobal->clogGroupFirst. However, if there's already a process
465 * listed there, we compare our pageno with that of that process; if it
466 * differs, we cannot participate in the group, so we return for caller to
467 * update pg_xact in the normal way.
468 *
469 * If we're not the first process in the list, we must follow the leader.
470 * We do this by storing the data we want updated in our PGPROC entry
471 * where the leader can find it, then going to sleep.
472 *
473 * If no process is already in the list, we're the leader; our first step
474 * is to lock the SLRU bank to which our page belongs, then we close out
475 * the group by resetting the list pointer from ProcGlobal->clogGroupFirst
476 * (this lets other processes set up other groups later); finally we do
477 * the SLRU updates, release the SLRU bank lock, and wake up the sleeping
478 * processes.
479 *
480 * If another group starts to update a page in a different SLRU bank, they
481 * can proceed concurrently, since the bank lock they're going to use is
482 * different from ours. If another group starts to update a page in the
483 * same bank as ours, they wait until we release the lock.
484 */
485 nextidx = pg_atomic_read_u32(&procglobal->clogGroupFirst);
486
487 while (true)
488 {
489 /*
490 * Add the proc to list, if the clog page where we need to update the
491 * current transaction status is same as group leader's clog page.
492 *
493 * There is a race condition here, which is that after doing the below
494 * check and before adding this proc's clog update to a group, the
495 * group leader might have already finished the group update for this
496 * page and becomes group leader of another group, updating a
497 * different page. This will lead to a situation where a single group
498 * can have different clog page updates. This isn't likely and will
499 * still work, just less efficiently -- we handle this case by
500 * switching to a different bank lock in the loop below.
501 */
502 if (nextidx != INVALID_PROC_NUMBER &&
503 GetPGProcByNumber(nextidx)->clogGroupMemberPage != proc->clogGroupMemberPage)
504 {
505 /*
506 * Ensure that this proc is not a member of any clog group that
507 * needs an XID status update.
508 */
509 proc->clogGroupMember = false;
511 return false;
512 }
513
514 pg_atomic_write_u32(&proc->clogGroupNext, nextidx);
515
517 &nextidx,
519 break;
520 }
521
522 /*
523 * If the list was not empty, the leader will update the status of our
524 * XID. It is impossible to have followers without a leader because the
525 * first process that has added itself to the list will always have
526 * nextidx as INVALID_PROC_NUMBER.
527 */
528 if (nextidx != INVALID_PROC_NUMBER)
529 {
530 int extraWaits = 0;
531
532 /* Sleep until the leader updates our XID status. */
533 pgstat_report_wait_start(WAIT_EVENT_XACT_GROUP_UPDATE);
534 for (;;)
535 {
536 /* acts as a read barrier */
537 PGSemaphoreLock(proc->sem);
538 if (!proc->clogGroupMember)
539 break;
540 extraWaits++;
541 }
543
545
546 /* Fix semaphore count for any absorbed wakeups */
547 while (extraWaits-- > 0)
548 PGSemaphoreUnlock(proc->sem);
549 return true;
550 }
551
552 /*
553 * By here, we know we're the leader process. Acquire the SLRU bank lock
554 * that corresponds to the page we originally wanted to modify.
555 */
556 prevpageno = proc->clogGroupMemberPage;
557 prevlock = SimpleLruGetBankLock(XactCtl, prevpageno);
558 LWLockAcquire(prevlock, LW_EXCLUSIVE);
559
560 /*
561 * Now that we've got the lock, clear the list of processes waiting for
562 * group XID status update, saving a pointer to the head of the list.
563 * (Trying to pop elements one at a time could lead to an ABA problem.)
564 *
565 * At this point, any processes trying to do this would create a separate
566 * group.
567 */
568 nextidx = pg_atomic_exchange_u32(&procglobal->clogGroupFirst,
570
571 /* Remember head of list so we can perform wakeups after dropping lock. */
572 wakeidx = nextidx;
573
574 /* Walk the list and update the status of all XIDs. */
575 while (nextidx != INVALID_PROC_NUMBER)
576 {
577 PGPROC *nextproc = &ProcGlobal->allProcs[nextidx];
578 int64 thispageno = nextproc->clogGroupMemberPage;
579
580 /*
581 * If the page to update belongs to a different bank than the previous
582 * one, exchange bank lock to the new one. This should be quite rare,
583 * as described above.
584 *
585 * (We could try to optimize this by waking up the processes for which
586 * we have already updated the status while we exchange the lock, but
587 * the code doesn't do that at present. I think it'd require
588 * additional bookkeeping, making the common path slower in order to
589 * improve an infrequent case.)
590 */
591 if (thispageno != prevpageno)
592 {
593 LWLock *lock = SimpleLruGetBankLock(XactCtl, thispageno);
594
595 if (prevlock != lock)
596 {
597 LWLockRelease(prevlock);
599 }
600 prevlock = lock;
601 prevpageno = thispageno;
602 }
603
604 /*
605 * Transactions with more than THRESHOLD_SUBTRANS_CLOG_OPT sub-XIDs
606 * should not use group XID status update mechanism.
607 */
609
611 nextproc->subxidStatus.count,
612 nextproc->subxids.xids,
613 nextproc->clogGroupMemberXidStatus,
614 nextproc->clogGroupMemberLsn,
615 nextproc->clogGroupMemberPage);
616
617 /* Move to next proc in list. */
618 nextidx = pg_atomic_read_u32(&nextproc->clogGroupNext);
619 }
620
621 /* We're done with the lock now. */
622 if (prevlock != NULL)
623 LWLockRelease(prevlock);
624
625 /*
626 * Now that we've released the lock, go back and wake everybody up. We
627 * don't do this under the lock so as to keep lock hold times to a
628 * minimum.
629 *
630 * (Perhaps we could do this in two passes, the first setting
631 * clogGroupNext to invalid while saving the semaphores to an array, then
632 * a single write barrier, then another pass unlocking the semaphores.)
633 */
634 while (wakeidx != INVALID_PROC_NUMBER)
635 {
636 PGPROC *wakeproc = &ProcGlobal->allProcs[wakeidx];
637
638 wakeidx = pg_atomic_read_u32(&wakeproc->clogGroupNext);
640
641 /* ensure all previous writes are visible before follower continues. */
643
644 wakeproc->clogGroupMember = false;
645
646 if (wakeproc != MyProc)
647 PGSemaphoreUnlock(wakeproc->sem);
648 }
649
650 return true;
651}
static bool pg_atomic_compare_exchange_u32(volatile pg_atomic_uint32 *ptr, uint32 *expected, uint32 newval)
Definition: atomics.h:347
#define pg_write_barrier()
Definition: atomics.h:155
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:328
uint32_t uint32
Definition: c.h:538
#define THRESHOLD_SUBTRANS_CLOG_OPT
Definition: clog.c:103
static void TransactionIdSetPageStatusInternal(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn, int64 pageno)
Definition: clog.c:362
ProcNumber MyProcNumber
Definition: globals.c:90
void PGSemaphoreUnlock(PGSemaphore sema)
Definition: posix_sema.c:339
void PGSemaphoreLock(PGSemaphore sema)
Definition: posix_sema.c:319
#define GetPGProcByNumber(n)
Definition: proc.h:440
#define INVALID_PROC_NUMBER
Definition: procnumber.h:26
PGPROC * MyProc
Definition: proc.c:66
PROC_HDR * ProcGlobal
Definition: proc.c:78
Definition: proc.h:179
XLogRecPtr clogGroupMemberLsn
Definition: proc.h:306
TransactionId clogGroupMemberXid
Definition: proc.h:301
int64 clogGroupMemberPage
Definition: proc.h:304
bool clogGroupMember
Definition: proc.h:299
pg_atomic_uint32 clogGroupNext
Definition: proc.h:300
XidStatus clogGroupMemberXidStatus
Definition: proc.h:302
XidCacheStatus subxidStatus
Definition: proc.h:280
struct XidCache subxids
Definition: proc.h:282
PGSemaphore sem
Definition: proc.h:183
Definition: proc.h:386
PGPROC * allProcs
Definition: proc.h:388
pg_atomic_uint32 clogGroupFirst
Definition: proc.h:418
uint8 count
Definition: proc.h:44
TransactionId xids[PGPROC_MAX_CACHED_SUBXIDS]
Definition: proc.h:51
#define TransactionIdIsValid(xid)
Definition: transam.h:41
static void pgstat_report_wait_start(uint32 wait_event_info)
Definition: wait_event.h:69
static void pgstat_report_wait_end(void)
Definition: wait_event.h:85

References PROC_HDR::allProcs, Assert(), PROC_HDR::clogGroupFirst, PGPROC::clogGroupMember, PGPROC::clogGroupMemberLsn, PGPROC::clogGroupMemberPage, PGPROC::clogGroupMemberXid, PGPROC::clogGroupMemberXidStatus, PGPROC::clogGroupNext, XidCacheStatus::count, 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(), PGPROC::subxids, PGPROC::subxidStatus, THRESHOLD_SUBTRANS_CLOG_OPT, TransactionIdIsValid, TransactionIdSetPageStatusInternal(), XactCtl, and XidCache::xids.

Referenced by TransactionIdSetPageStatus().

◆ TransactionIdGetStatus()

XidStatus TransactionIdGetStatus ( TransactionId  xid,
XLogRecPtr *  lsn 
)

Definition at line 733 of file clog.c.

734{
735 int64 pageno = TransactionIdToPage(xid);
736 int byteno = TransactionIdToByte(xid);
737 int bshift = TransactionIdToBIndex(xid) * CLOG_BITS_PER_XACT;
738 int slotno;
739 int lsnindex;
740 char *byteptr;
741 XidStatus status;
742
743 /* lock is acquired by SimpleLruReadPage_ReadOnly */
744
745 slotno = SimpleLruReadPage_ReadOnly(XactCtl, pageno, xid);
746 byteptr = XactCtl->shared->page_buffer[slotno] + byteno;
747
748 status = (*byteptr >> bshift) & CLOG_XACT_BITMASK;
749
750 lsnindex = GetLSNIndex(slotno, xid);
751 *lsn = XactCtl->shared->group_lsn[lsnindex];
752
754
755 return status;
756}
#define CLOG_XACT_BITMASK
Definition: clog.c:65
#define TransactionIdToBIndex(xid)
Definition: clog.c:89
#define CLOG_BITS_PER_XACT
Definition: clog.c:62
#define TransactionIdToByte(xid)
Definition: clog.c:88
#define GetLSNIndex(slotno, xid)
Definition: clog.c:95
int XidStatus
Definition: clog.h:25
int SimpleLruReadPage_ReadOnly(SlruCtl ctl, int64 pageno, TransactionId xid)
Definition: slru.c:630

References CLOG_BITS_PER_XACT, CLOG_XACT_BITMASK, GetLSNIndex, LWLockRelease(), SimpleLruGetBankLock(), SimpleLruReadPage_ReadOnly(), TransactionIdToBIndex, TransactionIdToByte, TransactionIdToPage(), and XactCtl.

Referenced by TransactionIdGetCommitLSN(), and TransactionLogFetch().

◆ TransactionIdSetPageStatus()

static void TransactionIdSetPageStatus ( TransactionId  xid,
int  nsubxids,
TransactionId *  subxids,
XidStatus  status,
XLogRecPtr  lsn,
int64  pageno,
bool  all_xact_same_page 
)
static

Definition at line 291 of file clog.c.

295{
296 LWLock *lock;
297
298 /* Can't use group update when PGPROC overflows. */
300 "group clog threshold less than PGPROC cached subxids");
301
302 /* Get the SLRU bank lock for the page we are going to access. */
303 lock = SimpleLruGetBankLock(XactCtl, pageno);
304
305 /*
306 * When there is contention on the SLRU bank lock we need, we try to group
307 * multiple updates; a single leader process will perform transaction
308 * status updates for multiple backends so that the number of times the
309 * bank lock needs to be acquired is reduced.
310 *
311 * For this optimization to be safe, the XID and subxids in MyProc must be
312 * the same as the ones for which we're setting the status. Check that
313 * this is the case.
314 *
315 * For this optimization to be efficient, we shouldn't have too many
316 * sub-XIDs and all of the XIDs for which we're adjusting clog should be
317 * on the same page. Check those conditions, too.
318 */
319 if (all_xact_same_page && xid == MyProc->xid &&
320 nsubxids <= THRESHOLD_SUBTRANS_CLOG_OPT &&
321 nsubxids == MyProc->subxidStatus.count &&
322 (nsubxids == 0 ||
323 memcmp(subxids, MyProc->subxids.xids,
324 nsubxids * sizeof(TransactionId)) == 0))
325 {
326 /*
327 * If we can immediately acquire the lock, we update the status of our
328 * own XID and release the lock. If not, try use group XID update. If
329 * that doesn't work out, fall back to waiting for the lock to perform
330 * an update for this transaction only.
331 */
333 {
334 /* Got the lock without waiting! Do the update. */
335 TransactionIdSetPageStatusInternal(xid, nsubxids, subxids, status,
336 lsn, pageno);
337 LWLockRelease(lock);
338 return;
339 }
340 else if (TransactionGroupUpdateXidStatus(xid, status, lsn, pageno))
341 {
342 /* Group update mechanism has done the work. */
343 return;
344 }
345
346 /* Fall through only if update isn't done yet. */
347 }
348
349 /* Group update not applicable, or couldn't accept this page number. */
351 TransactionIdSetPageStatusInternal(xid, nsubxids, subxids, status,
352 lsn, pageno);
353 LWLockRelease(lock);
354}
#define StaticAssertDecl(condition, errmessage)
Definition: c.h:935
static bool TransactionGroupUpdateXidStatus(TransactionId xid, XidStatus status, XLogRecPtr lsn, int64 pageno)
Definition: clog.c:439
bool LWLockConditionalAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1345
#define PGPROC_MAX_CACHED_SUBXIDS
Definition: proc.h:39
TransactionId xid
Definition: proc.h:189

References XidCacheStatus::count, 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 void TransactionIdSetPageStatusInternal ( TransactionId  xid,
int  nsubxids,
TransactionId *  subxids,
XidStatus  status,
XLogRecPtr  lsn,
int64  pageno 
)
static

Definition at line 362 of file clog.c.

365{
366 int slotno;
367 int i;
368
370 status == TRANSACTION_STATUS_ABORTED ||
373 LW_EXCLUSIVE));
374
375 /*
376 * If we're doing an async commit (ie, lsn is valid), then we must wait
377 * for any active write on the page slot to complete. Otherwise our
378 * update could reach disk in that write, which will not do since we
379 * mustn't let it reach disk until we've done the appropriate WAL flush.
380 * But when lsn is invalid, it's OK to scribble on a page while it is
381 * write-busy, since we don't care if the update reaches disk sooner than
382 * we think.
383 */
384 slotno = SimpleLruReadPage(XactCtl, pageno, XLogRecPtrIsInvalid(lsn), xid);
385
386 /*
387 * Set the main transaction id, if any.
388 *
389 * If we update more than one xid on this page while it is being written
390 * out, we might find that some of the bits go to disk and others don't.
391 * If we are updating commits on the page with the top-level xid that
392 * could break atomicity, so we subcommit the subxids first before we mark
393 * the top-level commit.
394 */
395 if (TransactionIdIsValid(xid))
396 {
397 /* Subtransactions first, if needed ... */
398 if (status == TRANSACTION_STATUS_COMMITTED)
399 {
400 for (i = 0; i < nsubxids; i++)
401 {
402 Assert(XactCtl->shared->page_number[slotno] == TransactionIdToPage(subxids[i]));
405 lsn, slotno);
406 }
407 }
408
409 /* ... then the main transaction */
410 TransactionIdSetStatusBit(xid, status, lsn, slotno);
411 }
412
413 /* Set the subtransactions */
414 for (i = 0; i < nsubxids; i++)
415 {
416 Assert(XactCtl->shared->page_number[slotno] == TransactionIdToPage(subxids[i]));
417 TransactionIdSetStatusBit(subxids[i], status, lsn, slotno);
418 }
419
420 XactCtl->shared->page_dirty[slotno] = true;
421}
static void TransactionIdSetStatusBit(TransactionId xid, XidStatus status, XLogRecPtr lsn, int slotno)
Definition: clog.c:659
#define TRANSACTION_STATUS_ABORTED
Definition: clog.h:29
#define TRANSACTION_STATUS_SUB_COMMITTED
Definition: clog.h:30
#define TRANSACTION_STATUS_COMMITTED
Definition: clog.h:28
bool LWLockHeldByMeInMode(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:2021
int SimpleLruReadPage(SlruCtl ctl, int64 pageno, bool write_ok, TransactionId xid)
Definition: slru.c:527
#define XLogRecPtrIsInvalid(r)
Definition: xlogdefs.h:29

References Assert(), i, LW_EXCLUSIVE, LWLockHeldByMeInMode(), SimpleLruGetBankLock(), SimpleLruReadPage(), TRANSACTION_STATUS_ABORTED, TRANSACTION_STATUS_COMMITTED, TRANSACTION_STATUS_SUB_COMMITTED, TransactionIdIsValid, TransactionIdSetStatusBit(), TransactionIdToPage(), XactCtl, and XLogRecPtrIsInvalid.

Referenced by TransactionGroupUpdateXidStatus(), and TransactionIdSetPageStatus().

◆ TransactionIdSetStatusBit()

static void TransactionIdSetStatusBit ( TransactionId  xid,
XidStatus  status,
XLogRecPtr  lsn,
int  slotno 
)
static

Definition at line 659 of file clog.c.

660{
661 int byteno = TransactionIdToByte(xid);
662 int bshift = TransactionIdToBIndex(xid) * CLOG_BITS_PER_XACT;
663 char *byteptr;
664 char byteval;
665 char curval;
666
667 Assert(XactCtl->shared->page_number[slotno] == TransactionIdToPage(xid));
669 XactCtl->shared->page_number[slotno]),
670 LW_EXCLUSIVE));
671
672 byteptr = XactCtl->shared->page_buffer[slotno] + byteno;
673 curval = (*byteptr >> bshift) & CLOG_XACT_BITMASK;
674
675 /*
676 * When replaying transactions during recovery we still need to perform
677 * the two phases of subcommit and then commit. However, some transactions
678 * are already correctly marked, so we just treat those as a no-op which
679 * allows us to keep the following Assert as restrictive as possible.
680 */
683 return;
684
685 /*
686 * Current state change should be from 0 or subcommitted to target state
687 * or we should already be there when replaying changes during recovery.
688 */
689 Assert(curval == 0 ||
692 curval == status);
693
694 /* note this assumes exclusive access to the clog page */
695 byteval = *byteptr;
696 byteval &= ~(((1 << CLOG_BITS_PER_XACT) - 1) << bshift);
697 byteval |= (status << bshift);
698 *byteptr = byteval;
699
700 /*
701 * Update the group LSN if the transaction completion LSN is higher.
702 *
703 * Note: lsn will be invalid when supplied during InRecovery processing,
704 * so we don't need to do anything special to avoid LSN updates during
705 * recovery. After recovery completes the next clog change will set the
706 * LSN correctly.
707 */
708 if (!XLogRecPtrIsInvalid(lsn))
709 {
710 int lsnindex = GetLSNIndex(slotno, xid);
711
712 if (XactCtl->shared->group_lsn[lsnindex] < lsn)
713 XactCtl->shared->group_lsn[lsnindex] = lsn;
714 }
715}
#define TRANSACTION_STATUS_IN_PROGRESS
Definition: clog.h:27
bool InRecovery
Definition: xlogutils.c:50

References Assert(), CLOG_BITS_PER_XACT, CLOG_XACT_BITMASK, GetLSNIndex, InRecovery, LW_EXCLUSIVE, LWLockHeldByMeInMode(), SimpleLruGetBankLock(), TRANSACTION_STATUS_COMMITTED, TRANSACTION_STATUS_IN_PROGRESS, TRANSACTION_STATUS_SUB_COMMITTED, TransactionIdToBIndex, TransactionIdToByte, TransactionIdToPage(), XactCtl, and XLogRecPtrIsInvalid.

Referenced by TransactionIdSetPageStatusInternal().

◆ TransactionIdSetTreeStatus()

void TransactionIdSetTreeStatus ( TransactionId  xid,
int  nsubxids,
TransactionId *  subxids,
XidStatus  status,
XLogRecPtr  lsn 
)

Definition at line 181 of file clog.c.

183{
184 int64 pageno = TransactionIdToPage(xid); /* get page of parent */
185 int i;
186
189
190 /*
191 * See how many subxids, if any, are on the same page as the parent, if
192 * any.
193 */
194 for (i = 0; i < nsubxids; i++)
195 {
196 if (TransactionIdToPage(subxids[i]) != pageno)
197 break;
198 }
199
200 /*
201 * Do all items fit on a single page?
202 */
203 if (i == nsubxids)
204 {
205 /*
206 * Set the parent and all subtransactions in a single call
207 */
208 TransactionIdSetPageStatus(xid, nsubxids, subxids, status, lsn,
209 pageno, true);
210 }
211 else
212 {
213 int nsubxids_on_first_page = i;
214
215 /*
216 * If this is a commit then we care about doing this correctly (i.e.
217 * using the subcommitted intermediate status). By here, we know
218 * we're updating more than one page of clog, so we must mark entries
219 * that are *not* on the first page so that they show as subcommitted
220 * before we then return to update the status to fully committed.
221 *
222 * To avoid touching the first page twice, skip marking subcommitted
223 * for the subxids on that first page.
224 */
225 if (status == TRANSACTION_STATUS_COMMITTED)
226 set_status_by_pages(nsubxids - nsubxids_on_first_page,
227 subxids + nsubxids_on_first_page,
229
230 /*
231 * Now set the parent and subtransactions on same page as the parent,
232 * if any
233 */
234 pageno = TransactionIdToPage(xid);
235 TransactionIdSetPageStatus(xid, nsubxids_on_first_page, subxids, status,
236 lsn, pageno, false);
237
238 /*
239 * Now work through the rest of the subxids one clog page at a time,
240 * starting from the second page onwards, like we did above.
241 */
242 set_status_by_pages(nsubxids - nsubxids_on_first_page,
243 subxids + nsubxids_on_first_page,
244 status, lsn);
245 }
246}
static void set_status_by_pages(int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn)
Definition: clog.c:255

References Assert(), 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()

static int64 TransactionIdToPage ( TransactionId  xid )
inlinestatic

Definition at line 82 of file clog.c.

83{
84 return xid / (int64) CLOG_XACTS_PER_PAGE;
85}

References CLOG_XACTS_PER_PAGE.

Referenced by ExtendCLOG(), set_status_by_pages(), StartupCLOG(), TransactionIdGetStatus(), TransactionIdSetPageStatusInternal(), TransactionIdSetStatusBit(), TransactionIdSetTreeStatus(), TrimCLOG(), and TruncateCLOG().

◆ TrimCLOG()

void TrimCLOG ( void  )

Definition at line 857 of file clog.c.

858{
860 int64 pageno = TransactionIdToPage(xid);
861 LWLock *lock = SimpleLruGetBankLock(XactCtl, pageno);
862
864
865 /*
866 * Zero out the remainder of the current clog page. Under normal
867 * circumstances it should be zeroes already, but it seems at least
868 * theoretically possible that XLOG replay will have settled on a nextXID
869 * value that is less than the last XID actually used and marked by the
870 * previous database lifecycle (since subtransaction commit writes clog
871 * but makes no WAL entry). Let's just be safe. (We need not worry about
872 * pages beyond the current one, since those will be zeroed when first
873 * used. For the same reason, there is no need to do anything when
874 * nextXid is exactly at a page boundary; and it's likely that the
875 * "current" page doesn't exist yet in that case.)
876 */
877 if (TransactionIdToPgIndex(xid) != 0)
878 {
879 int byteno = TransactionIdToByte(xid);
880 int bshift = TransactionIdToBIndex(xid) * CLOG_BITS_PER_XACT;
881 int slotno;
882 char *byteptr;
883
884 slotno = SimpleLruReadPage(XactCtl, pageno, false, xid);
885 byteptr = XactCtl->shared->page_buffer[slotno] + byteno;
886
887 /* Zero so-far-unused positions in the current byte */
888 *byteptr &= (1 << bshift) - 1;
889 /* Zero the rest of the page */
890 MemSet(byteptr + 1, 0, BLCKSZ - byteno - 1);
891
892 XactCtl->shared->page_dirty[slotno] = true;
893 }
894
895 LWLockRelease(lock);
896}
#define MemSet(start, val, len)
Definition: c.h:1019

References CLOG_BITS_PER_XACT, 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 966 of file clog.c.

967{
968 int64 cutoffPage;
969
970 /*
971 * The cutoff point is the start of the segment containing oldestXact. We
972 * pass the *page* containing oldestXact to SimpleLruTruncate.
973 */
974 cutoffPage = TransactionIdToPage(oldestXact);
975
976 /* Check to see if there's any files that could be removed */
978 return; /* nothing to remove */
979
980 /*
981 * Advance oldestClogXid before truncating clog, so concurrent xact status
982 * lookups can ensure they don't attempt to access truncated-away clog.
983 *
984 * It's only necessary to do this if we will actually truncate away clog
985 * pages.
986 */
987 AdvanceOldestClogXid(oldestXact);
988
989 /*
990 * Write XLOG record and flush XLOG to disk. We record the oldest xid
991 * we're keeping information about here so we can ensure that it's always
992 * ahead of clog truncation in case we crash, and so a standby finds out
993 * the new valid xid before the next checkpoint.
994 */
995 WriteTruncateXlogRec(cutoffPage, oldestXact, oldestxid_datoid);
996
997 /* Now we can remove the old CLOG segment(s) */
998 SimpleLruTruncate(XactCtl, cutoffPage);
999}
static void WriteTruncateXlogRec(int64 pageno, TransactionId oldestXact, Oid oldestXactDb)
Definition: clog.c:1043
bool SlruScanDirectory(SlruCtl ctl, SlruScanCallback callback, void *data)
Definition: slru.c:1816
bool SlruScanDirCbReportPresence(SlruCtl ctl, char *filename, int64 segpage, void *data)
Definition: slru.c:1737

References AdvanceOldestClogXid(), SimpleLruTruncate(), SlruScanDirCbReportPresence(), SlruScanDirectory(), TransactionIdToPage(), WriteTruncateXlogRec(), and XactCtl.

Referenced by vac_truncate_clog().

◆ WriteTruncateXlogRec()

static void WriteTruncateXlogRec ( int64  pageno,
TransactionId  oldestXact,
Oid  oldestXactDb 
)
static

Definition at line 1043 of file clog.c.

1044{
1045 XLogRecPtr recptr;
1046 xl_clog_truncate xlrec;
1047
1048 xlrec.pageno = pageno;
1049 xlrec.oldestXact = oldestXact;
1050 xlrec.oldestXactDb = oldestXactDb;
1051
1053 XLogRegisterData(&xlrec, sizeof(xl_clog_truncate));
1054 recptr = XLogInsert(RM_CLOG_ID, CLOG_TRUNCATE);
1055 XLogFlush(recptr);
1056}
Oid oldestXactDb
Definition: clog.h:36
void XLogFlush(XLogRecPtr record)
Definition: xlog.c:2780
uint64 XLogRecPtr
Definition: xlogdefs.h:21
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:474
void XLogRegisterData(const void *data, uint32 len)
Definition: xloginsert.c:364
void XLogBeginInsert(void)
Definition: xloginsert.c:149

References CLOG_TRUNCATE, xl_clog_truncate::oldestXact, xl_clog_truncate::oldestXactDb, xl_clog_truncate::pageno, XLogBeginInsert(), XLogFlush(), XLogInsert(), and XLogRegisterData().

Referenced by TruncateCLOG().

Variable Documentation

◆ XactCtlData

SlruCtlData XactCtlData
static

Definition at line 108 of file clog.c.

AltStyle によって変換されたページ (->オリジナル) /