PostgreSQL Source Code: src/backend/access/transam/xloginsert.c File Reference (original) (raw)

Go to the source code of this file.

◆ COMPRESS_BUFSIZE

◆ HEADER_SCRATCH_SIZE

#define HEADER_SCRATCH_SIZE

Value:

#define SizeOfXLogTransactionId

#define SizeOfXLogRecordDataHeaderLong

Definition at line 119 of file xloginsert.c.

◆ LZ4_MAX_BLCKSZ

◆ PGLZ_MAX_BLCKSZ

◆ SizeOfXlogOrigin

#define SizeOfXlogOrigin (sizeof(RepOriginId) + sizeof(char))

◆ SizeOfXLogTransactionId

#define SizeOfXLogTransactionId (sizeof(TransactionId) + sizeof(char))

◆ ZSTD_MAX_BLCKSZ

#define ZSTD_MAX_BLCKSZ 0

◆ InitXLogInsert()

Definition at line 1348 of file xloginsert.c.

1349{

1350#ifdef USE_ASSERT_CHECKING

1351

1352

1353

1354

1355

1356

1357

1358 size_t max_required =

1360

1362#endif

1363

1364

1366 {

1368 "WAL record construction",

1370 }

1371

1373 {

1378 }

1380 {

1384 }

1385

1386

1387

1388

1392}

Assert(PointerIsAligned(start, uint64))

void * MemoryContextAlloc(MemoryContext context, Size size)

void * MemoryContextAllocZero(MemoryContext context, Size size)

MemoryContext TopMemoryContext

#define AllocSetContextCreate

#define ALLOCSET_DEFAULT_SIZES

#define AllocSizeIsValid(size)

static int max_registered_buffers

static MemoryContext xloginsert_cxt

static char * hdr_scratch

static XLogRecData * rdatas

static registered_buffer * registered_buffers

#define HEADER_SCRATCH_SIZE

#define XLR_NORMAL_MAX_BLOCK_ID

#define XLR_NORMAL_RDATAS

size_t DecodeXLogRecordRequiredSpace(size_t xl_tot_len)

#define XLogRecordMaxSize

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, AllocSizeIsValid, Assert(), DecodeXLogRecordRequiredSpace(), hdr_scratch, HEADER_SCRATCH_SIZE, max_rdatas, max_registered_buffers, MemoryContextAlloc(), MemoryContextAllocZero(), rdatas, registered_buffers, TopMemoryContext, xloginsert_cxt, XLogRecordMaxSize, XLR_NORMAL_MAX_BLOCK_ID, and XLR_NORMAL_RDATAS.

Referenced by BaseInit().

◆ log_newpage()

Definition at line 1143 of file xloginsert.c.

1145{

1146 int flags;

1148

1150 if (page_std)

1152

1156

1157

1158

1159

1160

1162 {

1164 }

1165

1166 return recptr;

1167}

static bool PageIsNew(const PageData *page)

static void PageSetLSN(Page page, XLogRecPtr lsn)

XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)

void XLogRegisterBlock(uint8 block_id, RelFileLocator *rlocator, ForkNumber forknum, BlockNumber blknum, const PageData *page, uint8 flags)

void XLogBeginInsert(void)

#define REGBUF_FORCE_IMAGE

References PageIsNew(), PageSetLSN(), REGBUF_FORCE_IMAGE, REGBUF_STANDARD, XLOG_FPI, XLogBeginInsert(), XLogInsert(), and XLogRegisterBlock().

Referenced by _hash_alloc_buckets(), _hash_init(), and log_newpage_buffer().

◆ log_newpage_buffer()

Definition at line 1237 of file xloginsert.c.

1238{

1243

1244

1246

1247 BufferGetTag(buffer, &rlocator, &forknum, &blkno);

1248

1249 return log_newpage(&rlocator, forknum, blkno, page, page_std);

1250}

void BufferGetTag(Buffer buffer, RelFileLocator *rlocator, ForkNumber *forknum, BlockNumber *blknum)

static Page BufferGetPage(Buffer buffer)

volatile uint32 CritSectionCount

XLogRecPtr log_newpage(RelFileLocator *rlocator, ForkNumber forknum, BlockNumber blkno, Page page, bool page_std)

References Assert(), BufferGetPage(), BufferGetTag(), CritSectionCount, and log_newpage().

Referenced by brin_initialize_empty_new_buffer(), brinbuildempty(), FreeSpaceMapPrepareTruncateRel(), ginbuildempty(), gistbuildempty(), heap_force_common(), lazy_scan_new_or_empty(), RelationCopyStorageUsingBuffer(), and visibilitymap_prepare_truncate().

◆ log_newpage_range()

Definition at line 1270 of file xloginsert.c.

1273{

1274 int flags;

1276

1278 if (page_std)

1280

1281

1282

1283

1284

1285

1287

1288 blkno = startblk;

1289 while (blkno < endblk)

1290 {

1293 int nbufs;

1294 int i;

1295

1297

1298

1299 nbufs = 0;

1301 {

1304

1306

1307

1308

1309

1310

1311

1313 bufpack[nbufs++] = buf;

1314 else

1316 blkno++;

1317 }

1318

1319

1320 if (nbufs == 0)

1321 break;

1322

1323

1325

1327 for (i = 0; i < nbufs; i++)

1328 {

1331 }

1332

1334

1335 for (i = 0; i < nbufs; i++)

1336 {

1339 }

1341 }

1342}

void UnlockReleaseBuffer(Buffer buffer)

void MarkBufferDirty(Buffer buffer)

void LockBuffer(Buffer buffer, int mode)

Buffer ReadBufferExtended(Relation reln, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, BufferAccessStrategy strategy)

#define BUFFER_LOCK_EXCLUSIVE

#define START_CRIT_SECTION()

#define CHECK_FOR_INTERRUPTS()

#define END_CRIT_SECTION()

void XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags)

void XLogEnsureRecordSpace(int max_block_id, int ndatas)

References buf, BUFFER_LOCK_EXCLUSIVE, BufferGetPage(), CHECK_FOR_INTERRUPTS, END_CRIT_SECTION, i, LockBuffer(), MarkBufferDirty(), PageIsNew(), PageSetLSN(), RBM_NORMAL, ReadBufferExtended(), REGBUF_FORCE_IMAGE, REGBUF_STANDARD, START_CRIT_SECTION, UnlockReleaseBuffer(), XLOG_FPI, XLogBeginInsert(), XLogEnsureRecordSpace(), XLogInsert(), XLogRegisterBuffer(), and XLR_MAX_BLOCK_ID.

Referenced by ginbuild(), gistbuild(), smgrDoPendingSyncs(), and spgbuild().

◆ log_newpages()

Definition at line 1175 of file xloginsert.c.

1177{

1178 int flags;

1180 int i;

1181 int j;

1182

1184 if (page_std)

1186

1187

1188

1189

1190

1191

1193

1194 i = 0;

1195 while (i < num_pages)

1196 {

1198 int nbatch;

1199

1201

1202 nbatch = 0;

1204 {

1205 XLogRegisterBlock(nbatch, rlocator, forknum, blknos[i], pages[i], flags);

1206 i++;

1207 nbatch++;

1208 }

1209

1211

1213 {

1214

1215

1216

1217

1219 {

1221 }

1222 }

1223 }

1224}

Datum batch_start(PG_FUNCTION_ARGS)

References batch_start(), i, j, PageIsNew(), PageSetLSN(), REGBUF_FORCE_IMAGE, REGBUF_STANDARD, XLOG_FPI, XLogBeginInsert(), XLogEnsureRecordSpace(), XLogInsert(), XLogRegisterBlock(), and XLR_MAX_BLOCK_ID.

Referenced by smgr_bulk_flush().

◆ XLogBeginInsert()

Definition at line 149 of file xloginsert.c.

150{

154

155

157 elog(ERROR, "cannot make new WAL entries during recovery");

158

160 elog(ERROR, "XLogBeginInsert was already called");

161

163}

bool XLogInsertAllowed(void)

static XLogRecData * mainrdata_head

static uint64 mainrdata_len

static bool begininsert_called

static int max_registered_block_id

static XLogRecData * mainrdata_last

References Assert(), begininsert_called, elog, ERROR, mainrdata_head, mainrdata_last, mainrdata_len, max_registered_block_id, and XLogInsertAllowed().

Referenced by _bt_allocbuf(), _bt_dedup_pass(), _bt_delitems_delete(), _bt_delitems_vacuum(), _bt_getroot(), _bt_insertonpg(), _bt_mark_page_halfdead(), _bt_newlevel(), _bt_set_cleanup_info(), _bt_split(), _bt_unlink_halfdead_page(), _hash_addovflpage(), _hash_doinsert(), _hash_expandtable(), _hash_freeovflpage(), _hash_init(), _hash_splitbucket(), _hash_squeezebucket(), _hash_vacuum_one_page(), addLeafTuple(), AssignTransactionId(), brin_doinsert(), brin_doupdate(), brinbuild(), brinRevmapDesummarizeRange(), CreateCheckPoint(), CreateDatabaseUsingFileCopy(), CreateDirAndVersionFile(), CreateEndOfRecoveryRecord(), CreateOverwriteContrecordRecord(), createPostingTree(), CreateTableSpace(), do_pg_backup_stop(), do_setval(), doPickSplit(), DropTableSpace(), EndPrepare(), ExecuteTruncateGuts(), fill_seq_fork_with_data(), GenericXLogFinish(), ginDeletePage(), ginHeapTupleFastInsert(), ginPlaceToPage(), ginUpdateStats(), ginVacuumPostingTreeLeaf(), gistXLogAssignLSN(), gistXLogDelete(), gistXLogPageDelete(), gistXLogPageReuse(), gistXLogSplit(), gistXLogUpdate(), hashbucketcleanup(), hashbulkdelete(), heap_abort_speculative(), heap_delete(), heap_finish_speculative(), heap_inplace_update_and_unlock(), heap_insert(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_multi_insert(), heap_update(), log_heap_new_cid(), log_heap_prune_and_freeze(), log_heap_update(), log_heap_visible(), log_newpage(), log_newpage_range(), log_newpages(), log_smgrcreate(), log_split_page(), LogAccessExclusiveLocks(), LogCurrentRunningXacts(), logical_heap_rewrite_flush_mappings(), LogLogicalInvalidations(), LogLogicalMessage(), LogStandbyInvalidations(), movedb(), moveLeafs(), MultiXactIdCreateFromMembers(), nextval_internal(), pg_truncate_visibility_map(), RelationTruncate(), remove_dbtablespaces(), replorigin_advance(), replorigin_state_clear(), RequestXLogSwitch(), revmap_physical_extend(), shiftList(), spgAddNodeAction(), spgSplitNodeAction(), test_custom_rmgrs_insert_wal_record(), UpdateFullPageWrites(), vacuumLeafPage(), vacuumLeafRoot(), vacuumRedirectAndPlaceholder(), write_relmap_file(), writeListPage(), WriteMTruncateXlogRec(), WriteMZeroPageXlogRec(), WriteTruncateXlogRec(), WriteZeroPageXlogRec(), XactLogAbortRecord(), XactLogCommitRecord(), XLogPutNextOid(), XLogReportParameters(), XLogRestorePoint(), XLogSaveBufferForHint(), and xlogVacuumPage().

◆ XLogCheckBufferNeedsBackup()

◆ XLogCompressBackupBlock()

Definition at line 944 of file xloginsert.c.

946{

947 int32 orig_len = BLCKSZ - hole_length;

949 int32 extra_bytes = 0;

952

953 if (hole_length != 0)

954 {

955

956 memcpy(tmp.data, page, hole_offset);

957 memcpy(tmp.data + hole_offset,

958 page + (hole_offset + hole_length),

959 BLCKSZ - (hole_length + hole_offset));

961

962

963

964

965

967 }

968 else

970

972 {

975 break;

976

978#ifdef USE_LZ4

979 len = LZ4_compress_default(source, dest, orig_len,

981 if (len <= 0)

982 len = -1;

983#else

984 elog(ERROR, "LZ4 is not supported by this build");

985#endif

986 break;

987

989#ifdef USE_ZSTD

991 ZSTD_CLEVEL_DEFAULT);

992 if (ZSTD_isError(len))

993 len = -1;

994#else

995 elog(ERROR, "zstd is not supported by this build");

996#endif

997 break;

998

1000 Assert(false);

1001 break;

1002

1003 }

1004

1005

1006

1007

1008

1009

1010 if (len >= 0 &&

1011 len + extra_bytes < orig_len)

1012 {

1013 *dlen = (uint16) len;

1014 return true;

1015 }

1016 return false;

1017}

const PGLZ_Strategy *const PGLZ_strategy_default

int32 pglz_compress(const char *source, int32 slen, char *dest, const PGLZ_Strategy *strategy)

static rewind_source * source

#define SizeOfXLogRecordBlockCompressHeader

References Assert(), COMPRESS_BUFSIZE, PGAlignedBlock::data, generate_unaccent_rules::dest, elog, ERROR, len, pglz_compress(), PGLZ_strategy_default, SizeOfXLogRecordBlockCompressHeader, source, wal_compression, WAL_COMPRESSION_LZ4, WAL_COMPRESSION_NONE, WAL_COMPRESSION_PGLZ, and WAL_COMPRESSION_ZSTD.

Referenced by XLogRecordAssemble().

◆ XLogEnsureRecordSpace()

Definition at line 175 of file xloginsert.c.

176{

177 int nbuffers;

178

179

180

181

182

183

184

186

187

192

194 elog(ERROR, "maximum number of WAL record block references exceeded");

195 nbuffers = max_block_id + 1;

196

198 {

201

202

203

204

205

209 }

210

212 {

215 }

216}

#define MemSet(start, val, len)

void * repalloc(void *pointer, Size size)

References Assert(), CritSectionCount, elog, ERROR, max_rdatas, max_registered_buffers, MemSet, rdatas, registered_buffers, repalloc(), XLR_MAX_BLOCK_ID, XLR_NORMAL_MAX_BLOCK_ID, and XLR_NORMAL_RDATAS.

Referenced by _hash_freeovflpage(), _hash_squeezebucket(), EndPrepare(), gistplacetopage(), log_newpage_range(), log_newpages(), and shiftList().

Definition at line 474 of file xloginsert.c.

475{

477

478

480 elog(ERROR, "XLogBeginInsert was not called");

481

482

483

484

485

489 elog(PANIC, "invalid xlog info mask %02X", info);

490

491 TRACE_POSTGRESQL_WAL_INSERT(rmid, info);

492

493

494

495

496

498 {

501 return EndPos;

502 }

503

504 do

505 {

508 bool topxid_included = false;

511 int num_fpi = 0;

512

513

514

515

516

517

519

521 &fpw_lsn, &num_fpi, &topxid_included);

522

524 topxid_included);

526

528

529 return EndPos;

530}

#define IsBootstrapProcessingMode()

XLogRecPtr XLogInsertRecord(XLogRecData *rdata, XLogRecPtr fpw_lsn, uint8 flags, int num_fpi, bool topxid_included)

#define SizeOfXLogLongPHD

#define InvalidXLogRecPtr

static uint8 curinsert_flags

void XLogResetInsertion(void)

static XLogRecData * XLogRecordAssemble(RmgrId rmid, uint8 info, XLogRecPtr RedoRecPtr, bool doPageWrites, XLogRecPtr *fpw_lsn, int *num_fpi, bool *topxid_included)

#define XLR_RMGR_INFO_MASK

#define XLR_SPECIAL_REL_UPDATE

#define XLR_CHECK_CONSISTENCY

References begininsert_called, curinsert_flags, doPageWrites, elog, ERROR, GetFullPageWriteInfo(), InvalidXLogRecPtr, IsBootstrapProcessingMode, PANIC, RedoRecPtr, SizeOfXLogLongPHD, XLogInsertRecord(), XLogRecordAssemble(), XLogResetInsertion(), XLR_CHECK_CONSISTENCY, XLR_RMGR_INFO_MASK, and XLR_SPECIAL_REL_UPDATE.

Referenced by _bt_allocbuf(), _bt_dedup_pass(), _bt_delitems_delete(), _bt_delitems_vacuum(), _bt_getroot(), _bt_insertonpg(), _bt_mark_page_halfdead(), _bt_newlevel(), _bt_set_cleanup_info(), _bt_split(), _bt_unlink_halfdead_page(), _hash_addovflpage(), _hash_doinsert(), _hash_expandtable(), _hash_freeovflpage(), _hash_init(), _hash_splitbucket(), _hash_squeezebucket(), _hash_vacuum_one_page(), addLeafTuple(), AssignTransactionId(), brin_doinsert(), brin_doupdate(), brinbuild(), brinRevmapDesummarizeRange(), CreateCheckPoint(), CreateDatabaseUsingFileCopy(), CreateDirAndVersionFile(), CreateEndOfRecoveryRecord(), CreateOverwriteContrecordRecord(), createPostingTree(), CreateTableSpace(), do_pg_backup_stop(), do_setval(), doPickSplit(), DropTableSpace(), EndPrepare(), ExecuteTruncateGuts(), fill_seq_fork_with_data(), GenericXLogFinish(), ginDeletePage(), ginHeapTupleFastInsert(), ginPlaceToPage(), ginUpdateStats(), ginVacuumPostingTreeLeaf(), gistXLogAssignLSN(), gistXLogDelete(), gistXLogPageDelete(), gistXLogPageReuse(), gistXLogSplit(), gistXLogUpdate(), hashbucketcleanup(), hashbulkdelete(), heap_abort_speculative(), heap_delete(), heap_finish_speculative(), heap_inplace_update_and_unlock(), heap_insert(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_multi_insert(), heap_update(), log_heap_new_cid(), log_heap_prune_and_freeze(), log_heap_update(), log_heap_visible(), log_newpage(), log_newpage_range(), log_newpages(), log_smgrcreate(), log_split_page(), LogAccessExclusiveLocks(), LogCurrentRunningXacts(), logical_heap_rewrite_flush_mappings(), LogLogicalInvalidations(), LogLogicalMessage(), LogStandbyInvalidations(), movedb(), moveLeafs(), MultiXactIdCreateFromMembers(), nextval_internal(), pg_truncate_visibility_map(), RelationTruncate(), remove_dbtablespaces(), replorigin_advance(), replorigin_state_clear(), RequestXLogSwitch(), revmap_physical_extend(), shiftList(), spgAddNodeAction(), spgSplitNodeAction(), test_custom_rmgrs_insert_wal_record(), UpdateFullPageWrites(), vacuumLeafPage(), vacuumLeafRoot(), vacuumRedirectAndPlaceholder(), write_relmap_file(), writeListPage(), WriteMTruncateXlogRec(), WriteMZeroPageXlogRec(), WriteTruncateXlogRec(), WriteZeroPageXlogRec(), XactLogAbortRecord(), XactLogCommitRecord(), XLogPutNextOid(), XLogReportParameters(), XLogRestorePoint(), XLogSaveBufferForHint(), and xlogVacuumPage().

◆ XLogRecordAssemble()

Definition at line 548 of file xloginsert.c.

551{

553 uint64 total_len = 0;

554 int block_id;

560

561

562

563

564

565

566

569

571 rdt_datas_last = &hdr_rdt;

573

574

575

576

577

578

579

582

583

584

585

586

587

590 {

592 bool needs_backup;

593 bool needs_data;

597 bool samerel;

598 bool is_compressed = false;

599 bool include_image;

600

602 continue;

603

604

606 needs_backup = true;

608 needs_backup = false;

610 needs_backup = false;

611 else

612 {

613

614

615

616

617

619

620 needs_backup = (page_lsn <= RedoRecPtr);

621 if (!needs_backup)

622 {

624 *fpw_lsn = page_lsn;

625 }

626 }

627

628

630 needs_data = false;

632 needs_data = true;

633 else

634 needs_data = !needs_backup;

635

636 bkpb.id = block_id;

639

642

643

644

645

646

648

649 if (include_image)

650 {

652 uint16 compressed_len = 0;

653

654

655

656

657

659 {

660

663

667 {

670 }

671 else

672 {

673

676 }

677 }

678 else

679 {

680

683 }

684

685

686

687

689 {

690 is_compressed =

694 &compressed_len);

695 }

696

697

698

699

700

702

703

704 *num_fpi += 1;

705

706

707

708

710 rdt_datas_last = rdt_datas_last->next;

711

713

714

715

716

717

718

719

720 if (needs_backup)

722

723 if (is_compressed)

724 {

725

726 bimg.length = compressed_len;

727

728

730 {

733 break;

734

736#ifdef USE_LZ4

738#else

739 elog(ERROR, "LZ4 is not supported by this build");

740#endif

741 break;

742

744#ifdef USE_ZSTD

746#else

747 elog(ERROR, "zstd is not supported by this build");

748#endif

749 break;

750

752 Assert(false);

753 break;

754

755 }

756

758 rdt_datas_last->len = compressed_len;

759 }

760 else

761 {

763

765 {

766 rdt_datas_last->data = page;

767 rdt_datas_last->len = BLCKSZ;

768 }

769 else

770 {

771

772 rdt_datas_last->data = page;

774

776 rdt_datas_last = rdt_datas_last->next;

777

778 rdt_datas_last->data =

780 rdt_datas_last->len =

782 }

783 }

784

785 total_len += bimg.length;

786 }

787

788 if (needs_data)

789 {

790

791

792

793

795

796

797

798

799

803

806 }

807

809 {

810 samerel = true;

812 }

813 else

814 samerel = false;

815 prev_regbuf = regbuf;

816

817

820 if (include_image)

821 {

824 if (cbimg.hole_length != 0 && is_compressed)

825 {

826 memcpy(scratch, &cbimg,

829 }

830 }

831 if (!samerel)

832 {

835 }

838 }

839

840

843 {

847 }

848

849

851 {

853

854

855 *topxid_included = true;

856

860 }

861

862

864 {

866 {

867 uint32 mainrdata_len_4b;

868

872 errdetail_internal("Main data length is %" PRIu64 " bytes for a maximum of %u bytes.",

875

878 memcpy(scratch, &mainrdata_len_4b, sizeof(uint32));

879 scratch += sizeof(uint32);

880 }

881 else

882 {

885 }

889 }

890 rdt_datas_last->next = NULL;

891

894

895

896

897

898

899

900

901

902

907

908

909

910

911

912

913

914

918 errdetail_internal("WAL record would be %" PRIu64 " bytes (of maximum %u bytes); rmid %u flags %u.",

920

921

922

923

924

925

931 rechdr->xl_crc = rdata_crc;

932

934}

PageHeaderData * PageHeader

#define SizeOfPageHeaderData

int errmsg_internal(const char *fmt,...)

int errdetail_internal(const char *fmt,...)

#define ereport(elevel,...)

Datum lower(PG_FUNCTION_ARGS)

Datum upper(PG_FUNCTION_ARGS)

RepOriginId replorigin_session_origin

#define InvalidRepOriginId

#define COMP_CRC32C(crc, data, len)

struct RelFileLocator RelFileLocator

#define RelFileLocatorEquals(locator1, locator2)

struct XLogRecData * next

XLogRecData bkp_rdatas[2]

char compressed_page[COMPRESS_BUFSIZE]

TransactionId GetTopTransactionIdIfAny(void)

TransactionId GetCurrentTransactionIdIfAny(void)

bool IsSubxactTopXidLogPending(void)

bool * wal_consistency_checking

#define XLOG_INCLUDE_ORIGIN

static bool XLogCompressBackupBlock(const PageData *page, uint16 hole_offset, uint16 hole_length, void *dest, uint16 *dlen)

static XLogRecData hdr_rdt

#define SizeOfXLogRecordBlockImageHeader

#define BKPIMAGE_COMPRESS_ZSTD

#define BKPBLOCK_HAS_DATA

#define BKPIMAGE_HAS_HOLE

#define XLR_BLOCK_ID_DATA_LONG

#define BKPBLOCK_WILL_INIT

#define BKPIMAGE_COMPRESS_LZ4

#define XLR_BLOCK_ID_TOPLEVEL_XID

#define XLR_BLOCK_ID_DATA_SHORT

#define BKPBLOCK_SAME_REL

#define SizeOfXLogRecordBlockHeader

#define BKPIMAGE_COMPRESS_PGLZ

#define XLR_BLOCK_ID_ORIGIN

#define BKPBLOCK_HAS_IMAGE

References Assert(), XLogRecordBlockImageHeader::bimg_info, registered_buffer::bkp_rdatas, BKPBLOCK_HAS_DATA, BKPBLOCK_HAS_IMAGE, BKPBLOCK_SAME_REL, BKPBLOCK_WILL_INIT, BKPIMAGE_APPLY, BKPIMAGE_COMPRESS_LZ4, BKPIMAGE_COMPRESS_PGLZ, BKPIMAGE_COMPRESS_ZSTD, BKPIMAGE_HAS_HOLE, registered_buffer::block, COMP_CRC32C, registered_buffer::compressed_page, curinsert_flags, XLogRecData::data, XLogRecordBlockHeader::data_length, doPageWrites, elog, ereport, errdetail_internal(), errmsg_internal(), ERROR, registered_buffer::flags, XLogRecordBlockHeader::fork_flags, registered_buffer::forkno, GetCurrentTransactionIdIfAny(), GetTopTransactionIdIfAny(), hdr_rdt, hdr_scratch, XLogRecordBlockCompressHeader::hole_length, XLogRecordBlockImageHeader::hole_offset, XLogRecordBlockHeader::id, registered_buffer::in_use, INIT_CRC32C, InvalidRepOriginId, InvalidXLogRecPtr, IsSubxactTopXidLogPending(), XLogRecData::len, XLogRecordBlockImageHeader::length, lower(), mainrdata_head, mainrdata_last, mainrdata_len, max_registered_block_id, XLogRecData::next, registered_buffer::page, PageGetLSN(), PG_UINT32_MAX, registered_buffer::rdata_head, registered_buffer::rdata_len, registered_buffer::rdata_tail, RedoRecPtr, REGBUF_FORCE_IMAGE, REGBUF_KEEP_DATA, REGBUF_NO_IMAGE, REGBUF_STANDARD, REGBUF_WILL_INIT, registered_buffers, RelFileLocatorEquals, replorigin_session_origin, registered_buffer::rlocator, SizeOfPageHeaderData, SizeOfXLogRecord, SizeOfXLogRecordBlockCompressHeader, SizeOfXLogRecordBlockHeader, SizeOfXLogRecordBlockImageHeader, upper(), wal_compression, WAL_COMPRESSION_LZ4, WAL_COMPRESSION_NONE, WAL_COMPRESSION_PGLZ, WAL_COMPRESSION_ZSTD, wal_consistency_checking, XLogRecord::xl_crc, XLogRecord::xl_info, XLogRecord::xl_prev, XLogRecord::xl_rmid, XLogRecord::xl_tot_len, XLogRecord::xl_xid, XLOG_INCLUDE_ORIGIN, XLogCompressBackupBlock(), XLogRecordMaxSize, XLR_BLOCK_ID_DATA_LONG, XLR_BLOCK_ID_DATA_SHORT, XLR_BLOCK_ID_ORIGIN, XLR_BLOCK_ID_TOPLEVEL_XID, and XLR_CHECK_CONSISTENCY.

Referenced by XLogInsert().

◆ XLogRegisterBlock()

Definition at line 309 of file xloginsert.c.

311{

313

315

318

320 elog(ERROR, "too many registered buffers");

321

323

324 regbuf->rlocator = *rlocator;

325 regbuf->forkno = forknum;

326 regbuf->block = blknum;

327 regbuf->page = page;

328 regbuf->flags = flags;

331

332

333

334

335

336#ifdef USE_ASSERT_CHECKING

337 {

338 int i;

339

341 {

343

344 if (i == block_id || !regbuf_old->in_use)

345 continue;

346

350 }

351 }

352#endif

353

354 regbuf->in_use = true;

355}

References Assert(), begininsert_called, registered_buffer::block, elog, ERROR, registered_buffer::flags, for(), registered_buffer::forkno, i, registered_buffer::in_use, max_registered_block_id, max_registered_buffers, registered_buffer::page, registered_buffer::rdata_head, registered_buffer::rdata_len, registered_buffer::rdata_tail, registered_buffers, RelFileLocatorEquals, and registered_buffer::rlocator.

Referenced by heap_inplace_update_and_unlock(), log_newpage(), log_newpages(), and XLogSaveBufferForHint().

◆ XLogRegisterBufData()

Definition at line 405 of file xloginsert.c.

406{

409

411

412

415 elog(ERROR, "no block with id %d registered with WAL insertion",

416 block_id);

417

418

419

420

421

422

423

429 if (regbuf->rdata_len + len > UINT16_MAX || len > UINT16_MAX)

432 errdetail_internal("Registering more than maximum %u bytes allowed to block %u: current %u bytes, adding %u bytes.",

433 UINT16_MAX, block_id, regbuf->rdata_len, len)));

434

436

439

443}

References Assert(), begininsert_called, XLogRecData::data, data, elog, ereport, errdetail_internal(), errmsg_internal(), ERROR, registered_buffer::in_use, XLogRecData::len, len, max_rdatas, XLogRecData::next, num_rdatas, registered_buffer::rdata_len, registered_buffer::rdata_tail, rdatas, and registered_buffers.

Referenced by _bt_dedup_pass(), _bt_delitems_delete(), _bt_delitems_vacuum(), _bt_getroot(), _bt_insertonpg(), _bt_newlevel(), _bt_set_cleanup_info(), _bt_split(), _bt_unlink_halfdead_page(), _hash_addovflpage(), _hash_doinsert(), _hash_expandtable(), _hash_freeovflpage(), _hash_squeezebucket(), brin_doinsert(), brin_doupdate(), dataExecPlaceToPageInternal(), dataExecPlaceToPageLeaf(), entryExecPlaceToPage(), GenericXLogFinish(), ginHeapTupleFastInsert(), ginVacuumPostingTreeLeaf(), gistXLogSplit(), gistXLogUpdate(), hashbucketcleanup(), heap_inplace_update_and_unlock(), heap_insert(), heap_multi_insert(), log_heap_prune_and_freeze(), log_heap_update(), and writeListPage().

◆ XLogRegisterBuffer()

Definition at line 242 of file xloginsert.c.

243{

245

246

249

250

251

252

253

254

255

256

257

258

259#ifdef USE_ASSERT_CHECKING

262#endif

263

265 {

267 elog(ERROR, "too many registered buffers");

269 }

270

272

275 regbuf->flags = flags;

278

279

280

281

282

283#ifdef USE_ASSERT_CHECKING

284 {

285 int i;

286

288 {

290

291 if (i == block_id || !regbuf_old->in_use)

292 continue;

293

297 }

298 }

299#endif

300

301 regbuf->in_use = true;

302}

bool BufferIsExclusiveLocked(Buffer buffer)

bool BufferIsDirty(Buffer buffer)

References Assert(), begininsert_called, registered_buffer::block, BufferGetPage(), BufferGetTag(), BufferIsDirty(), BufferIsExclusiveLocked(), elog, ERROR, registered_buffer::flags, for(), registered_buffer::forkno, i, registered_buffer::in_use, max_registered_block_id, max_registered_buffers, registered_buffer::page, registered_buffer::rdata_head, registered_buffer::rdata_len, registered_buffer::rdata_tail, REGBUF_FORCE_IMAGE, REGBUF_NO_CHANGE, REGBUF_NO_IMAGE, registered_buffers, RelFileLocatorEquals, and registered_buffer::rlocator.

Referenced by _bt_dedup_pass(), _bt_delitems_delete(), _bt_delitems_vacuum(), _bt_getroot(), _bt_insertonpg(), _bt_mark_page_halfdead(), _bt_newlevel(), _bt_set_cleanup_info(), _bt_split(), _bt_unlink_halfdead_page(), _hash_addovflpage(), _hash_doinsert(), _hash_expandtable(), _hash_freeovflpage(), _hash_init(), _hash_splitbucket(), _hash_squeezebucket(), _hash_vacuum_one_page(), addLeafTuple(), brin_doinsert(), brin_doupdate(), brinbuild(), brinRevmapDesummarizeRange(), createPostingTree(), dataExecPlaceToPageInternal(), dataExecPlaceToPageLeaf(), do_setval(), doPickSplit(), entryExecPlaceToPage(), fill_seq_fork_with_data(), GenericXLogFinish(), ginDeletePage(), ginHeapTupleFastInsert(), ginPlaceToPage(), ginUpdateStats(), ginVacuumPostingTreeLeaf(), gistXLogDelete(), gistXLogPageDelete(), gistXLogSplit(), gistXLogUpdate(), hashbucketcleanup(), hashbulkdelete(), heap_abort_speculative(), heap_delete(), heap_finish_speculative(), heap_insert(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_multi_insert(), heap_update(), log_heap_prune_and_freeze(), log_heap_update(), log_heap_visible(), log_newpage_range(), log_split_page(), moveLeafs(), nextval_internal(), revmap_physical_extend(), shiftList(), spgAddNodeAction(), spgSplitNodeAction(), vacuumLeafPage(), vacuumLeafRoot(), vacuumRedirectAndPlaceholder(), writeListPage(), and xlogVacuumPage().

◆ XLogRegisterData()

Definition at line 364 of file xloginsert.c.

365{

367

369

376

379

380

381

382

383

384

387

389}

References Assert(), begininsert_called, XLogRecData::data, data, ereport, errdetail_internal(), errmsg_internal(), ERROR, XLogRecData::len, len, mainrdata_last, mainrdata_len, max_rdatas, XLogRecData::next, num_rdatas, and rdatas.

Referenced by _bt_allocbuf(), _bt_dedup_pass(), _bt_delitems_delete(), _bt_delitems_vacuum(), _bt_getroot(), _bt_insertonpg(), _bt_mark_page_halfdead(), _bt_newlevel(), _bt_split(), _bt_unlink_halfdead_page(), _hash_addovflpage(), _hash_doinsert(), _hash_expandtable(), _hash_freeovflpage(), _hash_init(), _hash_splitbucket(), _hash_squeezebucket(), _hash_vacuum_one_page(), addLeafTuple(), AssignTransactionId(), brin_doinsert(), brin_doupdate(), brinbuild(), brinRevmapDesummarizeRange(), CreateCheckPoint(), CreateDatabaseUsingFileCopy(), CreateDirAndVersionFile(), CreateEndOfRecoveryRecord(), CreateOverwriteContrecordRecord(), createPostingTree(), CreateTableSpace(), do_pg_backup_stop(), do_setval(), doPickSplit(), DropTableSpace(), EndPrepare(), ExecuteTruncateGuts(), fill_seq_fork_with_data(), ginDeletePage(), ginHeapTupleFastInsert(), ginPlaceToPage(), ginUpdateStats(), gistXLogAssignLSN(), gistXLogDelete(), gistXLogPageDelete(), gistXLogPageReuse(), gistXLogSplit(), gistXLogUpdate(), hashbucketcleanup(), hashbulkdelete(), heap_abort_speculative(), heap_delete(), heap_finish_speculative(), heap_inplace_update_and_unlock(), heap_insert(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_multi_insert(), heap_update(), log_heap_new_cid(), log_heap_prune_and_freeze(), log_heap_update(), log_heap_visible(), log_smgrcreate(), LogAccessExclusiveLocks(), LogCurrentRunningXacts(), logical_heap_rewrite_flush_mappings(), LogLogicalInvalidations(), LogLogicalMessage(), LogStandbyInvalidations(), movedb(), moveLeafs(), MultiXactIdCreateFromMembers(), nextval_internal(), pg_truncate_visibility_map(), RelationTruncate(), remove_dbtablespaces(), replorigin_advance(), replorigin_state_clear(), revmap_physical_extend(), shiftList(), spgAddNodeAction(), spgSplitNodeAction(), test_custom_rmgrs_insert_wal_record(), UpdateFullPageWrites(), vacuumLeafPage(), vacuumLeafRoot(), vacuumRedirectAndPlaceholder(), write_relmap_file(), writeListPage(), WriteMTruncateXlogRec(), WriteMZeroPageXlogRec(), WriteTruncateXlogRec(), WriteZeroPageXlogRec(), XactLogAbortRecord(), XactLogCommitRecord(), XLogPutNextOid(), XLogReportParameters(), and XLogRestorePoint().

◆ XLogResetInsertion()

Definition at line 222 of file xloginsert.c.

223{

224 int i;

225

228

235}

References begininsert_called, curinsert_flags, i, mainrdata_head, mainrdata_last, mainrdata_len, max_registered_block_id, num_rdatas, and registered_buffers.

Referenced by AbortSubTransaction(), AbortTransaction(), and XLogInsert().

◆ XLogSaveBufferForHint()

Definition at line 1065 of file xloginsert.c.

1066{

1070

1071

1072

1073

1075

1076

1077

1078

1080

1081

1082

1083

1084

1085

1086

1088

1090 {

1091 int flags = 0;

1097

1098

1099

1100

1101

1102

1103 if (buffer_std)

1104 {

1105

1109

1110 memcpy(copied_buffer.data, origdata, lower);

1112 }

1113 else

1114 memcpy(copied_buffer.data, origdata, BLCKSZ);

1115

1117

1118 if (buffer_std)

1120

1121 BufferGetTag(buffer, &rlocator, &forkno, &blkno);

1123

1125 }

1126

1127 return recptr;

1128}

XLogRecPtr BufferGetLSNAtomic(Buffer buffer)

static Block BufferGetBlock(Buffer buffer)

#define XLOG_FPI_FOR_HINT

#define DELAY_CHKPT_START

XLogRecPtr GetRedoRecPtr(void)

References Assert(), BufferGetBlock(), BufferGetLSNAtomic(), BufferGetPage(), BufferGetTag(), PGAlignedBlock::data, DELAY_CHKPT_START, PGPROC::delayChkptFlags, GetRedoRecPtr(), InvalidXLogRecPtr, lower(), MyProc, RedoRecPtr, REGBUF_STANDARD, upper(), XLOG_FPI_FOR_HINT, XLogBeginInsert(), XLogInsert(), and XLogRegisterBlock().

Referenced by MarkBufferDirtyHint().

◆ XLogSetRecordFlags()

Definition at line 456 of file xloginsert.c.

References Assert(), begininsert_called, and curinsert_flags.

Referenced by EndPrepare(), ExecuteTruncateGuts(), gistXLogAssignLSN(), heap_delete(), heap_finish_speculative(), heap_insert(), heap_multi_insert(), log_heap_update(), LogAccessExclusiveLocks(), LogCurrentRunningXacts(), LogLogicalMessage(), RequestXLogSwitch(), test_custom_rmgrs_insert_wal_record(), XactLogAbortRecord(), and XactLogCommitRecord().

◆ begininsert_called

◆ curinsert_flags

◆ hdr_rdt

◆ hdr_scratch

◆ mainrdata_head

◆ mainrdata_last

◆ mainrdata_len

◆ max_rdatas

◆ max_registered_block_id

◆ max_registered_buffers

◆ num_rdatas

◆ rdatas

◆ registered_buffers

◆ xloginsert_cxt