#include "access/xlogdefs.h"
#include "storage/block.h"
#include "storage/item.h"
#include "storage/off.h"

Include dependency graph for bufpage.h:

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

Data Structures
struct	PageXLogRecPtr

struct	PageHeaderData

Macros
#define	PageXLogRecPtrGet(val) ((uint64) (val).xlogid << 32 \| (val).xrecoff)

#define	PageXLogRecPtrSet(ptr, lsn) ((ptr).xlogid = (uint32) ((lsn) >> 32), (ptr).xrecoff = (uint32) (lsn))

#define	PD_HAS_FREE_LINES 0x0001 /* are there any unused line pointers? */

#define	PD_PAGE_FULL 0x0002 /* not enough free space for new tuple? */

#define	PD_ALL_VISIBLE

#define	PD_VALID_FLAG_BITS 0x0007 /* OR of all valid pd_flags bits */

#define	PG_PAGE_LAYOUT_VERSION 4

#define	PG_DATA_CHECKSUM_VERSION 1

#define	PageIsValid(page) PointerIsValid(page)

#define	SizeOfPageHeaderData (offsetof(PageHeaderData, pd_linp))

#define	PageIsEmpty(page) (((PageHeader) (page))->pd_lower <= SizeOfPageHeaderData)

#define	PageIsNew(page) (((PageHeader) (page))->pd_upper == 0)

#define	PageGetItemId(page, offsetNumber) ((ItemId) (&((PageHeader) (page))->pd_linp[(offsetNumber) - 1]))

#define	PageGetContents(page) ((char *) (page) + MAXALIGN(SizeOfPageHeaderData))

#define	PageSizeIsValid(pageSize) ((pageSize) == BLCKSZ)

#define	PageGetPageSize(page) ((Size) (((PageHeader) (page))->pd_pagesize_version & (uint16) 0xFF00))

#define	PageGetPageLayoutVersion(page) (((PageHeader) (page))->pd_pagesize_version & 0x00FF)

#define	PageSetPageSizeAndVersion(page, size, version)

#define	PageGetSpecialSize(page) ((uint16) (PageGetPageSize(page) - ((PageHeader)(page))->pd_special))

#define	PageGetSpecialPointer(page)

#define	PageGetItem(page, itemId)

#define	PageGetMaxOffsetNumber(page)

#define	PageGetLSN(page) PageXLogRecPtrGet(((PageHeader) (page))->pd_lsn)

#define	PageSetLSN(page, lsn) PageXLogRecPtrSet(((PageHeader) (page))->pd_lsn, lsn)

#define	PageHasFreeLinePointers(page) (((PageHeader) (page))->pd_flags & PD_HAS_FREE_LINES)

#define	PageSetHasFreeLinePointers(page) (((PageHeader) (page))->pd_flags \|= PD_HAS_FREE_LINES)

#define	PageClearHasFreeLinePointers(page) (((PageHeader) (page))->pd_flags &= ~PD_HAS_FREE_LINES)

#define	PageIsFull(page) (((PageHeader) (page))->pd_flags & PD_PAGE_FULL)

#define	PageSetFull(page) (((PageHeader) (page))->pd_flags \|= PD_PAGE_FULL)

#define	PageClearFull(page) (((PageHeader) (page))->pd_flags &= ~PD_PAGE_FULL)

#define	PageIsAllVisible(page) (((PageHeader) (page))->pd_flags & PD_ALL_VISIBLE)

#define	PageSetAllVisible(page) (((PageHeader) (page))->pd_flags \|= PD_ALL_VISIBLE)

#define	PageClearAllVisible(page) (((PageHeader) (page))->pd_flags &= ~PD_ALL_VISIBLE)

#define	PageIsPrunable(page, oldestxmin)

#define	PageSetPrunable(page, xid)

#define	PageClearPrunable(page) (((PageHeader) (page))->pd_prune_xid = InvalidTransactionId)

#define	PAI_OVERWRITE (1 << 0)

#define	PAI_IS_HEAP (1 << 1)

#define	PageAddItem(page, item, size, offsetNumber, overwrite, is_heap)

Typedefs
typedef Pointer	Page

typedef uint16	LocationIndex

typedef struct PageHeaderData	PageHeaderData

typedef PageHeaderData *	PageHeader

Functions
static bool	PageValidateSpecialPointer (Page page)

	StaticAssertDecl (BLCKSZ==((BLCKSZ/sizeof(size_t)) *sizeof(size_t)), "BLCKSZ has to be a multiple of sizeof(size_t)")

void	PageInit (Page page, Size pageSize, Size specialSize)

bool	PageIsVerified (Page page, BlockNumber blkno)

OffsetNumber	PageAddItemExtended (Page page, Item item, Size size, OffsetNumber offsetNumber, int flags)

Page	PageGetTempPage (Page page)

Page	PageGetTempPageCopy (Page page)

Page	PageGetTempPageCopySpecial (Page page)

void	PageRestoreTempPage (Page tempPage, Page oldPage)

void	PageRepairFragmentation (Page page)

Size	PageGetFreeSpace (Page page)

Size	PageGetFreeSpaceForMultipleTuples (Page page, int ntups)

Size	PageGetExactFreeSpace (Page page)

Size	PageGetHeapFreeSpace (Page page)

void	PageIndexTupleDelete (Page page, OffsetNumber offset)

void	PageIndexMultiDelete (Page page, OffsetNumber *itemnos, int nitems)

void	PageIndexTupleDeleteNoCompact (Page page, OffsetNumber offset)

bool	PageIndexTupleOverwrite (Page page, OffsetNumber offnum, Item newtup, Size newsize)

char *	PageSetChecksumCopy (Page page, BlockNumber blkno)

void	PageSetChecksumInplace (Page page, BlockNumber blkno)

Macro Definition Documentation

◆ PageAddItem

#define PageAddItem	(	page,
		item,
		size,
		offsetNumber,
		overwrite,
		is_heap
	)

Value:

PageAddItemExtended(page, item, size, offsetNumber, \
                        ((overwrite) ? PAI_OVERWRITE : 0) | \
                        ((is_heap) ? PAI_IS_HEAP : 0))

Definition at line 416 of file bufpage.h.

Referenced by _bt_dedup_finish_pending(), _bt_dedup_one_page(), _bt_insertonpg(), _bt_newroot(), _bt_pgaddtup(), _bt_restore_page(), _bt_sortaddtup(), _bt_split(), _hash_pgaddmultitup(), _hash_pgaddtup(), addLeafTuple(), addOrReplaceTuple(), brin_doinsert(), brin_doupdate(), brin_xlog_insert_update(), btree_xlog_dedup(), btree_xlog_insert(), btree_xlog_mark_page_halfdead(), btree_xlog_split(), btree_xlog_unlink_page(), doPickSplit(), entryExecPlaceToPage(), entrySplitPage(), fill_seq_with_data(), ginEntryFillRoot(), ginHeapTupleFastInsert(), ginRedoInsertEntry(), ginRedoInsertListPage(), ginRedoUpdateMetapage(), ginVacuumEntryPage(), gistfillbuffer(), gistplacetopage(), gistRedoPageUpdateRecord(), hash_xlog_insert(), hash_xlog_move_page_contents(), hash_xlog_squeeze_page(), heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_update(), raw_heap_insert(), RelationPutHeapTuple(), seq_redo(), spgAddNodeAction(), SpGistPageAddNewItem(), spgPageIndexMultiDelete(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoSplitTuple(), spgSplitNodeAction(), and writeListPage().

◆ PageClearAllVisible

#define PageClearAllVisible ( page ) (((PageHeader) (page))->pd_flags &= ~PD_ALL_VISIBLE)

Definition at line 389 of file bufpage.h.

Referenced by heap_delete(), heap_insert(), heap_multi_insert(), heap_update(), heap_xlog_delete(), heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_update(), lazy_scan_heap(), and mask_page_hint_bits().

◆ PageClearFull

#define PageClearFull ( page ) (((PageHeader) (page))->pd_flags &= ~PD_PAGE_FULL)

Definition at line 382 of file bufpage.h.

Referenced by heap_page_prune(), and mask_page_hint_bits().

◆ PageClearHasFreeLinePointers

#define PageClearHasFreeLinePointers ( page ) (((PageHeader) (page))->pd_flags &= ~PD_HAS_FREE_LINES)

Definition at line 375 of file bufpage.h.

Referenced by mask_page_hint_bits(), PageAddItemExtended(), and PageRepairFragmentation().

◆ PageClearPrunable

#define PageClearPrunable ( page ) (((PageHeader) (page))->pd_prune_xid = InvalidTransactionId)

Definition at line 405 of file bufpage.h.

◆ PageGetContents

#define PageGetContents ( page ) ((char *) (page) + MAXALIGN(SizeOfPageHeaderData))

◆ PageGetItem

#define PageGetItem	(	page,
		itemId
	)

Value:

( \
    AssertMacro(PageIsValid(page)), \
    AssertMacro(ItemIdHasStorage(itemId)), \
    (Item)(((char *)(page)) + ItemIdGetOffset(itemId)) \
)

Definition at line 340 of file bufpage.h.

Referenced by _bt_afternewitemoff(), _bt_binsrch_posting(), _bt_buildadd(), _bt_check_natts(), _bt_check_unique(), _bt_compare(), _bt_dedup_one_page(), _bt_do_singleval(), _bt_get_endpoint(), _bt_getstackbuf(), _bt_insert_parent(), _bt_insertonpg(), _bt_killitems(), _bt_mark_page_halfdead(), _bt_newroot(), _bt_pagedel(), _bt_readpage(), _bt_recsplitloc(), _bt_search(), _bt_split(), _bt_split_firstright(), _bt_split_lastleft(), _bt_strategy(), _bt_unlink_halfdead_page(), _bt_xid_horizon(), _hash_binsearch(), _hash_binsearch_last(), _hash_finish_split(), _hash_kill_items(), _hash_load_qualified_items(), _hash_splitbucket(), _hash_squeezebucket(), addLeafTuple(), addOrReplaceTuple(), brin_doupdate(), brin_evacuate_page(), brin_page_items(), brinGetTupleForHeapBlock(), brinRevmapDesummarizeRange(), bt_check_level_from_leftmost(), bt_child_check(), bt_child_highkey_check(), bt_downlink_missing_check(), bt_page_print_tuples(), bt_right_page_check_scankey(), bt_target_page_check(), btree_xlog_dedup(), btree_xlog_insert(), btree_xlog_mark_page_halfdead(), btree_xlog_split(), btree_xlog_vacuum(), btvacuumpage(), checkSplitConditions(), collect_corrupt_items(), collectMatchBitmap(), collectMatchesForHeapRow(), doPickSplit(), entryFindChildPtr(), entryGetLeftMostPage(), entryIsEnoughSpace(), entryLocateEntry(), entryLocateLeafEntry(), entryPreparePage(), entrySplitPage(), GetBTPageStatistics(), getRightMostTuple(), ginbulkdelete(), ginEntryInsert(), ginRedoInsertEntry(), ginVacuumEntryPage(), gistBufferingFindCorrectParent(), gistbufferinginserttuples(), gistchoose(), gistdeletepage(), gistdoinsert(), gistextractpage(), gistFindCorrectParent(), gistFindPath(), gistformdownlink(), gistGetMaxLevel(), gistMemorizeAllDownlinks(), gistnospace(), gistProcessItup(), gistScanPage(), gistvacuum_delete_empty_pages(), gistvacuumpage(), hash_page_items(), hashbucketcleanup(), heap_abort_speculative(), heap_compute_xid_horizon_for_tuples(), heap_delete(), heap_fetch(), heap_finish_speculative(), heap_get_latest_tid(), heap_get_root_tuples(), heap_hot_search_buffer(), heap_inplace_update(), heap_lock_tuple(), heap_page_is_all_visible(), heap_page_items(), heap_prune_chain(), heap_update(), heap_xlog_confirm(), heap_xlog_delete(), heap_xlog_freeze_page(), heap_xlog_inplace(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_update(), heapam_scan_analyze_next_tuple(), heapam_scan_bitmap_next_block(), heapam_scan_bitmap_next_tuple(), heapam_scan_sample_next_tuple(), heapgetpage(), heapgettup(), heapgettup_pagemode(), index_compute_xid_horizon_for_tuples(), invariant_l_nontarget_offset(), invariant_l_offset(), lazy_check_needs_freeze(), lazy_scan_heap(), matchPartialInPendingList(), moveLeafs(), PageIndexTupleOverwrite(), processPendingPage(), raw_heap_insert(), read_seq_tuple(), RelationPutHeapTuple(), saveNodeLink(), scanGetCandidate(), setRedirectionTuple(), spgdoinsert(), SpGistPageAddNewItem(), spgprocesspending(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoMoveLeafs(), spgRedoPickSplit(), spgRedoVacuumLeaf(), spgRedoVacuumRedirect(), spgSplitNodeAction(), spgTestLeafTuple(), spgWalk(), startScanEntry(), statapprox_heap(), vacuumLeafPage(), vacuumLeafRoot(), and vacuumRedirectAndPlaceholder().

◆ PageGetItemId

#define PageGetItemId	(	page,
		offsetNumber
	)	((ItemId) (&((PageHeader) (page))->pd_linp[(offsetNumber) - 1]))

Definition at line 235 of file bufpage.h.

Referenced by _bt_afternewitemoff(), _bt_binsrch_posting(), _bt_buildadd(), _bt_check_natts(), _bt_check_unique(), _bt_compare(), _bt_dedup_one_page(), _bt_do_singleval(), _bt_findsplitloc(), _bt_get_endpoint(), _bt_getstackbuf(), _bt_insert_parent(), _bt_insertonpg(), _bt_killitems(), _bt_mark_page_halfdead(), _bt_newroot(), _bt_pagedel(), _bt_readpage(), _bt_recsplitloc(), _bt_search(), _bt_slideleft(), _bt_split(), _bt_split_firstright(), _bt_split_lastleft(), _bt_split_penalty(), _bt_strategy(), _bt_unlink_halfdead_page(), _bt_vacuum_one_page(), _bt_xid_horizon(), _hash_binsearch(), _hash_binsearch_last(), _hash_finish_split(), _hash_kill_items(), _hash_load_qualified_items(), _hash_splitbucket(), _hash_squeezebucket(), _hash_vacuum_one_page(), addLeafTuple(), addOrReplaceTuple(), brin_doupdate(), brin_evacuate_page(), brin_page_items(), brin_start_evacuating_page(), brinGetTupleForHeapBlock(), brininsert(), brinRevmapDesummarizeRange(), bt_page_print_tuples(), btree_xlog_dedup(), btree_xlog_insert(), btree_xlog_mark_page_halfdead(), btree_xlog_split(), btree_xlog_vacuum(), btvacuumpage(), checkSplitConditions(), collect_corrupt_items(), collectMatchBitmap(), collectMatchesForHeapRow(), compactify_tuples(), count_nondeletable_pages(), doPickSplit(), entryFindChildPtr(), entryGetLeftMostPage(), entryIsEnoughSpace(), entryLocateEntry(), entryLocateLeafEntry(), entryPreparePage(), entrySplitPage(), GetBTPageStatistics(), GetHashPageStatistics(), GetHashPageStats(), getRightMostTuple(), ginbulkdelete(), ginEntryInsert(), ginRedoInsertEntry(), ginVacuumEntryPage(), gistBufferingFindCorrectParent(), gistbufferinginserttuples(), gistchoose(), gistdeletepage(), gistdoinsert(), gistextractpage(), gistFindCorrectParent(), gistFindPath(), gistformdownlink(), gistGetMaxLevel(), gistkillitems(), gistMemorizeAllDownlinks(), gistnospace(), gistProcessItup(), gistprunepage(), gistScanPage(), gistvacuum_delete_empty_pages(), gistvacuumpage(), hash_page_items(), hashbucketcleanup(), heap_abort_speculative(), heap_compute_xid_horizon_for_tuples(), heap_delete(), heap_fetch(), heap_finish_speculative(), heap_get_latest_tid(), heap_get_root_tuples(), heap_hot_search_buffer(), heap_inplace_update(), heap_lock_tuple(), heap_mask(), heap_page_is_all_visible(), heap_page_items(), heap_page_prune(), heap_page_prune_execute(), heap_prune_chain(), heap_update(), heap_xlog_confirm(), heap_xlog_delete(), heap_xlog_freeze_page(), heap_xlog_inplace(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_update(), heapam_scan_analyze_next_tuple(), heapam_scan_bitmap_next_block(), heapam_scan_bitmap_next_tuple(), heapam_scan_sample_next_tuple(), heapgetpage(), heapgettup(), heapgettup_pagemode(), index_compute_xid_horizon_for_tuples(), lazy_check_needs_freeze(), lazy_scan_heap(), lazy_vacuum_page(), mask_lp_flags(), matchPartialInPendingList(), moveLeafs(), PageAddItemExtended(), PageGetHeapFreeSpace(), PageGetItemIdCareful(), PageIndexMultiDelete(), PageIndexTupleDelete(), PageIndexTupleDeleteNoCompact(), PageIndexTupleOverwrite(), PageRepairFragmentation(), pgstat_index_page(), processPendingPage(), raw_heap_insert(), read_seq_tuple(), RelationPutHeapTuple(), saveNodeLink(), scanGetCandidate(), setRedirectionTuple(), spgdoinsert(), SpGistPageAddNewItem(), spgprocesspending(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoMoveLeafs(), spgRedoPickSplit(), spgRedoVacuumLeaf(), spgRedoVacuumRedirect(), spgSplitNodeAction(), spgTestLeafTuple(), spgWalk(), startScanEntry(), statapprox_heap(), vacuumLeafPage(), vacuumLeafRoot(), and vacuumRedirectAndPlaceholder().

◆ PageGetLSN

#define PageGetLSN ( page ) PageXLogRecPtrGet(((PageHeader) (page))->pd_lsn)

Definition at line 366 of file bufpage.h.

Referenced by _bt_dedup_one_page(), _bt_split(), bt_check_level_from_leftmost(), bt_downlink_missing_check(), BufferGetLSNAtomic(), checkXLogConsistency(), gistdoinsert(), gistFindCorrectParent(), heap_xlog_visible(), lazy_scan_heap(), nextval_internal(), page_header(), sendFile(), TestForOldSnapshot(), XLogCheckBufferNeedsBackup(), XLogReadBufferForRedoExtended(), and XLogRecordAssemble().

◆ PageGetMaxOffsetNumber

#define PageGetMaxOffsetNumber ( page )

Value:

(((PageHeader) (page))->pd_lower <= SizeOfPageHeaderData ? 0 : \
     ((((PageHeader) (page))->pd_lower - SizeOfPageHeaderData) \
      / sizeof(ItemIdData)))

Definition at line 357 of file bufpage.h.

Referenced by _bt_binsrch(), _bt_binsrch_insert(), _bt_check_natts(), _bt_check_unique(), _bt_dedup_finish_pending(), _bt_dedup_one_page(), _bt_do_singleval(), _bt_endpoint(), _bt_findinsertloc(), _bt_findsplitloc(), _bt_get_endpoint(), _bt_getstackbuf(), _bt_killitems(), _bt_lock_branch_parent(), _bt_mark_page_halfdead(), _bt_pagedel(), _bt_readnextpage(), _bt_readpage(), _bt_search_insert(), _bt_slideleft(), _bt_split(), _bt_unlink_halfdead_page(), _bt_vacuum_one_page(), _hash_binsearch(), _hash_binsearch_last(), _hash_finish_split(), _hash_kill_items(), _hash_load_qualified_items(), _hash_splitbucket(), _hash_squeezebucket(), _hash_vacuum_one_page(), addOrReplaceTuple(), brin_doupdate(), brin_evacuate_page(), brin_page_items(), brin_start_evacuating_page(), brin_xlog_insert_update(), brinGetTupleForHeapBlock(), brinRevmapDesummarizeRange(), bt_child_check(), bt_child_highkey_check(), bt_page_items(), bt_page_items_bytea(), bt_right_page_check_scankey(), bt_rootdescend(), bt_target_page_check(), btree_xlog_dedup(), btvacuumpage(), checkSplitConditions(), collect_corrupt_items(), count_nondeletable_pages(), doPickSplit(), entryFindChildPtr(), entryGetLeftMostPage(), entryLocateEntry(), entryLocateLeafEntry(), entrySplitPage(), GetBTPageStatistics(), GetHashPageStatistics(), GetHashPageStats(), getRightMostTuple(), ginbulkdelete(), ginHeapTupleFastInsert(), ginInsertCleanup(), ginRedoInsertEntry(), ginRedoUpdateMetapage(), ginvacuumcleanup(), ginVacuumEntryPage(), ginVacuumPostingTreeLeaves(), gistBufferingFindCorrectParent(), gistbufferinginserttuples(), gistchoose(), gistdeletepage(), gistextractpage(), gistfillbuffer(), gistFindCorrectParent(), gistFindPath(), gistformdownlink(), gistMemorizeAllDownlinks(), gistprunepage(), gistRedoPageUpdateRecord(), gistScanPage(), gistvacuum_delete_empty_pages(), gistvacuumpage(), hash_page_items(), hashbucketcleanup(), heap_fetch(), heap_finish_speculative(), heap_get_latest_tid(), heap_get_root_tuples(), heap_hot_search_buffer(), heap_inplace_update(), heap_insert(), heap_mask(), heap_multi_insert(), heap_page_is_all_visible(), heap_page_items(), heap_page_prune(), heap_prune_chain(), heap_xlog_confirm(), heap_xlog_delete(), heap_xlog_inplace(), heap_xlog_insert(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_multi_insert(), heap_xlog_update(), heapam_scan_analyze_next_tuple(), heapam_scan_bitmap_next_block(), heapam_scan_sample_next_tuple(), heapgetpage(), heapgettup(), lazy_check_needs_freeze(), lazy_scan_heap(), log_heap_update(), mask_lp_flags(), moveLeafs(), moveRightIfItNeeded(), PageAddItemExtended(), PageGetHeapFreeSpace(), PageIndexMultiDelete(), PageIndexTupleDelete(), PageIndexTupleDeleteNoCompact(), PageIndexTupleOverwrite(), PageRepairFragmentation(), palloc_btree_page(), pgstat_btree_page(), pgstat_gist_page(), pgstat_hash_page(), processPendingPage(), scanGetCandidate(), SpGistPageAddNewItem(), spgRedoVacuumRedirect(), spgWalk(), statapprox_heap(), vacuumLeafPage(), vacuumLeafRoot(), and vacuumRedirectAndPlaceholder().

◆ PageGetPageLayoutVersion

#define PageGetPageLayoutVersion ( page ) (((PageHeader) (page))->pd_pagesize_version & 0x00FF)

Definition at line 275 of file bufpage.h.

Referenced by page_header().

◆ PageGetPageSize

#define PageGetPageSize ( page ) ((Size) (((PageHeader) (page))->pd_pagesize_version & (uint16) 0xFF00))

Definition at line 268 of file bufpage.h.

Referenced by _bt_findsplitloc(), _bt_singleval_fillfactor(), dataSplitPageInternal(), entrySplitPage(), GetBTPageStatistics(), GetHashPageStatistics(), page_header(), PageGetTempPage(), PageGetTempPageCopy(), PageGetTempPageCopySpecial(), and PageRestoreTempPage().

◆ PageGetSpecialPointer

#define PageGetSpecialPointer ( page )

Value:

( \
    AssertMacro(PageValidateSpecialPointer(page)), \
    (char *) ((char *) (page) + ((PageHeader) (page))->pd_special) \
)

Definition at line 326 of file bufpage.h.

Referenced by _bt_binsrch(), _bt_binsrch_insert(), _bt_blnewpage(), _bt_buildadd(), _bt_check_natts(), _bt_check_third_page(), _bt_check_unique(), _bt_clear_incomplete_split(), _bt_compare(), _bt_dedup_one_page(), _bt_delitems_delete(), _bt_delitems_vacuum(), _bt_endpoint(), _bt_findinsertloc(), _bt_findsplitloc(), _bt_finish_split(), _bt_get_endpoint(), _bt_getbuf(), _bt_getmeta(), _bt_getroot(), _bt_getstackbuf(), _bt_gettrueroot(), _bt_initmetapage(), _bt_insert_parent(), _bt_insertonpg(), _bt_is_page_halfdead(), _bt_killitems(), _bt_lock_branch_parent(), _bt_mark_page_halfdead(), _bt_moveright(), _bt_newroot(), _bt_page_recyclable(), _bt_pagedel(), _bt_pgaddtup(), _bt_readnextpage(), _bt_readpage(), _bt_restore_meta(), _bt_search(), _bt_search_insert(), _bt_sortaddtup(), _bt_split(), _bt_stepright(), _bt_unlink_halfdead_page(), _bt_upgrademetapage(), _bt_uppershutdown(), _bt_vacuum_one_page(), _bt_walk_left(), _hash_addovflpage(), _hash_alloc_buckets(), _hash_checkpage(), _hash_doinsert(), _hash_expandtable(), _hash_finish_split(), _hash_first(), _hash_freeovflpage(), _hash_getbucketbuf_from_hashkey(), _hash_init_metabuffer(), _hash_initbitmapbuffer(), _hash_initbuf(), _hash_kill_items(), _hash_readnext(), _hash_readpage(), _hash_readprev(), _hash_splitbucket(), _hash_squeezebucket(), _hash_vacuum_one_page(), bt_check_level_from_leftmost(), bt_child_check(), bt_child_highkey_check(), bt_downlink_missing_check(), bt_page_items(), bt_page_items_bytea(), bt_right_page_check_scankey(), bt_target_page_check(), btree_mask(), btree_xlog_dedup(), btree_xlog_delete(), btree_xlog_mark_page_halfdead(), btree_xlog_newroot(), btree_xlog_split(), btree_xlog_unlink_page(), btree_xlog_vacuum(), btvacuumpage(), fill_seq_with_data(), GetBTPageStatistics(), GetHashPageStatistics(), gin_leafpage_items(), gin_metapage_info(), gin_page_opaque_info(), ginRedoRecompress(), hash_mask(), hash_page_type(), hash_xlog_add_ovfl_page(), hash_xlog_delete(), hash_xlog_split_allocate_page(), hash_xlog_split_cleanup(), hash_xlog_split_complete(), hash_xlog_squeeze_page(), hash_xlog_vacuum_one_page(), hashbucketcleanup(), hashbulkdelete(), invariant_l_nontarget_offset(), invariant_l_offset(), PageGetTempPageCopySpecial(), palloc_btree_page(), pgstat_btree_page(), pgstat_hash_page(), pgstathashindex(), pgstatindex_impl(), read_seq_tuple(), seq_redo(), and verify_hash_page().

◆ PageGetSpecialSize

#define PageGetSpecialSize ( page ) ((uint16) (PageGetPageSize(page) - ((PageHeader)(page))->pd_special))

Definition at line 300 of file bufpage.h.

Referenced by _bt_checkpage(), _hash_checkpage(), gin_leafpage_items(), gistcheckpage(), PageGetTempPageCopySpecial(), pgstat_hash_page(), pgstathashindex(), and verify_hash_page().

◆ PageHasFreeLinePointers

#define PageHasFreeLinePointers ( page ) (((PageHeader) (page))->pd_flags & PD_HAS_FREE_LINES)

Definition at line 371 of file bufpage.h.

Referenced by PageAddItemExtended(), and PageGetHeapFreeSpace().

◆ PageIsAllVisible

#define PageIsAllVisible ( page ) (((PageHeader) (page))->pd_flags & PD_ALL_VISIBLE)

Definition at line 385 of file bufpage.h.

Referenced by collect_visibility_data(), GetVisibilityMapPins(), heap_abort_speculative(), heap_delete(), heap_insert(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_multi_insert(), heap_update(), heapam_scan_sample_next_tuple(), heapgetpage(), lazy_scan_heap(), lazy_vacuum_page(), pg_visibility(), RelationGetBufferForTuple(), and visibilitymap_set().

◆ PageIsEmpty

#define PageIsEmpty ( page ) (((PageHeader) (page))->pd_lower <= SizeOfPageHeaderData)

Definition at line 222 of file bufpage.h.

Referenced by _bt_slideleft(), _hash_squeezebucket(), count_nondeletable_pages(), ginHeapTupleFastInsert(), ginRedoUpdateMetapage(), gistfillbuffer(), GistPageSetDeleted(), gistRedoPageUpdateRecord(), lazy_check_needs_freeze(), lazy_scan_heap(), PageIndexTupleDelete(), PageIndexTupleDeleteNoCompact(), SpGistGetBuffer(), SpGistNewBuffer(), spgvacuumpage(), and statapprox_heap().

◆ PageIsFull

#define PageIsFull ( page ) (((PageHeader) (page))->pd_flags & PD_PAGE_FULL)

Definition at line 378 of file bufpage.h.

Referenced by heap_page_prune(), heap_page_prune_opt(), and heap_update().

◆ PageIsNew

#define PageIsNew ( page ) (((PageHeader) (page))->pd_upper == 0)

Definition at line 229 of file bufpage.h.

Referenced by _bt_checkpage(), _bt_getbuf(), _bt_page_recyclable(), _hash_checkpage(), blbulkdelete(), blgetbitmap(), blinsert(), BloomNewBuffer(), BloomPageAddItem(), blvacuumcleanup(), brin_page_cleanup(), brin_start_evacuating_page(), btvacuumpage(), count_nondeletable_pages(), fsm_readbuf(), gistcheckpage(), gistdeletepage(), gistNewBuffer(), gistPageRecyclable(), gistvacuum_delete_empty_pages(), hash_page_type(), heap_xlog_visible(), lazy_check_needs_freeze(), lazy_scan_heap(), log_newpage(), log_newpage_range(), PageIsVerified(), PageSetChecksumCopy(), PageSetChecksumInplace(), pg_checksum_page(), pgstat_btree_page(), pgstathashindex(), ReadBuffer_common(), RelationAddExtraBlocks(), RelationGetBufferForTuple(), revmap_physical_extend(), scan_file(), sendFile(), SpGistGetBuffer(), SpGistNewBuffer(), spgprocesspending(), spgvacuumpage(), statapprox_heap(), verify_hash_page(), vm_readbuf(), XLogReadBufferExtended(), XLogReadBufferForRedoExtended(), and XLogRecordPageWithFreeSpace().

◆ PageIsPrunable

#define PageIsPrunable	(	page,
		oldestxmin
	)

Value:

( \
    AssertMacro(TransactionIdIsNormal(oldestxmin)), \
    TransactionIdIsValid(((PageHeader) (page))->pd_prune_xid) && \
    TransactionIdPrecedes(((PageHeader) (page))->pd_prune_xid, oldestxmin) \
)

Definition at line 392 of file bufpage.h.

Referenced by heap_page_prune_opt().

◆ PageIsValid

#define PageIsValid ( page ) PointerIsValid(page)

Definition at line 211 of file bufpage.h.

Referenced by PageValidateSpecialPointer().

◆ PageSetAllVisible

#define PageSetAllVisible ( page ) (((PageHeader) (page))->pd_flags |= PD_ALL_VISIBLE)

Definition at line 387 of file bufpage.h.

Referenced by heap_xlog_visible(), lazy_scan_heap(), and lazy_vacuum_page().

◆ PageSetFull

#define PageSetFull ( page ) (((PageHeader) (page))->pd_flags |= PD_PAGE_FULL)

Definition at line 380 of file bufpage.h.

Referenced by heap_update().

◆ PageSetHasFreeLinePointers

#define PageSetHasFreeLinePointers ( page ) (((PageHeader) (page))->pd_flags |= PD_HAS_FREE_LINES)

Definition at line 373 of file bufpage.h.

Referenced by PageRepairFragmentation().

◆ PageSetLSN

#define PageSetLSN	(	page,
		lsn
	)	PageXLogRecPtrSet(((PageHeader) (page))->pd_lsn, lsn)

Definition at line 368 of file bufpage.h.

Referenced by _bt_clear_incomplete_split(), _bt_dedup_one_page(), _bt_delitems_delete(), _bt_delitems_vacuum(), _bt_getroot(), _bt_insertonpg(), _bt_mark_page_halfdead(), _bt_newroot(), _bt_restore_meta(), _bt_split(), _bt_unlink_halfdead_page(), _bt_update_meta_cleanup_info(), _hash_addovflpage(), _hash_doinsert(), _hash_expandtable(), _hash_freeovflpage(), _hash_init(), _hash_splitbucket(), _hash_squeezebucket(), _hash_vacuum_one_page(), addLeafTuple(), brin_doinsert(), brin_doupdate(), brin_xlog_createidx(), brin_xlog_desummarize_page(), brin_xlog_insert_update(), brin_xlog_revmap_extend(), brin_xlog_samepage_update(), brin_xlog_update(), brinbuild(), brinRevmapDesummarizeRange(), btree_xlog_dedup(), btree_xlog_delete(), btree_xlog_insert(), btree_xlog_mark_page_halfdead(), btree_xlog_newroot(), btree_xlog_split(), btree_xlog_unlink_page(), btree_xlog_vacuum(), createPostingTree(), do_setval(), doPickSplit(), fill_seq_with_data(), generic_redo(), GenericXLogFinish(), ginDeletePage(), ginHeapTupleFastInsert(), ginPlaceToPage(), ginRedoClearIncompleteSplit(), ginRedoCreatePTree(), ginRedoDeleteListPages(), ginRedoDeletePage(), ginRedoInsert(), ginRedoInsertListPage(), ginRedoUpdateMetapage(), ginRedoVacuumDataLeafPage(), ginUpdateStats(), ginVacuumPostingTreeLeaf(), gistbuild(), gistdeletepage(), gistplacetopage(), gistprunepage(), gistRedoClearFollowRight(), gistRedoDeleteRecord(), gistRedoPageDelete(), gistRedoPageSplitRecord(), gistRedoPageUpdateRecord(), gistvacuumpage(), hash_xlog_add_ovfl_page(), hash_xlog_delete(), hash_xlog_init_bitmap_page(), hash_xlog_init_meta_page(), hash_xlog_insert(), hash_xlog_move_page_contents(), hash_xlog_split_allocate_page(), hash_xlog_split_cleanup(), hash_xlog_split_complete(), hash_xlog_squeeze_page(), hash_xlog_update_meta_page(), hash_xlog_vacuum_one_page(), hashbucketcleanup(), hashbulkdelete(), heap_abort_speculative(), heap_delete(), heap_finish_speculative(), heap_inplace_update(), heap_insert(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_multi_insert(), heap_page_prune(), heap_update(), heap_xlog_clean(), heap_xlog_confirm(), heap_xlog_delete(), heap_xlog_freeze_page(), heap_xlog_inplace(), heap_xlog_insert(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_multi_insert(), heap_xlog_update(), lazy_scan_heap(), lazy_vacuum_page(), log_newpage(), log_newpage_range(), log_split_page(), MarkBufferDirtyHint(), moveLeafs(), nextval_internal(), revmap_physical_extend(), seq_redo(), shiftList(), spgAddNodeAction(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoMoveLeafs(), spgRedoPickSplit(), spgRedoSplitTuple(), spgRedoVacuumLeaf(), spgRedoVacuumRedirect(), spgRedoVacuumRoot(), spgSplitNodeAction(), vacuumLeafPage(), vacuumLeafRoot(), vacuumRedirectAndPlaceholder(), visibilitymap_set(), writeListPage(), XLogReadBufferForRedoExtended(), and xlogVacuumPage().

◆ PageSetPageSizeAndVersion

#define PageSetPageSizeAndVersion	(	page,
		size,
		version
	)

Value:

( \
    AssertMacro(((size) & 0xFF00) == (size)), \
    AssertMacro(((version) & 0x00FF) == (version)), \
    ((PageHeader) (page))->pd_pagesize_version = (size) | (version) \
)

Definition at line 285 of file bufpage.h.

Referenced by PageInit().

◆ PageSetPrunable

#define PageSetPrunable	(	page,
		xid
	)

Value:

do { \
    Assert(TransactionIdIsNormal(xid)); \
    if (!TransactionIdIsValid(((PageHeader) (page))->pd_prune_xid) || \
        TransactionIdPrecedes(xid, ((PageHeader) (page))->pd_prune_xid)) \
        ((PageHeader) (page))->pd_prune_xid = (xid); \
} while (0)

Definition at line 398 of file bufpage.h.

Referenced by heap_abort_speculative(), heap_delete(), heap_update(), heap_xlog_delete(), and heap_xlog_update().

◆ PageSizeIsValid

#define PageSizeIsValid ( pageSize ) ((pageSize) == BLCKSZ)

Definition at line 258 of file bufpage.h.

◆ PageXLogRecPtrGet

#define PageXLogRecPtrGet ( val ) ((uint64) (val).xlogid << 32 | (val).xrecoff)

Definition at line 100 of file bufpage.h.

◆ PageXLogRecPtrSet

#define PageXLogRecPtrSet	(	ptr,
		lsn
	)	((ptr).xlogid = (uint32) ((lsn) >> 32), (ptr).xrecoff = (uint32) (lsn))

Definition at line 102 of file bufpage.h.

Referenced by mask_page_lsn_and_checksum().

◆ PAI_IS_HEAP

#define PAI_IS_HEAP (1 << 1)

Definition at line 414 of file bufpage.h.

Referenced by PageAddItemExtended().

◆ PAI_OVERWRITE

#define PAI_OVERWRITE (1 << 0)

Definition at line 413 of file bufpage.h.

Referenced by PageAddItemExtended().

◆ PD_ALL_VISIBLE

#define PD_ALL_VISIBLE

Value:

0x0004 /* all tuples on page are visible to

* everyone */

Definition at line 182 of file bufpage.h.

◆ PD_HAS_FREE_LINES

#define PD_HAS_FREE_LINES 0x0001 /* are there any unused line pointers? */

Definition at line 180 of file bufpage.h.

◆ PD_PAGE_FULL

#define PD_PAGE_FULL 0x0002 /* not enough free space for new tuple? */

Definition at line 181 of file bufpage.h.

◆ PD_VALID_FLAG_BITS

#define PD_VALID_FLAG_BITS 0x0007 /* OR of all valid pd_flags bits */

Definition at line 185 of file bufpage.h.

Referenced by PageIsVerified().

◆ PG_DATA_CHECKSUM_VERSION

#define PG_DATA_CHECKSUM_VERSION 1

Definition at line 200 of file bufpage.h.

Referenced by AuxiliaryProcessMain(), main(), sanityChecks(), and scan_file().

◆ PG_PAGE_LAYOUT_VERSION

#define PG_PAGE_LAYOUT_VERSION 4

Definition at line 199 of file bufpage.h.

Referenced by PageInit().

◆ SizeOfPageHeaderData

Typedef Documentation

◆ LocationIndex

typedef uint16 LocationIndex

Definition at line 87 of file bufpage.h.

◆ Page

typedef Pointer Page

Definition at line 78 of file bufpage.h.

◆ PageHeader

typedef PageHeaderData* PageHeader

Definition at line 166 of file bufpage.h.

◆ PageHeaderData

typedef struct PageHeaderData PageHeaderData

Function Documentation

◆ PageAddItemExtended()

OffsetNumber PageAddItemExtended	(	Page	page,
		Item	item,
		Size	size,
		OffsetNumber	offsetNumber,
		int	flags
	)

Definition at line 186 of file bufpage.c.

References elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), InvalidOffsetNumber, ItemIdHasStorage, ItemIdIsUsed, ItemIdSetNormal, lower(), MAXALIGN, MaxHeapTuplesPerPage, OffsetNumberIsValid, OffsetNumberNext, PageClearHasFreeLinePointers, PageGetItemId, PageGetMaxOffsetNumber, PageHasFreeLinePointers, PAI_IS_HEAP, PAI_OVERWRITE, PANIC, PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, SizeOfPageHeaderData, upper(), VALGRIND_CHECK_MEM_IS_DEFINED, and WARNING.

 {
     PageHeader  phdr = (PageHeader) page;
     Size        alignedSize;
     int         lower;
     int         upper;
     ItemId      itemId;
     OffsetNumber limit;
     bool        needshuffle = false;
 
     /*
      * Be wary about corrupted page pointers
      */
     if (phdr->pd_lower < SizeOfPageHeaderData ||
         phdr->pd_lower > phdr->pd_upper ||
         phdr->pd_upper > phdr->pd_special ||
         phdr->pd_special > BLCKSZ)
         ereport(PANIC,
                 (errcode(ERRCODE_DATA_CORRUPTED),
                  errmsg("corrupted page pointers: lower = %u, upper = %u, special = %u",
                         phdr->pd_lower, phdr->pd_upper, phdr->pd_special)));
 
     /*
      * Select offsetNumber to place the new item at
      */
     limit = OffsetNumberNext(PageGetMaxOffsetNumber(page));
 
     /* was offsetNumber passed in? */
     if (OffsetNumberIsValid(offsetNumber))
     {
         /* yes, check it */
         if ((flags & PAI_OVERWRITE) != 0)
         {
             if (offsetNumber < limit)
             {
                 itemId = PageGetItemId(phdr, offsetNumber);
                 if (ItemIdIsUsed(itemId) || ItemIdHasStorage(itemId))
                 {
                     elog(WARNING, "will not overwrite a used ItemId");
                     return InvalidOffsetNumber;
                 }
             }
         }
         else
         {
             if (offsetNumber < limit)
                 needshuffle = true; /* need to move existing linp's */
         }
     }
     else
     {
         /* offsetNumber was not passed in, so find a free slot */
         /* if no free slot, we'll put it at limit (1st open slot) */
         if (PageHasFreeLinePointers(phdr))
         {
             /*
              * Look for "recyclable" (unused) ItemId.  We check for no storage
              * as well, just to be paranoid --- unused items should never have
              * storage.
              */
             for (offsetNumber = 1; offsetNumber < limit; offsetNumber++)
             {
                 itemId = PageGetItemId(phdr, offsetNumber);
                 if (!ItemIdIsUsed(itemId) && !ItemIdHasStorage(itemId))
                     break;
             }
             if (offsetNumber >= limit)
             {
                 /* the hint is wrong, so reset it */
                 PageClearHasFreeLinePointers(phdr);
             }
         }
         else
         {
             /* don't bother searching if hint says there's no free slot */
             offsetNumber = limit;
         }
     }
 
     /* Reject placing items beyond the first unused line pointer */
     if (offsetNumber > limit)
     {
         elog(WARNING, "specified item offset is too large");
         return InvalidOffsetNumber;
     }
 
     /* Reject placing items beyond heap boundary, if heap */
     if ((flags & PAI_IS_HEAP) != 0 && offsetNumber > MaxHeapTuplesPerPage)
     {
         elog(WARNING, "can't put more than MaxHeapTuplesPerPage items in a heap page");
         return InvalidOffsetNumber;
     }
 
     /*
      * Compute new lower and upper pointers for page, see if it'll fit.
      *
      * Note: do arithmetic as signed ints, to avoid mistakes if, say,
      * alignedSize > pd_upper.
      */
     if (offsetNumber == limit || needshuffle)
         lower = phdr->pd_lower + sizeof(ItemIdData);
     else
         lower = phdr->pd_lower;
 
     alignedSize = MAXALIGN(size);
 
     upper = (int) phdr->pd_upper - (int) alignedSize;
 
     if (lower > upper)
         return InvalidOffsetNumber;
 
     /*
      * OK to insert the item.  First, shuffle the existing pointers if needed.
      */
     itemId = PageGetItemId(phdr, offsetNumber);
 
     if (needshuffle)
         memmove(itemId + 1, itemId,
                 (limit - offsetNumber) * sizeof(ItemIdData));
 
     /* set the line pointer */
     ItemIdSetNormal(itemId, upper, size);
 
     /*
      * Items normally contain no uninitialized bytes.  Core bufpage consumers
      * conform, but this is not a necessary coding rule; a new index AM could
      * opt to depart from it.  However, data type input functions and other
      * C-language functions that synthesize datums should initialize all
      * bytes; datumIsEqual() relies on this.  Testing here, along with the
      * similar check in printtup(), helps to catch such mistakes.
      *
      * Values of the "name" type retrieved via index-only scans may contain
      * uninitialized bytes; see comment in btrescan().  Valgrind will report
      * this as an error, but it is safe to ignore.
      */
     VALGRIND_CHECK_MEM_IS_DEFINED(item, size);
 
     /* copy the item's data onto the page */
     memcpy((char *) page + upper, item, size);
 
     /* adjust page header */
     phdr->pd_lower = (LocationIndex) lower;
     phdr->pd_upper = (LocationIndex) upper;
 
     return offsetNumber;
 }

◆ PageGetExactFreeSpace()

Size PageGetExactFreeSpace ( Page page )

Definition at line 625 of file bufpage.c.

Referenced by _bt_dedup_one_page(), _bt_findsplitloc(), allocNewBuffer(), brin_can_do_samepage_update(), doPickSplit(), GetHashPageStats(), ginHeapTupleFastInsert(), spgAddNodeAction(), SpGistGetBuffer(), SpGistPageAddNewItem(), SpGistSetLastUsedPage(), and writeListPage().

 {
     int         space;
 
     /*
      * Use signed arithmetic here so that we behave sensibly if pd_lower >
      * pd_upper.
      */
     space = (int) ((PageHeader) page)->pd_upper -
         (int) ((PageHeader) page)->pd_lower;
 
     if (space < 0)
         return 0;
 
     return (Size) space;
 }

◆ PageGetFreeSpace()

Size PageGetFreeSpace ( Page page )

Definition at line 574 of file bufpage.c.

Referenced by _bt_buildadd(), _bt_dedup_one_page(), _bt_findinsertloc(), _bt_insertonpg(), _bt_search_insert(), _hash_doinsert(), br_page_get_freespace(), entryIsEnoughSpace(), GetBTPageStatistics(), GetHashPageStatistics(), gistnospace(), heap_xlog_visible(), PageGetHeapFreeSpace(), pgstat_index_page(), pgstatindex_impl(), and terminate_brin_buildstate().

 {
     int         space;
 
     /*
      * Use signed arithmetic here so that we behave sensibly if pd_lower >
      * pd_upper.
      */
     space = (int) ((PageHeader) page)->pd_upper -
         (int) ((PageHeader) page)->pd_lower;
 
     if (space < (int) sizeof(ItemIdData))
         return 0;
     space -= sizeof(ItemIdData);
 
     return (Size) space;
 }

◆ PageGetFreeSpaceForMultipleTuples()

Size PageGetFreeSpaceForMultipleTuples	(	Page	page,
		int	ntups
	)

Definition at line 601 of file bufpage.c.

Referenced by _hash_splitbucket(), and _hash_squeezebucket().

 {
     int         space;
 
     /*
      * Use signed arithmetic here so that we behave sensibly if pd_lower >
      * pd_upper.
      */
     space = (int) ((PageHeader) page)->pd_upper -
         (int) ((PageHeader) page)->pd_lower;
 
     if (space < (int) (ntups * sizeof(ItemIdData)))
         return 0;
     space -= ntups * sizeof(ItemIdData);
 
     return (Size) space;
 }

◆ PageGetHeapFreeSpace()

Size PageGetHeapFreeSpace ( Page page )

Definition at line 658 of file bufpage.c.

References FirstOffsetNumber, ItemIdIsUsed, MaxHeapTuplesPerPage, OffsetNumberNext, PageGetFreeSpace(), PageGetItemId, PageGetMaxOffsetNumber, and PageHasFreeLinePointers.

Referenced by heap_multi_insert(), heap_page_prune_opt(), heap_update(), heap_xlog_clean(), heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_update(), lazy_scan_heap(), lazy_vacuum_heap(), pgstat_heap(), raw_heap_insert(), RelationGetBufferForTuple(), and statapprox_heap().

 {
     Size        space;
 
     space = PageGetFreeSpace(page);
     if (space > 0)
     {
         OffsetNumber offnum,
                     nline;
 
         /*
          * Are there already MaxHeapTuplesPerPage line pointers in the page?
          */
         nline = PageGetMaxOffsetNumber(page);
         if (nline >= MaxHeapTuplesPerPage)
         {
             if (PageHasFreeLinePointers((PageHeader) page))
             {
                 /*
                  * Since this is just a hint, we must confirm that there is
                  * indeed a free line pointer
                  */
                 for (offnum = FirstOffsetNumber; offnum <= nline; offnum = OffsetNumberNext(offnum))
                 {
                     ItemId      lp = PageGetItemId(page, offnum);
 
                     if (!ItemIdIsUsed(lp))
                         break;
                 }
 
                 if (offnum > nline)
                 {
                     /*
                      * The hint is wrong, but we can't clear it here since we
                      * don't have the ability to mark the page dirty.
                      */
                     space = 0;
                 }
             }
             else
             {
                 /*
                  * Although the hint might be wrong, PageAddItem will believe
                  * it anyway, so we must believe it too.
                  */
                 space = 0;
             }
         }
     }
     return space;
 }

◆ PageGetTempPage()

Page PageGetTempPage ( Page page )

Definition at line 344 of file bufpage.c.

References PageGetPageSize, and palloc().

Referenced by _bt_split(), dataSplitPageInternal(), and ginPlaceToPage().

 {
     Size        pageSize;
     Page        temp;
 
     pageSize = PageGetPageSize(page);
     temp = (Page) palloc(pageSize);
 
     return temp;
 }

◆ PageGetTempPageCopy()

Page PageGetTempPageCopy ( Page page )

Definition at line 361 of file bufpage.c.

References PageGetPageSize, and palloc().

Referenced by entrySplitPage(), and ginVacuumEntryPage().

 {
     Size        pageSize;
     Page        temp;
 
     pageSize = PageGetPageSize(page);
     temp = (Page) palloc(pageSize);
 
     memcpy(temp, page, pageSize);
 
     return temp;
 }

◆ PageGetTempPageCopySpecial()

Page PageGetTempPageCopySpecial ( Page page )

Definition at line 381 of file bufpage.c.

References PageGetPageSize, PageGetSpecialPointer, PageGetSpecialSize, PageInit(), and palloc().

Referenced by _bt_dedup_one_page(), btree_xlog_dedup(), btree_xlog_split(), and gistplacetopage().

 {
     Size        pageSize;
     Page        temp;
 
     pageSize = PageGetPageSize(page);
     temp = (Page) palloc(pageSize);
 
     PageInit(temp, pageSize, PageGetSpecialSize(page));
     memcpy(PageGetSpecialPointer(temp),
            PageGetSpecialPointer(page),
            PageGetSpecialSize(page));
 
     return temp;
 }

◆ PageIndexMultiDelete()

void PageIndexMultiDelete	(	Page	page,
		OffsetNumber *	itemnos,
		int	nitems
	)

Definition at line 828 of file bufpage.c.

References itemIdSortData::alignedlen, Assert, compactify_tuples(), elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), ERROR, FirstOffsetNumber, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, itemIdSortData::itemoff, MAXALIGN, MaxIndexTuplesPerPage, itemIdSortData::offsetindex, OffsetNumberNext, PageGetItemId, PageGetMaxOffsetNumber, PageIndexTupleDelete(), PageHeaderData::pd_linp, PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, and SizeOfPageHeaderData.

Referenced by _bt_delitems_delete(), _bt_delitems_vacuum(), _hash_squeezebucket(), _hash_vacuum_one_page(), btree_xlog_delete(), btree_xlog_vacuum(), gistprunepage(), gistRedoDeleteRecord(), gistRedoPageUpdateRecord(), gistvacuumpage(), hash_xlog_delete(), hash_xlog_move_page_contents(), hash_xlog_vacuum_one_page(), hashbucketcleanup(), spgPageIndexMultiDelete(), spgRedoVacuumRedirect(), spgRedoVacuumRoot(), vacuumLeafRoot(), and vacuumRedirectAndPlaceholder().

 {
     PageHeader  phdr = (PageHeader) page;
     Offset      pd_lower = phdr->pd_lower;
     Offset      pd_upper = phdr->pd_upper;
     Offset      pd_special = phdr->pd_special;
     itemIdSortData itemidbase[MaxIndexTuplesPerPage];
     ItemIdData  newitemids[MaxIndexTuplesPerPage];
     itemIdSort  itemidptr;
     ItemId      lp;
     int         nline,
                 nused;
     Size        totallen;
     Size        size;
     unsigned    offset;
     int         nextitm;
     OffsetNumber offnum;
 
     Assert(nitems <= MaxIndexTuplesPerPage);
 
     /*
      * If there aren't very many items to delete, then retail
      * PageIndexTupleDelete is the best way.  Delete the items in reverse
      * order so we don't have to think about adjusting item numbers for
      * previous deletions.
      *
      * TODO: tune the magic number here
      */
     if (nitems <= 2)
     {
         while (--nitems >= 0)
             PageIndexTupleDelete(page, itemnos[nitems]);
         return;
     }
 
     /*
      * As with PageRepairFragmentation, paranoia seems justified.
      */
     if (pd_lower < SizeOfPageHeaderData ||
         pd_lower > pd_upper ||
         pd_upper > pd_special ||
         pd_special > BLCKSZ ||
         pd_special != MAXALIGN(pd_special))
         ereport(ERROR,
                 (errcode(ERRCODE_DATA_CORRUPTED),
                  errmsg("corrupted page pointers: lower = %u, upper = %u, special = %u",
                         pd_lower, pd_upper, pd_special)));
 
     /*
      * Scan the line pointer array and build a list of just the ones we are
      * going to keep.  Notice we do not modify the page yet, since we are
      * still validity-checking.
      */
     nline = PageGetMaxOffsetNumber(page);
     itemidptr = itemidbase;
     totallen = 0;
     nused = 0;
     nextitm = 0;
     for (offnum = FirstOffsetNumber; offnum <= nline; offnum = OffsetNumberNext(offnum))
     {
         lp = PageGetItemId(page, offnum);
         Assert(ItemIdHasStorage(lp));
         size = ItemIdGetLength(lp);
         offset = ItemIdGetOffset(lp);
         if (offset < pd_upper ||
             (offset + size) > pd_special ||
             offset != MAXALIGN(offset))
             ereport(ERROR,
                     (errcode(ERRCODE_DATA_CORRUPTED),
                      errmsg("corrupted line pointer: offset = %u, size = %u",
                             offset, (unsigned int) size)));
 
         if (nextitm < nitems && offnum == itemnos[nextitm])
         {
             /* skip item to be deleted */
             nextitm++;
         }
         else
         {
             itemidptr->offsetindex = nused; /* where it will go */
             itemidptr->itemoff = offset;
             itemidptr->alignedlen = MAXALIGN(size);
             totallen += itemidptr->alignedlen;
             newitemids[nused] = *lp;
             itemidptr++;
             nused++;
         }
     }
 
     /* this will catch invalid or out-of-order itemnos[] */
     if (nextitm != nitems)
         elog(ERROR, "incorrect index offsets supplied");
 
     if (totallen > (Size) (pd_special - pd_lower))
         ereport(ERROR,
                 (errcode(ERRCODE_DATA_CORRUPTED),
                  errmsg("corrupted item lengths: total %u, available space %u",
                         (unsigned int) totallen, pd_special - pd_lower)));
 
     /*
      * Looks good. Overwrite the line pointers with the copy, from which we've
      * removed all the unused items.
      */
     memcpy(phdr->pd_linp, newitemids, nused * sizeof(ItemIdData));
     phdr->pd_lower = SizeOfPageHeaderData + nused * sizeof(ItemIdData);
 
     /* and compactify the tuple data */
     compactify_tuples(itemidbase, nused, page);
 }

◆ PageIndexTupleDelete()

void PageIndexTupleDelete	(	Page	page,
		OffsetNumber	offset
	)

Definition at line 719 of file bufpage.c.

References Assert, elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), ERROR, i, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, ItemIdData::lp_off, MAXALIGN, PageGetItemId, PageGetMaxOffsetNumber, PageIsEmpty, PageHeaderData::pd_linp, PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, and SizeOfPageHeaderData.

Referenced by _bt_mark_page_halfdead(), addLeafTuple(), addOrReplaceTuple(), btree_xlog_mark_page_halfdead(), entryPreparePage(), ginRedoInsertEntry(), ginVacuumEntryPage(), gistdeletepage(), gistplacetopage(), gistRedoPageDelete(), PageIndexMultiDelete(), spgAddNodeAction(), SpGistPageAddNewItem(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoSplitTuple(), and spgSplitNodeAction().

 {
     PageHeader  phdr = (PageHeader) page;
     char       *addr;
     ItemId      tup;
     Size        size;
     unsigned    offset;
     int         nbytes;
     int         offidx;
     int         nline;
 
     /*
      * As with PageRepairFragmentation, paranoia seems justified.
      */
     if (phdr->pd_lower < SizeOfPageHeaderData ||
         phdr->pd_lower > phdr->pd_upper ||
         phdr->pd_upper > phdr->pd_special ||
         phdr->pd_special > BLCKSZ ||
         phdr->pd_special != MAXALIGN(phdr->pd_special))
         ereport(ERROR,
                 (errcode(ERRCODE_DATA_CORRUPTED),
                  errmsg("corrupted page pointers: lower = %u, upper = %u, special = %u",
                         phdr->pd_lower, phdr->pd_upper, phdr->pd_special)));
 
     nline = PageGetMaxOffsetNumber(page);
     if ((int) offnum <= 0 || (int) offnum > nline)
         elog(ERROR, "invalid index offnum: %u", offnum);
 
     /* change offset number to offset index */
     offidx = offnum - 1;
 
     tup = PageGetItemId(page, offnum);
     Assert(ItemIdHasStorage(tup));
     size = ItemIdGetLength(tup);
     offset = ItemIdGetOffset(tup);
 
     if (offset < phdr->pd_upper || (offset + size) > phdr->pd_special ||
         offset != MAXALIGN(offset))
         ereport(ERROR,
                 (errcode(ERRCODE_DATA_CORRUPTED),
                  errmsg("corrupted line pointer: offset = %u, size = %u",
                         offset, (unsigned int) size)));
 
     /* Amount of space to actually be deleted */
     size = MAXALIGN(size);
 
     /*
      * First, we want to get rid of the pd_linp entry for the index tuple. We
      * copy all subsequent linp's back one slot in the array. We don't use
      * PageGetItemId, because we are manipulating the _array_, not individual
      * linp's.
      */
     nbytes = phdr->pd_lower -
         ((char *) &phdr->pd_linp[offidx + 1] - (char *) phdr);
 
     if (nbytes > 0)
         memmove((char *) &(phdr->pd_linp[offidx]),
                 (char *) &(phdr->pd_linp[offidx + 1]),
                 nbytes);
 
     /*
      * Now move everything between the old upper bound (beginning of tuple
      * space) and the beginning of the deleted tuple forward, so that space in
      * the middle of the page is left free.  If we've just deleted the tuple
      * at the beginning of tuple space, then there's no need to do the copy.
      */
 
     /* beginning of tuple space */
     addr = (char *) page + phdr->pd_upper;
 
     if (offset > phdr->pd_upper)
         memmove(addr + size, addr, offset - phdr->pd_upper);
 
     /* adjust free space boundary pointers */
     phdr->pd_upper += size;
     phdr->pd_lower -= sizeof(ItemIdData);
 
     /*
      * Finally, we need to adjust the linp entries that remain.
      *
      * Anything that used to be before the deleted tuple's data was moved
      * forward by the size of the deleted tuple.
      */
     if (!PageIsEmpty(page))
     {
         int         i;
 
         nline--;                /* there's one less than when we started */
         for (i = 1; i <= nline; i++)
         {
             ItemId      ii = PageGetItemId(phdr, i);
 
             Assert(ItemIdHasStorage(ii));
             if (ItemIdGetOffset(ii) <= offset)
                 ii->lp_off += size;
         }
     }
 }

◆ PageIndexTupleDeleteNoCompact()

void PageIndexTupleDeleteNoCompact	(	Page	page,
		OffsetNumber	offset
	)

Definition at line 950 of file bufpage.c.

References Assert, elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), ERROR, i, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, ItemIdSetUnused, ItemIdData::lp_off, MAXALIGN, PageGetItemId, PageGetMaxOffsetNumber, PageIsEmpty, PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, and SizeOfPageHeaderData.

Referenced by brin_doupdate(), brin_xlog_desummarize_page(), brin_xlog_update(), and brinRevmapDesummarizeRange().

 {
     PageHeader  phdr = (PageHeader) page;
     char       *addr;
     ItemId      tup;
     Size        size;
     unsigned    offset;
     int         nline;
 
     /*
      * As with PageRepairFragmentation, paranoia seems justified.
      */
     if (phdr->pd_lower < SizeOfPageHeaderData ||
         phdr->pd_lower > phdr->pd_upper ||
         phdr->pd_upper > phdr->pd_special ||
         phdr->pd_special > BLCKSZ ||
         phdr->pd_special != MAXALIGN(phdr->pd_special))
         ereport(ERROR,
                 (errcode(ERRCODE_DATA_CORRUPTED),
                  errmsg("corrupted page pointers: lower = %u, upper = %u, special = %u",
                         phdr->pd_lower, phdr->pd_upper, phdr->pd_special)));
 
     nline = PageGetMaxOffsetNumber(page);
     if ((int) offnum <= 0 || (int) offnum > nline)
         elog(ERROR, "invalid index offnum: %u", offnum);
 
     tup = PageGetItemId(page, offnum);
     Assert(ItemIdHasStorage(tup));
     size = ItemIdGetLength(tup);
     offset = ItemIdGetOffset(tup);
 
     if (offset < phdr->pd_upper || (offset + size) > phdr->pd_special ||
         offset != MAXALIGN(offset))
         ereport(ERROR,
                 (errcode(ERRCODE_DATA_CORRUPTED),
                  errmsg("corrupted line pointer: offset = %u, size = %u",
                         offset, (unsigned int) size)));
 
     /* Amount of space to actually be deleted */
     size = MAXALIGN(size);
 
     /*
      * Either set the line pointer to "unused", or zap it if it's the last
      * one.  (Note: it's possible that the next-to-last one(s) are already
      * unused, but we do not trouble to try to compact them out if so.)
      */
     if ((int) offnum < nline)
         ItemIdSetUnused(tup);
     else
     {
         phdr->pd_lower -= sizeof(ItemIdData);
         nline--;                /* there's one less than when we started */
     }
 
     /*
      * Now move everything between the old upper bound (beginning of tuple
      * space) and the beginning of the deleted tuple forward, so that space in
      * the middle of the page is left free.  If we've just deleted the tuple
      * at the beginning of tuple space, then there's no need to do the copy.
      */
 
     /* beginning of tuple space */
     addr = (char *) page + phdr->pd_upper;
 
     if (offset > phdr->pd_upper)
         memmove(addr + size, addr, offset - phdr->pd_upper);
 
     /* adjust free space boundary pointer */
     phdr->pd_upper += size;
 
     /*
      * Finally, we need to adjust the linp entries that remain.
      *
      * Anything that used to be before the deleted tuple's data was moved
      * forward by the size of the deleted tuple.
      */
     if (!PageIsEmpty(page))
     {
         int         i;
 
         for (i = 1; i <= nline; i++)
         {
             ItemId      ii = PageGetItemId(phdr, i);
 
             if (ItemIdHasStorage(ii) && ItemIdGetOffset(ii) <= offset)
                 ii->lp_off += size;
         }
     }
 }

◆ PageIndexTupleOverwrite()

bool PageIndexTupleOverwrite	(	Page	page,
		OffsetNumber	offnum,
		Item	newtup,
		Size	newsize
	)

Definition at line 1060 of file bufpage.c.

References Assert, elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), ERROR, FirstOffsetNumber, i, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, ItemIdData::lp_len, ItemIdData::lp_off, MAXALIGN, PageGetItem, PageGetItemId, PageGetMaxOffsetNumber, PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, and SizeOfPageHeaderData.

Referenced by _bt_buildadd(), _bt_delitems_vacuum(), _bt_mark_page_halfdead(), brin_doupdate(), brin_xlog_samepage_update(), btree_xlog_vacuum(), gistplacetopage(), and gistRedoPageUpdateRecord().

 {
     PageHeader  phdr = (PageHeader) page;
     ItemId      tupid;
     int         oldsize;
     unsigned    offset;
     Size        alignednewsize;
     int         size_diff;
     int         itemcount;
 
     /*
      * As with PageRepairFragmentation, paranoia seems justified.
      */
     if (phdr->pd_lower < SizeOfPageHeaderData ||
         phdr->pd_lower > phdr->pd_upper ||
         phdr->pd_upper > phdr->pd_special ||
         phdr->pd_special > BLCKSZ ||
         phdr->pd_special != MAXALIGN(phdr->pd_special))
         ereport(ERROR,
                 (errcode(ERRCODE_DATA_CORRUPTED),
                  errmsg("corrupted page pointers: lower = %u, upper = %u, special = %u",
                         phdr->pd_lower, phdr->pd_upper, phdr->pd_special)));
 
     itemcount = PageGetMaxOffsetNumber(page);
     if ((int) offnum <= 0 || (int) offnum > itemcount)
         elog(ERROR, "invalid index offnum: %u", offnum);
 
     tupid = PageGetItemId(page, offnum);
     Assert(ItemIdHasStorage(tupid));
     oldsize = ItemIdGetLength(tupid);
     offset = ItemIdGetOffset(tupid);
 
     if (offset < phdr->pd_upper || (offset + oldsize) > phdr->pd_special ||
         offset != MAXALIGN(offset))
         ereport(ERROR,
                 (errcode(ERRCODE_DATA_CORRUPTED),
                  errmsg("corrupted line pointer: offset = %u, size = %u",
                         offset, (unsigned int) oldsize)));
 
     /*
      * Determine actual change in space requirement, check for page overflow.
      */
     oldsize = MAXALIGN(oldsize);
     alignednewsize = MAXALIGN(newsize);
     if (alignednewsize > oldsize + (phdr->pd_upper - phdr->pd_lower))
         return false;
 
     /*
      * Relocate existing data and update line pointers, unless the new tuple
      * is the same size as the old (after alignment), in which case there's
      * nothing to do.  Notice that what we have to relocate is data before the
      * target tuple, not data after, so it's convenient to express size_diff
      * as the amount by which the tuple's size is decreasing, making it the
      * delta to add to pd_upper and affected line pointers.
      */
     size_diff = oldsize - (int) alignednewsize;
     if (size_diff != 0)
     {
         char       *addr = (char *) page + phdr->pd_upper;
         int         i;
 
         /* relocate all tuple data before the target tuple */
         memmove(addr + size_diff, addr, offset - phdr->pd_upper);
 
         /* adjust free space boundary pointer */
         phdr->pd_upper += size_diff;
 
         /* adjust affected line pointers too */
         for (i = FirstOffsetNumber; i <= itemcount; i++)
         {
             ItemId      ii = PageGetItemId(phdr, i);
 
             /* Allow items without storage; currently only BRIN needs that */
             if (ItemIdHasStorage(ii) && ItemIdGetOffset(ii) <= offset)
                 ii->lp_off += size_diff;
         }
     }
 
     /* Update the item's tuple length without changing its lp_flags field */
     tupid->lp_off = offset + size_diff;
     tupid->lp_len = newsize;
 
     /* Copy new tuple data onto page */
     memcpy(PageGetItem(page, tupid), newtup, newsize);
 
     return true;
 }

◆ PageInit()

void PageInit	(	Page	page,
		Size	pageSize,
		Size	specialSize
	)

Definition at line 42 of file bufpage.c.

References Assert, MAXALIGN, MemSet, PageSetPageSizeAndVersion, PageHeaderData::pd_flags, PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, PG_PAGE_LAYOUT_VERSION, and SizeOfPageHeaderData.

Referenced by _bt_pageinit(), _hash_pageinit(), BloomInitPage(), brin_page_init(), fill_seq_with_data(), fsm_extend(), fsm_readbuf(), GinInitPage(), GISTInitBuffer(), heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_update(), heap_xlog_visible(), PageGetTempPageCopySpecial(), raw_heap_insert(), RelationGetBufferForTuple(), seq_redo(), SpGistInitPage(), vm_extend(), vm_readbuf(), and XLogRecordPageWithFreeSpace().

 {
     PageHeader  p = (PageHeader) page;
 
     specialSize = MAXALIGN(specialSize);
 
     Assert(pageSize == BLCKSZ);
     Assert(pageSize > specialSize + SizeOfPageHeaderData);
 
     /* Make sure all fields of page are zero, as well as unused space */
     MemSet(p, 0, pageSize);
 
     p->pd_flags = 0;
     p->pd_lower = SizeOfPageHeaderData;
     p->pd_upper = pageSize - specialSize;
     p->pd_special = pageSize - specialSize;
     PageSetPageSizeAndVersion(page, pageSize, PG_PAGE_LAYOUT_VERSION);
     /* p->pd_prune_xid = InvalidTransactionId;      done by above MemSet */
 }

◆ PageIsVerified()

bool PageIsVerified	(	Page	page,
		BlockNumber	blkno
	)

Definition at line 82 of file bufpage.c.

References checksum_failure, DataChecksumsEnabled(), ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), i, ignore_checksum_failure, MAXALIGN, PageIsNew, PageHeaderData::pd_checksum, PageHeaderData::pd_flags, PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, PD_VALID_FLAG_BITS, pg_checksum_page(), pgstat_report_checksum_failure(), and WARNING.

Referenced by ReadBuffer_common(), and RelationCopyStorage().

 {
     PageHeader  p = (PageHeader) page;
     size_t     *pagebytes;
     int         i;
     bool        checksum_failure = false;
     bool        header_sane = false;
     bool        all_zeroes = false;
     uint16      checksum = 0;
 
     /*
      * Don't verify page data unless the page passes basic non-zero test
      */
     if (!PageIsNew(page))
     {
         if (DataChecksumsEnabled())
         {
             checksum = pg_checksum_page((char *) page, blkno);
 
             if (checksum != p->pd_checksum)
                 checksum_failure = true;
         }
 
         /*
          * The following checks don't prove the header is correct, only that
          * it looks sane enough to allow into the buffer pool. Later usage of
          * the block can still reveal problems, which is why we offer the
          * checksum option.
          */
         if ((p->pd_flags & ~PD_VALID_FLAG_BITS) == 0 &&
             p->pd_lower <= p->pd_upper &&
             p->pd_upper <= p->pd_special &&
             p->pd_special <= BLCKSZ &&
             p->pd_special == MAXALIGN(p->pd_special))
             header_sane = true;
 
         if (header_sane && !checksum_failure)
             return true;
     }
 
     /* Check all-zeroes case */
     all_zeroes = true;
     pagebytes = (size_t *) page;
     for (i = 0; i < (BLCKSZ / sizeof(size_t)); i++)
     {
         if (pagebytes[i] != 0)
         {
             all_zeroes = false;
             break;
         }
     }
 
     if (all_zeroes)
         return true;
 
     /*
      * Throw a WARNING if the checksum fails, but only after we've checked for
      * the all-zeroes case.
      */
     if (checksum_failure)
     {
         ereport(WARNING,
                 (errcode(ERRCODE_DATA_CORRUPTED),
                  errmsg("page verification failed, calculated checksum %u but expected %u",
                         checksum, p->pd_checksum)));
 
         pgstat_report_checksum_failure();
 
         if (header_sane && ignore_checksum_failure)
             return true;
     }
 
     return false;
 }

◆ PageRepairFragmentation()

void PageRepairFragmentation ( Page page )

Definition at line 475 of file bufpage.c.

References itemIdSortData::alignedlen, compactify_tuples(), ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), ERROR, FirstOffsetNumber, i, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, ItemIdIsUsed, ItemIdSetUnused, itemIdSortData::itemoff, MAXALIGN, MaxHeapTuplesPerPage, itemIdSortData::offsetindex, PageClearHasFreeLinePointers, PageGetItemId, PageGetMaxOffsetNumber, PageSetHasFreeLinePointers, SizeOfPageHeaderData, and unlikely.

Referenced by heap_page_prune_execute(), and lazy_vacuum_page().

 {
     Offset      pd_lower = ((PageHeader) page)->pd_lower;
     Offset      pd_upper = ((PageHeader) page)->pd_upper;
     Offset      pd_special = ((PageHeader) page)->pd_special;
     itemIdSortData itemidbase[MaxHeapTuplesPerPage];
     itemIdSort  itemidptr;
     ItemId      lp;
     int         nline,
                 nstorage,
                 nunused;
     int         i;
     Size        totallen;
 
     /*
      * It's worth the trouble to be more paranoid here than in most places,
      * because we are about to reshuffle data in (what is usually) a shared
      * disk buffer.  If we aren't careful then corrupted pointers, lengths,
      * etc could cause us to clobber adjacent disk buffers, spreading the data
      * loss further.  So, check everything.
      */
     if (pd_lower < SizeOfPageHeaderData ||
         pd_lower > pd_upper ||
         pd_upper > pd_special ||
         pd_special > BLCKSZ ||
         pd_special != MAXALIGN(pd_special))
         ereport(ERROR,
                 (errcode(ERRCODE_DATA_CORRUPTED),
                  errmsg("corrupted page pointers: lower = %u, upper = %u, special = %u",
                         pd_lower, pd_upper, pd_special)));
 
     /*
      * Run through the line pointer array and collect data about live items.
      */
     nline = PageGetMaxOffsetNumber(page);
     itemidptr = itemidbase;
     nunused = totallen = 0;
     for (i = FirstOffsetNumber; i <= nline; i++)
     {
         lp = PageGetItemId(page, i);
         if (ItemIdIsUsed(lp))
         {
             if (ItemIdHasStorage(lp))
             {
                 itemidptr->offsetindex = i - 1;
                 itemidptr->itemoff = ItemIdGetOffset(lp);
                 if (unlikely(itemidptr->itemoff < (int) pd_upper ||
                              itemidptr->itemoff >= (int) pd_special))
                     ereport(ERROR,
                             (errcode(ERRCODE_DATA_CORRUPTED),
                              errmsg("corrupted line pointer: %u",
                                     itemidptr->itemoff)));
                 itemidptr->alignedlen = MAXALIGN(ItemIdGetLength(lp));
                 totallen += itemidptr->alignedlen;
                 itemidptr++;
             }
         }
         else
         {
             /* Unused entries should have lp_len = 0, but make sure */
             ItemIdSetUnused(lp);
             nunused++;
         }
     }
 
     nstorage = itemidptr - itemidbase;
     if (nstorage == 0)
     {
         /* Page is completely empty, so just reset it quickly */
         ((PageHeader) page)->pd_upper = pd_special;
     }
     else
     {
         /* Need to compact the page the hard way */
         if (totallen > (Size) (pd_special - pd_lower))
             ereport(ERROR,
                     (errcode(ERRCODE_DATA_CORRUPTED),
                      errmsg("corrupted item lengths: total %u, available space %u",
                             (unsigned int) totallen, pd_special - pd_lower)));
 
         compactify_tuples(itemidbase, nstorage, page);
     }
 
     /* Set hint bit for PageAddItem */
     if (nunused > 0)
         PageSetHasFreeLinePointers(page);
     else
         PageClearHasFreeLinePointers(page);
 }

◆ PageRestoreTempPage()

void PageRestoreTempPage	(	Page	tempPage,
		Page	oldPage
	)

Definition at line 403 of file bufpage.c.

References PageGetPageSize, and pfree().

Referenced by _bt_dedup_one_page(), _bt_split(), btree_xlog_dedup(), btree_xlog_split(), createPostingTree(), ginbulkdelete(), and gistplacetopage().

 {
     Size        pageSize;
 
     pageSize = PageGetPageSize(tempPage);
     memcpy((char *) oldPage, (char *) tempPage, pageSize);
 
     pfree(tempPage);
 }

◆ PageSetChecksumCopy()

char* PageSetChecksumCopy	(	Page	page,
		BlockNumber	blkno
	)

Definition at line 1165 of file bufpage.c.

References DataChecksumsEnabled(), MemoryContextAlloc(), PageIsNew, pg_checksum_page(), and TopMemoryContext.

Referenced by FlushBuffer().

 {
     static char *pageCopy = NULL;
 
     /* If we don't need a checksum, just return the passed-in data */
     if (PageIsNew(page) || !DataChecksumsEnabled())
         return (char *) page;
 
     /*
      * We allocate the copy space once and use it over on each subsequent
      * call.  The point of palloc'ing here, rather than having a static char
      * array, is first to ensure adequate alignment for the checksumming code
      * and second to avoid wasting space in processes that never call this.
      */
     if (pageCopy == NULL)
         pageCopy = MemoryContextAlloc(TopMemoryContext, BLCKSZ);
 
     memcpy(pageCopy, (char *) page, BLCKSZ);
     ((PageHeader) pageCopy)->pd_checksum = pg_checksum_page(pageCopy, blkno);
     return pageCopy;
 }

◆ PageSetChecksumInplace()

void PageSetChecksumInplace	(	Page	page,
		BlockNumber	blkno
	)

Definition at line 1194 of file bufpage.c.

References DataChecksumsEnabled(), PageIsNew, and pg_checksum_page().

Referenced by _bt_blwritepage(), _hash_alloc_buckets(), blbuildempty(), btbuildempty(), end_heap_rewrite(), FlushRelationBuffers(), fsm_extend(), LocalBufferAlloc(), raw_heap_insert(), RelationCopyStorage(), spgbuildempty(), and vm_extend().

 {
     /* If we don't need a checksum, just return */
     if (PageIsNew(page) || !DataChecksumsEnabled())
         return;
 
     ((PageHeader) page)->pd_checksum = pg_checksum_page((char *) page, blkno);
 }

◆ PageValidateSpecialPointer()

static bool PageValidateSpecialPointer ( Page page )

inlinestatic

Definition at line 313 of file bufpage.h.

References Assert, PageIsValid, PageHeaderData::pd_special, and SizeOfPageHeaderData.

 {
     Assert(PageIsValid(page));
     Assert(((PageHeader) (page))->pd_special <= BLCKSZ);
     Assert(((PageHeader) (page))->pd_special >= SizeOfPageHeaderData);
 
     return true;
 }

◆ StaticAssertDecl()

StaticAssertDecl	(	BLCKSZ	= `=((BLCKSZ/sizeof(size_t)) *sizeof(size_t))`,
		"BLCKSZ has to be a multiple of sizeof(size_t)"
	)

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

◆ PageAddItem

◆ PageClearAllVisible

◆ PageClearFull

◆ PageClearHasFreeLinePointers

◆ PageClearPrunable

◆ PageGetContents

◆ PageGetItem

◆ PageGetItemId

◆ PageGetLSN

◆ PageGetMaxOffsetNumber

◆ PageGetPageLayoutVersion

◆ PageGetPageSize

◆ PageGetSpecialPointer

◆ PageGetSpecialSize

◆ PageHasFreeLinePointers

◆ PageIsAllVisible

◆ PageIsEmpty

◆ PageIsFull

◆ PageIsNew

◆ PageIsPrunable

◆ PageIsValid

◆ PageSetAllVisible

◆ PageSetFull

◆ PageSetHasFreeLinePointers

◆ PageSetLSN

◆ PageSetPageSizeAndVersion

◆ PageSetPrunable

◆ PageSizeIsValid

◆ PageXLogRecPtrGet

◆ PageXLogRecPtrSet

◆ PAI_IS_HEAP

◆ PAI_OVERWRITE

◆ PD_ALL_VISIBLE

◆ PD_HAS_FREE_LINES

◆ PD_PAGE_FULL

◆ PD_VALID_FLAG_BITS

◆ PG_DATA_CHECKSUM_VERSION

◆ PG_PAGE_LAYOUT_VERSION

◆ SizeOfPageHeaderData

Typedef Documentation

◆ LocationIndex

◆ Page

◆ PageHeader

◆ PageHeaderData

Function Documentation

◆ PageAddItemExtended()

◆ PageGetExactFreeSpace()

◆ PageGetFreeSpace()

◆ PageGetFreeSpaceForMultipleTuples()

◆ PageGetHeapFreeSpace()

◆ PageGetTempPage()

◆ PageGetTempPageCopy()

◆ PageGetTempPageCopySpecial()

◆ PageIndexMultiDelete()

◆ PageIndexTupleDelete()

◆ PageIndexTupleDeleteNoCompact()

◆ PageIndexTupleOverwrite()

◆ PageInit()

◆ PageIsVerified()

◆ PageRepairFragmentation()

◆ PageRestoreTempPage()

◆ PageSetChecksumCopy()

◆ PageSetChecksumInplace()

◆ PageValidateSpecialPointer()

◆ StaticAssertDecl()