PostgreSQL Source Code  git master
clog.h File Reference
#include "access/xlogreader.h"
#include "storage/sync.h"
#include "lib/stringinfo.h"
Include dependency graph for clog.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  xl_clog_truncate
 

Macros

#define TRANSACTION_STATUS_IN_PROGRESS   0x00
 
#define TRANSACTION_STATUS_COMMITTED   0x01
 
#define TRANSACTION_STATUS_ABORTED   0x02
 
#define TRANSACTION_STATUS_SUB_COMMITTED   0x03
 
#define CLOG_ZEROPAGE   0x00
 
#define CLOG_TRUNCATE   0x10
 

Typedefs

typedef int XidStatus
 
typedef struct xl_clog_truncate xl_clog_truncate
 

Functions

void TransactionIdSetTreeStatus (TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn)
 
XidStatus TransactionIdGetStatus (TransactionId xid, XLogRecPtr *lsn)
 
Size CLOGShmemBuffers (void)
 
Size CLOGShmemSize (void)
 
void CLOGShmemInit (void)
 
void BootStrapCLOG (void)
 
void StartupCLOG (void)
 
void TrimCLOG (void)
 
void CheckPointCLOG (void)
 
void ExtendCLOG (TransactionId newestXact)
 
void TruncateCLOG (TransactionId oldestXact, Oid oldestxid_datoid)
 
int clogsyncfiletag (const FileTag *ftag, char *path)
 
void clog_redo (XLogReaderState *record)
 
void clog_desc (StringInfo buf, XLogReaderState *record)
 
const char * clog_identify (uint8 info)
 

Macro Definition Documentation

◆ CLOG_TRUNCATE

#define CLOG_TRUNCATE   0x10

Definition at line 57 of file clog.h.

◆ CLOG_ZEROPAGE

#define CLOG_ZEROPAGE   0x00

Definition at line 56 of file clog.h.

◆ TRANSACTION_STATUS_ABORTED

#define TRANSACTION_STATUS_ABORTED   0x02

Definition at line 29 of file clog.h.

◆ TRANSACTION_STATUS_COMMITTED

#define TRANSACTION_STATUS_COMMITTED   0x01

Definition at line 28 of file clog.h.

◆ TRANSACTION_STATUS_IN_PROGRESS

#define TRANSACTION_STATUS_IN_PROGRESS   0x00

Definition at line 27 of file clog.h.

◆ TRANSACTION_STATUS_SUB_COMMITTED

#define TRANSACTION_STATUS_SUB_COMMITTED   0x03

Definition at line 30 of file clog.h.

Typedef Documentation

◆ XidStatus

typedef int XidStatus

Definition at line 25 of file clog.h.

◆ xl_clog_truncate

Function Documentation

◆ BootStrapCLOG()

void BootStrapCLOG ( void  )

Definition at line 713 of file clog.c.

714 {
715  int slotno;
716 
717  LWLockAcquire(XactSLRULock, LW_EXCLUSIVE);
718 
719  /* Create and zero the first page of the commit log */
720  slotno = ZeroCLOGPage(0, false);
721 
722  /* Make sure it's written out */
723  SimpleLruWritePage(XactCtl, slotno);
724  Assert(!XactCtl->shared->page_dirty[slotno]);
725 
726  LWLockRelease(XactSLRULock);
727 }
#define XactCtl
Definition: clog.c:89
static int ZeroCLOGPage(int pageno, bool writeXlog)
Definition: clog.c:739
Assert(fmt[strlen(fmt) - 1] !='\n')
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1196
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1800
@ LW_EXCLUSIVE
Definition: lwlock.h:104
void SimpleLruWritePage(SlruCtl ctl, int slotno)
Definition: slru.c:614

References Assert(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SimpleLruWritePage(), XactCtl, and ZeroCLOGPage().

Referenced by BootStrapXLOG().

◆ CheckPointCLOG()

void CheckPointCLOG ( void  )

Definition at line 819 of file clog.c.

820 {
821  /*
822  * Write dirty CLOG pages to disk. This may result in sync requests
823  * queued for later handling by ProcessSyncRequests(), as part of the
824  * checkpoint.
825  */
826  TRACE_POSTGRESQL_CLOG_CHECKPOINT_START(true);
827  SimpleLruWriteAll(XactCtl, true);
828  TRACE_POSTGRESQL_CLOG_CHECKPOINT_DONE(true);
829 }
void SimpleLruWriteAll(SlruCtl ctl, bool allow_redirtied)
Definition: slru.c:1156

References SimpleLruWriteAll(), and XactCtl.

Referenced by CheckPointGuts().

◆ clog_desc()

void clog_desc ( StringInfo  buf,
XLogReaderState record 
)

Definition at line 21 of file clogdesc.c.

22 {
23  char *rec = XLogRecGetData(record);
24  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
25 
26  if (info == CLOG_ZEROPAGE)
27  {
28  int pageno;
29 
30  memcpy(&pageno, rec, sizeof(int));
31  appendStringInfo(buf, "page %d", pageno);
32  }
33  else if (info == CLOG_TRUNCATE)
34  {
35  xl_clog_truncate xlrec;
36 
37  memcpy(&xlrec, rec, sizeof(xl_clog_truncate));
38  appendStringInfo(buf, "page %d; oldestXact %u",
39  xlrec.pageno, xlrec.oldestXact);
40  }
41 }
unsigned char uint8
Definition: c.h:439
#define CLOG_ZEROPAGE
Definition: clog.h:56
#define CLOG_TRUNCATE
Definition: clog.h:57
static char * buf
Definition: pg_test_fsync.c:67
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
int pageno
Definition: clog.h:34
TransactionId oldestXact
Definition: clog.h:35
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:408
#define XLogRecGetData(decoder)
Definition: xlogreader.h:413
#define XLR_INFO_MASK
Definition: xlogrecord.h:62

References appendStringInfo(), buf, CLOG_TRUNCATE, CLOG_ZEROPAGE, xl_clog_truncate::oldestXact, xl_clog_truncate::pageno, XLogRecGetData, XLogRecGetInfo, and XLR_INFO_MASK.

◆ clog_identify()

const char* clog_identify ( uint8  info)

Definition at line 44 of file clogdesc.c.

45 {
46  const char *id = NULL;
47 
48  switch (info & ~XLR_INFO_MASK)
49  {
50  case CLOG_ZEROPAGE:
51  id = "ZEROPAGE";
52  break;
53  case CLOG_TRUNCATE:
54  id = "TRUNCATE";
55  break;
56  }
57 
58  return id;
59 }

References CLOG_TRUNCATE, CLOG_ZEROPAGE, and XLR_INFO_MASK.

◆ clog_redo()

void clog_redo ( XLogReaderState record)

Definition at line 987 of file clog.c.

988 {
989  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
990 
991  /* Backup blocks are not used in clog records */
992  Assert(!XLogRecHasAnyBlockRefs(record));
993 
994  if (info == CLOG_ZEROPAGE)
995  {
996  int pageno;
997  int slotno;
998 
999  memcpy(&pageno, XLogRecGetData(record), sizeof(int));
1000 
1001  LWLockAcquire(XactSLRULock, LW_EXCLUSIVE);
1002 
1003  slotno = ZeroCLOGPage(pageno, false);
1004  SimpleLruWritePage(XactCtl, slotno);
1005  Assert(!XactCtl->shared->page_dirty[slotno]);
1006 
1007  LWLockRelease(XactSLRULock);
1008  }
1009  else if (info == CLOG_TRUNCATE)
1010  {
1011  xl_clog_truncate xlrec;
1012 
1013  memcpy(&xlrec, XLogRecGetData(record), sizeof(xl_clog_truncate));
1014 
1016 
1018  }
1019  else
1020  elog(PANIC, "clog_redo: unknown op code %u", info);
1021 }
#define PANIC
Definition: elog.h:36
#define elog(elevel,...)
Definition: elog.h:218
void SimpleLruTruncate(SlruCtl ctl, int cutoffPage)
Definition: slru.c:1226
void AdvanceOldestClogXid(TransactionId oldest_datfrozenxid)
Definition: varsup.c:328
#define XLogRecHasAnyBlockRefs(decoder)
Definition: xlogreader.h:415

References AdvanceOldestClogXid(), Assert(), CLOG_TRUNCATE, CLOG_ZEROPAGE, elog, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), xl_clog_truncate::oldestXact, xl_clog_truncate::pageno, PANIC, SimpleLruTruncate(), SimpleLruWritePage(), XactCtl, XLogRecGetData, XLogRecGetInfo, XLogRecHasAnyBlockRefs, XLR_INFO_MASK, and ZeroCLOGPage().

◆ CLOGShmemBuffers()

Size CLOGShmemBuffers ( void  )

Definition at line 682 of file clog.c.

683 {
684  return Min(128, Max(4, NBuffers / 512));
685 }
#define Min(x, y)
Definition: c.h:986
#define Max(x, y)
Definition: c.h:980
int NBuffers
Definition: globals.c:136

References Max, Min, and NBuffers.

Referenced by CLOGShmemInit(), and CLOGShmemSize().

◆ CLOGShmemInit()

void CLOGShmemInit ( void  )

Definition at line 697 of file clog.c.

698 {
699  XactCtl->PagePrecedes = CLOGPagePrecedes;
701  XactSLRULock, "pg_xact", LWTRANCHE_XACT_BUFFER,
704 }
#define CLOG_XACTS_PER_PAGE
Definition: clog.c:62
static bool CLOGPagePrecedes(int page1, int page2)
Definition: clog.c:935
Size CLOGShmemBuffers(void)
Definition: clog.c:682
#define CLOG_LSNS_PER_PAGE
Definition: clog.c:72
@ LWTRANCHE_XACT_BUFFER
Definition: lwlock.h:169
void SimpleLruInit(SlruCtl ctl, const char *name, int nslots, int nlsns, LWLock *ctllock, const char *subdir, int tranche_id, SyncRequestHandler sync_handler)
Definition: slru.c:187
#define SlruPagePrecedesUnitTests(ctl, per_page)
Definition: slru.h:156
@ SYNC_HANDLER_CLOG
Definition: sync.h:38

References CLOG_LSNS_PER_PAGE, CLOG_XACTS_PER_PAGE, CLOGPagePrecedes(), CLOGShmemBuffers(), LWTRANCHE_XACT_BUFFER, SimpleLruInit(), SlruPagePrecedesUnitTests, SYNC_HANDLER_CLOG, and XactCtl.

Referenced by CreateSharedMemoryAndSemaphores().

◆ CLOGShmemSize()

Size CLOGShmemSize ( void  )

Definition at line 691 of file clog.c.

692 {
694 }
Size SimpleLruShmemSize(int nslots, int nlsns)
Definition: slru.c:156

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

Referenced by CalculateShmemSize().

◆ clogsyncfiletag()

int clogsyncfiletag ( const FileTag ftag,
char *  path 
)

Definition at line 1027 of file clog.c.

1028 {
1029  return SlruSyncFileTag(XactCtl, ftag, path);
1030 }
int SlruSyncFileTag(SlruCtl ctl, const FileTag *ftag, char *path)
Definition: slru.c:1593

References SlruSyncFileTag(), and XactCtl.

◆ ExtendCLOG()

void ExtendCLOG ( TransactionId  newestXact)

Definition at line 841 of file clog.c.

842 {
843  int pageno;
844 
845  /*
846  * No work except at first XID of a page. But beware: just after
847  * wraparound, the first XID of page zero is FirstNormalTransactionId.
848  */
849  if (TransactionIdToPgIndex(newestXact) != 0 &&
851  return;
852 
853  pageno = TransactionIdToPage(newestXact);
854 
855  LWLockAcquire(XactSLRULock, LW_EXCLUSIVE);
856 
857  /* Zero the page and make an XLOG entry about it */
858  ZeroCLOGPage(pageno, true);
859 
860  LWLockRelease(XactSLRULock);
861 }
#define TransactionIdToPgIndex(xid)
Definition: clog.c:66
#define TransactionIdToPage(xid)
Definition: clog.c:65
#define TransactionIdEquals(id1, id2)
Definition: transam.h:43
#define FirstNormalTransactionId
Definition: transam.h:34

References FirstNormalTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), TransactionIdEquals, TransactionIdToPage, TransactionIdToPgIndex, and ZeroCLOGPage().

Referenced by GetNewTransactionId().

◆ StartupCLOG()

void StartupCLOG ( void  )

Definition at line 756 of file clog.c.

757 {
759  int pageno = TransactionIdToPage(xid);
760 
761  LWLockAcquire(XactSLRULock, LW_EXCLUSIVE);
762 
763  /*
764  * Initialize our idea of the latest page number.
765  */
766  XactCtl->shared->latest_page_number = pageno;
767 
768  LWLockRelease(XactSLRULock);
769 }
uint32 TransactionId
Definition: c.h:587
FullTransactionId nextXid
Definition: transam.h:220
#define XidFromFullTransactionId(x)
Definition: transam.h:48
VariableCache ShmemVariableCache
Definition: varsup.c:34

References LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), VariableCacheData::nextXid, ShmemVariableCache, TransactionIdToPage, XactCtl, and XidFromFullTransactionId.

Referenced by StartupXLOG().

◆ TransactionIdGetStatus()

XidStatus TransactionIdGetStatus ( TransactionId  xid,
XLogRecPtr lsn 
)

Definition at line 640 of file clog.c.

641 {
642  int pageno = TransactionIdToPage(xid);
643  int byteno = TransactionIdToByte(xid);
644  int bshift = TransactionIdToBIndex(xid) * CLOG_BITS_PER_XACT;
645  int slotno;
646  int lsnindex;
647  char *byteptr;
649 
650  /* lock is acquired by SimpleLruReadPage_ReadOnly */
651 
652  slotno = SimpleLruReadPage_ReadOnly(XactCtl, pageno, xid);
653  byteptr = XactCtl->shared->page_buffer[slotno] + byteno;
654 
655  status = (*byteptr >> bshift) & CLOG_XACT_BITMASK;
656 
657  lsnindex = GetLSNIndex(slotno, xid);
658  *lsn = XactCtl->shared->group_lsn[lsnindex];
659 
660  LWLockRelease(XactSLRULock);
661 
662  return status;
663 }
#define CLOG_XACT_BITMASK
Definition: clog.c:63
#define TransactionIdToBIndex(xid)
Definition: clog.c:68
#define CLOG_BITS_PER_XACT
Definition: clog.c:60
#define TransactionIdToByte(xid)
Definition: clog.c:67
#define GetLSNIndex(slotno, xid)
Definition: clog.c:74
int XidStatus
Definition: clog.h:25
static void static void status(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:229
int SimpleLruReadPage_ReadOnly(SlruCtl ctl, int pageno, TransactionId xid)
Definition: slru.c:495

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

Referenced by TransactionIdGetCommitLSN(), and TransactionLogFetch().

◆ TransactionIdSetTreeStatus()

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

Definition at line 164 of file clog.c.

166 {
167  int pageno = TransactionIdToPage(xid); /* get page of parent */
168  int i;
169 
172 
173  /*
174  * See how many subxids, if any, are on the same page as the parent, if
175  * any.
176  */
177  for (i = 0; i < nsubxids; i++)
178  {
179  if (TransactionIdToPage(subxids[i]) != pageno)
180  break;
181  }
182 
183  /*
184  * Do all items fit on a single page?
185  */
186  if (i == nsubxids)
187  {
188  /*
189  * Set the parent and all subtransactions in a single call
190  */
191  TransactionIdSetPageStatus(xid, nsubxids, subxids, status, lsn,
192  pageno, true);
193  }
194  else
195  {
196  int nsubxids_on_first_page = i;
197 
198  /*
199  * If this is a commit then we care about doing this correctly (i.e.
200  * using the subcommitted intermediate status). By here, we know
201  * we're updating more than one page of clog, so we must mark entries
202  * that are *not* on the first page so that they show as subcommitted
203  * before we then return to update the status to fully committed.
204  *
205  * To avoid touching the first page twice, skip marking subcommitted
206  * for the subxids on that first page.
207  */
209  set_status_by_pages(nsubxids - nsubxids_on_first_page,
210  subxids + nsubxids_on_first_page,
212 
213  /*
214  * Now set the parent and subtransactions on same page as the parent,
215  * if any
216  */
217  pageno = TransactionIdToPage(xid);
218  TransactionIdSetPageStatus(xid, nsubxids_on_first_page, subxids, status,
219  lsn, pageno, false);
220 
221  /*
222  * Now work through the rest of the subxids one clog page at a time,
223  * starting from the second page onwards, like we did above.
224  */
225  set_status_by_pages(nsubxids - nsubxids_on_first_page,
226  subxids + nsubxids_on_first_page,
227  status, lsn);
228  }
229 }
static void TransactionIdSetPageStatus(TransactionId xid, int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn, int pageno, bool all_xact_same_page)
Definition: clog.c:274
static void set_status_by_pages(int nsubxids, TransactionId *subxids, XidStatus status, XLogRecPtr lsn)
Definition: clog.c:238
#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
int i
Definition: isn.c:73

References Assert(), i, set_status_by_pages(), status(), TRANSACTION_STATUS_ABORTED, TRANSACTION_STATUS_COMMITTED, TRANSACTION_STATUS_SUB_COMMITTED, TransactionIdSetPageStatus(), and TransactionIdToPage.

Referenced by TransactionIdAbortTree(), TransactionIdAsyncCommitTree(), and TransactionIdCommitTree().

◆ TrimCLOG()

void TrimCLOG ( void  )

Definition at line 775 of file clog.c.

776 {
778  int pageno = TransactionIdToPage(xid);
779 
780  LWLockAcquire(XactSLRULock, LW_EXCLUSIVE);
781 
782  /*
783  * Zero out the remainder of the current clog page. Under normal
784  * circumstances it should be zeroes already, but it seems at least
785  * theoretically possible that XLOG replay will have settled on a nextXID
786  * value that is less than the last XID actually used and marked by the
787  * previous database lifecycle (since subtransaction commit writes clog
788  * but makes no WAL entry). Let's just be safe. (We need not worry about
789  * pages beyond the current one, since those will be zeroed when first
790  * used. For the same reason, there is no need to do anything when
791  * nextXid is exactly at a page boundary; and it's likely that the
792  * "current" page doesn't exist yet in that case.)
793  */
794  if (TransactionIdToPgIndex(xid) != 0)
795  {
796  int byteno = TransactionIdToByte(xid);
797  int bshift = TransactionIdToBIndex(xid) * CLOG_BITS_PER_XACT;
798  int slotno;
799  char *byteptr;
800 
801  slotno = SimpleLruReadPage(XactCtl, pageno, false, xid);
802  byteptr = XactCtl->shared->page_buffer[slotno] + byteno;
803 
804  /* Zero so-far-unused positions in the current byte */
805  *byteptr &= (1 << bshift) - 1;
806  /* Zero the rest of the page */
807  MemSet(byteptr + 1, 0, BLCKSZ - byteno - 1);
808 
809  XactCtl->shared->page_dirty[slotno] = true;
810  }
811 
812  LWLockRelease(XactSLRULock);
813 }
#define MemSet(start, val, len)
Definition: c.h:1008
int SimpleLruReadPage(SlruCtl ctl, int pageno, bool write_ok, TransactionId xid)
Definition: slru.c:395

References CLOG_BITS_PER_XACT, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MemSet, VariableCacheData::nextXid, ShmemVariableCache, SimpleLruReadPage(), TransactionIdToBIndex, TransactionIdToByte, TransactionIdToPage, TransactionIdToPgIndex, XactCtl, and XidFromFullTransactionId.

Referenced by StartupXLOG().

◆ TruncateCLOG()

void TruncateCLOG ( TransactionId  oldestXact,
Oid  oldestxid_datoid 
)

Definition at line 880 of file clog.c.

881 {
882  int cutoffPage;
883 
884  /*
885  * The cutoff point is the start of the segment containing oldestXact. We
886  * pass the *page* containing oldestXact to SimpleLruTruncate.
887  */
888  cutoffPage = TransactionIdToPage(oldestXact);
889 
890  /* Check to see if there's any files that could be removed */
892  return; /* nothing to remove */
893 
894  /*
895  * Advance oldestClogXid before truncating clog, so concurrent xact status
896  * lookups can ensure they don't attempt to access truncated-away clog.
897  *
898  * It's only necessary to do this if we will actually truncate away clog
899  * pages.
900  */
901  AdvanceOldestClogXid(oldestXact);
902 
903  /*
904  * Write XLOG record and flush XLOG to disk. We record the oldest xid
905  * we're keeping information about here so we can ensure that it's always
906  * ahead of clog truncation in case we crash, and so a standby finds out
907  * the new valid xid before the next checkpoint.
908  */
909  WriteTruncateXlogRec(cutoffPage, oldestXact, oldestxid_datoid);
910 
911  /* Now we can remove the old CLOG segment(s) */
912  SimpleLruTruncate(XactCtl, cutoffPage);
913 }
static void WriteTruncateXlogRec(int pageno, TransactionId oldestXact, Oid oldestXactDb)
Definition: clog.c:968
bool SlruScanDirCbReportPresence(SlruCtl ctl, char *filename, int segpage, void *data)
Definition: slru.c:1500
bool SlruScanDirectory(SlruCtl ctl, SlruScanCallback callback, void *data)
Definition: slru.c:1553

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

Referenced by vac_truncate_clog().