1/*-------------------------------------------------------------------------
2 *
3 * visibilitymap.c
4 * bitmap for tracking visibility of heap tuples
5 *
6 * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/access/heap/visibilitymap.c
12 *
13 * INTERFACE ROUTINES
14 * visibilitymap_clear - clear bits for one page 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_get_status - get status of bits
19 * visibilitymap_count - count number of bits set in visibility map
20 * visibilitymap_truncate - truncate the visibility map
21 *
22 * NOTES
23 *
24 * The visibility map is a bitmap with two bits (all-visible and all-frozen)
25 * per heap page. A set all-visible bit means that all tuples on the page are
26 * known visible to all transactions, and therefore the page doesn't need to
27 * be vacuumed. A set all-frozen bit means that all tuples on the page are
28 * completely frozen, and therefore the page doesn't need to be vacuumed even
29 * if whole table scanning vacuum is required (e.g. anti-wraparound vacuum).
30 * The all-frozen bit must be set only when the page is already all-visible.
31 *
32 * The map is conservative in the sense that we make sure that whenever a bit
33 * is set, we know the condition is true, but if a bit is not set, it might or
34 * might not be true.
35 *
36 * Clearing visibility map bits is not separately WAL-logged. The callers
37 * must make sure that whenever a bit is cleared, the bit is cleared on WAL
38 * replay of the updating operation as well.
39 *
40 * When we *set* a visibility map during VACUUM, we must write WAL. This may
41 * seem counterintuitive, since the bit is basically a hint: if it is clear,
42 * it may still be the case that every tuple on the page is visible to all
43 * transactions; we just don't know that for certain. The difficulty is that
44 * there are two bits which are typically set together: the PD_ALL_VISIBLE bit
45 * on the page itself, and the visibility map bit. If a crash occurs after the
46 * visibility map page makes it to disk and before the updated heap page makes
47 * it to disk, redo must set the bit on the heap page. Otherwise, the next
48 * insert, update, or delete on the heap page will fail to realize that the
49 * visibility map bit must be cleared, possibly causing index-only scans to
50 * return wrong answers.
51 *
52 * VACUUM will normally skip pages for which the visibility map bit is set;
53 * such pages can't contain any dead tuples and therefore don't need vacuuming.
54 *
55 * LOCKING
56 *
57 * In heapam.c, whenever a page is modified so that not all tuples on the
58 * page are visible to everyone anymore, the corresponding bit in the
59 * visibility map is cleared. In order to be crash-safe, we need to do this
60 * while still holding a lock on the heap page and in the same critical
61 * section that logs the page modification. However, we don't want to hold
62 * the buffer lock over any I/O that may be required to read in the visibility
63 * map page. To avoid this, we examine the heap page before locking it;
64 * if the page-level PD_ALL_VISIBLE bit is set, we pin the visibility map
65 * bit. Then, we lock the buffer. But this creates a race condition: there
66 * is a possibility that in the time it takes to lock the buffer, the
67 * PD_ALL_VISIBLE bit gets set. If that happens, we have to unlock the
68 * buffer, pin the visibility map page, and relock the buffer. This shouldn't
69 * happen often, because only VACUUM currently sets visibility map bits,
70 * and the race will only occur if VACUUM processes a given page at almost
71 * exactly the same time that someone tries to further modify it.
72 *
73 * To set a bit, you need to hold a lock on the heap page. That prevents
74 * the race condition where VACUUM sees that all tuples on the page are
75 * visible to everyone, but another backend modifies the page before VACUUM
76 * sets the bit in the visibility map.
77 *
78 * When a bit is set, the LSN of the visibility map page is updated to make
79 * sure that the visibility map update doesn't get written to disk before the
80 * WAL record of the changes that made it possible to set the bit is flushed.
81 * But when a bit is cleared, we don't have to do that because it's always
82 * safe to clear a bit in the map from correctness point of view.
83 *
84 *-------------------------------------------------------------------------
85 */
86#include "postgres.h"
87
88#include "access/heapam_xlog.h"
89#include "access/visibilitymap.h"
90#include "access/xlog.h"
91#include "miscadmin.h"
92#include "port/pg_bitutils.h"
93#include "storage/bufmgr.h"
94#include "storage/lmgr.h"
95#include "storage/smgr.h"
96#include "utils/inval.h"
97
98
99/*#define TRACE_VISIBILITYMAP */
100
101/*
102 * Size of the bitmap on each visibility map page, in bytes. There's no
103 * extra headers, so the whole page minus the standard page header is
104 * used for the bitmap.
105 */
106#define MAPSIZE (BLCKSZ - MAXALIGN(SizeOfPageHeaderData))
107
108/* Number of heap blocks we can represent in one byte */
109#define HEAPBLOCKS_PER_BYTE (BITS_PER_BYTE / BITS_PER_HEAPBLOCK)
110
111/* Number of heap blocks we can represent in one visibility map page. */
112#define HEAPBLOCKS_PER_PAGE (MAPSIZE * HEAPBLOCKS_PER_BYTE)
113
114/* Mapping from heap block number to the right bit in the visibility map */
115#define HEAPBLK_TO_MAPBLOCK(x) ((x) / HEAPBLOCKS_PER_PAGE)
116#define HEAPBLK_TO_MAPBYTE(x) (((x) % HEAPBLOCKS_PER_PAGE) / HEAPBLOCKS_PER_BYTE)
117#define HEAPBLK_TO_OFFSET(x) (((x) % HEAPBLOCKS_PER_BYTE) * BITS_PER_HEAPBLOCK)
118
119/* Masks for counting subsets of bits in the visibility map. */
120#define VISIBLE_MASK64 UINT64CONST(0x5555555555555555) /* The lower bit of each
121 * bit pair */
122#define FROZEN_MASK64 UINT64CONST(0xaaaaaaaaaaaaaaaa) /* The upper bit of each
123 * bit pair */
124
125/* prototypes for internal routines */
126static Buffer vm_readbuf(Relation rel, BlockNumber blkno, bool extend);
127static void vm_extend(Relation rel, BlockNumber nvmblocks);
128
129
130/*
131 * visibilitymap_clear - clear specified bits for one page in visibility map
132 *
133 * You must pass a buffer containing the correct map page to this function.
134 * Call visibilitymap_pin first to pin the right one. This function doesn't do
135 * any I/O. Returns true if any bits have been cleared and false otherwise.
136 */
137bool
138visibilitymap_clear(Relation rel, BlockNumber heapBlk, Buffer buf, uint8 flags)
139{
140 BlockNumber mapBlock = HEAPBLK_TO_MAPBLOCK(heapBlk);
141 int mapByte = HEAPBLK_TO_MAPBYTE(heapBlk);
142 int mapOffset = HEAPBLK_TO_OFFSET(heapBlk);
143 uint8 mask = flags << mapOffset;
144 char *map;
145 bool cleared = false;
146
147 Assert(flags & VISIBILITYMAP_VALID_BITS);
148
149#ifdef TRACE_VISIBILITYMAP
150 elog(DEBUG1, "vm_clear %s %d", RelationGetRelationName(rel), heapBlk);
151#endif
152
153 if (!BufferIsValid(buf) || BufferGetBlockNumber(buf) != mapBlock)
154 elog(ERROR, "wrong buffer passed to visibilitymap_clear");
155
156 LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
157 map = PageGetContents(BufferGetPage(buf));
158
159 if (map[mapByte] & mask)
160 {
161 map[mapByte] &= ~mask;
162
163 MarkBufferDirty(buf);
164 cleared = true;
165 }
166
167 LockBuffer(buf, BUFFER_LOCK_UNLOCK);
168
169 return cleared;
170}
171
172/*
173 * visibilitymap_pin - pin a map page for setting a bit
174 *
175 * Setting a bit in the visibility map is a two-phase operation. First, call
176 * visibilitymap_pin, to pin the visibility map page containing the bit for
177 * the heap page. Because that can require I/O to read the map page, you
178 * shouldn't hold a lock on the heap page while doing that. Then, call
179 * visibilitymap_set to actually set the bit.
180 *
181 * On entry, *buf should be InvalidBuffer or a valid buffer returned by
182 * an earlier call to visibilitymap_pin or visibilitymap_get_status on the same
183 * relation. On return, *buf is a valid buffer with the map page containing
184 * the bit for heapBlk.
185 *
186 * If the page doesn't exist in the map file yet, it is extended.
187 */
188void
189visibilitymap_pin(Relation rel, BlockNumber heapBlk, Buffer *buf)
190{
191 BlockNumber mapBlock = HEAPBLK_TO_MAPBLOCK(heapBlk);
192
193 /* Reuse the old pinned buffer if possible */
194 if (BufferIsValid(*buf))
195 {
196 if (BufferGetBlockNumber(*buf) == mapBlock)
197 return;
198
199 ReleaseBuffer(*buf);
200 }
201 *buf = vm_readbuf(rel, mapBlock, true);
202}
203
204/*
205 * visibilitymap_pin_ok - do we already have the correct page pinned?
206 *
207 * On entry, buf should be InvalidBuffer or a valid buffer returned by
208 * an earlier call to visibilitymap_pin or visibilitymap_get_status on the same
209 * relation. The return value indicates whether the buffer covers the
210 * given heapBlk.
211 */
212bool
213visibilitymap_pin_ok(BlockNumber heapBlk, Buffer buf)
214{
215 BlockNumber mapBlock = HEAPBLK_TO_MAPBLOCK(heapBlk);
216
217 return BufferIsValid(buf) && BufferGetBlockNumber(buf) == mapBlock;
218}
219
220/*
221 * visibilitymap_set - set bit(s) on a previously pinned page
222 *
223 * recptr is the LSN of the XLOG record we're replaying, if we're in recovery,
224 * or InvalidXLogRecPtr in normal running. The page LSN is advanced to the
225 * one provided; in normal running, we generate a new XLOG record and set the
226 * page LSN to that value. cutoff_xid is the largest xmin on the page being
227 * marked all-visible; it is needed for Hot Standby, and can be
228 * InvalidTransactionId if the page contains no tuples. It can also be set
229 * to InvalidTransactionId when a page that is already all-visible is being
230 * marked all-frozen.
231 *
232 * Caller is expected to set the heap page's PD_ALL_VISIBLE bit before calling
233 * this function. Except in recovery, caller should also pass the heap
234 * buffer. When checksums are enabled and we're not in recovery, we must add
235 * the heap buffer to the WAL chain to protect it from being torn.
236 *
237 * You must pass a buffer containing the correct map page to this function.
238 * Call visibilitymap_pin first to pin the right one. This function doesn't do
239 * any I/O.
240 */
241void
242visibilitymap_set(Relation rel, BlockNumber heapBlk, Buffer heapBuf,
243 XLogRecPtr recptr, Buffer vmBuf, TransactionId cutoff_xid,
244 uint8 flags)
245{
246 BlockNumber mapBlock = HEAPBLK_TO_MAPBLOCK(heapBlk);
247 uint32 mapByte = HEAPBLK_TO_MAPBYTE(heapBlk);
248 uint8 mapOffset = HEAPBLK_TO_OFFSET(heapBlk);
249 Page page;
250 uint8 *map;
251
252#ifdef TRACE_VISIBILITYMAP
253 elog(DEBUG1, "vm_set %s %d", RelationGetRelationName(rel), heapBlk);
254#endif
255
256 Assert(InRecovery || XLogRecPtrIsInvalid(recptr));
257 Assert(InRecovery || BufferIsValid(heapBuf));
258 Assert(flags & VISIBILITYMAP_VALID_BITS);
259
260 /* Check that we have the right heap page pinned, if present */
261 if (BufferIsValid(heapBuf) && BufferGetBlockNumber(heapBuf) != heapBlk)
262 elog(ERROR, "wrong heap buffer passed to visibilitymap_set");
263
264 /* Check that we have the right VM page pinned */
265 if (!BufferIsValid(vmBuf) || BufferGetBlockNumber(vmBuf) != mapBlock)
266 elog(ERROR, "wrong VM buffer passed to visibilitymap_set");
267
268 page = BufferGetPage(vmBuf);
269 map = (uint8 *) PageGetContents(page);
270 LockBuffer(vmBuf, BUFFER_LOCK_EXCLUSIVE);
271
272 if (flags != (map[mapByte] >> mapOffset & VISIBILITYMAP_VALID_BITS))
273 {
274 START_CRIT_SECTION();
275
276 map[mapByte] |= (flags << mapOffset);
277 MarkBufferDirty(vmBuf);
278
279 if (RelationNeedsWAL(rel))
280 {
281 if (XLogRecPtrIsInvalid(recptr))
282 {
283 Assert(!InRecovery);
284 recptr = log_heap_visible(rel->rd_node, heapBuf, vmBuf,
285 cutoff_xid, flags);
286
287 /*
288 * If data checksums are enabled (or wal_log_hints=on), we
289 * need to protect the heap page from being torn.
290 */
291 if (XLogHintBitIsNeeded())
292 {
293 Page heapPage = BufferGetPage(heapBuf);
294
295 /* caller is expected to set PD_ALL_VISIBLE first */
296 Assert(PageIsAllVisible(heapPage));
297 PageSetLSN(heapPage, recptr);
298 }
299 }
300 PageSetLSN(page, recptr);
301 }
302
303 END_CRIT_SECTION();
304 }
305
306 LockBuffer(vmBuf, BUFFER_LOCK_UNLOCK);
307}
308
309/*
310 * visibilitymap_get_status - get status of bits
311 *
312 * Are all tuples on heapBlk visible to all or are marked frozen, according
313 * to the visibility map?
314 *
315 * On entry, *buf should be InvalidBuffer or a valid buffer returned by an
316 * earlier call to visibilitymap_pin or visibilitymap_get_status on the same
317 * relation. On return, *buf is a valid buffer with the map page containing
318 * the bit for heapBlk, or InvalidBuffer. The caller is responsible for
319 * releasing *buf after it's done testing and setting bits.
320 *
321 * NOTE: This function is typically called without a lock on the heap page,
322 * so somebody else could change the bit just after we look at it. In fact,
323 * since we don't lock the visibility map page either, it's even possible that
324 * someone else could have changed the bit just before we look at it, but yet
325 * we might see the old value. It is the caller's responsibility to deal with
326 * all concurrency issues!
327 */
328uint8
329visibilitymap_get_status(Relation rel, BlockNumber heapBlk, Buffer *buf)
330{
331 BlockNumber mapBlock = HEAPBLK_TO_MAPBLOCK(heapBlk);
332 uint32 mapByte = HEAPBLK_TO_MAPBYTE(heapBlk);
333 uint8 mapOffset = HEAPBLK_TO_OFFSET(heapBlk);
334 char *map;
335 uint8 result;
336
337#ifdef TRACE_VISIBILITYMAP
338 elog(DEBUG1, "vm_get_status %s %d", RelationGetRelationName(rel), heapBlk);
339#endif
340
341 /* Reuse the old pinned buffer if possible */
342 if (BufferIsValid(*buf))
343 {
344 if (BufferGetBlockNumber(*buf) != mapBlock)
345 {
346 ReleaseBuffer(*buf);
347 *buf = InvalidBuffer;
348 }
349 }
350
351 if (!BufferIsValid(*buf))
352 {
353 *buf = vm_readbuf(rel, mapBlock, false);
354 if (!BufferIsValid(*buf))
355 return false;
356 }
357
358 map = PageGetContents(BufferGetPage(*buf));
359
360 /*
361 * A single byte read is atomic. There could be memory-ordering effects
362 * here, but for performance reasons we make it the caller's job to worry
363 * about that.
364 */
365 result = ((map[mapByte] >> mapOffset) & VISIBILITYMAP_VALID_BITS);
366 return result;
367}
368
369/*
370 * visibilitymap_count - count number of bits set in visibility map
371 *
372 * Note: we ignore the possibility of race conditions when the table is being
373 * extended concurrently with the call. New pages added to the table aren't
374 * going to be marked all-visible or all-frozen, so they won't affect the result.
375 */
376void
377visibilitymap_count(Relation rel, BlockNumber *all_visible, BlockNumber *all_frozen)
378{
379 BlockNumber mapBlock;
380 BlockNumber nvisible = 0;
381 BlockNumber nfrozen = 0;
382
383 /* all_visible must be specified */
384 Assert(all_visible);
385
386 for (mapBlock = 0;; mapBlock++)
387 {
388 Buffer mapBuffer;
389 uint64 *map;
390 int i;
391
392 /*
393 * Read till we fall off the end of the map. We assume that any extra
394 * bytes in the last page are zeroed, so we don't bother excluding
395 * them from the count.
396 */
397 mapBuffer = vm_readbuf(rel, mapBlock, false);
398 if (!BufferIsValid(mapBuffer))
399 break;
400
401 /*
402 * We choose not to lock the page, since the result is going to be
403 * immediately stale anyway if anyone is concurrently setting or
404 * clearing bits, and we only really need an approximate value.
405 */
406 map = (uint64 *) PageGetContents(BufferGetPage(mapBuffer));
407
408 StaticAssertStmt(MAPSIZE % sizeof(uint64) == 0,
409 "unsupported MAPSIZE");
410 if (all_frozen == NULL)
411 {
412 for (i = 0; i < MAPSIZE / sizeof(uint64); i++)
413 nvisible += pg_popcount64(map[i] & VISIBLE_MASK64);
414 }
415 else
416 {
417 for (i = 0; i < MAPSIZE / sizeof(uint64); i++)
418 {
419 nvisible += pg_popcount64(map[i] & VISIBLE_MASK64);
420 nfrozen += pg_popcount64(map[i] & FROZEN_MASK64);
421 }
422 }
423
424 ReleaseBuffer(mapBuffer);
425 }
426
427 *all_visible = nvisible;
428 if (all_frozen)
429 *all_frozen = nfrozen;
430}
431
432/*
433 * visibilitymap_truncate - truncate the visibility map
434 *
435 * The caller must hold AccessExclusiveLock on the relation, to ensure that
436 * other backends receive the smgr invalidation event that this function sends
437 * before they access the VM again.
438 *
439 * nheapblocks is the new size of the heap.
440 */
441void
442visibilitymap_truncate(Relation rel, BlockNumber nheapblocks)
443{
444 BlockNumber newnblocks;
445
446 /* last remaining block, byte, and bit */
447 BlockNumber truncBlock = HEAPBLK_TO_MAPBLOCK(nheapblocks);
448 uint32 truncByte = HEAPBLK_TO_MAPBYTE(nheapblocks);
449 uint8 truncOffset = HEAPBLK_TO_OFFSET(nheapblocks);
450
451#ifdef TRACE_VISIBILITYMAP
452 elog(DEBUG1, "vm_truncate %s %d", RelationGetRelationName(rel), nheapblocks);
453#endif
454
455 RelationOpenSmgr(rel);
456
457 /*
458 * If no visibility map has been created yet for this relation, there's
459 * nothing to truncate.
460 */
461 if (!smgrexists(rel->rd_smgr, VISIBILITYMAP_FORKNUM))
462 return;
463
464 /*
465 * Unless the new size is exactly at a visibility map page boundary, the
466 * tail bits in the last remaining map page, representing truncated heap
467 * blocks, need to be cleared. This is not only tidy, but also necessary
468 * because we don't get a chance to clear the bits if the heap is extended
469 * again.
470 */
471 if (truncByte != 0 || truncOffset != 0)
472 {
473 Buffer mapBuffer;
474 Page page;
475 char *map;
476
477 newnblocks = truncBlock + 1;
478
479 mapBuffer = vm_readbuf(rel, truncBlock, false);
480 if (!BufferIsValid(mapBuffer))
481 {
482 /* nothing to do, the file was already smaller */
483 return;
484 }
485
486 page = BufferGetPage(mapBuffer);
487 map = PageGetContents(page);
488
489 LockBuffer(mapBuffer, BUFFER_LOCK_EXCLUSIVE);
490
491 /* NO EREPORT(ERROR) from here till changes are logged */
492 START_CRIT_SECTION();
493
494 /* Clear out the unwanted bytes. */
495 MemSet(&map[truncByte + 1], 0, MAPSIZE - (truncByte + 1));
496
497 /*----
498 * Mask out the unwanted bits of the last remaining byte.
499 *
500 * ((1 << 0) - 1) = 00000000
501 * ((1 << 1) - 1) = 00000001
502 * ...
503 * ((1 << 6) - 1) = 00111111
504 * ((1 << 7) - 1) = 01111111
505 *----
506 */
507 map[truncByte] &= (1 << truncOffset) - 1;
508
509 /*
510 * Truncation of a relation is WAL-logged at a higher-level, and we
511 * will be called at WAL replay. But if checksums are enabled, we need
512 * to still write a WAL record to protect against a torn page, if the
513 * page is flushed to disk before the truncation WAL record. We cannot
514 * use MarkBufferDirtyHint here, because that will not dirty the page
515 * during recovery.
516 */
517 MarkBufferDirty(mapBuffer);
518 if (!InRecovery && RelationNeedsWAL(rel) && XLogHintBitIsNeeded())
519 log_newpage_buffer(mapBuffer, false);
520
521 END_CRIT_SECTION();
522
523 UnlockReleaseBuffer(mapBuffer);
524 }
525 else
526 newnblocks = truncBlock;
527
528 if (smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM) <= newnblocks)
529 {
530 /* nothing to do, the file was already smaller than requested size */
531 return;
532 }
533
534 /* Truncate the unused VM pages, and send smgr inval message */
535 smgrtruncate(rel->rd_smgr, VISIBILITYMAP_FORKNUM, newnblocks);
536
537 /*
538 * We might as well update the local smgr_vm_nblocks setting. smgrtruncate
539 * sent an smgr cache inval message, which will cause other backends to
540 * invalidate their copy of smgr_vm_nblocks, and this one too at the next
541 * command boundary. But this ensures it isn't outright wrong until then.
542 */
543 if (rel->rd_smgr)
544 rel->rd_smgr->smgr_vm_nblocks = newnblocks;
545}
546
547/*
548 * Read a visibility map page.
549 *
550 * If the page doesn't exist, InvalidBuffer is returned, or if 'extend' is
551 * true, the visibility map file is extended.
552 */
553static Buffer
554vm_readbuf(Relation rel, BlockNumber blkno, bool extend)
555{
556 Buffer buf;
557
558 /*
559 * We might not have opened the relation at the smgr level yet, or we
560 * might have been forced to close it by a sinval message. The code below
561 * won't necessarily notice relation extension immediately when extend =
562 * false, so we rely on sinval messages to ensure that our ideas about the
563 * size of the map aren't too far out of date.
564 */
565 RelationOpenSmgr(rel);
566
567 /*
568 * If we haven't cached the size of the visibility map fork yet, check it
569 * first.
570 */
571 if (rel->rd_smgr->smgr_vm_nblocks == InvalidBlockNumber)
572 {
573 if (smgrexists(rel->rd_smgr, VISIBILITYMAP_FORKNUM))
574 rel->rd_smgr->smgr_vm_nblocks = smgrnblocks(rel->rd_smgr,
575 VISIBILITYMAP_FORKNUM);
576 else
577 rel->rd_smgr->smgr_vm_nblocks = 0;
578 }
579
580 /* Handle requests beyond EOF */
581 if (blkno >= rel->rd_smgr->smgr_vm_nblocks)
582 {
583 if (extend)
584 vm_extend(rel, blkno + 1);
585 else
586 return InvalidBuffer;
587 }
588
589 /*
590 * Use ZERO_ON_ERROR mode, and initialize the page if necessary. It's
591 * always safe to clear bits, so it's better to clear corrupt pages than
592 * error out.
593 *
594 * The initialize-the-page part is trickier than it looks, because of the
595 * possibility of multiple backends doing this concurrently, and our
596 * desire to not uselessly take the buffer lock in the normal path where
597 * the page is OK. We must take the lock to initialize the page, so
598 * recheck page newness after we have the lock, in case someone else
599 * already did it. Also, because we initially check PageIsNew with no
600 * lock, it's possible to fall through and return the buffer while someone
601 * else is still initializing the page (i.e., we might see pd_upper as set
602 * but other page header fields are still zeroes). This is harmless for
603 * callers that will take a buffer lock themselves, but some callers
604 * inspect the page without any lock at all. The latter is OK only so
605 * long as it doesn't depend on the page header having correct contents.
606 * Current usage is safe because PageGetContents() does not require that.
607 */
608 buf = ReadBufferExtended(rel, VISIBILITYMAP_FORKNUM, blkno,
609 RBM_ZERO_ON_ERROR, NULL);
610 if (PageIsNew(BufferGetPage(buf)))
611 {
612 LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
613 if (PageIsNew(BufferGetPage(buf)))
614 PageInit(BufferGetPage(buf), BLCKSZ, 0);
615 LockBuffer(buf, BUFFER_LOCK_UNLOCK);
616 }
617 return buf;
618}
619
620/*
621 * Ensure that the visibility map fork is at least vm_nblocks long, extending
622 * it if necessary with zeroed pages.
623 */
624static void
625vm_extend(Relation rel, BlockNumber vm_nblocks)
626{
627 BlockNumber vm_nblocks_now;
628 PGAlignedBlock pg;
629
630 PageInit((Page) pg.data, BLCKSZ, 0);
631
632 /*
633 * We use the relation extension lock to lock out other backends trying to
634 * extend the visibility map at the same time. It also locks out extension
635 * of the main fork, unnecessarily, but extending the visibility map
636 * happens seldom enough that it doesn't seem worthwhile to have a
637 * separate lock tag type for it.
638 *
639 * Note that another backend might have extended or created the relation
640 * by the time we get the lock.
641 */
642 LockRelationForExtension(rel, ExclusiveLock);
643
644 /* Might have to re-open if a cache flush happened */
645 RelationOpenSmgr(rel);
646
647 /*
648 * Create the file first if it doesn't exist. If smgr_vm_nblocks is
649 * positive then it must exist, no need for an smgrexists call.
650 */
651 if ((rel->rd_smgr->smgr_vm_nblocks == 0 ||
652 rel->rd_smgr->smgr_vm_nblocks == InvalidBlockNumber) &&
653 !smgrexists(rel->rd_smgr, VISIBILITYMAP_FORKNUM))
654 smgrcreate(rel->rd_smgr, VISIBILITYMAP_FORKNUM, false);
655
656 vm_nblocks_now = smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM);
657
658 /* Now extend the file */
659 while (vm_nblocks_now < vm_nblocks)
660 {
661 PageSetChecksumInplace((Page) pg.data, vm_nblocks_now);
662
663 smgrextend(rel->rd_smgr, VISIBILITYMAP_FORKNUM, vm_nblocks_now,
664 pg.data, false);
665 vm_nblocks_now++;
666 }
667
668 /*
669 * Send a shared-inval message to force other backends to close any smgr
670 * references they may have for this rel, which we are about to change.
671 * This is a useful optimization because it means that backends don't have
672 * to keep checking for creation or extension of the file, which happens
673 * infrequently.
674 */
675 CacheInvalidateSmgr(rel->rd_smgr->smgr_rnode);
676
677 /* Update local cache with the up-to-date size */
678 rel->rd_smgr->smgr_vm_nblocks = vm_nblocks_now;
679
680 UnlockRelationForExtension(rel, ExclusiveLock);
681}
682