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

Go to the source code of this file.

Data Structures

struct  xl_smgr_create
 
struct  xl_smgr_truncate
 

Macros

#define XLOG_SMGR_CREATE   0x10
 
#define XLOG_SMGR_TRUNCATE   0x20
 
#define SMGR_TRUNCATE_HEAP   0x0001
 
#define SMGR_TRUNCATE_VM   0x0002
 
#define SMGR_TRUNCATE_FSM   0x0004
 
#define SMGR_TRUNCATE_ALL   (SMGR_TRUNCATE_HEAP|SMGR_TRUNCATE_VM|SMGR_TRUNCATE_FSM)
 

Typedefs

typedef struct xl_smgr_create xl_smgr_create
 
typedef struct xl_smgr_truncate xl_smgr_truncate
 

Functions

void log_smgrcreate (const RelFileNode *rnode, ForkNumber forkNum)
 
void smgr_redo (XLogReaderState *record)
 
void smgr_desc (StringInfo buf, XLogReaderState *record)
 
const char * smgr_identify (uint8 info)
 

Macro Definition Documentation

◆ SMGR_TRUNCATE_ALL

#define SMGR_TRUNCATE_ALL   (SMGR_TRUNCATE_HEAP|SMGR_TRUNCATE_VM|SMGR_TRUNCATE_FSM)

Definition at line 43 of file storage_xlog.h.

Referenced by RelationTruncate().

◆ SMGR_TRUNCATE_FSM

#define SMGR_TRUNCATE_FSM   0x0004

Definition at line 42 of file storage_xlog.h.

Referenced by smgr_redo().

◆ SMGR_TRUNCATE_HEAP

#define SMGR_TRUNCATE_HEAP   0x0001

Definition at line 40 of file storage_xlog.h.

Referenced by smgr_redo().

◆ SMGR_TRUNCATE_VM

#define SMGR_TRUNCATE_VM   0x0002

Definition at line 41 of file storage_xlog.h.

Referenced by pg_truncate_visibility_map(), and smgr_redo().

◆ XLOG_SMGR_CREATE

#define XLOG_SMGR_CREATE   0x10

Definition at line 30 of file storage_xlog.h.

Referenced by extractPageInfo(), log_smgrcreate(), smgr_desc(), smgr_identify(), and smgr_redo().

◆ XLOG_SMGR_TRUNCATE

#define XLOG_SMGR_TRUNCATE   0x20

Typedef Documentation

◆ xl_smgr_create

◆ xl_smgr_truncate

Function Documentation

◆ log_smgrcreate()

void log_smgrcreate ( const RelFileNode rnode,
ForkNumber  forkNum 
)

Definition at line 128 of file storage.c.

References xl_smgr_create::forkNum, xl_smgr_create::rnode, XLOG_SMGR_CREATE, XLogBeginInsert(), XLogInsert(), XLogRegisterData(), and XLR_SPECIAL_REL_UPDATE.

Referenced by heapam_relation_copy_data(), heapam_relation_set_new_filenode(), index_copy_data(), and RelationCreateStorage().

129 {
130  xl_smgr_create xlrec;
131 
132  /*
133  * Make an XLOG entry reporting the file creation.
134  */
135  xlrec.rnode = *rnode;
136  xlrec.forkNum = forkNum;
137 
138  XLogBeginInsert();
139  XLogRegisterData((char *) &xlrec, sizeof(xlrec));
141 }
#define XLR_SPECIAL_REL_UPDATE
Definition: xlogrecord.h:71
#define XLOG_SMGR_CREATE
Definition: storage_xlog.h:30
void XLogRegisterData(char *data, int len)
Definition: xloginsert.c:323
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:415
ForkNumber forkNum
Definition: storage_xlog.h:36
void XLogBeginInsert(void)
Definition: xloginsert.c:120
RelFileNode rnode
Definition: storage_xlog.h:35

◆ smgr_desc()

void smgr_desc ( StringInfo  buf,
XLogReaderState record 
)

Definition at line 21 of file smgrdesc.c.

References appendStringInfo(), appendStringInfoString(), xl_smgr_truncate::blkno, xl_smgr_truncate::flags, xl_smgr_create::forkNum, MAIN_FORKNUM, pfree(), relpathperm, xl_smgr_create::rnode, xl_smgr_truncate::rnode, XLOG_SMGR_CREATE, XLOG_SMGR_TRUNCATE, XLogRecGetData, XLogRecGetInfo, and XLR_INFO_MASK.

22 {
23  char *rec = XLogRecGetData(record);
24  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
25 
26  if (info == XLOG_SMGR_CREATE)
27  {
28  xl_smgr_create *xlrec = (xl_smgr_create *) rec;
29  char *path = relpathperm(xlrec->rnode, xlrec->forkNum);
30 
31  appendStringInfoString(buf, path);
32  pfree(path);
33  }
34  else if (info == XLOG_SMGR_TRUNCATE)
35  {
36  xl_smgr_truncate *xlrec = (xl_smgr_truncate *) rec;
37  char *path = relpathperm(xlrec->rnode, MAIN_FORKNUM);
38 
39  appendStringInfo(buf, "%s to %u blocks flags %d", path,
40  xlrec->blkno, xlrec->flags);
41  pfree(path);
42  }
43 }
#define relpathperm(rnode, forknum)
Definition: relpath.h:83
unsigned char uint8
Definition: c.h:356
RelFileNode rnode
Definition: storage_xlog.h:49
#define XLOG_SMGR_CREATE
Definition: storage_xlog.h:30
void pfree(void *pointer)
Definition: mcxt.c:1056
#define XLogRecGetData(decoder)
Definition: xlogreader.h:246
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:78
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:163
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:242
#define XLOG_SMGR_TRUNCATE
Definition: storage_xlog.h:31
ForkNumber forkNum
Definition: storage_xlog.h:36
#define XLR_INFO_MASK
Definition: xlogrecord.h:62
BlockNumber blkno
Definition: storage_xlog.h:48
RelFileNode rnode
Definition: storage_xlog.h:35

◆ smgr_identify()

const char* smgr_identify ( uint8  info)

Definition at line 46 of file smgrdesc.c.

References XLOG_SMGR_CREATE, XLOG_SMGR_TRUNCATE, and XLR_INFO_MASK.

47 {
48  const char *id = NULL;
49 
50  switch (info & ~XLR_INFO_MASK)
51  {
52  case XLOG_SMGR_CREATE:
53  id = "CREATE";
54  break;
55  case XLOG_SMGR_TRUNCATE:
56  id = "TRUNCATE";
57  break;
58  }
59 
60  return id;
61 }
#define XLOG_SMGR_CREATE
Definition: storage_xlog.h:30
#define XLOG_SMGR_TRUNCATE
Definition: storage_xlog.h:31
#define XLR_INFO_MASK
Definition: xlogrecord.h:62

◆ smgr_redo()

void smgr_redo ( XLogReaderState record)

Definition at line 602 of file storage.c.

References Assert, xl_smgr_truncate::blkno, BlockNumberIsValid, blocks, CreateFakeRelcacheEntry(), elog, XLogReaderState::EndRecPtr, xl_smgr_truncate::flags, xl_smgr_create::forkNum, FreeFakeRelcacheEntry(), FreeSpaceMapPrepareTruncateRel(), FreeSpaceMapVacuumRange(), FSM_FORKNUM, InvalidBackendId, InvalidBlockNumber, MAIN_FORKNUM, MAX_FORKNUM, PANIC, xl_smgr_create::rnode, xl_smgr_truncate::rnode, SMGR_TRUNCATE_FSM, SMGR_TRUNCATE_HEAP, SMGR_TRUNCATE_VM, smgrcreate(), smgrexists(), smgropen(), smgrtruncate(), VISIBILITYMAP_FORKNUM, visibilitymap_prepare_truncate(), XLOG_SMGR_CREATE, XLOG_SMGR_TRUNCATE, XLogFlush(), XLogRecGetData, XLogRecGetInfo, XLogRecHasAnyBlockRefs, XLogTruncateRelation(), and XLR_INFO_MASK.

603 {
604  XLogRecPtr lsn = record->EndRecPtr;
605  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
606 
607  /* Backup blocks are not used in smgr records */
608  Assert(!XLogRecHasAnyBlockRefs(record));
609 
610  if (info == XLOG_SMGR_CREATE)
611  {
612  xl_smgr_create *xlrec = (xl_smgr_create *) XLogRecGetData(record);
613  SMgrRelation reln;
614 
615  reln = smgropen(xlrec->rnode, InvalidBackendId);
616  smgrcreate(reln, xlrec->forkNum, true);
617  }
618  else if (info == XLOG_SMGR_TRUNCATE)
619  {
620  xl_smgr_truncate *xlrec = (xl_smgr_truncate *) XLogRecGetData(record);
621  SMgrRelation reln;
622  Relation rel;
623  ForkNumber forks[MAX_FORKNUM];
625  int nforks = 0;
626  bool need_fsm_vacuum = false;
627 
628  reln = smgropen(xlrec->rnode, InvalidBackendId);
629 
630  /*
631  * Forcibly create relation if it doesn't exist (which suggests that
632  * it was dropped somewhere later in the WAL sequence). As in
633  * XLogReadBufferForRedo, we prefer to recreate the rel and replay the
634  * log as best we can until the drop is seen.
635  */
636  smgrcreate(reln, MAIN_FORKNUM, true);
637 
638  /*
639  * Before we perform the truncation, update minimum recovery point to
640  * cover this WAL record. Once the relation is truncated, there's no
641  * going back. The buffer manager enforces the WAL-first rule for
642  * normal updates to relation files, so that the minimum recovery
643  * point is always updated before the corresponding change in the data
644  * file is flushed to disk. We have to do the same manually here.
645  *
646  * Doing this before the truncation means that if the truncation fails
647  * for some reason, you cannot start up the system even after restart,
648  * until you fix the underlying situation so that the truncation will
649  * succeed. Alternatively, we could update the minimum recovery point
650  * after truncation, but that would leave a small window where the
651  * WAL-first rule could be violated.
652  */
653  XLogFlush(lsn);
654 
655  /* Prepare for truncation of MAIN fork */
656  if ((xlrec->flags & SMGR_TRUNCATE_HEAP) != 0)
657  {
658  forks[nforks] = MAIN_FORKNUM;
659  blocks[nforks] = xlrec->blkno;
660  nforks++;
661 
662  /* Also tell xlogutils.c about it */
663  XLogTruncateRelation(xlrec->rnode, MAIN_FORKNUM, xlrec->blkno);
664  }
665 
666  /* Prepare for truncation of FSM and VM too */
667  rel = CreateFakeRelcacheEntry(xlrec->rnode);
668 
669  if ((xlrec->flags & SMGR_TRUNCATE_FSM) != 0 &&
670  smgrexists(reln, FSM_FORKNUM))
671  {
672  blocks[nforks] = FreeSpaceMapPrepareTruncateRel(rel, xlrec->blkno);
673  if (BlockNumberIsValid(blocks[nforks]))
674  {
675  forks[nforks] = FSM_FORKNUM;
676  nforks++;
677  need_fsm_vacuum = true;
678  }
679  }
680  if ((xlrec->flags & SMGR_TRUNCATE_VM) != 0 &&
682  {
683  blocks[nforks] = visibilitymap_prepare_truncate(rel, xlrec->blkno);
684  if (BlockNumberIsValid(blocks[nforks]))
685  {
686  forks[nforks] = VISIBILITYMAP_FORKNUM;
687  nforks++;
688  }
689  }
690 
691  /* Do the real work to truncate relation forks */
692  if (nforks > 0)
693  smgrtruncate(reln, forks, nforks, blocks);
694 
695  /*
696  * Update upper-level FSM pages to account for the truncation.
697  * This is important because the just-truncated pages were likely
698  * marked as all-free, and would be preferentially selected.
699  */
700  if (need_fsm_vacuum)
701  FreeSpaceMapVacuumRange(rel, xlrec->blkno,
703 
705  }
706  else
707  elog(PANIC, "smgr_redo: unknown op code %u", info);
708 }
void XLogTruncateRelation(RelFileNode rnode, ForkNumber forkNum, BlockNumber nblocks)
Definition: xlogutils.c:636
#define SMGR_TRUNCATE_HEAP
Definition: storage_xlog.h:40
void smgrcreate(SMgrRelation reln, ForkNumber forknum, bool isRedo)
Definition: smgr.c:333
unsigned char uint8
Definition: c.h:356
#define SMGR_TRUNCATE_FSM
Definition: storage_xlog.h:42
uint32 BlockNumber
Definition: block.h:31
RelFileNode rnode
Definition: storage_xlog.h:49
bool smgrexists(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:247
#define PANIC
Definition: elog.h:53
void XLogFlush(XLogRecPtr record)
Definition: xlog.c:2798
#define XLOG_SMGR_CREATE
Definition: storage_xlog.h:30
XLogRecPtr EndRecPtr
Definition: xlogreader.h:133
#define XLogRecGetData(decoder)
Definition: xlogreader.h:246
Relation CreateFakeRelcacheEntry(RelFileNode rnode)
Definition: xlogutils.c:550
BlockNumber FreeSpaceMapPrepareTruncateRel(Relation rel, BlockNumber nblocks)
Definition: freespace.c:261
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:242
SMgrRelation smgropen(RelFileNode rnode, BackendId backend)
Definition: smgr.c:145
ForkNumber
Definition: relpath.h:40
#define XLOG_SMGR_TRUNCATE
Definition: storage_xlog.h:31
void FreeFakeRelcacheEntry(Relation fakerel)
Definition: xlogutils.c:591
#define InvalidBackendId
Definition: backendid.h:23
void smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nblocks)
Definition: smgr.c:571
#define BlockNumberIsValid(blockNumber)
Definition: block.h:70
ForkNumber forkNum
Definition: storage_xlog.h:36
uint64 XLogRecPtr
Definition: xlogdefs.h:21
#define Assert(condition)
Definition: c.h:732
#define XLR_INFO_MASK
Definition: xlogrecord.h:62
#define InvalidBlockNumber
Definition: block.h:33
#define SMGR_TRUNCATE_VM
Definition: storage_xlog.h:41
#define MAX_FORKNUM
Definition: relpath.h:55
static int64 blocks
Definition: pg_checksums.c:35
#define elog(elevel,...)
Definition: elog.h:226
BlockNumber visibilitymap_prepare_truncate(Relation rel, BlockNumber nheapblocks)
#define XLogRecHasAnyBlockRefs(decoder)
Definition: xlogreader.h:248
BlockNumber blkno
Definition: storage_xlog.h:48
void FreeSpaceMapVacuumRange(Relation rel, BlockNumber start, BlockNumber end)
Definition: freespace.c:352
RelFileNode rnode
Definition: storage_xlog.h:35