Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * heapam_xlog.c
4 : * WAL replay logic for heap access method.
5 : *
6 : * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 : * Portions Copyright (c) 1994, Regents of the University of California
8 : *
9 : *
10 : * IDENTIFICATION
11 : * src/backend/access/heap/heapam_xlog.c
12 : *
13 : *-------------------------------------------------------------------------
14 : */
15 : #include "postgres.h"
16 :
17 : #include "access/bufmask.h"
18 : #include "access/heapam.h"
19 : #include "access/visibilitymap.h"
20 : #include "access/xlog.h"
21 : #include "access/xlogutils.h"
22 : #include "storage/freespace.h"
23 : #include "storage/standby.h"
24 :
25 :
26 : /*
27 : * Replay XLOG_HEAP2_PRUNE_* records.
28 : */
29 : static void
30 24978 : heap_xlog_prune_freeze(XLogReaderState *record)
31 : {
32 24978 : XLogRecPtr lsn = record->EndRecPtr;
33 24978 : char *maindataptr = XLogRecGetData(record);
34 : xl_heap_prune xlrec;
35 : Buffer buffer;
36 : RelFileLocator rlocator;
37 : BlockNumber blkno;
38 : XLogRedoAction action;
39 :
40 24978 : XLogRecGetBlockTag(record, 0, &rlocator, NULL, &blkno);
41 24978 : memcpy(&xlrec, maindataptr, SizeOfHeapPrune);
42 24978 : maindataptr += SizeOfHeapPrune;
43 :
44 : /*
45 : * We will take an ordinary exclusive lock or a cleanup lock depending on
46 : * whether the XLHP_CLEANUP_LOCK flag is set. With an ordinary exclusive
47 : * lock, we better not be doing anything that requires moving existing
48 : * tuple data.
49 : */
50 : Assert((xlrec.flags & XLHP_CLEANUP_LOCK) != 0 ||
51 : (xlrec.flags & (XLHP_HAS_REDIRECTIONS | XLHP_HAS_DEAD_ITEMS)) == 0);
52 :
53 : /*
54 : * We are about to remove and/or freeze tuples. In Hot Standby mode,
55 : * ensure that there are no queries running for which the removed tuples
56 : * are still visible or which still consider the frozen xids as running.
57 : * The conflict horizon XID comes after xl_heap_prune.
58 : */
59 24978 : if ((xlrec.flags & XLHP_HAS_CONFLICT_HORIZON) != 0)
60 : {
61 : TransactionId snapshot_conflict_horizon;
62 :
63 : /* memcpy() because snapshot_conflict_horizon is stored unaligned */
64 18756 : memcpy(&snapshot_conflict_horizon, maindataptr, sizeof(TransactionId));
65 18756 : maindataptr += sizeof(TransactionId);
66 :
67 18756 : if (InHotStandby)
68 18292 : ResolveRecoveryConflictWithSnapshot(snapshot_conflict_horizon,
69 18292 : (xlrec.flags & XLHP_IS_CATALOG_REL) != 0,
70 : rlocator);
71 : }
72 :
73 : /*
74 : * If we have a full-page image, restore it and we're done.
75 : */
76 24978 : action = XLogReadBufferForRedoExtended(record, 0, RBM_NORMAL,
77 24978 : (xlrec.flags & XLHP_CLEANUP_LOCK) != 0,
78 : &buffer);
79 24978 : if (action == BLK_NEEDS_REDO)
80 : {
81 16458 : Page page = BufferGetPage(buffer);
82 : OffsetNumber *redirected;
83 : OffsetNumber *nowdead;
84 : OffsetNumber *nowunused;
85 : int nredirected;
86 : int ndead;
87 : int nunused;
88 : int nplans;
89 : Size datalen;
90 : xlhp_freeze_plan *plans;
91 : OffsetNumber *frz_offsets;
92 16458 : char *dataptr = XLogRecGetBlockData(record, 0, &datalen);
93 :
94 16458 : heap_xlog_deserialize_prune_and_freeze(dataptr, xlrec.flags,
95 : &nplans, &plans, &frz_offsets,
96 : &nredirected, &redirected,
97 : &ndead, &nowdead,
98 : &nunused, &nowunused);
99 :
100 : /*
101 : * Update all line pointers per the record, and repair fragmentation
102 : * if needed.
103 : */
104 16458 : if (nredirected > 0 || ndead > 0 || nunused > 0)
105 14962 : heap_page_prune_execute(buffer,
106 14962 : (xlrec.flags & XLHP_CLEANUP_LOCK) == 0,
107 : redirected, nredirected,
108 : nowdead, ndead,
109 : nowunused, nunused);
110 :
111 : /* Freeze tuples */
112 18968 : for (int p = 0; p < nplans; p++)
113 : {
114 : HeapTupleFreeze frz;
115 :
116 : /*
117 : * Convert freeze plan representation from WAL record into
118 : * per-tuple format used by heap_execute_freeze_tuple
119 : */
120 2510 : frz.xmax = plans[p].xmax;
121 2510 : frz.t_infomask2 = plans[p].t_infomask2;
122 2510 : frz.t_infomask = plans[p].t_infomask;
123 2510 : frz.frzflags = plans[p].frzflags;
124 2510 : frz.offset = InvalidOffsetNumber; /* unused, but be tidy */
125 :
126 123944 : for (int i = 0; i < plans[p].ntuples; i++)
127 : {
128 121434 : OffsetNumber offset = *(frz_offsets++);
129 : ItemId lp;
130 : HeapTupleHeader tuple;
131 :
132 121434 : lp = PageGetItemId(page, offset);
133 121434 : tuple = (HeapTupleHeader) PageGetItem(page, lp);
134 121434 : heap_execute_freeze_tuple(tuple, &frz);
135 : }
136 : }
137 :
138 : /* There should be no more data */
139 : Assert((char *) frz_offsets == dataptr + datalen);
140 :
141 : /*
142 : * Note: we don't worry about updating the page's prunability hints.
143 : * At worst this will cause an extra prune cycle to occur soon.
144 : */
145 :
146 16458 : PageSetLSN(page, lsn);
147 16458 : MarkBufferDirty(buffer);
148 : }
149 :
150 : /*
151 : * If we released any space or line pointers, update the free space map.
152 : *
153 : * Do this regardless of a full-page image being applied, since the FSM
154 : * data is not in the page anyway.
155 : */
156 24978 : if (BufferIsValid(buffer))
157 : {
158 24978 : if (xlrec.flags & (XLHP_HAS_REDIRECTIONS |
159 : XLHP_HAS_DEAD_ITEMS |
160 : XLHP_HAS_NOW_UNUSED_ITEMS))
161 : {
162 21358 : Size freespace = PageGetHeapFreeSpace(BufferGetPage(buffer));
163 :
164 21358 : UnlockReleaseBuffer(buffer);
165 :
166 21358 : XLogRecordPageWithFreeSpace(rlocator, blkno, freespace);
167 : }
168 : else
169 3620 : UnlockReleaseBuffer(buffer);
170 : }
171 24978 : }
172 :
173 : /*
174 : * Replay XLOG_HEAP2_VISIBLE records.
175 : *
176 : * The critical integrity requirement here is that we must never end up with
177 : * a situation where the visibility map bit is set, and the page-level
178 : * PD_ALL_VISIBLE bit is clear. If that were to occur, then a subsequent
179 : * page modification would fail to clear the visibility map bit.
180 : */
181 : static void
182 14700 : heap_xlog_visible(XLogReaderState *record)
183 : {
184 14700 : XLogRecPtr lsn = record->EndRecPtr;
185 14700 : xl_heap_visible *xlrec = (xl_heap_visible *) XLogRecGetData(record);
186 14700 : Buffer vmbuffer = InvalidBuffer;
187 : Buffer buffer;
188 : Page page;
189 : RelFileLocator rlocator;
190 : BlockNumber blkno;
191 : XLogRedoAction action;
192 :
193 : Assert((xlrec->flags & VISIBILITYMAP_XLOG_VALID_BITS) == xlrec->flags);
194 :
195 14700 : XLogRecGetBlockTag(record, 1, &rlocator, NULL, &blkno);
196 :
197 : /*
198 : * If there are any Hot Standby transactions running that have an xmin
199 : * horizon old enough that this page isn't all-visible for them, they
200 : * might incorrectly decide that an index-only scan can skip a heap fetch.
201 : *
202 : * NB: It might be better to throw some kind of "soft" conflict here that
203 : * forces any index-only scan that is in flight to perform heap fetches,
204 : * rather than killing the transaction outright.
205 : */
206 14700 : if (InHotStandby)
207 14352 : ResolveRecoveryConflictWithSnapshot(xlrec->snapshotConflictHorizon,
208 14352 : xlrec->flags & VISIBILITYMAP_XLOG_CATALOG_REL,
209 : rlocator);
210 :
211 : /*
212 : * Read the heap page, if it still exists. If the heap file has dropped or
213 : * truncated later in recovery, we don't need to update the page, but we'd
214 : * better still update the visibility map.
215 : */
216 14700 : action = XLogReadBufferForRedo(record, 1, &buffer);
217 14700 : if (action == BLK_NEEDS_REDO)
218 : {
219 : /*
220 : * We don't bump the LSN of the heap page when setting the visibility
221 : * map bit (unless checksums or wal_hint_bits is enabled, in which
222 : * case we must). This exposes us to torn page hazards, but since
223 : * we're not inspecting the existing page contents in any way, we
224 : * don't care.
225 : */
226 11002 : page = BufferGetPage(buffer);
227 :
228 11002 : PageSetAllVisible(page);
229 :
230 11002 : if (XLogHintBitIsNeeded())
231 11002 : PageSetLSN(page, lsn);
232 :
233 11002 : MarkBufferDirty(buffer);
234 : }
235 : else if (action == BLK_RESTORED)
236 : {
237 : /*
238 : * If heap block was backed up, we already restored it and there's
239 : * nothing more to do. (This can only happen with checksums or
240 : * wal_log_hints enabled.)
241 : */
242 : }
243 :
244 14700 : if (BufferIsValid(buffer))
245 : {
246 14700 : Size space = PageGetFreeSpace(BufferGetPage(buffer));
247 :
248 14700 : UnlockReleaseBuffer(buffer);
249 :
250 : /*
251 : * Since FSM is not WAL-logged and only updated heuristically, it
252 : * easily becomes stale in standbys. If the standby is later promoted
253 : * and runs VACUUM, it will skip updating individual free space
254 : * figures for pages that became all-visible (or all-frozen, depending
255 : * on the vacuum mode,) which is troublesome when FreeSpaceMapVacuum
256 : * propagates too optimistic free space values to upper FSM layers;
257 : * later inserters try to use such pages only to find out that they
258 : * are unusable. This can cause long stalls when there are many such
259 : * pages.
260 : *
261 : * Forestall those problems by updating FSM's idea about a page that
262 : * is becoming all-visible or all-frozen.
263 : *
264 : * Do this regardless of a full-page image being applied, since the
265 : * FSM data is not in the page anyway.
266 : */
267 14700 : if (xlrec->flags & VISIBILITYMAP_VALID_BITS)
268 14700 : XLogRecordPageWithFreeSpace(rlocator, blkno, space);
269 : }
270 :
271 : /*
272 : * Even if we skipped the heap page update due to the LSN interlock, it's
273 : * still safe to update the visibility map. Any WAL record that clears
274 : * the visibility map bit does so before checking the page LSN, so any
275 : * bits that need to be cleared will still be cleared.
276 : */
277 14700 : if (XLogReadBufferForRedoExtended(record, 0, RBM_ZERO_ON_ERROR, false,
278 : &vmbuffer) == BLK_NEEDS_REDO)
279 : {
280 14160 : Page vmpage = BufferGetPage(vmbuffer);
281 : Relation reln;
282 : uint8 vmbits;
283 :
284 : /* initialize the page if it was read as zeros */
285 14160 : if (PageIsNew(vmpage))
286 0 : PageInit(vmpage, BLCKSZ, 0);
287 :
288 : /* remove VISIBILITYMAP_XLOG_* */
289 14160 : vmbits = xlrec->flags & VISIBILITYMAP_VALID_BITS;
290 :
291 : /*
292 : * XLogReadBufferForRedoExtended locked the buffer. But
293 : * visibilitymap_set will handle locking itself.
294 : */
295 14160 : LockBuffer(vmbuffer, BUFFER_LOCK_UNLOCK);
296 :
297 14160 : reln = CreateFakeRelcacheEntry(rlocator);
298 14160 : visibilitymap_pin(reln, blkno, &vmbuffer);
299 :
300 14160 : visibilitymap_set(reln, blkno, InvalidBuffer, lsn, vmbuffer,
301 : xlrec->snapshotConflictHorizon, vmbits);
302 :
303 14160 : ReleaseBuffer(vmbuffer);
304 14160 : FreeFakeRelcacheEntry(reln);
305 : }
306 540 : else if (BufferIsValid(vmbuffer))
307 540 : UnlockReleaseBuffer(vmbuffer);
308 14700 : }
309 :
310 : /*
311 : * Given an "infobits" field from an XLog record, set the correct bits in the
312 : * given infomask and infomask2 for the tuple touched by the record.
313 : *
314 : * (This is the reverse of compute_infobits).
315 : */
316 : static void
317 891222 : fix_infomask_from_infobits(uint8 infobits, uint16 *infomask, uint16 *infomask2)
318 : {
319 891222 : *infomask &= ~(HEAP_XMAX_IS_MULTI | HEAP_XMAX_LOCK_ONLY |
320 : HEAP_XMAX_KEYSHR_LOCK | HEAP_XMAX_EXCL_LOCK);
321 891222 : *infomask2 &= ~HEAP_KEYS_UPDATED;
322 :
323 891222 : if (infobits & XLHL_XMAX_IS_MULTI)
324 4 : *infomask |= HEAP_XMAX_IS_MULTI;
325 891222 : if (infobits & XLHL_XMAX_LOCK_ONLY)
326 110060 : *infomask |= HEAP_XMAX_LOCK_ONLY;
327 891222 : if (infobits & XLHL_XMAX_EXCL_LOCK)
328 109264 : *infomask |= HEAP_XMAX_EXCL_LOCK;
329 : /* note HEAP_XMAX_SHR_LOCK isn't considered here */
330 891222 : if (infobits & XLHL_XMAX_KEYSHR_LOCK)
331 818 : *infomask |= HEAP_XMAX_KEYSHR_LOCK;
332 :
333 891222 : if (infobits & XLHL_KEYS_UPDATED)
334 597738 : *infomask2 |= HEAP_KEYS_UPDATED;
335 891222 : }
336 :
337 : /*
338 : * Replay XLOG_HEAP_DELETE records.
339 : */
340 : static void
341 598978 : heap_xlog_delete(XLogReaderState *record)
342 : {
343 598978 : XLogRecPtr lsn = record->EndRecPtr;
344 598978 : xl_heap_delete *xlrec = (xl_heap_delete *) XLogRecGetData(record);
345 : Buffer buffer;
346 : Page page;
347 598978 : ItemId lp = NULL;
348 : HeapTupleHeader htup;
349 : BlockNumber blkno;
350 : RelFileLocator target_locator;
351 : ItemPointerData target_tid;
352 :
353 598978 : XLogRecGetBlockTag(record, 0, &target_locator, NULL, &blkno);
354 598978 : ItemPointerSetBlockNumber(&target_tid, blkno);
355 598978 : ItemPointerSetOffsetNumber(&target_tid, xlrec->offnum);
356 :
357 : /*
358 : * The visibility map may need to be fixed even if the heap page is
359 : * already up-to-date.
360 : */
361 598978 : if (xlrec->flags & XLH_DELETE_ALL_VISIBLE_CLEARED)
362 : {
363 38 : Relation reln = CreateFakeRelcacheEntry(target_locator);
364 38 : Buffer vmbuffer = InvalidBuffer;
365 :
366 38 : visibilitymap_pin(reln, blkno, &vmbuffer);
367 38 : visibilitymap_clear(reln, blkno, vmbuffer, VISIBILITYMAP_VALID_BITS);
368 38 : ReleaseBuffer(vmbuffer);
369 38 : FreeFakeRelcacheEntry(reln);
370 : }
371 :
372 598978 : if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
373 : {
374 595034 : page = BufferGetPage(buffer);
375 :
376 595034 : if (PageGetMaxOffsetNumber(page) >= xlrec->offnum)
377 595034 : lp = PageGetItemId(page, xlrec->offnum);
378 :
379 595034 : if (PageGetMaxOffsetNumber(page) < xlrec->offnum || !ItemIdIsNormal(lp))
380 0 : elog(PANIC, "invalid lp");
381 :
382 595034 : htup = (HeapTupleHeader) PageGetItem(page, lp);
383 :
384 595034 : htup->t_infomask &= ~(HEAP_XMAX_BITS | HEAP_MOVED);
385 595034 : htup->t_infomask2 &= ~HEAP_KEYS_UPDATED;
386 595034 : HeapTupleHeaderClearHotUpdated(htup);
387 595034 : fix_infomask_from_infobits(xlrec->infobits_set,
388 : &htup->t_infomask, &htup->t_infomask2);
389 595034 : if (!(xlrec->flags & XLH_DELETE_IS_SUPER))
390 595034 : HeapTupleHeaderSetXmax(htup, xlrec->xmax);
391 : else
392 0 : HeapTupleHeaderSetXmin(htup, InvalidTransactionId);
393 595034 : HeapTupleHeaderSetCmax(htup, FirstCommandId, false);
394 :
395 : /* Mark the page as a candidate for pruning */
396 595034 : PageSetPrunable(page, XLogRecGetXid(record));
397 :
398 595034 : if (xlrec->flags & XLH_DELETE_ALL_VISIBLE_CLEARED)
399 26 : PageClearAllVisible(page);
400 :
401 : /* Make sure t_ctid is set correctly */
402 595034 : if (xlrec->flags & XLH_DELETE_IS_PARTITION_MOVE)
403 284 : HeapTupleHeaderSetMovedPartitions(htup);
404 : else
405 594750 : htup->t_ctid = target_tid;
406 595034 : PageSetLSN(page, lsn);
407 595034 : MarkBufferDirty(buffer);
408 : }
409 598978 : if (BufferIsValid(buffer))
410 598978 : UnlockReleaseBuffer(buffer);
411 598978 : }
412 :
413 : /*
414 : * Replay XLOG_HEAP_INSERT records.
415 : */
416 : static void
417 2569188 : heap_xlog_insert(XLogReaderState *record)
418 : {
419 2569188 : XLogRecPtr lsn = record->EndRecPtr;
420 2569188 : xl_heap_insert *xlrec = (xl_heap_insert *) XLogRecGetData(record);
421 : Buffer buffer;
422 : Page page;
423 : union
424 : {
425 : HeapTupleHeaderData hdr;
426 : char data[MaxHeapTupleSize];
427 : } tbuf;
428 : HeapTupleHeader htup;
429 : xl_heap_header xlhdr;
430 : uint32 newlen;
431 2569188 : Size freespace = 0;
432 : RelFileLocator target_locator;
433 : BlockNumber blkno;
434 : ItemPointerData target_tid;
435 : XLogRedoAction action;
436 :
437 2569188 : XLogRecGetBlockTag(record, 0, &target_locator, NULL, &blkno);
438 2569188 : ItemPointerSetBlockNumber(&target_tid, blkno);
439 2569188 : ItemPointerSetOffsetNumber(&target_tid, xlrec->offnum);
440 :
441 : /* No freezing in the heap_insert() code path */
442 : Assert(!(xlrec->flags & XLH_INSERT_ALL_FROZEN_SET));
443 :
444 : /*
445 : * The visibility map may need to be fixed even if the heap page is
446 : * already up-to-date.
447 : */
448 2569188 : if (xlrec->flags & XLH_INSERT_ALL_VISIBLE_CLEARED)
449 : {
450 1804 : Relation reln = CreateFakeRelcacheEntry(target_locator);
451 1804 : Buffer vmbuffer = InvalidBuffer;
452 :
453 1804 : visibilitymap_pin(reln, blkno, &vmbuffer);
454 1804 : visibilitymap_clear(reln, blkno, vmbuffer, VISIBILITYMAP_VALID_BITS);
455 1804 : ReleaseBuffer(vmbuffer);
456 1804 : FreeFakeRelcacheEntry(reln);
457 : }
458 :
459 : /*
460 : * If we inserted the first and only tuple on the page, re-initialize the
461 : * page from scratch.
462 : */
463 2569188 : if (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE)
464 : {
465 34280 : buffer = XLogInitBufferForRedo(record, 0);
466 34280 : page = BufferGetPage(buffer);
467 34280 : PageInit(page, BufferGetPageSize(buffer), 0);
468 34280 : action = BLK_NEEDS_REDO;
469 : }
470 : else
471 2534908 : action = XLogReadBufferForRedo(record, 0, &buffer);
472 2569188 : if (action == BLK_NEEDS_REDO)
473 : {
474 : Size datalen;
475 : char *data;
476 :
477 2563984 : page = BufferGetPage(buffer);
478 :
479 2563984 : if (PageGetMaxOffsetNumber(page) + 1 < xlrec->offnum)
480 0 : elog(PANIC, "invalid max offset number");
481 :
482 2563984 : data = XLogRecGetBlockData(record, 0, &datalen);
483 :
484 2563984 : newlen = datalen - SizeOfHeapHeader;
485 : Assert(datalen > SizeOfHeapHeader && newlen <= MaxHeapTupleSize);
486 2563984 : memcpy(&xlhdr, data, SizeOfHeapHeader);
487 2563984 : data += SizeOfHeapHeader;
488 :
489 2563984 : htup = &tbuf.hdr;
490 2563984 : MemSet(htup, 0, SizeofHeapTupleHeader);
491 : /* PG73FORMAT: get bitmap [+ padding] [+ oid] + data */
492 2563984 : memcpy((char *) htup + SizeofHeapTupleHeader,
493 : data,
494 : newlen);
495 2563984 : newlen += SizeofHeapTupleHeader;
496 2563984 : htup->t_infomask2 = xlhdr.t_infomask2;
497 2563984 : htup->t_infomask = xlhdr.t_infomask;
498 2563984 : htup->t_hoff = xlhdr.t_hoff;
499 2563984 : HeapTupleHeaderSetXmin(htup, XLogRecGetXid(record));
500 2563984 : HeapTupleHeaderSetCmin(htup, FirstCommandId);
501 2563984 : htup->t_ctid = target_tid;
502 :
503 2563984 : if (PageAddItem(page, (Item) htup, newlen, xlrec->offnum,
504 : true, true) == InvalidOffsetNumber)
505 0 : elog(PANIC, "failed to add tuple");
506 :
507 2563984 : freespace = PageGetHeapFreeSpace(page); /* needed to update FSM below */
508 :
509 2563984 : PageSetLSN(page, lsn);
510 :
511 2563984 : if (xlrec->flags & XLH_INSERT_ALL_VISIBLE_CLEARED)
512 588 : PageClearAllVisible(page);
513 :
514 2563984 : MarkBufferDirty(buffer);
515 : }
516 2569188 : if (BufferIsValid(buffer))
517 2569188 : UnlockReleaseBuffer(buffer);
518 :
519 : /*
520 : * If the page is running low on free space, update the FSM as well.
521 : * Arbitrarily, our definition of "low" is less than 20%. We can't do much
522 : * better than that without knowing the fill-factor for the table.
523 : *
524 : * XXX: Don't do this if the page was restored from full page image. We
525 : * don't bother to update the FSM in that case, it doesn't need to be
526 : * totally accurate anyway.
527 : */
528 2569188 : if (action == BLK_NEEDS_REDO && freespace < BLCKSZ / 5)
529 504102 : XLogRecordPageWithFreeSpace(target_locator, blkno, freespace);
530 2569188 : }
531 :
532 : /*
533 : * Replay XLOG_HEAP2_MULTI_INSERT records.
534 : */
535 : static void
536 114680 : heap_xlog_multi_insert(XLogReaderState *record)
537 : {
538 114680 : XLogRecPtr lsn = record->EndRecPtr;
539 : xl_heap_multi_insert *xlrec;
540 : RelFileLocator rlocator;
541 : BlockNumber blkno;
542 : Buffer buffer;
543 : Page page;
544 : union
545 : {
546 : HeapTupleHeaderData hdr;
547 : char data[MaxHeapTupleSize];
548 : } tbuf;
549 : HeapTupleHeader htup;
550 : uint32 newlen;
551 114680 : Size freespace = 0;
552 : int i;
553 114680 : bool isinit = (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE) != 0;
554 : XLogRedoAction action;
555 :
556 : /*
557 : * Insertion doesn't overwrite MVCC data, so no conflict processing is
558 : * required.
559 : */
560 114680 : xlrec = (xl_heap_multi_insert *) XLogRecGetData(record);
561 :
562 114680 : XLogRecGetBlockTag(record, 0, &rlocator, NULL, &blkno);
563 :
564 : /* check that the mutually exclusive flags are not both set */
565 : Assert(!((xlrec->flags & XLH_INSERT_ALL_VISIBLE_CLEARED) &&
566 : (xlrec->flags & XLH_INSERT_ALL_FROZEN_SET)));
567 :
568 : /*
569 : * The visibility map may need to be fixed even if the heap page is
570 : * already up-to-date.
571 : */
572 114680 : if (xlrec->flags & XLH_INSERT_ALL_VISIBLE_CLEARED)
573 : {
574 1802 : Relation reln = CreateFakeRelcacheEntry(rlocator);
575 1802 : Buffer vmbuffer = InvalidBuffer;
576 :
577 1802 : visibilitymap_pin(reln, blkno, &vmbuffer);
578 1802 : visibilitymap_clear(reln, blkno, vmbuffer, VISIBILITYMAP_VALID_BITS);
579 1802 : ReleaseBuffer(vmbuffer);
580 1802 : FreeFakeRelcacheEntry(reln);
581 : }
582 :
583 114680 : if (isinit)
584 : {
585 3658 : buffer = XLogInitBufferForRedo(record, 0);
586 3658 : page = BufferGetPage(buffer);
587 3658 : PageInit(page, BufferGetPageSize(buffer), 0);
588 3658 : action = BLK_NEEDS_REDO;
589 : }
590 : else
591 111022 : action = XLogReadBufferForRedo(record, 0, &buffer);
592 114680 : if (action == BLK_NEEDS_REDO)
593 : {
594 : char *tupdata;
595 : char *endptr;
596 : Size len;
597 :
598 : /* Tuples are stored as block data */
599 111718 : tupdata = XLogRecGetBlockData(record, 0, &len);
600 111718 : endptr = tupdata + len;
601 :
602 111718 : page = BufferGetPage(buffer);
603 :
604 523684 : for (i = 0; i < xlrec->ntuples; i++)
605 : {
606 : OffsetNumber offnum;
607 : xl_multi_insert_tuple *xlhdr;
608 :
609 : /*
610 : * If we're reinitializing the page, the tuples are stored in
611 : * order from FirstOffsetNumber. Otherwise there's an array of
612 : * offsets in the WAL record, and the tuples come after that.
613 : */
614 411966 : if (isinit)
615 198628 : offnum = FirstOffsetNumber + i;
616 : else
617 213338 : offnum = xlrec->offsets[i];
618 411966 : if (PageGetMaxOffsetNumber(page) + 1 < offnum)
619 0 : elog(PANIC, "invalid max offset number");
620 :
621 411966 : xlhdr = (xl_multi_insert_tuple *) SHORTALIGN(tupdata);
622 411966 : tupdata = ((char *) xlhdr) + SizeOfMultiInsertTuple;
623 :
624 411966 : newlen = xlhdr->datalen;
625 : Assert(newlen <= MaxHeapTupleSize);
626 411966 : htup = &tbuf.hdr;
627 411966 : MemSet(htup, 0, SizeofHeapTupleHeader);
628 : /* PG73FORMAT: get bitmap [+ padding] [+ oid] + data */
629 411966 : memcpy((char *) htup + SizeofHeapTupleHeader,
630 : tupdata,
631 : newlen);
632 411966 : tupdata += newlen;
633 :
634 411966 : newlen += SizeofHeapTupleHeader;
635 411966 : htup->t_infomask2 = xlhdr->t_infomask2;
636 411966 : htup->t_infomask = xlhdr->t_infomask;
637 411966 : htup->t_hoff = xlhdr->t_hoff;
638 411966 : HeapTupleHeaderSetXmin(htup, XLogRecGetXid(record));
639 411966 : HeapTupleHeaderSetCmin(htup, FirstCommandId);
640 411966 : ItemPointerSetBlockNumber(&htup->t_ctid, blkno);
641 411966 : ItemPointerSetOffsetNumber(&htup->t_ctid, offnum);
642 :
643 411966 : offnum = PageAddItem(page, (Item) htup, newlen, offnum, true, true);
644 411966 : if (offnum == InvalidOffsetNumber)
645 0 : elog(PANIC, "failed to add tuple");
646 : }
647 111718 : if (tupdata != endptr)
648 0 : elog(PANIC, "total tuple length mismatch");
649 :
650 111718 : freespace = PageGetHeapFreeSpace(page); /* needed to update FSM below */
651 :
652 111718 : PageSetLSN(page, lsn);
653 :
654 111718 : if (xlrec->flags & XLH_INSERT_ALL_VISIBLE_CLEARED)
655 176 : PageClearAllVisible(page);
656 :
657 : /* XLH_INSERT_ALL_FROZEN_SET implies that all tuples are visible */
658 111718 : if (xlrec->flags & XLH_INSERT_ALL_FROZEN_SET)
659 8 : PageSetAllVisible(page);
660 :
661 111718 : MarkBufferDirty(buffer);
662 : }
663 114680 : if (BufferIsValid(buffer))
664 114680 : UnlockReleaseBuffer(buffer);
665 :
666 : /*
667 : * If the page is running low on free space, update the FSM as well.
668 : * Arbitrarily, our definition of "low" is less than 20%. We can't do much
669 : * better than that without knowing the fill-factor for the table.
670 : *
671 : * XXX: Don't do this if the page was restored from full page image. We
672 : * don't bother to update the FSM in that case, it doesn't need to be
673 : * totally accurate anyway.
674 : */
675 114680 : if (action == BLK_NEEDS_REDO && freespace < BLCKSZ / 5)
676 29956 : XLogRecordPageWithFreeSpace(rlocator, blkno, freespace);
677 114680 : }
678 :
679 : /*
680 : * Replay XLOG_HEAP_UPDATE and XLOG_HEAP_HOT_UPDATE records.
681 : */
682 : static void
683 186728 : heap_xlog_update(XLogReaderState *record, bool hot_update)
684 : {
685 186728 : XLogRecPtr lsn = record->EndRecPtr;
686 186728 : xl_heap_update *xlrec = (xl_heap_update *) XLogRecGetData(record);
687 : RelFileLocator rlocator;
688 : BlockNumber oldblk;
689 : BlockNumber newblk;
690 : ItemPointerData newtid;
691 : Buffer obuffer,
692 : nbuffer;
693 : Page page;
694 : OffsetNumber offnum;
695 186728 : ItemId lp = NULL;
696 : HeapTupleData oldtup;
697 : HeapTupleHeader htup;
698 186728 : uint16 prefixlen = 0,
699 186728 : suffixlen = 0;
700 : char *newp;
701 : union
702 : {
703 : HeapTupleHeaderData hdr;
704 : char data[MaxHeapTupleSize];
705 : } tbuf;
706 : xl_heap_header xlhdr;
707 : uint32 newlen;
708 186728 : Size freespace = 0;
709 : XLogRedoAction oldaction;
710 : XLogRedoAction newaction;
711 :
712 : /* initialize to keep the compiler quiet */
713 186728 : oldtup.t_data = NULL;
714 186728 : oldtup.t_len = 0;
715 :
716 186728 : XLogRecGetBlockTag(record, 0, &rlocator, NULL, &newblk);
717 186728 : if (XLogRecGetBlockTagExtended(record, 1, NULL, NULL, &oldblk, NULL))
718 : {
719 : /* HOT updates are never done across pages */
720 : Assert(!hot_update);
721 : }
722 : else
723 78032 : oldblk = newblk;
724 :
725 186728 : ItemPointerSet(&newtid, newblk, xlrec->new_offnum);
726 :
727 : /*
728 : * The visibility map may need to be fixed even if the heap page is
729 : * already up-to-date.
730 : */
731 186728 : if (xlrec->flags & XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED)
732 : {
733 410 : Relation reln = CreateFakeRelcacheEntry(rlocator);
734 410 : Buffer vmbuffer = InvalidBuffer;
735 :
736 410 : visibilitymap_pin(reln, oldblk, &vmbuffer);
737 410 : visibilitymap_clear(reln, oldblk, vmbuffer, VISIBILITYMAP_VALID_BITS);
738 410 : ReleaseBuffer(vmbuffer);
739 410 : FreeFakeRelcacheEntry(reln);
740 : }
741 :
742 : /*
743 : * In normal operation, it is important to lock the two pages in
744 : * page-number order, to avoid possible deadlocks against other update
745 : * operations going the other way. However, during WAL replay there can
746 : * be no other update happening, so we don't need to worry about that. But
747 : * we *do* need to worry that we don't expose an inconsistent state to Hot
748 : * Standby queries --- so the original page can't be unlocked before we've
749 : * added the new tuple to the new page.
750 : */
751 :
752 : /* Deal with old tuple version */
753 186728 : oldaction = XLogReadBufferForRedo(record, (oldblk == newblk) ? 0 : 1,
754 : &obuffer);
755 186728 : if (oldaction == BLK_NEEDS_REDO)
756 : {
757 186128 : page = BufferGetPage(obuffer);
758 186128 : offnum = xlrec->old_offnum;
759 186128 : if (PageGetMaxOffsetNumber(page) >= offnum)
760 186128 : lp = PageGetItemId(page, offnum);
761 :
762 186128 : if (PageGetMaxOffsetNumber(page) < offnum || !ItemIdIsNormal(lp))
763 0 : elog(PANIC, "invalid lp");
764 :
765 186128 : htup = (HeapTupleHeader) PageGetItem(page, lp);
766 :
767 186128 : oldtup.t_data = htup;
768 186128 : oldtup.t_len = ItemIdGetLength(lp);
769 :
770 186128 : htup->t_infomask &= ~(HEAP_XMAX_BITS | HEAP_MOVED);
771 186128 : htup->t_infomask2 &= ~HEAP_KEYS_UPDATED;
772 186128 : if (hot_update)
773 71992 : HeapTupleHeaderSetHotUpdated(htup);
774 : else
775 114136 : HeapTupleHeaderClearHotUpdated(htup);
776 186128 : fix_infomask_from_infobits(xlrec->old_infobits_set, &htup->t_infomask,
777 : &htup->t_infomask2);
778 186128 : HeapTupleHeaderSetXmax(htup, xlrec->old_xmax);
779 186128 : HeapTupleHeaderSetCmax(htup, FirstCommandId, false);
780 : /* Set forward chain link in t_ctid */
781 186128 : htup->t_ctid = newtid;
782 :
783 : /* Mark the page as a candidate for pruning */
784 186128 : PageSetPrunable(page, XLogRecGetXid(record));
785 :
786 186128 : if (xlrec->flags & XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED)
787 394 : PageClearAllVisible(page);
788 :
789 186128 : PageSetLSN(page, lsn);
790 186128 : MarkBufferDirty(obuffer);
791 : }
792 :
793 : /*
794 : * Read the page the new tuple goes into, if different from old.
795 : */
796 186728 : if (oldblk == newblk)
797 : {
798 78032 : nbuffer = obuffer;
799 78032 : newaction = oldaction;
800 : }
801 108696 : else if (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE)
802 : {
803 1194 : nbuffer = XLogInitBufferForRedo(record, 0);
804 1194 : page = BufferGetPage(nbuffer);
805 1194 : PageInit(page, BufferGetPageSize(nbuffer), 0);
806 1194 : newaction = BLK_NEEDS_REDO;
807 : }
808 : else
809 107502 : newaction = XLogReadBufferForRedo(record, 0, &nbuffer);
810 :
811 : /*
812 : * The visibility map may need to be fixed even if the heap page is
813 : * already up-to-date.
814 : */
815 186728 : if (xlrec->flags & XLH_UPDATE_NEW_ALL_VISIBLE_CLEARED)
816 : {
817 290 : Relation reln = CreateFakeRelcacheEntry(rlocator);
818 290 : Buffer vmbuffer = InvalidBuffer;
819 :
820 290 : visibilitymap_pin(reln, newblk, &vmbuffer);
821 290 : visibilitymap_clear(reln, newblk, vmbuffer, VISIBILITYMAP_VALID_BITS);
822 290 : ReleaseBuffer(vmbuffer);
823 290 : FreeFakeRelcacheEntry(reln);
824 : }
825 :
826 : /* Deal with new tuple */
827 186728 : if (newaction == BLK_NEEDS_REDO)
828 : {
829 : char *recdata;
830 : char *recdata_end;
831 : Size datalen;
832 : Size tuplen;
833 :
834 185740 : recdata = XLogRecGetBlockData(record, 0, &datalen);
835 185740 : recdata_end = recdata + datalen;
836 :
837 185740 : page = BufferGetPage(nbuffer);
838 :
839 185740 : offnum = xlrec->new_offnum;
840 185740 : if (PageGetMaxOffsetNumber(page) + 1 < offnum)
841 0 : elog(PANIC, "invalid max offset number");
842 :
843 185740 : if (xlrec->flags & XLH_UPDATE_PREFIX_FROM_OLD)
844 : {
845 : Assert(newblk == oldblk);
846 30278 : memcpy(&prefixlen, recdata, sizeof(uint16));
847 30278 : recdata += sizeof(uint16);
848 : }
849 185740 : if (xlrec->flags & XLH_UPDATE_SUFFIX_FROM_OLD)
850 : {
851 : Assert(newblk == oldblk);
852 67054 : memcpy(&suffixlen, recdata, sizeof(uint16));
853 67054 : recdata += sizeof(uint16);
854 : }
855 :
856 185740 : memcpy(&xlhdr, recdata, SizeOfHeapHeader);
857 185740 : recdata += SizeOfHeapHeader;
858 :
859 185740 : tuplen = recdata_end - recdata;
860 : Assert(tuplen <= MaxHeapTupleSize);
861 :
862 185740 : htup = &tbuf.hdr;
863 185740 : MemSet(htup, 0, SizeofHeapTupleHeader);
864 :
865 : /*
866 : * Reconstruct the new tuple using the prefix and/or suffix from the
867 : * old tuple, and the data stored in the WAL record.
868 : */
869 185740 : newp = (char *) htup + SizeofHeapTupleHeader;
870 185740 : if (prefixlen > 0)
871 : {
872 : int len;
873 :
874 : /* copy bitmap [+ padding] [+ oid] from WAL record */
875 30278 : len = xlhdr.t_hoff - SizeofHeapTupleHeader;
876 30278 : memcpy(newp, recdata, len);
877 30278 : recdata += len;
878 30278 : newp += len;
879 :
880 : /* copy prefix from old tuple */
881 30278 : memcpy(newp, (char *) oldtup.t_data + oldtup.t_data->t_hoff, prefixlen);
882 30278 : newp += prefixlen;
883 :
884 : /* copy new tuple data from WAL record */
885 30278 : len = tuplen - (xlhdr.t_hoff - SizeofHeapTupleHeader);
886 30278 : memcpy(newp, recdata, len);
887 30278 : recdata += len;
888 30278 : newp += len;
889 : }
890 : else
891 : {
892 : /*
893 : * copy bitmap [+ padding] [+ oid] + data from record, all in one
894 : * go
895 : */
896 155462 : memcpy(newp, recdata, tuplen);
897 155462 : recdata += tuplen;
898 155462 : newp += tuplen;
899 : }
900 : Assert(recdata == recdata_end);
901 :
902 : /* copy suffix from old tuple */
903 185740 : if (suffixlen > 0)
904 67054 : memcpy(newp, (char *) oldtup.t_data + oldtup.t_len - suffixlen, suffixlen);
905 :
906 185740 : newlen = SizeofHeapTupleHeader + tuplen + prefixlen + suffixlen;
907 185740 : htup->t_infomask2 = xlhdr.t_infomask2;
908 185740 : htup->t_infomask = xlhdr.t_infomask;
909 185740 : htup->t_hoff = xlhdr.t_hoff;
910 :
911 185740 : HeapTupleHeaderSetXmin(htup, XLogRecGetXid(record));
912 185740 : HeapTupleHeaderSetCmin(htup, FirstCommandId);
913 185740 : HeapTupleHeaderSetXmax(htup, xlrec->new_xmax);
914 : /* Make sure there is no forward chain link in t_ctid */
915 185740 : htup->t_ctid = newtid;
916 :
917 185740 : offnum = PageAddItem(page, (Item) htup, newlen, offnum, true, true);
918 185740 : if (offnum == InvalidOffsetNumber)
919 0 : elog(PANIC, "failed to add tuple");
920 :
921 185740 : if (xlrec->flags & XLH_UPDATE_NEW_ALL_VISIBLE_CLEARED)
922 122 : PageClearAllVisible(page);
923 :
924 185740 : freespace = PageGetHeapFreeSpace(page); /* needed to update FSM below */
925 :
926 185740 : PageSetLSN(page, lsn);
927 185740 : MarkBufferDirty(nbuffer);
928 : }
929 :
930 186728 : if (BufferIsValid(nbuffer) && nbuffer != obuffer)
931 108696 : UnlockReleaseBuffer(nbuffer);
932 186728 : if (BufferIsValid(obuffer))
933 186728 : UnlockReleaseBuffer(obuffer);
934 :
935 : /*
936 : * If the new page is running low on free space, update the FSM as well.
937 : * Arbitrarily, our definition of "low" is less than 20%. We can't do much
938 : * better than that without knowing the fill-factor for the table.
939 : *
940 : * However, don't update the FSM on HOT updates, because after crash
941 : * recovery, either the old or the new tuple will certainly be dead and
942 : * prunable. After pruning, the page will have roughly as much free space
943 : * as it did before the update, assuming the new tuple is about the same
944 : * size as the old one.
945 : *
946 : * XXX: Don't do this if the page was restored from full page image. We
947 : * don't bother to update the FSM in that case, it doesn't need to be
948 : * totally accurate anyway.
949 : */
950 186728 : if (newaction == BLK_NEEDS_REDO && !hot_update && freespace < BLCKSZ / 5)
951 23178 : XLogRecordPageWithFreeSpace(rlocator, newblk, freespace);
952 186728 : }
953 :
954 : /*
955 : * Replay XLOG_HEAP_CONFIRM records.
956 : */
957 : static void
958 154 : heap_xlog_confirm(XLogReaderState *record)
959 : {
960 154 : XLogRecPtr lsn = record->EndRecPtr;
961 154 : xl_heap_confirm *xlrec = (xl_heap_confirm *) XLogRecGetData(record);
962 : Buffer buffer;
963 : Page page;
964 : OffsetNumber offnum;
965 154 : ItemId lp = NULL;
966 : HeapTupleHeader htup;
967 :
968 154 : if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
969 : {
970 154 : page = BufferGetPage(buffer);
971 :
972 154 : offnum = xlrec->offnum;
973 154 : if (PageGetMaxOffsetNumber(page) >= offnum)
974 154 : lp = PageGetItemId(page, offnum);
975 :
976 154 : if (PageGetMaxOffsetNumber(page) < offnum || !ItemIdIsNormal(lp))
977 0 : elog(PANIC, "invalid lp");
978 :
979 154 : htup = (HeapTupleHeader) PageGetItem(page, lp);
980 :
981 : /*
982 : * Confirm tuple as actually inserted
983 : */
984 154 : ItemPointerSet(&htup->t_ctid, BufferGetBlockNumber(buffer), offnum);
985 :
986 154 : PageSetLSN(page, lsn);
987 154 : MarkBufferDirty(buffer);
988 : }
989 154 : if (BufferIsValid(buffer))
990 154 : UnlockReleaseBuffer(buffer);
991 154 : }
992 :
993 : /*
994 : * Replay XLOG_HEAP_LOCK records.
995 : */
996 : static void
997 110476 : heap_xlog_lock(XLogReaderState *record)
998 : {
999 110476 : XLogRecPtr lsn = record->EndRecPtr;
1000 110476 : xl_heap_lock *xlrec = (xl_heap_lock *) XLogRecGetData(record);
1001 : Buffer buffer;
1002 : Page page;
1003 : OffsetNumber offnum;
1004 110476 : ItemId lp = NULL;
1005 : HeapTupleHeader htup;
1006 :
1007 : /*
1008 : * The visibility map may need to be fixed even if the heap page is
1009 : * already up-to-date.
1010 : */
1011 110476 : if (xlrec->flags & XLH_LOCK_ALL_FROZEN_CLEARED)
1012 : {
1013 : RelFileLocator rlocator;
1014 94 : Buffer vmbuffer = InvalidBuffer;
1015 : BlockNumber block;
1016 : Relation reln;
1017 :
1018 94 : XLogRecGetBlockTag(record, 0, &rlocator, NULL, &block);
1019 94 : reln = CreateFakeRelcacheEntry(rlocator);
1020 :
1021 94 : visibilitymap_pin(reln, block, &vmbuffer);
1022 94 : visibilitymap_clear(reln, block, vmbuffer, VISIBILITYMAP_ALL_FROZEN);
1023 :
1024 94 : ReleaseBuffer(vmbuffer);
1025 94 : FreeFakeRelcacheEntry(reln);
1026 : }
1027 :
1028 110476 : if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
1029 : {
1030 110060 : page = BufferGetPage(buffer);
1031 :
1032 110060 : offnum = xlrec->offnum;
1033 110060 : if (PageGetMaxOffsetNumber(page) >= offnum)
1034 110060 : lp = PageGetItemId(page, offnum);
1035 :
1036 110060 : if (PageGetMaxOffsetNumber(page) < offnum || !ItemIdIsNormal(lp))
1037 0 : elog(PANIC, "invalid lp");
1038 :
1039 110060 : htup = (HeapTupleHeader) PageGetItem(page, lp);
1040 :
1041 110060 : htup->t_infomask &= ~(HEAP_XMAX_BITS | HEAP_MOVED);
1042 110060 : htup->t_infomask2 &= ~HEAP_KEYS_UPDATED;
1043 110060 : fix_infomask_from_infobits(xlrec->infobits_set, &htup->t_infomask,
1044 : &htup->t_infomask2);
1045 :
1046 : /*
1047 : * Clear relevant update flags, but only if the modified infomask says
1048 : * there's no update.
1049 : */
1050 110060 : if (HEAP_XMAX_IS_LOCKED_ONLY(htup->t_infomask))
1051 : {
1052 110060 : HeapTupleHeaderClearHotUpdated(htup);
1053 : /* Make sure there is no forward chain link in t_ctid */
1054 110060 : ItemPointerSet(&htup->t_ctid,
1055 : BufferGetBlockNumber(buffer),
1056 : offnum);
1057 : }
1058 110060 : HeapTupleHeaderSetXmax(htup, xlrec->xmax);
1059 110060 : HeapTupleHeaderSetCmax(htup, FirstCommandId, false);
1060 110060 : PageSetLSN(page, lsn);
1061 110060 : MarkBufferDirty(buffer);
1062 : }
1063 110476 : if (BufferIsValid(buffer))
1064 110476 : UnlockReleaseBuffer(buffer);
1065 110476 : }
1066 :
1067 : /*
1068 : * Replay XLOG_HEAP2_LOCK_UPDATED records.
1069 : */
1070 : static void
1071 0 : heap_xlog_lock_updated(XLogReaderState *record)
1072 : {
1073 0 : XLogRecPtr lsn = record->EndRecPtr;
1074 : xl_heap_lock_updated *xlrec;
1075 : Buffer buffer;
1076 : Page page;
1077 : OffsetNumber offnum;
1078 0 : ItemId lp = NULL;
1079 : HeapTupleHeader htup;
1080 :
1081 0 : xlrec = (xl_heap_lock_updated *) XLogRecGetData(record);
1082 :
1083 : /*
1084 : * The visibility map may need to be fixed even if the heap page is
1085 : * already up-to-date.
1086 : */
1087 0 : if (xlrec->flags & XLH_LOCK_ALL_FROZEN_CLEARED)
1088 : {
1089 : RelFileLocator rlocator;
1090 0 : Buffer vmbuffer = InvalidBuffer;
1091 : BlockNumber block;
1092 : Relation reln;
1093 :
1094 0 : XLogRecGetBlockTag(record, 0, &rlocator, NULL, &block);
1095 0 : reln = CreateFakeRelcacheEntry(rlocator);
1096 :
1097 0 : visibilitymap_pin(reln, block, &vmbuffer);
1098 0 : visibilitymap_clear(reln, block, vmbuffer, VISIBILITYMAP_ALL_FROZEN);
1099 :
1100 0 : ReleaseBuffer(vmbuffer);
1101 0 : FreeFakeRelcacheEntry(reln);
1102 : }
1103 :
1104 0 : if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
1105 : {
1106 0 : page = BufferGetPage(buffer);
1107 :
1108 0 : offnum = xlrec->offnum;
1109 0 : if (PageGetMaxOffsetNumber(page) >= offnum)
1110 0 : lp = PageGetItemId(page, offnum);
1111 :
1112 0 : if (PageGetMaxOffsetNumber(page) < offnum || !ItemIdIsNormal(lp))
1113 0 : elog(PANIC, "invalid lp");
1114 :
1115 0 : htup = (HeapTupleHeader) PageGetItem(page, lp);
1116 :
1117 0 : htup->t_infomask &= ~(HEAP_XMAX_BITS | HEAP_MOVED);
1118 0 : htup->t_infomask2 &= ~HEAP_KEYS_UPDATED;
1119 0 : fix_infomask_from_infobits(xlrec->infobits_set, &htup->t_infomask,
1120 : &htup->t_infomask2);
1121 0 : HeapTupleHeaderSetXmax(htup, xlrec->xmax);
1122 :
1123 0 : PageSetLSN(page, lsn);
1124 0 : MarkBufferDirty(buffer);
1125 : }
1126 0 : if (BufferIsValid(buffer))
1127 0 : UnlockReleaseBuffer(buffer);
1128 0 : }
1129 :
1130 : /*
1131 : * Replay XLOG_HEAP_INPLACE records.
1132 : */
1133 : static void
1134 14996 : heap_xlog_inplace(XLogReaderState *record)
1135 : {
1136 14996 : XLogRecPtr lsn = record->EndRecPtr;
1137 14996 : xl_heap_inplace *xlrec = (xl_heap_inplace *) XLogRecGetData(record);
1138 : Buffer buffer;
1139 : Page page;
1140 : OffsetNumber offnum;
1141 14996 : ItemId lp = NULL;
1142 : HeapTupleHeader htup;
1143 : uint32 oldlen;
1144 : Size newlen;
1145 :
1146 14996 : if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
1147 : {
1148 14604 : char *newtup = XLogRecGetBlockData(record, 0, &newlen);
1149 :
1150 14604 : page = BufferGetPage(buffer);
1151 :
1152 14604 : offnum = xlrec->offnum;
1153 14604 : if (PageGetMaxOffsetNumber(page) >= offnum)
1154 14604 : lp = PageGetItemId(page, offnum);
1155 :
1156 14604 : if (PageGetMaxOffsetNumber(page) < offnum || !ItemIdIsNormal(lp))
1157 0 : elog(PANIC, "invalid lp");
1158 :
1159 14604 : htup = (HeapTupleHeader) PageGetItem(page, lp);
1160 :
1161 14604 : oldlen = ItemIdGetLength(lp) - htup->t_hoff;
1162 14604 : if (oldlen != newlen)
1163 0 : elog(PANIC, "wrong tuple length");
1164 :
1165 14604 : memcpy((char *) htup + htup->t_hoff, newtup, newlen);
1166 :
1167 14604 : PageSetLSN(page, lsn);
1168 14604 : MarkBufferDirty(buffer);
1169 : }
1170 14996 : if (BufferIsValid(buffer))
1171 14996 : UnlockReleaseBuffer(buffer);
1172 :
1173 14996 : ProcessCommittedInvalidationMessages(xlrec->msgs,
1174 : xlrec->nmsgs,
1175 14996 : xlrec->relcacheInitFileInval,
1176 : xlrec->dbId,
1177 : xlrec->tsId);
1178 14996 : }
1179 :
1180 : void
1181 3480524 : heap_redo(XLogReaderState *record)
1182 : {
1183 3480524 : uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
1184 :
1185 : /*
1186 : * These operations don't overwrite MVCC data so no conflict processing is
1187 : * required. The ones in heap2 rmgr do.
1188 : */
1189 :
1190 3480524 : switch (info & XLOG_HEAP_OPMASK)
1191 : {
1192 2569188 : case XLOG_HEAP_INSERT:
1193 2569188 : heap_xlog_insert(record);
1194 2569188 : break;
1195 598978 : case XLOG_HEAP_DELETE:
1196 598978 : heap_xlog_delete(record);
1197 598978 : break;
1198 114196 : case XLOG_HEAP_UPDATE:
1199 114196 : heap_xlog_update(record, false);
1200 114196 : break;
1201 4 : case XLOG_HEAP_TRUNCATE:
1202 :
1203 : /*
1204 : * TRUNCATE is a no-op because the actions are already logged as
1205 : * SMGR WAL records. TRUNCATE WAL record only exists for logical
1206 : * decoding.
1207 : */
1208 4 : break;
1209 72532 : case XLOG_HEAP_HOT_UPDATE:
1210 72532 : heap_xlog_update(record, true);
1211 72532 : break;
1212 154 : case XLOG_HEAP_CONFIRM:
1213 154 : heap_xlog_confirm(record);
1214 154 : break;
1215 110476 : case XLOG_HEAP_LOCK:
1216 110476 : heap_xlog_lock(record);
1217 110476 : break;
1218 14996 : case XLOG_HEAP_INPLACE:
1219 14996 : heap_xlog_inplace(record);
1220 14996 : break;
1221 0 : default:
1222 0 : elog(PANIC, "heap_redo: unknown op code %u", info);
1223 : }
1224 3480524 : }
1225 :
1226 : void
1227 156346 : heap2_redo(XLogReaderState *record)
1228 : {
1229 156346 : uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
1230 :
1231 156346 : switch (info & XLOG_HEAP_OPMASK)
1232 : {
1233 24978 : case XLOG_HEAP2_PRUNE_ON_ACCESS:
1234 : case XLOG_HEAP2_PRUNE_VACUUM_SCAN:
1235 : case XLOG_HEAP2_PRUNE_VACUUM_CLEANUP:
1236 24978 : heap_xlog_prune_freeze(record);
1237 24978 : break;
1238 14700 : case XLOG_HEAP2_VISIBLE:
1239 14700 : heap_xlog_visible(record);
1240 14700 : break;
1241 114680 : case XLOG_HEAP2_MULTI_INSERT:
1242 114680 : heap_xlog_multi_insert(record);
1243 114680 : break;
1244 0 : case XLOG_HEAP2_LOCK_UPDATED:
1245 0 : heap_xlog_lock_updated(record);
1246 0 : break;
1247 1988 : case XLOG_HEAP2_NEW_CID:
1248 :
1249 : /*
1250 : * Nothing to do on a real replay, only used during logical
1251 : * decoding.
1252 : */
1253 1988 : break;
1254 0 : case XLOG_HEAP2_REWRITE:
1255 0 : heap_xlog_logical_rewrite(record);
1256 0 : break;
1257 0 : default:
1258 0 : elog(PANIC, "heap2_redo: unknown op code %u", info);
1259 : }
1260 156346 : }
1261 :
1262 : /*
1263 : * Mask a heap page before performing consistency checks on it.
1264 : */
1265 : void
1266 5813252 : heap_mask(char *pagedata, BlockNumber blkno)
1267 : {
1268 5813252 : Page page = (Page) pagedata;
1269 : OffsetNumber off;
1270 :
1271 5813252 : mask_page_lsn_and_checksum(page);
1272 :
1273 5813252 : mask_page_hint_bits(page);
1274 5813252 : mask_unused_space(page);
1275 :
1276 474238664 : for (off = 1; off <= PageGetMaxOffsetNumber(page); off++)
1277 : {
1278 468425412 : ItemId iid = PageGetItemId(page, off);
1279 : char *page_item;
1280 :
1281 468425412 : page_item = (char *) (page + ItemIdGetOffset(iid));
1282 :
1283 468425412 : if (ItemIdIsNormal(iid))
1284 : {
1285 445010292 : HeapTupleHeader page_htup = (HeapTupleHeader) page_item;
1286 :
1287 : /*
1288 : * If xmin of a tuple is not yet frozen, we should ignore
1289 : * differences in hint bits, since they can be set without
1290 : * emitting WAL.
1291 : */
1292 445010292 : if (!HeapTupleHeaderXminFrozen(page_htup))
1293 440735040 : page_htup->t_infomask &= ~HEAP_XACT_MASK;
1294 : else
1295 : {
1296 : /* Still we need to mask xmax hint bits. */
1297 4275252 : page_htup->t_infomask &= ~HEAP_XMAX_INVALID;
1298 4275252 : page_htup->t_infomask &= ~HEAP_XMAX_COMMITTED;
1299 : }
1300 :
1301 : /*
1302 : * During replay, we set Command Id to FirstCommandId. Hence, mask
1303 : * it. See heap_xlog_insert() for details.
1304 : */
1305 445010292 : page_htup->t_choice.t_heap.t_field3.t_cid = MASK_MARKER;
1306 :
1307 : /*
1308 : * For a speculative tuple, heap_insert() does not set ctid in the
1309 : * caller-passed heap tuple itself, leaving the ctid field to
1310 : * contain a speculative token value - a per-backend monotonically
1311 : * increasing identifier. Besides, it does not WAL-log ctid under
1312 : * any circumstances.
1313 : *
1314 : * During redo, heap_xlog_insert() sets t_ctid to current block
1315 : * number and self offset number. It doesn't care about any
1316 : * speculative insertions on the primary. Hence, we set t_ctid to
1317 : * current block number and self offset number to ignore any
1318 : * inconsistency.
1319 : */
1320 445010292 : if (HeapTupleHeaderIsSpeculative(page_htup))
1321 156 : ItemPointerSet(&page_htup->t_ctid, blkno, off);
1322 :
1323 : /*
1324 : * NB: Not ignoring ctid changes due to the tuple having moved
1325 : * (i.e. HeapTupleHeaderIndicatesMovedPartitions), because that's
1326 : * important information that needs to be in-sync between primary
1327 : * and standby, and thus is WAL logged.
1328 : */
1329 : }
1330 :
1331 : /*
1332 : * Ignore any padding bytes after the tuple, when the length of the
1333 : * item is not MAXALIGNed.
1334 : */
1335 468425412 : if (ItemIdHasStorage(iid))
1336 : {
1337 445010292 : int len = ItemIdGetLength(iid);
1338 445010292 : int padlen = MAXALIGN(len) - len;
1339 :
1340 445010292 : if (padlen > 0)
1341 237549472 : memset(page_item + len, MASK_MARKER, padlen);
1342 : }
1343 : }
1344 5813252 : }
|
