#include "storage/block.h"
#include "storage/relfilenode.h"
#include "utils/relcache.h"

Include dependency graph for freespace.h:

This graph shows which files directly or indirectly include this file:

Functions
Size	GetRecordedFreeSpace (Relation rel, BlockNumber heapBlk)

BlockNumber	GetPageWithFreeSpace (Relation rel, Size spaceNeeded)

BlockNumber	RecordAndGetPageWithFreeSpace (Relation rel, BlockNumber oldPage, Size oldSpaceAvail, Size spaceNeeded)

void	RecordPageWithFreeSpace (Relation rel, BlockNumber heapBlk, Size spaceAvail)

void	XLogRecordPageWithFreeSpace (RelFileNode rnode, BlockNumber heapBlk, Size spaceAvail)

BlockNumber	FreeSpaceMapPrepareTruncateRel (Relation rel, BlockNumber nblocks)

void	FreeSpaceMapVacuum (Relation rel)

void	FreeSpaceMapVacuumRange (Relation rel, BlockNumber start, BlockNumber end)

Function Documentation

◆ FreeSpaceMapPrepareTruncateRel()

BlockNumber FreeSpaceMapPrepareTruncateRel	(	Relation	rel,
		BlockNumber	nblocks
	)

Definition at line 263 of file freespace.c.

 {
     BlockNumber new_nfsmblocks;
     FSMAddress  first_removed_address;
     uint16      first_removed_slot;
     Buffer      buf;
  
     /*
      * If no FSM has been created yet for this relation, there's nothing to
      * truncate.
      */
     if (!smgrexists(RelationGetSmgr(rel), FSM_FORKNUM))
         return InvalidBlockNumber;
  
     /* Get the location in the FSM of the first removed heap block */
     first_removed_address = fsm_get_location(nblocks, &first_removed_slot);
  
     /*
      * Zero out the tail of the last remaining FSM page. If the slot
      * representing the first removed heap block is at a page boundary, as the
      * first slot on the FSM page that first_removed_address points to, we can
      * just truncate that page altogether.
      */
     if (first_removed_slot > 0)
     {
         buf = fsm_readbuf(rel, first_removed_address, false);
         if (!BufferIsValid(buf))
             return InvalidBlockNumber;  /* nothing to do; the FSM was already
                                          * smaller */
         LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
  
         /* NO EREPORT(ERROR) from here till changes are logged */
         START_CRIT_SECTION();
  
         fsm_truncate_avail(BufferGetPage(buf), first_removed_slot);
  
         /*
          * Truncation of a relation is WAL-logged at a higher-level, and we
          * will be called at WAL replay. But if checksums are enabled, we need
          * to still write a WAL record to protect against a torn page, if the
          * page is flushed to disk before the truncation WAL record. We cannot
          * use MarkBufferDirtyHint here, because that will not dirty the page
          * during recovery.
          */
         MarkBufferDirty(buf);
         if (!InRecovery && RelationNeedsWAL(rel) && XLogHintBitIsNeeded())
             log_newpage_buffer(buf, false);
  
         END_CRIT_SECTION();
  
         UnlockReleaseBuffer(buf);
  
         new_nfsmblocks = fsm_logical_to_physical(first_removed_address) + 1;
     }
     else
     {
         new_nfsmblocks = fsm_logical_to_physical(first_removed_address);
         if (smgrnblocks(RelationGetSmgr(rel), FSM_FORKNUM) <= new_nfsmblocks)
             return InvalidBlockNumber;  /* nothing to do; the FSM was already
                                          * smaller */
     }
  
     return new_nfsmblocks;
 }

References buf, BUFFER_LOCK_EXCLUSIVE, BufferGetPage, BufferIsValid, END_CRIT_SECTION, FSM_FORKNUM, fsm_get_location(), fsm_logical_to_physical(), fsm_readbuf(), fsm_truncate_avail(), InRecovery, InvalidBlockNumber, LockBuffer(), log_newpage_buffer(), MarkBufferDirty(), RelationGetSmgr(), RelationNeedsWAL, smgrexists(), smgrnblocks(), START_CRIT_SECTION, UnlockReleaseBuffer(), and XLogHintBitIsNeeded.

Referenced by RelationTruncate(), and smgr_redo().

◆ FreeSpaceMapVacuum()

void FreeSpaceMapVacuum ( Relation rel )

Definition at line 335 of file freespace.c.

 {
     bool        dummy;
  
     /* Recursively scan the tree, starting at the root */
     (void) fsm_vacuum_page(rel, FSM_ROOT_ADDRESS,
                            (BlockNumber) 0, InvalidBlockNumber,
                            &dummy);
 }

References FSM_ROOT_ADDRESS, fsm_vacuum_page(), and InvalidBlockNumber.

Referenced by brin_vacuum_scan(), and IndexFreeSpaceMapVacuum().

◆ FreeSpaceMapVacuumRange()

void FreeSpaceMapVacuumRange	(	Relation	rel,
		BlockNumber	start,
		BlockNumber	end
	)

Definition at line 354 of file freespace.c.

 {
     bool        dummy;
  
     /* Recursively scan the tree, starting at the root */
     if (end > start)
         (void) fsm_vacuum_page(rel, FSM_ROOT_ADDRESS, start, end, &dummy);
 }

References FSM_ROOT_ADDRESS, and fsm_vacuum_page().

Referenced by brin_doinsert(), brin_doupdate(), brin_getinsertbuffer(), lazy_scan_heap(), RelationAddExtraBlocks(), RelationTruncate(), smgr_redo(), and terminate_brin_buildstate().

◆ GetPageWithFreeSpace()

BlockNumber GetPageWithFreeSpace	(	Relation	rel,
		Size	spaceNeeded
	)

Definition at line 133 of file freespace.c.

 {
     uint8       min_cat = fsm_space_needed_to_cat(spaceNeeded);
  
     return fsm_search(rel, min_cat);
 }

References fsm_search(), and fsm_space_needed_to_cat().

Referenced by brin_getinsertbuffer(), GetFreeIndexPage(), and RelationGetBufferForTuple().

◆ GetRecordedFreeSpace()

Size GetRecordedFreeSpace	(	Relation	rel,
		BlockNumber	heapBlk
	)

Definition at line 232 of file freespace.c.

 {
     FSMAddress  addr;
     uint16      slot;
     Buffer      buf;
     uint8       cat;
  
     /* Get the location of the FSM byte representing the heap block */
     addr = fsm_get_location(heapBlk, &slot);
  
     buf = fsm_readbuf(rel, addr, false);
     if (!BufferIsValid(buf))
         return 0;
     cat = fsm_get_avail(BufferGetPage(buf), slot);
     ReleaseBuffer(buf);
  
     return fsm_space_cat_to_avail(cat);
 }

References buf, BufferGetPage, BufferIsValid, fsm_get_avail(), fsm_get_location(), fsm_readbuf(), fsm_space_cat_to_avail(), and ReleaseBuffer().

Referenced by lazy_scan_new_or_empty(), pg_freespace(), and statapprox_heap().

◆ RecordAndGetPageWithFreeSpace()

BlockNumber RecordAndGetPageWithFreeSpace	(	Relation	rel,
		BlockNumber	oldPage,
		Size	oldSpaceAvail,
		Size	spaceNeeded
	)

Definition at line 150 of file freespace.c.

 {
     int         old_cat = fsm_space_avail_to_cat(oldSpaceAvail);
     int         search_cat = fsm_space_needed_to_cat(spaceNeeded);
     FSMAddress  addr;
     uint16      slot;
     int         search_slot;
  
     /* Get the location of the FSM byte representing the heap block */
     addr = fsm_get_location(oldPage, &slot);
  
     search_slot = fsm_set_and_search(rel, addr, slot, old_cat, search_cat);
  
     /*
      * If fsm_set_and_search found a suitable new block, return that.
      * Otherwise, search as usual.
      */
     if (search_slot != -1)
         return fsm_get_heap_blk(addr, search_slot);
     else
         return fsm_search(rel, search_cat);
 }

References fsm_get_heap_blk(), fsm_get_location(), fsm_search(), fsm_set_and_search(), fsm_space_avail_to_cat(), and fsm_space_needed_to_cat().

Referenced by brin_getinsertbuffer(), and RelationGetBufferForTuple().

◆ RecordPageWithFreeSpace()

void RecordPageWithFreeSpace	(	Relation	rel,
		BlockNumber	heapBlk,
		Size	spaceAvail
	)

Definition at line 182 of file freespace.c.

 {
     int         new_cat = fsm_space_avail_to_cat(spaceAvail);
     FSMAddress  addr;
     uint16      slot;
  
     /* Get the location of the FSM byte representing the heap block */
     addr = fsm_get_location(heapBlk, &slot);
  
     fsm_set_and_search(rel, addr, slot, new_cat, 0);
 }

References fsm_get_location(), fsm_set_and_search(), and fsm_space_avail_to_cat().

Referenced by brin_doinsert(), brin_doupdate(), brin_initialize_empty_new_buffer(), brin_page_cleanup(), lazy_scan_heap(), lazy_scan_new_or_empty(), lazy_vacuum_heap_rel(), RecordFreeIndexPage(), RecordUsedIndexPage(), RelationAddExtraBlocks(), and terminate_brin_buildstate().

◆ XLogRecordPageWithFreeSpace()

void XLogRecordPageWithFreeSpace	(	RelFileNode	rnode,
		BlockNumber	heapBlk,
		Size	spaceAvail
	)

Definition at line 199 of file freespace.c.

 {
     int         new_cat = fsm_space_avail_to_cat(spaceAvail);
     FSMAddress  addr;
     uint16      slot;
     BlockNumber blkno;
     Buffer      buf;
     Page        page;
  
     /* Get the location of the FSM byte representing the heap block */
     addr = fsm_get_location(heapBlk, &slot);
     blkno = fsm_logical_to_physical(addr);
  
     /* If the page doesn't exist already, extend */
     buf = XLogReadBufferExtended(rnode, FSM_FORKNUM, blkno, RBM_ZERO_ON_ERROR,
                                  InvalidBuffer);
     LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
  
     page = BufferGetPage(buf);
     if (PageIsNew(page))
         PageInit(page, BLCKSZ, 0);
  
     if (fsm_set_avail(page, slot, new_cat))
         MarkBufferDirtyHint(buf, false);
     UnlockReleaseBuffer(buf);
 }

References buf, BUFFER_LOCK_EXCLUSIVE, BufferGetPage, FSM_FORKNUM, fsm_get_location(), fsm_logical_to_physical(), fsm_set_avail(), fsm_space_avail_to_cat(), InvalidBuffer, LockBuffer(), MarkBufferDirtyHint(), PageInit(), PageIsNew, RBM_ZERO_ON_ERROR, UnlockReleaseBuffer(), and XLogReadBufferExtended().

Referenced by heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_prune(), heap_xlog_update(), heap_xlog_vacuum(), and heap_xlog_visible().

Functions