xloginsert.h File Reference (original) (raw)

Go to the source code of this file.

Macros
#define	XLR_NORMAL_MAX_BLOCK_ID 4

#define	XLR_NORMAL_RDATAS 20

#define	REGBUF_FORCE_IMAGE 0x01 /* force a full-page image */

#define	REGBUF_NO_IMAGE 0x02 /* don't take a full-page image */

#define	REGBUF_WILL_INIT

#define	REGBUF_STANDARD

#define	REGBUF_KEEP_DATA

#define	REGBUF_NO_CHANGE 0x20 /* intentionally register clean buffer */

Functions
void	XLogBeginInsert (void)

void	XLogSetRecordFlags (uint8 flags)

XLogRecPtr	XLogInsert (RmgrId rmid, uint8 info)

void	XLogEnsureRecordSpace (int max_block_id, int ndatas)

void	XLogRegisterData (const void *data, uint32 len)

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

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

void	XLogRegisterBufData (uint8 block_id, const void *data, uint32 len)

void	XLogResetInsertion (void)

bool	XLogCheckBufferNeedsBackup (Buffer buffer)

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

void	log_newpages (RelFileLocator rlocator, ForkNumber forknum, int num_pages, BlockNumber blknos, Page *pages, bool page_std)

XLogRecPtr	log_newpage_buffer (Buffer buffer, bool page_std)

void	log_newpage_range (Relation rel, ForkNumber forknum, BlockNumber startblk, BlockNumber endblk, bool page_std)

XLogRecPtr	XLogSaveBufferForHint (Buffer buffer, bool buffer_std)

void	InitXLogInsert (void)

◆ REGBUF_FORCE_IMAGE

#define REGBUF_FORCE_IMAGE 0x01 /* force a full-page image */

◆ REGBUF_KEEP_DATA

◆ REGBUF_NO_CHANGE

#define REGBUF_NO_CHANGE 0x20 /* intentionally register clean buffer */

◆ REGBUF_NO_IMAGE

#define REGBUF_NO_IMAGE 0x02 /* don't take a full-page image */

◆ REGBUF_STANDARD

◆ REGBUF_WILL_INIT

◆ XLR_NORMAL_MAX_BLOCK_ID

#define XLR_NORMAL_MAX_BLOCK_ID 4

◆ XLR_NORMAL_RDATAS

#define XLR_NORMAL_RDATAS 20

◆ InitXLogInsert()

void InitXLogInsert	(	void	)

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()

void XLogBeginInsert	(	void	)

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()

bool XLogCheckBufferNeedsBackup	(	Buffer	buffer	)

◆ XLogEnsureRecordSpace()

void XLogEnsureRecordSpace	(	int	max_block_id,
int	ndatas
)

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.

◆ 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}

#define RelFileLocatorEquals(locator1, locator2)

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()

void XLogRegisterBufData	(	uint8	block_id,
const void *	data,
uint32	len
)

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}

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

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

#define ereport(elevel,...)

struct XLogRecData * next

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)

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()

void XLogRegisterData	(	const void *	data,
uint32	len
)

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()

void XLogResetInsertion	(	void	)

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)

PageHeaderData * PageHeader

Datum lower(PG_FUNCTION_ARGS)

Datum upper(PG_FUNCTION_ARGS)

#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()

void XLogSetRecordFlags	(	uint8	flags	)

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().