*** a/src/backend/access/minmax/mmrevmap.c
--- b/src/backend/access/minmax/mmrevmap.c
***************
*** 30,36 ****
  #define HEAPBLK_TO_REVMAP_INDEX(pagesPerRange, heapBlk) \
  	((heapBlk / pagesPerRange) % IDXITEMS_PER_PAGE)
  
! static void mmRevmapExtend(mmRevmapAccess *rmAccess, BlockNumber blkno);
  
  /* typedef appears in minmax_revmap.h */
  struct mmRevmapAccess
--- 30,36 ----
  #define HEAPBLK_TO_REVMAP_INDEX(pagesPerRange, heapBlk) \
  	((heapBlk / pagesPerRange) % IDXITEMS_PER_PAGE)
  
! static bool mmRevmapExtend(mmRevmapAccess *rmAccess, BlockNumber blkno);
  
  /* typedef appears in minmax_revmap.h */
  struct mmRevmapAccess
***************
*** 52,62 **** mmRevmapAccessInit(Relation idxrel, BlockNumber pagesPerRange)
  {
  	mmRevmapAccess *rmAccess = palloc(sizeof(mmRevmapAccess));
  
  	rmAccess->idxrel = idxrel;
  	rmAccess->pagesPerRange = pagesPerRange;
  	rmAccess->currBuf = InvalidBuffer;
  	rmAccess->physPagesInRevmap =
! 		RelationGetNumberOfBlocksInFork(idxrel, MM_REVMAP_FORKNUM);
  
  	return rmAccess;
  }
--- 52,64 ----
  {
  	mmRevmapAccess *rmAccess = palloc(sizeof(mmRevmapAccess));
  
+ 	RelationOpenSmgr(idxrel);
+ 
  	rmAccess->idxrel = idxrel;
  	rmAccess->pagesPerRange = pagesPerRange;
  	rmAccess->currBuf = InvalidBuffer;
  	rmAccess->physPagesInRevmap =
! 		smgrnblocks(idxrel->rd_smgr, MM_REVMAP_FORKNUM);
  
  	return rmAccess;
  }
***************
*** 111,121 **** mmSetHeapBlockItemptr(mmRevmapAccess *rmAccess, BlockNumber heapBlk,
  	/*
  	 * If the revmap is out of space, extend it first.
  	 */
! 	if (mapBlk > rmAccess->physPagesInRevmap - 1)
! 	{
! 		mmRevmapExtend(rmAccess, mapBlk);
! 		extend = true;
! 	}
  
  	/*
  	 * Obtain the buffer from which we need to read.  If we already have the
--- 113,120 ----
  	/*
  	 * If the revmap is out of space, extend it first.
  	 */
! 	if (mapBlk >= rmAccess->physPagesInRevmap)
! 		extend = mmRevmapExtend(rmAccess, mapBlk);
  
  	/*
  	 * Obtain the buffer from which we need to read.  If we already have the
***************
*** 202,211 **** mmGetHeapBlockItemptr(mmRevmapAccess *rmAccess, BlockNumber heapBlk,
  
  	mapBlk = HEAPBLK_TO_REVMAP_BLK(rmAccess->pagesPerRange, heapBlk);
  
! 	if (mapBlk > rmAccess->physPagesInRevmap)
  	{
! 		ItemPointerSetInvalid(out);
! 		return;
  	}
  
  	if (rmAccess->currBuf == InvalidBuffer ||
--- 201,229 ----
  
  	mapBlk = HEAPBLK_TO_REVMAP_BLK(rmAccess->pagesPerRange, heapBlk);
  
! 	/*
! 	 * If we are asked for a block of the map which is beyond what we know
! 	 * about it, try to see if our fork has grown since we last checked its
! 	 * size; a concurrent inserter could have extended it.
! 	 */
! 	if (mapBlk >= rmAccess->physPagesInRevmap)
  	{
! 		RelationOpenSmgr(rmAccess->idxrel);
! 		LockRelationForExtension(rmAccess->idxrel, ShareLock);
! 		rmAccess->physPagesInRevmap =
! 			smgrnblocks(rmAccess->idxrel->rd_smgr, MM_REVMAP_FORKNUM);
! 
! 		if (mapBlk >= rmAccess->physPagesInRevmap)
! 		{
! 			/* definitely not in range */
! 
! 			UnlockRelationForExtension(rmAccess->idxrel, ShareLock);
! 			ItemPointerSetInvalid(out);
! 			return;
! 		}
! 
! 		/* the block exists now, proceed */
! 		UnlockRelationForExtension(rmAccess->idxrel, ShareLock);
  	}
  
  	if (rmAccess->currBuf == InvalidBuffer ||
***************
*** 273,286 **** mmRevmapCreate(Relation idxrel)
  }
  
  /*
!  * Extend the reverse range map to cover the given block number.
   *
   * NB -- caller is responsible for ensuring this action is properly WAL-logged.
   */
! static void
  mmRevmapExtend(mmRevmapAccess *rmAccess, BlockNumber blkno)
  {
  	char		page[BLCKSZ];
  
  	MemSet(page, 0, sizeof(page));
  	PageInit(page, BLCKSZ, 0);
--- 291,307 ----
  }
  
  /*
!  * Extend the reverse range map to cover the given block number.  Return false
!  * if the map already covered the requested range (no extension actually done),
!  * true otherwise.
   *
   * NB -- caller is responsible for ensuring this action is properly WAL-logged.
   */
! static bool
  mmRevmapExtend(mmRevmapAccess *rmAccess, BlockNumber blkno)
  {
  	char		page[BLCKSZ];
+ 	bool		extended = false;
  
  	MemSet(page, 0, sizeof(page));
  	PageInit(page, BLCKSZ, 0);
***************
*** 291,316 **** mmRevmapExtend(mmRevmapAccess *rmAccess, BlockNumber blkno)
  	 * first, refresh our idea of the current size; it might well have grown
  	 * up to what we need since we last checked.
  	 */
  	rmAccess->physPagesInRevmap =
! 		RelationGetNumberOfBlocksInFork(rmAccess->idxrel,
! 										MM_REVMAP_FORKNUM);
  
  	/*
  	 * Now extend it one page at a time.  This might seem a bit inefficient,
  	 * but normally we'd be extending for a single page anyway.
  	 */
! 	while (blkno > rmAccess->physPagesInRevmap - 1)
  	{
  		smgrextend(rmAccess->idxrel->rd_smgr, MM_REVMAP_FORKNUM,
  				   rmAccess->physPagesInRevmap, page, false);
  		rmAccess->physPagesInRevmap++;
  	}
  
  	Assert(rmAccess->physPagesInRevmap ==
! 		   RelationGetNumberOfBlocksInFork(rmAccess->idxrel,
! 										   MM_REVMAP_FORKNUM));
  
  	UnlockRelationForExtension(rmAccess->idxrel, ExclusiveLock);
  }
  
  /*
--- 312,339 ----
  	 * first, refresh our idea of the current size; it might well have grown
  	 * up to what we need since we last checked.
  	 */
+ 	RelationOpenSmgr(rmAccess->idxrel);
  	rmAccess->physPagesInRevmap =
! 		smgrnblocks(rmAccess->idxrel->rd_smgr, MM_REVMAP_FORKNUM);
  
  	/*
  	 * Now extend it one page at a time.  This might seem a bit inefficient,
  	 * but normally we'd be extending for a single page anyway.
  	 */
! 	while (blkno >= rmAccess->physPagesInRevmap)
  	{
+ 		extended = true;
  		smgrextend(rmAccess->idxrel->rd_smgr, MM_REVMAP_FORKNUM,
  				   rmAccess->physPagesInRevmap, page, false);
  		rmAccess->physPagesInRevmap++;
  	}
  
  	Assert(rmAccess->physPagesInRevmap ==
! 		   smgrnblocks(rmAccess->idxrel->rd_smgr, MM_REVMAP_FORKNUM));
  
  	UnlockRelationForExtension(rmAccess->idxrel, ExclusiveLock);
+ 
+ 	return extended;
  }
  
  /*