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 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 56 of file clog.h.

◆ CLOG_ZEROPAGE

#define CLOG_ZEROPAGE   0x00

Definition at line 55 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 833 of file clog.c.

834 {
835  int slotno;
836  LWLock *lock = SimpleLruGetBankLock(XactCtl, 0);
837 
839 
840  /* Create and zero the first page of the commit log */
841  slotno = ZeroCLOGPage(0, false);
842 
843  /* Make sure it's written out */
844  SimpleLruWritePage(XactCtl, slotno);
845  Assert(!XactCtl->shared->page_dirty[slotno]);
846 
847  LWLockRelease(lock);
848 }
#define Assert(condition)
Definition: c.h:858
static int ZeroCLOGPage(int64 pageno, bool writeXlog)
Definition: clog.c:860
#define XactCtl
Definition: clog.c:110
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1170
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1783
@ LW_EXCLUSIVE
Definition: lwlock.h:114
void SimpleLruWritePage(SlruCtl ctl, int slotno)
Definition: slru.c:714
static LWLock * SimpleLruGetBankLock(SlruCtl ctl, int64 pageno)
Definition: slru.h:179
Definition: lwlock.h:42

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

Referenced by BootStrapXLOG().

◆ CheckPointCLOG()

void CheckPointCLOG ( void  )

Definition at line 937 of file clog.c.

938 {
939  /*
940  * Write dirty CLOG pages to disk. This may result in sync requests
941  * queued for later handling by ProcessSyncRequests(), as part of the
942  * checkpoint.
943  */
944  TRACE_POSTGRESQL_CLOG_CHECKPOINT_START(true);
945  SimpleLruWriteAll(XactCtl, true);
946  TRACE_POSTGRESQL_CLOG_CHECKPOINT_DONE(true);
947 }
void SimpleLruWriteAll(SlruCtl ctl, bool allow_redirtied)
Definition: slru.c:1304

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  int64 pageno;
29 
30  memcpy(&pageno, rec, sizeof(pageno));
31  appendStringInfo(buf, "page %lld", (long long) 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 %lld; oldestXact %u",
39  (long long) xlrec.pageno, xlrec.oldestXact);
40  }
41 }
unsigned char uint8
Definition: c.h:504
#define CLOG_ZEROPAGE
Definition: clog.h:55
#define CLOG_TRUNCATE
Definition: clog.h:56
static char * buf
Definition: pg_test_fsync.c:73
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:97
int64 pageno
Definition: clog.h:34
TransactionId oldestXact
Definition: clog.h:35
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:410
#define XLogRecGetData(decoder)
Definition: xlogreader.h:415
#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 1107 of file clog.c.

1108 {
1109  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
1110 
1111  /* Backup blocks are not used in clog records */
1112  Assert(!XLogRecHasAnyBlockRefs(record));
1113 
1114  if (info == CLOG_ZEROPAGE)
1115  {
1116  int64 pageno;
1117  int slotno;
1118  LWLock *lock;
1119 
1120  memcpy(&pageno, XLogRecGetData(record), sizeof(pageno));
1121 
1122  lock = SimpleLruGetBankLock(XactCtl, pageno);
1123  LWLockAcquire(lock, LW_EXCLUSIVE);
1124 
1125  slotno = ZeroCLOGPage(pageno, false);
1126  SimpleLruWritePage(XactCtl, slotno);
1127  Assert(!XactCtl->shared->page_dirty[slotno]);
1128 
1129  LWLockRelease(lock);
1130  }
1131  else if (info == CLOG_TRUNCATE)
1132  {
1133  xl_clog_truncate xlrec;
1134 
1135  memcpy(&xlrec, XLogRecGetData(record), sizeof(xl_clog_truncate));
1136 
1138 
1140  }
1141  else
1142  elog(PANIC, "clog_redo: unknown op code %u", info);
1143 }
#define PANIC
Definition: elog.h:42
#define elog(elevel,...)
Definition: elog.h:224
void SimpleLruTruncate(SlruCtl ctl, int64 cutoffPage)
Definition: slru.c:1390
void AdvanceOldestClogXid(TransactionId oldest_datfrozenxid)
Definition: varsup.c:355
#define XLogRecHasAnyBlockRefs(decoder)
Definition: xlogreader.h:417

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

◆ CLOGShmemInit()

void CLOGShmemInit ( void  )

Definition at line 787 of file clog.c.

788 {
789  /* If auto-tuning is requested, now is the time to do it */
790  if (transaction_buffers == 0)
791  {
792  char buf[32];
793 
794  snprintf(buf, sizeof(buf), "%d", CLOGShmemBuffers());
795  SetConfigOption("transaction_buffers", buf, PGC_POSTMASTER,
797 
798  /*
799  * We prefer to report this value's source as PGC_S_DYNAMIC_DEFAULT.
800  * However, if the DBA explicitly set transaction_buffers = 0 in the
801  * config file, then PGC_S_DYNAMIC_DEFAULT will fail to override that
802  * and we must force the matter with PGC_S_OVERRIDE.
803  */
804  if (transaction_buffers == 0) /* failed to apply it? */
805  SetConfigOption("transaction_buffers", buf, PGC_POSTMASTER,
807  }
809 
810  XactCtl->PagePrecedes = CLOGPagePrecedes;
812  "pg_xact", LWTRANCHE_XACT_BUFFER,
815 }
#define CLOG_XACTS_PER_PAGE
Definition: clog.c:64
static int CLOGShmemBuffers(void)
Definition: clog.c:768
static bool CLOGPagePrecedes(int64 page1, int64 page2)
Definition: clog.c:1055
#define CLOG_LSNS_PER_PAGE
Definition: clog.c:93
int transaction_buffers
Definition: globals.c:168
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
Definition: guc.c:4285
@ PGC_S_DYNAMIC_DEFAULT
Definition: guc.h:110
@ PGC_S_OVERRIDE
Definition: guc.h:119
@ PGC_POSTMASTER
Definition: guc.h:70
@ LWTRANCHE_XACT_BUFFER
Definition: lwlock.h:179
@ LWTRANCHE_XACT_SLRU
Definition: lwlock.h:216
#define snprintf
Definition: port.h:238
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:237
#define SlruPagePrecedesUnitTests(ctl, per_page)
Definition: slru.h:203
@ SYNC_HANDLER_CLOG
Definition: sync.h:38

References Assert, buf, CLOG_LSNS_PER_PAGE, CLOG_XACTS_PER_PAGE, CLOGPagePrecedes(), CLOGShmemBuffers(), LWTRANCHE_XACT_BUFFER, LWTRANCHE_XACT_SLRU, 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 781 of file clog.c.

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

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

Referenced by CalculateShmemSize().

◆ clogsyncfiletag()

int clogsyncfiletag ( const FileTag ftag,
char *  path 
)

Definition at line 1149 of file clog.c.

1150 {
1151  return SlruSyncFileTag(XactCtl, ftag, path);
1152 }
int SlruSyncFileTag(SlruCtl ctl, const FileTag *ftag, char *path)
Definition: slru.c:1813

References SlruSyncFileTag(), and XactCtl.

◆ ExtendCLOG()

void ExtendCLOG ( TransactionId  newestXact)

Definition at line 959 of file clog.c.

960 {
961  int64 pageno;
962  LWLock *lock;
963 
964  /*
965  * No work except at first XID of a page. But beware: just after
966  * wraparound, the first XID of page zero is FirstNormalTransactionId.
967  */
968  if (TransactionIdToPgIndex(newestXact) != 0 &&
970  return;
971 
972  pageno = TransactionIdToPage(newestXact);
973  lock = SimpleLruGetBankLock(XactCtl, pageno);
974 
976 
977  /* Zero the page and make an XLOG entry about it */
978  ZeroCLOGPage(pageno, true);
979 
980  LWLockRelease(lock);
981 }
static int64 TransactionIdToPage(TransactionId xid)
Definition: clog.c:82
#define TransactionIdToPgIndex(xid)
Definition: clog.c:87
#define TransactionIdEquals(id1, id2)
Definition: transam.h:43
#define FirstNormalTransactionId
Definition: transam.h:34

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

Referenced by GetNewTransactionId().

◆ StartupCLOG()

void StartupCLOG ( void  )

Definition at line 877 of file clog.c.

878 {
880  int64 pageno = TransactionIdToPage(xid);
881 
882  /*
883  * Initialize our idea of the latest page number.
884  */
885  pg_atomic_write_u64(&XactCtl->shared->latest_page_number, pageno);
886 }
static void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:480
uint32 TransactionId
Definition: c.h:652
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().

◆ TransactionIdGetStatus()

XidStatus TransactionIdGetStatus ( TransactionId  xid,
XLogRecPtr lsn 
)

Definition at line 735 of file clog.c.

736 {
737  int64 pageno = TransactionIdToPage(xid);
738  int byteno = TransactionIdToByte(xid);
739  int bshift = TransactionIdToBIndex(xid) * CLOG_BITS_PER_XACT;
740  int slotno;
741  int lsnindex;
742  char *byteptr;
743  XidStatus status;
744 
745  /* lock is acquired by SimpleLruReadPage_ReadOnly */
746 
747  slotno = SimpleLruReadPage_ReadOnly(XactCtl, pageno, xid);
748  byteptr = XactCtl->shared->page_buffer[slotno] + byteno;
749 
750  status = (*byteptr >> bshift) & CLOG_XACT_BITMASK;
751 
752  lsnindex = GetLSNIndex(slotno, xid);
753  *lsn = XactCtl->shared->group_lsn[lsnindex];
754 
756 
757  return status;
758 }
#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:590

References CLOG_BITS_PER_XACT, CLOG_XACT_BITMASK, GetLSNIndex, LWLockRelease(), SimpleLruGetBankLock(), SimpleLruReadPage_ReadOnly(), 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 183 of file clog.c.

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

893 {
895  int64 pageno = TransactionIdToPage(xid);
896  LWLock *lock = SimpleLruGetBankLock(XactCtl, pageno);
897 
899 
900  /*
901  * Zero out the remainder of the current clog page. Under normal
902  * circumstances it should be zeroes already, but it seems at least
903  * theoretically possible that XLOG replay will have settled on a nextXID
904  * value that is less than the last XID actually used and marked by the
905  * previous database lifecycle (since subtransaction commit writes clog
906  * but makes no WAL entry). Let's just be safe. (We need not worry about
907  * pages beyond the current one, since those will be zeroed when first
908  * used. For the same reason, there is no need to do anything when
909  * nextXid is exactly at a page boundary; and it's likely that the
910  * "current" page doesn't exist yet in that case.)
911  */
912  if (TransactionIdToPgIndex(xid) != 0)
913  {
914  int byteno = TransactionIdToByte(xid);
915  int bshift = TransactionIdToBIndex(xid) * CLOG_BITS_PER_XACT;
916  int slotno;
917  char *byteptr;
918 
919  slotno = SimpleLruReadPage(XactCtl, pageno, false, xid);
920  byteptr = XactCtl->shared->page_buffer[slotno] + byteno;
921 
922  /* Zero so-far-unused positions in the current byte */
923  *byteptr &= (1 << bshift) - 1;
924  /* Zero the rest of the page */
925  MemSet(byteptr + 1, 0, BLCKSZ - byteno - 1);
926 
927  XactCtl->shared->page_dirty[slotno] = true;
928  }
929 
930  LWLockRelease(lock);
931 }
#define MemSet(start, val, len)
Definition: c.h:1020
int SimpleLruReadPage(SlruCtl ctl, int64 pageno, bool write_ok, TransactionId xid)
Definition: slru.c:487

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 1000 of file clog.c.

1001 {
1002  int64 cutoffPage;
1003 
1004  /*
1005  * The cutoff point is the start of the segment containing oldestXact. We
1006  * pass the *page* containing oldestXact to SimpleLruTruncate.
1007  */
1008  cutoffPage = TransactionIdToPage(oldestXact);
1009 
1010  /* Check to see if there's any files that could be removed */
1012  return; /* nothing to remove */
1013 
1014  /*
1015  * Advance oldestClogXid before truncating clog, so concurrent xact status
1016  * lookups can ensure they don't attempt to access truncated-away clog.
1017  *
1018  * It's only necessary to do this if we will actually truncate away clog
1019  * pages.
1020  */
1021  AdvanceOldestClogXid(oldestXact);
1022 
1023  /*
1024  * Write XLOG record and flush XLOG to disk. We record the oldest xid
1025  * we're keeping information about here so we can ensure that it's always
1026  * ahead of clog truncation in case we crash, and so a standby finds out
1027  * the new valid xid before the next checkpoint.
1028  */
1029  WriteTruncateXlogRec(cutoffPage, oldestXact, oldestxid_datoid);
1030 
1031  /* Now we can remove the old CLOG segment(s) */
1032  SimpleLruTruncate(XactCtl, cutoffPage);
1033 }
static void WriteTruncateXlogRec(int64 pageno, TransactionId oldestXact, Oid oldestXactDb)
Definition: clog.c:1088
bool SlruScanDirectory(SlruCtl ctl, SlruScanCallback callback, void *data)
Definition: slru.c:1773
bool SlruScanDirCbReportPresence(SlruCtl ctl, char *filename, int64 segpage, void *data)
Definition: slru.c:1694

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

Referenced by vac_truncate_clog().