Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit503c730

Browse files
committed
Make the visibility map crash-safe.
This involves two main changes from the previous behavior. First,when we set a bit in the visibility map, emit a new WAL record of typeXLOG_HEAP2_VISIBLE. Replay sets the page-level PD_ALL_VISIBLE bit andthe visibility map bit. Second, when inserting, updating, or deletinga tuple, we can no longer get away with clearing the visibility mapbit after releasing the lock on the corresponding heap page, becausean intervening crash might leave the visibility map bit set and thepage-level bit clear. Making this work requires a bit of interfacerefactoring.In passing, a few minor but related cleanups: change the test invisibilitymap_set and visibilitymap_clear to throw an error if thewrong page (or no page) is pinned, rather than silently doing nothing;this case should never occur. Also, remove duplicate definitions ofInvalidXLogRecPtr.Patch by me, review by Noah Misch.
1 parent431ab0e commit503c730

File tree

12 files changed

+373
-90
lines changed

12 files changed

+373
-90
lines changed

‎src/backend/access/heap/heapam.c

Lines changed: 238 additions & 25 deletions
Large diffs are not rendered by default.

‎src/backend/access/heap/hio.c

Lines changed: 47 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,7 @@
1717

1818
#include"access/heapam.h"
1919
#include"access/hio.h"
20+
#include"access/visibilitymap.h"
2021
#include"storage/bufmgr.h"
2122
#include"storage/freespace.h"
2223
#include"storage/lmgr.h"
@@ -150,7 +151,8 @@ ReadBufferBI(Relation relation, BlockNumber targetBlock,
150151
Buffer
151152
RelationGetBufferForTuple(Relationrelation,Sizelen,
152153
BufferotherBuffer,intoptions,
153-
structBulkInsertStateData*bistate)
154+
structBulkInsertStateData*bistate,
155+
Buffer*vmbuffer)
154156
{
155157
booluse_fsm= !(options&HEAP_INSERT_SKIP_FSM);
156158
Bufferbuffer=InvalidBuffer;
@@ -237,34 +239,78 @@ RelationGetBufferForTuple(Relation relation, Size len,
237239
* Read and exclusive-lock the target block, as well as the other
238240
* block if one was given, taking suitable care with lock ordering and
239241
* the possibility they are the same block.
242+
*
243+
* If the page-level all-visible flag is set, caller will need to clear
244+
* both that and the corresponding visibility map bit. However, by the
245+
* time we return, we'll have x-locked the buffer, and we don't want to
246+
* do any I/O while in that state. So we check the bit here before
247+
* taking the lock, and pin the page if it appears necessary.
248+
* Checking without the lock creates a risk of getting the wrong
249+
* answer, so we'll have to recheck after acquiring the lock.
240250
*/
241251
if (otherBuffer==InvalidBuffer)
242252
{
243253
/* easy case */
244254
buffer=ReadBufferBI(relation,targetBlock,bistate);
255+
if (PageIsAllVisible(BufferGetPage(buffer)))
256+
visibilitymap_pin(relation,targetBlock,vmbuffer);
245257
LockBuffer(buffer,BUFFER_LOCK_EXCLUSIVE);
246258
}
247259
elseif (otherBlock==targetBlock)
248260
{
249261
/* also easy case */
250262
buffer=otherBuffer;
263+
if (PageIsAllVisible(BufferGetPage(buffer)))
264+
visibilitymap_pin(relation,targetBlock,vmbuffer);
251265
LockBuffer(buffer,BUFFER_LOCK_EXCLUSIVE);
252266
}
253267
elseif (otherBlock<targetBlock)
254268
{
255269
/* lock other buffer first */
256270
buffer=ReadBuffer(relation,targetBlock);
271+
if (PageIsAllVisible(BufferGetPage(buffer)))
272+
visibilitymap_pin(relation,targetBlock,vmbuffer);
257273
LockBuffer(otherBuffer,BUFFER_LOCK_EXCLUSIVE);
258274
LockBuffer(buffer,BUFFER_LOCK_EXCLUSIVE);
259275
}
260276
else
261277
{
262278
/* lock target buffer first */
263279
buffer=ReadBuffer(relation,targetBlock);
280+
if (PageIsAllVisible(BufferGetPage(buffer)))
281+
visibilitymap_pin(relation,targetBlock,vmbuffer);
264282
LockBuffer(buffer,BUFFER_LOCK_EXCLUSIVE);
265283
LockBuffer(otherBuffer,BUFFER_LOCK_EXCLUSIVE);
266284
}
267285

286+
/*
287+
* If the page is all visible but we don't have the right visibility
288+
* map page pinned, then give up our locks, go get the pin, and
289+
* re-lock. This is pretty painful, but hopefully shouldn't happen
290+
* often. Note that there's a small possibility that we didn't pin
291+
* the page above but still have the correct page pinned anyway, either
292+
* because we've already made a previous pass through this loop, or
293+
* because caller passed us the right page anyway.
294+
*
295+
* Note also that it's possible that by the time we get the pin and
296+
* retake the buffer locks, the visibility map bit will have been
297+
* cleared by some other backend anyway. In that case, we'll have done
298+
* a bit of extra work for no gain, but there's no real harm done.
299+
*/
300+
if (PageIsAllVisible(BufferGetPage(buffer))
301+
&& !visibilitymap_pin_ok(targetBlock,*vmbuffer))
302+
{
303+
LockBuffer(buffer,BUFFER_LOCK_UNLOCK);
304+
if (otherBlock!=targetBlock)
305+
LockBuffer(otherBuffer,BUFFER_LOCK_UNLOCK);
306+
visibilitymap_pin(relation,targetBlock,vmbuffer);
307+
if (otherBuffer!=InvalidBuffer&&otherBlock<targetBlock)
308+
LockBuffer(otherBuffer,BUFFER_LOCK_EXCLUSIVE);
309+
LockBuffer(buffer,BUFFER_LOCK_EXCLUSIVE);
310+
if (otherBuffer!=InvalidBuffer&&otherBlock>targetBlock)
311+
LockBuffer(otherBuffer,BUFFER_LOCK_EXCLUSIVE);
312+
}
313+
268314
/*
269315
* Now we can check to see if there's enough free space here. If so,
270316
* we're done.

‎src/backend/access/heap/visibilitymap.c

Lines changed: 59 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -11,10 +11,11 @@
1111
* src/backend/access/heap/visibilitymap.c
1212
*
1313
* INTERFACE ROUTINES
14-
*visibilitymap_clear - clear a bit in the visibility map
15-
*visibilitymap_pin- pin a map page for setting a bit
16-
*visibilitymap_set- set a bit in a previously pinned page
17-
*visibilitymap_test- test if a bit is set
14+
*visibilitymap_clear - clear a bit in the visibility map
15+
*visibilitymap_pin - pin a map page for setting a bit
16+
*visibilitymap_pin_ok - check whether correct map page is already pinned
17+
*visibilitymap_set - set a bit in a previously pinned page
18+
*visibilitymap_test - test if a bit is set
1819
*
1920
* NOTES
2021
*
@@ -64,32 +65,13 @@
6465
* It would be nice to use the visibility map to skip visibility checks in
6566
* index scans.
6667
*
67-
* Currently, the visibility map is not 100% correct all the time.
68-
* During updates, the bit in the visibility map is cleared after releasing
69-
* the lock on the heap page. During the window between releasing the lock
70-
* and clearing the bit in the visibility map, the bit in the visibility map
71-
* is set, but the new insertion or deletion is not yet visible to other
72-
* backends.
73-
*
74-
* That might actually be OK for the index scans, though. The newly inserted
75-
* tuple wouldn't have an index pointer yet, so all tuples reachable from an
76-
* index would still be visible to all other backends, and deletions wouldn't
77-
* be visible to other backends yet. (But HOT breaks that argument, no?)
78-
*
79-
* There's another hole in the way the PD_ALL_VISIBLE flag is set. When
80-
* vacuum observes that all tuples are visible to all, it sets the flag on
81-
* the heap page, and also sets the bit in the visibility map. If we then
82-
* crash, and only the visibility map page was flushed to disk, we'll have
83-
* a bit set in the visibility map, but the corresponding flag on the heap
84-
* page is not set. If the heap page is then updated, the updater won't
85-
* know to clear the bit in the visibility map. (Isn't that prevented by
86-
* the LSN interlock?)
87-
*
8868
*-------------------------------------------------------------------------
8969
*/
9070
#include"postgres.h"
9171

72+
#include"access/heapam.h"
9273
#include"access/visibilitymap.h"
74+
#include"miscadmin.h"
9375
#include"storage/bufmgr.h"
9476
#include"storage/bufpage.h"
9577
#include"storage/lmgr.h"
@@ -127,38 +109,37 @@ static void vm_extend(Relation rel, BlockNumber nvmblocks);
127109
/*
128110
*visibilitymap_clear - clear a bit in visibility map
129111
*
130-
* Clear a bit in the visibility map, marking that not all tuples are
131-
* visible to all transactions anymore.
112+
* You must pass a buffer containing the correct map page to this function.
113+
* Call visibilitymap_pin first to pin the right one. This function doesn't do
114+
* any I/O.
132115
*/
133116
void
134-
visibilitymap_clear(Relationrel,BlockNumberheapBlk)
117+
visibilitymap_clear(Relationrel,BlockNumberheapBlk,Bufferbuf)
135118
{
136119
BlockNumbermapBlock=HEAPBLK_TO_MAPBLOCK(heapBlk);
137120
intmapByte=HEAPBLK_TO_MAPBYTE(heapBlk);
138121
intmapBit=HEAPBLK_TO_MAPBIT(heapBlk);
139122
uint8mask=1 <<mapBit;
140-
BuffermapBuffer;
141123
char*map;
142124

143125
#ifdefTRACE_VISIBILITYMAP
144126
elog(DEBUG1,"vm_clear %s %d",RelationGetRelationName(rel),heapBlk);
145127
#endif
146128

147-
mapBuffer=vm_readbuf(rel,mapBlock, false);
148-
if (!BufferIsValid(mapBuffer))
149-
return;/* nothing to do */
129+
if (!BufferIsValid(buf)||BufferGetBlockNumber(buf)!=mapBlock)
130+
elog(ERROR,"wrong buffer passed to visibilitymap_clear");
150131

151-
LockBuffer(mapBuffer,BUFFER_LOCK_EXCLUSIVE);
152-
map=PageGetContents(BufferGetPage(mapBuffer));
132+
LockBuffer(buf,BUFFER_LOCK_EXCLUSIVE);
133+
map=PageGetContents(BufferGetPage(buf));
153134

154135
if (map[mapByte]&mask)
155136
{
156137
map[mapByte] &= ~mask;
157138

158-
MarkBufferDirty(mapBuffer);
139+
MarkBufferDirty(buf);
159140
}
160141

161-
UnlockReleaseBuffer(mapBuffer);
142+
LockBuffer(buf,BUFFER_LOCK_UNLOCK);
162143
}
163144

164145
/*
@@ -193,20 +174,37 @@ visibilitymap_pin(Relation rel, BlockNumber heapBlk, Buffer *buf)
193174
*buf=vm_readbuf(rel,mapBlock, true);
194175
}
195176

177+
/*
178+
*visibilitymap_pin_ok - do we already have the correct page pinned?
179+
*
180+
* On entry, buf should be InvalidBuffer or a valid buffer returned by
181+
* an earlier call to visibilitymap_pin or visibilitymap_test on the same
182+
* relation. The return value indicates whether the buffer covers the
183+
* given heapBlk.
184+
*/
185+
bool
186+
visibilitymap_pin_ok(BlockNumberheapBlk,Bufferbuf)
187+
{
188+
BlockNumbermapBlock=HEAPBLK_TO_MAPBLOCK(heapBlk);
189+
190+
returnBufferIsValid(buf)&&BufferGetBlockNumber(buf)==mapBlock;
191+
}
192+
196193
/*
197194
*visibilitymap_set - set a bit on a previously pinned page
198195
*
199-
* recptr is the LSN of the heap page. The LSN of the visibility map page is
200-
* advanced to that, to make sure that the visibility map doesn't get flushed
201-
* to disk before the update to the heap page that made all tuples visible.
196+
* recptr is the LSN of the XLOG record we're replaying, if we're in recovery,
197+
* or InvalidXLogRecPtr in normal running. The page LSN is advanced to the
198+
* one provided; in normal running, we generate a new XLOG record and set the
199+
* page LSN to that value.
202200
*
203-
*This is an opportunistic function. It does nothing, unless *buf
204-
*contains the bit for heapBlk.Call visibilitymap_pin first to pin
205-
*the right map page. This function doesn't doany I/O.
201+
*You must pass a buffer containing the correct map page to this function.
202+
* Call visibilitymap_pin first to pin the right one. This function doesn't do
203+
* any I/O.
206204
*/
207205
void
208206
visibilitymap_set(Relationrel,BlockNumberheapBlk,XLogRecPtrrecptr,
209-
Buffer*buf)
207+
Bufferbuf)
210208
{
211209
BlockNumbermapBlock=HEAPBLK_TO_MAPBLOCK(heapBlk);
212210
uint32mapByte=HEAPBLK_TO_MAPBYTE(heapBlk);
@@ -218,25 +216,35 @@ visibilitymap_set(Relation rel, BlockNumber heapBlk, XLogRecPtr recptr,
218216
elog(DEBUG1,"vm_set %s %d",RelationGetRelationName(rel),heapBlk);
219217
#endif
220218

219+
Assert(InRecovery||XLogRecPtrIsInvalid(recptr));
220+
221221
/* Check that we have the right page pinned */
222-
if (!BufferIsValid(*buf)||BufferGetBlockNumber(*buf)!=mapBlock)
223-
return;
222+
if (!BufferIsValid(buf)||BufferGetBlockNumber(buf)!=mapBlock)
223+
elog(ERROR,"wrong buffer passed to visibilitymap_set");
224224

225-
page=BufferGetPage(*buf);
225+
page=BufferGetPage(buf);
226226
map=PageGetContents(page);
227-
LockBuffer(*buf,BUFFER_LOCK_EXCLUSIVE);
227+
LockBuffer(buf,BUFFER_LOCK_EXCLUSIVE);
228228

229229
if (!(map[mapByte]& (1 <<mapBit)))
230230
{
231+
START_CRIT_SECTION();
232+
231233
map[mapByte] |= (1 <<mapBit);
234+
MarkBufferDirty(buf);
232235

233-
if (XLByteLT(PageGetLSN(page),recptr))
236+
if (RelationNeedsWAL(rel))
237+
{
238+
if (XLogRecPtrIsInvalid(recptr))
239+
recptr=log_heap_visible(rel->rd_node,heapBlk,buf);
234240
PageSetLSN(page,recptr);
235-
PageSetTLI(page,ThisTimeLineID);
236-
MarkBufferDirty(*buf);
241+
PageSetTLI(page,ThisTimeLineID);
242+
}
243+
244+
END_CRIT_SECTION();
237245
}
238246

239-
LockBuffer(*buf,BUFFER_LOCK_UNLOCK);
247+
LockBuffer(buf,BUFFER_LOCK_UNLOCK);
240248
}
241249

242250
/*

‎src/backend/access/transam/transam.c

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,8 @@
2424
#include"access/transam.h"
2525
#include"utils/snapmgr.h"
2626

27+
/* Handy constant for an invalid xlog recptr */
28+
constXLogRecPtrInvalidXLogRecPtr= {0,0};
2729

2830
/*
2931
* Single-item cache for results of TransactionLogFetch. It's worth having
@@ -35,9 +37,6 @@ static TransactionId cachedFetchXid = InvalidTransactionId;
3537
staticXidStatuscachedFetchXidStatus;
3638
staticXLogRecPtrcachedCommitLSN;
3739

38-
/* Handy constant for an invalid xlog recptr */
39-
staticconstXLogRecPtrInvalidXLogRecPtr= {0,0};
40-
4140
/* Local functions */
4241
staticXidStatusTransactionLogFetch(TransactionIdtransactionId);
4342

‎src/backend/access/transam/xlog.c

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -5462,7 +5462,6 @@ exitArchiveRecovery(TimeLineID endTLI, uint32 endLogId, uint32 endLogSeg)
54625462
{
54635463
charrecoveryPath[MAXPGPATH];
54645464
charxlogpath[MAXPGPATH];
5465-
XLogRecPtrInvalidXLogRecPtr= {0,0};
54665465

54675466
/*
54685467
* We are no longer in archive recovery state.
@@ -8069,8 +8068,6 @@ CreateRestartPoint(int flags)
80698068
if (XLogRecPtrIsInvalid(lastCheckPointRecPtr)||
80708069
XLByteLE(lastCheckPoint.redo,ControlFile->checkPointCopy.redo))
80718070
{
8072-
XLogRecPtrInvalidXLogRecPtr= {0,0};
8073-
80748071
ereport(DEBUG2,
80758072
(errmsg("skipping restartpoint, already performed at %X/%X",
80768073
lastCheckPoint.redo.xlogid,lastCheckPoint.redo.xrecoff)));

‎src/backend/commands/vacuumlazy.c

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -513,7 +513,8 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
513513
visibilitymap_pin(onerel,blkno,&vmbuffer);
514514
LockBuffer(buf,BUFFER_LOCK_SHARE);
515515
if (PageIsAllVisible(page))
516-
visibilitymap_set(onerel,blkno,PageGetLSN(page),&vmbuffer);
516+
visibilitymap_set(onerel,blkno,InvalidXLogRecPtr,
517+
vmbuffer);
517518
LockBuffer(buf,BUFFER_LOCK_UNLOCK);
518519
}
519520

@@ -765,7 +766,8 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
765766
* updating the visibility map, but since this case shouldn't
766767
* happen anyway, don't worry about that.
767768
*/
768-
visibilitymap_clear(onerel,blkno);
769+
visibilitymap_pin(onerel,blkno,&vmbuffer);
770+
visibilitymap_clear(onerel,blkno,vmbuffer);
769771
}
770772

771773
LockBuffer(buf,BUFFER_LOCK_UNLOCK);
@@ -776,7 +778,7 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
776778
visibilitymap_pin(onerel,blkno,&vmbuffer);
777779
LockBuffer(buf,BUFFER_LOCK_SHARE);
778780
if (PageIsAllVisible(page))
779-
visibilitymap_set(onerel,blkno,PageGetLSN(page),&vmbuffer);
781+
visibilitymap_set(onerel,blkno,InvalidXLogRecPtr,vmbuffer);
780782
LockBuffer(buf,BUFFER_LOCK_UNLOCK);
781783
}
782784

‎src/include/access/heapam.h

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -136,6 +136,8 @@ extern XLogRecPtr log_heap_clean(Relation reln, Buffer buffer,
136136
externXLogRecPtrlog_heap_freeze(Relationreln,Bufferbuffer,
137137
TransactionIdcutoff_xid,
138138
OffsetNumber*offsets,intoffcnt);
139+
externXLogRecPtrlog_heap_visible(RelFileNodernode,BlockNumberblock,
140+
Buffervm_buffer);
139141
externXLogRecPtrlog_newpage(RelFileNode*rnode,ForkNumberforkNum,
140142
BlockNumberblk,Pagepage);
141143

‎src/include/access/hio.h

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,7 @@ extern void RelationPutHeapTuple(Relation relation, Buffer buffer,
3838
HeapTupletuple);
3939
externBufferRelationGetBufferForTuple(Relationrelation,Sizelen,
4040
BufferotherBuffer,intoptions,
41-
structBulkInsertStateData*bistate);
41+
structBulkInsertStateData*bistate,
42+
Buffer*vmbuffer);
4243

4344
#endif/* HIO_H */

‎src/include/access/htup.h

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -606,6 +606,7 @@ typedef HeapTupleData *HeapTuple;
606606
#defineXLOG_HEAP2_CLEAN0x10
607607
/* 0x20 is free, was XLOG_HEAP2_CLEAN_MOVE */
608608
#defineXLOG_HEAP2_CLEANUP_INFO 0x30
609+
#defineXLOG_HEAP2_VISIBLE0x40
609610

610611
/*
611612
* All what we need to find changed tuple
@@ -750,6 +751,15 @@ typedef struct xl_heap_freeze
750751

751752
#defineSizeOfHeapFreeze (offsetof(xl_heap_freeze, cutoff_xid) + sizeof(TransactionId))
752753

754+
/* This is what we need to know about setting a visibility map bit */
755+
typedefstructxl_heap_visible
756+
{
757+
RelFileNodenode;
758+
BlockNumberblock;
759+
}xl_heap_visible;
760+
761+
#defineSizeOfHeapVisible (offsetof(xl_heap_visible, block) + sizeof(BlockNumber))
762+
753763
externvoidHeapTupleHeaderAdvanceLatestRemovedXid(HeapTupleHeadertuple,
754764
TransactionId*latestRemovedXid);
755765

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp