bufpage.h File Reference

#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:

Go to the source code of 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)
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

#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 412 of file bufpage.h.

Referenced by _bt_mark_page_halfdead(), _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_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().

#define PageClearAllVisible

(

page

)

(((PageHeader) (page))->pd_flags &= ~PD_ALL_VISIBLE)

Definition at line 385 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().

#define PageClearFull

(

page

)

(((PageHeader) (page))->pd_flags &= ~PD_PAGE_FULL)

Definition at line 378 of file bufpage.h.

Referenced by heap_page_prune(), and mask_page_hint_bits().

#define PageClearHasFreeLinePointers

(

page

)

(((PageHeader) (page))->pd_flags &= ~PD_HAS_FREE_LINES)

Definition at line 371 of file bufpage.h.

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

#define PageClearPrunable

(

page

)

(((PageHeader) (page))->pd_prune_xid = InvalidTransactionId)

Definition at line 401 of file bufpage.h.

#define PageGetContents

(

page

)

((char *) (page) + MAXALIGN(SizeOfPageHeaderData))

Definition at line 242 of file bufpage.h.

Referenced by brin_metapage_info(), brin_metapage_init(), brin_revmap_data(), brin_xlog_revmap_extend(), brinGetStats(), brinGetTupleForHeapBlock(), brinRevmapDesummarizeRange(), brinRevmapInitialize(), brinSetHeapBlockItemptr(), fsm_get_avail(), fsm_get_max_avail(), fsm_page_contents(), fsm_rebuild_page(), fsm_search_avail(), fsm_set_avail(), fsm_truncate_avail(), fsm_vacuum_page(), revmap_physical_extend(), visibilitymap_clear(), visibilitymap_count(), visibilitymap_get_status(), visibilitymap_set(), and visibilitymap_truncate().

#define PageGetItem	(		page,
			itemId
	)

Value:

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

Definition at line 336 of file bufpage.h.

Referenced by _bt_buildadd(), _bt_check_unique(), _bt_checkkeys(), _bt_compare(), _bt_get_endpoint(), _bt_getstackbuf(), _bt_insert_parent(), _bt_isequal(), _bt_killitems(), _bt_mark_page_halfdead(), _bt_newroot(), _bt_pagedel(), _bt_search(), _bt_split(), _bt_unlink_halfdead_page(), _hash_binsearch(), _hash_binsearch_last(), _hash_finish_split(), _hash_kill_items(), _hash_load_qualified_items(), _hash_splitbucket(), _hash_squeezebucket(), acquire_sample_rows(), addLeafTuple(), addOrReplaceTuple(), bitgetpage(), BitmapHeapNext(), brin_doupdate(), brin_evacuate_page(), brin_page_items(), brinGetTupleForHeapBlock(), brinRevmapDesummarizeRange(), bt_check_level_from_leftmost(), bt_page_print_tuples(), bt_right_page_check_scankey(), bt_target_page_check(), btree_xlog_delete_get_latestRemovedXid(), btree_xlog_mark_page_halfdead(), btree_xlog_split(), btvacuumpage(), checkSplitConditions(), collect_corrupt_items(), collectMatchBitmap(), collectMatchesForHeapRow(), doPickSplit(), entryFindChildPtr(), entryGetLeftMostPage(), entryIsEnoughSpace(), entryLocateEntry(), entryLocateLeafEntry(), entryPreparePage(), entrySplitPage(), GetBTPageStatistics(), getRightMostTuple(), GetTupleForTrigger(), ginbulkdelete(), ginEntryInsert(), ginRedoInsertEntry(), ginVacuumEntryPage(), gistBufferingFindCorrectParent(), gistbufferinginserttuples(), gistbulkdelete(), gistchoose(), gistdoinsert(), gistextractpage(), gistFindCorrectParent(), gistFindPath(), gistformdownlink(), gistGetMaxLevel(), gistMemorizeAllDownlinks(), gistnospace(), gistProcessItup(), gistScanPage(), hash_page_items(), hash_xlog_vacuum_get_latestRemovedXid(), hashbucketcleanup(), heap_abort_speculative(), 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(), heapgetpage(), heapgettup(), heapgettup_pagemode(), 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(), spgWalk(), startScanEntry(), statapprox_heap(), tablesample_getnext(), vacuumLeafPage(), vacuumLeafRoot(), and vacuumRedirectAndPlaceholder().

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

Definition at line 231 of file bufpage.h.

Referenced by _bt_buildadd(), _bt_check_unique(), _bt_checkkeys(), _bt_compare(), _bt_findsplitloc(), _bt_get_endpoint(), _bt_getstackbuf(), _bt_insert_parent(), _bt_isequal(), _bt_killitems(), _bt_mark_page_halfdead(), _bt_newroot(), _bt_pagedel(), _bt_search(), _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(), acquire_sample_rows(), addLeafTuple(), addOrReplaceTuple(), bitgetpage(), BitmapHeapNext(), brin_doupdate(), brin_evacuate_page(), brin_page_items(), brin_start_evacuating_page(), brinGetTupleForHeapBlock(), brininsert(), brinRevmapDesummarizeRange(), bt_check_level_from_leftmost(), bt_page_print_tuples(), bt_right_page_check_scankey(), bt_target_page_check(), btree_xlog_delete_get_latestRemovedXid(), btree_xlog_mark_page_halfdead(), btree_xlog_split(), btvacuumpage(), checkSplitConditions(), collect_corrupt_items(), collectMatchBitmap(), collectMatchesForHeapRow(), compactify_tuples(), count_nondeletable_pages(), doPickSplit(), entryFindChildPtr(), entryGetLeftMostPage(), entryIsEnoughSpace(), entryLocateEntry(), entryLocateLeafEntry(), entryPreparePage(), entrySplitPage(), GetBTPageStatistics(), GetHashPageStatistics(), GetHashPageStats(), getRightMostTuple(), GetTupleForTrigger(), ginbulkdelete(), ginEntryInsert(), ginRedoInsertEntry(), ginVacuumEntryPage(), gistBufferingFindCorrectParent(), gistbufferinginserttuples(), gistbulkdelete(), gistchoose(), gistdoinsert(), gistextractpage(), gistFindCorrectParent(), gistFindPath(), gistformdownlink(), gistGetMaxLevel(), gistkillitems(), gistMemorizeAllDownlinks(), gistnospace(), gistProcessItup(), gistScanPage(), gistvacuumpage(), hash_page_items(), hash_xlog_vacuum_get_latestRemovedXid(), hashbucketcleanup(), heap_abort_speculative(), 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(), heapgetpage(), heapgettup(), heapgettup_pagemode(), lazy_check_needs_freeze(), lazy_scan_heap(), lazy_vacuum_page(), mask_lp_flags(), matchPartialInPendingList(), moveLeafs(), PageAddItemExtended(), PageGetHeapFreeSpace(), 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(), spgWalk(), startScanEntry(), statapprox_heap(), tablesample_getnext(), vacuumLeafPage(), vacuumLeafRoot(), and vacuumRedirectAndPlaceholder().

#define PageGetLSN

(

page

)

PageXLogRecPtrGet(((PageHeader) (page))->pd_lsn)

Definition at line 362 of file bufpage.h.

Referenced by _bt_killitems(), _bt_readpage(), _bt_split(), bt_check_level_from_leftmost(), BufferGetLSNAtomic(), checkXLogConsistency(), gistbulkdelete(), gistdoinsert(), gistFindCorrectParent(), gistFindPath(), gistkillitems(), gistScanPage(), heap_xlog_visible(), lazy_scan_heap(), nextval_internal(), page_header(), TestForOldSnapshot(), XLogCheckBufferNeedsBackup(), XLogReadBufferForRedoExtended(), and XLogRecordAssemble().

#define PageGetMaxOffsetNumber

(

page

)

Value:

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

Definition at line 353 of file bufpage.h.

Referenced by _bt_binsrch(), _bt_check_unique(), _bt_checkkeys(), _bt_endpoint(), _bt_findsplitloc(), _bt_get_endpoint(), _bt_getstackbuf(), _bt_killitems(), _bt_lock_branch_parent(), _bt_mark_page_halfdead(), _bt_pagedel(), _bt_readnextpage(), _bt_readpage(), _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(), acquire_sample_rows(), addOrReplaceTuple(), bitgetpage(), brin_evacuate_page(), brin_page_items(), brin_start_evacuating_page(), brin_xlog_insert_update(), brinGetTupleForHeapBlock(), brinRevmapDesummarizeRange(), bt_downlink_check(), bt_page_items(), bt_page_items_bytea(), bt_right_page_check_scankey(), bt_target_page_check(), 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(), gistBufferingFindCorrectParent(), gistbufferinginserttuples(), gistbulkdelete(), gistchoose(), gistextractpage(), gistfillbuffer(), gistFindCorrectParent(), gistFindPath(), gistformdownlink(), gistMemorizeAllDownlinks(), gistRedoPageUpdateRecord(), gistScanPage(), 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(), heapgetpage(), heapgettup(), lazy_check_needs_freeze(), lazy_scan_heap(), log_heap_update(), mask_lp_flags(), moveLeafs(), moveRightIfItNeeded(), PageAddItemExtended(), PageGetHeapFreeSpace(), PageIndexMultiDelete(), PageIndexTupleDelete(), PageIndexTupleDeleteNoCompact(), PageIndexTupleOverwrite(), PageRepairFragmentation(), pgstat_btree_page(), pgstat_gist_page(), pgstat_hash_page(), processPendingPage(), scanGetCandidate(), SpGistPageAddNewItem(), spgRedoVacuumRedirect(), spgWalk(), statapprox_heap(), tablesample_getnext(), vacuumLeafPage(), vacuumLeafRoot(), and vacuumRedirectAndPlaceholder().

#define PageGetPageLayoutVersion

(

page

)

(((PageHeader) (page))->pd_pagesize_version & 0x00FF)

Definition at line 271 of file bufpage.h.

Referenced by page_header().

#define PageGetPageSize

(

page

)

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

Definition at line 264 of file bufpage.h.

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

#define PageGetSpecialPointer

(

page

)

Value:

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

Definition at line 322 of file bufpage.h.

Referenced by _bt_binsrch(), _bt_blnewpage(), _bt_buildadd(), _bt_check_unique(), _bt_checkkeys(), _bt_clear_incomplete_split(), _bt_compare(), _bt_delitems_delete(), _bt_delitems_vacuum(), _bt_endpoint(), _bt_findinsertloc(), _bt_findsplitloc(), _bt_finish_split(), _bt_get_endpoint(), _bt_getbuf(), _bt_getroot(), _bt_getrootheight(), _bt_getstackbuf(), _bt_gettrueroot(), _bt_initmetapage(), _bt_insert_parent(), _bt_insertonpg(), _bt_is_page_halfdead(), _bt_isequal(), _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_sortaddtup(), _bt_split(), _bt_unlink_halfdead_page(), _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_downlink_check(), bt_page_items(), bt_page_items_bytea(), bt_right_page_check_scankey(), bt_target_page_check(), btree_mask(), 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(), 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(), PageGetTempPageCopySpecial(), palloc_btree_page(), pgstat_btree_page(), pgstat_hash_page(), pgstathashindex(), pgstatindex_impl(), read_seq_tuple(), seq_redo(), and verify_hash_page().

#define PageGetSpecialSize

(

page

)

((uint16) (PageGetPageSize(page) - ((PageHeader)(page))->pd_special))

Definition at line 296 of file bufpage.h.

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

#define PageHasFreeLinePointers

(

page

)

(((PageHeader) (page))->pd_flags & PD_HAS_FREE_LINES)

Definition at line 367 of file bufpage.h.

Referenced by PageAddItemExtended(), and PageGetHeapFreeSpace().

#define PageIsAllVisible

(

page

)

(((PageHeader) (page))->pd_flags & PD_ALL_VISIBLE)

Definition at line 381 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(), heapgetpage(), lazy_scan_heap(), lazy_vacuum_page(), pg_visibility(), RelationGetBufferForTuple(), tablesample_getnext(), and visibilitymap_set().

#define PageIsEmpty

(

page

)

(((PageHeader) (page))->pd_lower <= SizeOfPageHeaderData)

Definition at line 218 of file bufpage.h.

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

#define PageIsFull

(

page

)

(((PageHeader) (page))->pd_flags & PD_PAGE_FULL)

Definition at line 374 of file bufpage.h.

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

#define PageIsNew

(

page

)

(((PageHeader) (page))->pd_upper == 0)

Definition at line 225 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(), GinNewBuffer(), ginvacuumcleanup(), gistcheckpage(), gistNewBuffer(), gistvacuumcleanup(), hash_page_type(), heap_xlog_visible(), lazy_check_needs_freeze(), lazy_scan_heap(), log_newpage(), PageIsVerified(), PageSetChecksumCopy(), PageSetChecksumInplace(), pg_checksum_page(), pgstat_btree_page(), pgstathashindex(), ReadBuffer_common(), RelationGetBufferForTuple(), revmap_physical_extend(), SpGistGetBuffer(), SpGistNewBuffer(), spgprocesspending(), spgvacuumpage(), statapprox_heap(), verify_hash_page(), vm_readbuf(), XLogReadBufferExtended(), XLogReadBufferForRedoExtended(), and XLogRecordPageWithFreeSpace().

#define PageIsPrunable	(		page,
			oldestxmin
	)

Value:

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

Definition at line 388 of file bufpage.h.

Referenced by heap_page_prune_opt().

#define PageIsValid

(

page

)

PointerIsValid(page)

Definition at line 207 of file bufpage.h.

Referenced by PageValidateSpecialPointer().

#define PageSetAllVisible

(

page

)

(((PageHeader) (page))->pd_flags |= PD_ALL_VISIBLE)

Definition at line 383 of file bufpage.h.

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

#define PageSetFull

(

page

)

(((PageHeader) (page))->pd_flags |= PD_PAGE_FULL)

Definition at line 376 of file bufpage.h.

Referenced by heap_update().

#define PageSetHasFreeLinePointers

(

page

)

(((PageHeader) (page))->pd_flags |= PD_HAS_FREE_LINES)

Definition at line 369 of file bufpage.h.

Referenced by PageRepairFragmentation().

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

Definition at line 364 of file bufpage.h.

Referenced by _bt_clear_incomplete_split(), _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(), _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_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(), ginbuild(), ginDeletePage(), ginHeapTupleFastInsert(), ginPlaceToPage(), ginRedoClearIncompleteSplit(), ginRedoCreateIndex(), ginRedoCreatePTree(), ginRedoDeleteListPages(), ginRedoDeletePage(), ginRedoInsert(), ginRedoInsertListPage(), ginRedoUpdateMetapage(), ginRedoVacuumDataLeafPage(), ginUpdateStats(), ginVacuumPostingTreeLeaf(), gistbuild(), gistbulkdelete(), gistplacetopage(), gistRedoClearFollowRight(), gistRedoCreateIndex(), 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_split_page(), MarkBufferDirtyHint(), moveLeafs(), nextval_internal(), revmap_physical_extend(), seq_redo(), shiftList(), spgAddNodeAction(), spgbuild(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoCreateIndex(), spgRedoMoveLeafs(), spgRedoPickSplit(), spgRedoSplitTuple(), spgRedoVacuumLeaf(), spgRedoVacuumRedirect(), spgRedoVacuumRoot(), spgSplitNodeAction(), vacuumLeafPage(), vacuumLeafRoot(), vacuumRedirectAndPlaceholder(), visibilitymap_set(), writeListPage(), XLogReadBufferForRedoExtended(), and xlogVacuumPage().

#define PageSetPageSizeAndVersion	(		page,
			size,
			version
	)

Value:

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

Definition at line 281 of file bufpage.h.

Referenced by PageInit().

#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 394 of file bufpage.h.

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

#define PageSizeIsValid

(

pageSize

)

((pageSize) == BLCKSZ)

Definition at line 254 of file bufpage.h.

#define PageXLogRecPtrGet

(

val

)

((uint64) (val).xlogid << 32 | (val).xrecoff)

Definition at line 96 of file bufpage.h.

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

Definition at line 98 of file bufpage.h.

Referenced by mask_page_lsn_and_checksum().

#define PAI_IS_HEAP   (1 << 1)

Definition at line 410 of file bufpage.h.

Referenced by PageAddItemExtended().

#define PAI_OVERWRITE   (1 << 0)

Definition at line 409 of file bufpage.h.

Referenced by PageAddItemExtended().

#define PD_ALL_VISIBLE

Value:

0x0004  /* all tuples on page are visible to
                                     * everyone */

Definition at line 178 of file bufpage.h.

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

Definition at line 176 of file bufpage.h.

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

Definition at line 177 of file bufpage.h.

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

Definition at line 181 of file bufpage.h.

Referenced by PageIsVerified().

#define PG_DATA_CHECKSUM_VERSION   1

Definition at line 196 of file bufpage.h.

Referenced by AuxiliaryProcessMain(), and sanityChecks().

#define PG_PAGE_LAYOUT_VERSION   4

Definition at line 195 of file bufpage.h.

Referenced by PageInit().

#define SizeOfPageHeaderData   (offsetof(PageHeaderData, pd_linp))

Definition at line 212 of file bufpage.h.

Referenced by _bt_findsplitloc(), bt_page_items_bytea(), calculatePagesPerBuffer(), estimate_rel_size(), GetBTPageStatistics(), gistInitBuffering(), heap_page_items(), mask_page_content(), page_header(), PageAddItemExtended(), PageIndexMultiDelete(), PageIndexTupleDelete(), PageIndexTupleDeleteNoCompact(), PageIndexTupleOverwrite(), PageInit(), PageRepairFragmentation(), PageValidateSpecialPointer(), pgstatindex_impl(), rewriteVisibilityMap(), statapprox_heap(), and XLogRecordAssemble().

Typedef Documentation

typedef uint16 LocationIndex

Definition at line 83 of file bufpage.h.

typedef Pointer Page

Definition at line 74 of file bufpage.h.

typedef PageHeaderData* PageHeader

Definition at line 162 of file bufpage.h.

typedef struct PageHeaderData PageHeaderData

Function Documentation

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

Definition at line 190 of file bufpage.c.

References elog, ereport, errcode(), errmsg(), InvalidOffsetNumber, ItemIdHasStorage, ItemIdIsUsed, ItemIdSetNormal, lower(), MAXALIGN, MaxHeapTuplesPerPage, memmove, 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 item 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;
}

Size PageGetExactFreeSpace

(

Page

page

)

Definition at line 633 of file bufpage.c.

Referenced by _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;
}

Size PageGetFreeSpace

(

Page

page

)

Definition at line 582 of file bufpage.c.

Referenced by _bt_buildadd(), _bt_findinsertloc(), _bt_insertonpg(), _hash_doinsert(), br_page_get_freespace(), entryIsEnoughSpace(), GetBTPageStatistics(), GetHashPageStatistics(), gistnospace(), 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;
}

Size PageGetFreeSpaceForMultipleTuples	(	Page	page,
		int	ntups
	)

Definition at line 609 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;
}

Size PageGetHeapFreeSpace

(

Page

page

)

Definition at line 666 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(), RelationAddExtraBlocks(), 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;
}

Page PageGetTempPage

(

Page

page

)

Definition at line 348 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;
}

Page PageGetTempPageCopy

(

Page

page

)

Definition at line 365 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;
}

Page PageGetTempPageCopySpecial

(

Page

page

)

Definition at line 385 of file bufpage.c.

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

Referenced by 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;
}

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

Definition at line 836 of file bufpage.c.

References itemIdSortData::alignedlen, Assert, compactify_tuples(), elog, ereport, errcode(), 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(), gistbulkdelete(), 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 item 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 item pointer: offset = %u, length = %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);
}

void PageIndexTupleDelete	(	Page	page,
		OffsetNumber	offset
	)

Definition at line 727 of file bufpage.c.

References Assert, elog, ereport, errcode(), errmsg(), ERROR, i, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, ItemIdData::lp_off, MAXALIGN, memmove, 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(), gistplacetopage(), 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 item 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;
        }
    }
}

void PageIndexTupleDeleteNoCompact	(	Page	page,
		OffsetNumber	offset
	)

Definition at line 958 of file bufpage.c.

References Assert, elog, ereport, errcode(), errmsg(), ERROR, i, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, ItemIdSetUnused, ItemIdData::lp_off, MAXALIGN, memmove, 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 item pointer: offset = %u, size = %u",
                        offset, (unsigned int) size)));

    /* Amount of space to actually be deleted */
    size = MAXALIGN(size);

    /*
     * Either set the item 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;
        }
    }
}

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

Definition at line 1066 of file bufpage.c.

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

Referenced by brin_doupdate(), brin_xlog_samepage_update(), 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 item 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 (other fields shouldn't change) */
    ItemIdSetNormal(tupid, offset + size_diff, newsize);

    /* Copy new tuple data onto page */
    memcpy(PageGetItem(page, tupid), newtup, newsize);

    return true;
}

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

Definition at line 41 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(), lazy_scan_heap(), PageGetTempPageCopySpecial(), raw_heap_insert(), RelationAddExtraBlocks(), 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 */
}

bool PageIsVerified	(	Page	page,
		BlockNumber	blkno
	)

Definition at line 81 of file bufpage.c.

References DataChecksumsEnabled(), ereport, 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(), StaticAssertStmt, and WARNING.

Referenced by copy_relation_data(), and ReadBuffer_common().

{
    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. Luckily BLCKSZ is guaranteed to always be a
     * multiple of size_t - and it's much faster to compare memory using the
     * native word size.
     */
    StaticAssertStmt(BLCKSZ == (BLCKSZ / sizeof(size_t)) * sizeof(size_t),
                     "BLCKSZ has to be a multiple of sizeof(size_t)");

    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_DATA_CORRUPTED,
                 errmsg("page verification failed, calculated checksum %u but expected %u",
                        checksum, p->pd_checksum)));

        if (header_sane && ignore_checksum_failure)
            return true;
    }

    return false;
}

void PageRepairFragmentation

(

Page

page

)

Definition at line 479 of file bufpage.c.

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

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;
    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)));

    nline = PageGetMaxOffsetNumber(page);
    nunused = nstorage = 0;
    for (i = FirstOffsetNumber; i <= nline; i++)
    {
        lp = PageGetItemId(page, i);
        if (ItemIdIsUsed(lp))
        {
            if (ItemIdHasStorage(lp))
                nstorage++;
        }
        else
        {
            /* Unused entries should have lp_len = 0, but make sure */
            ItemIdSetUnused(lp);
            nunused++;
        }
    }

    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 */
        itemIdSortData itemidbase[MaxHeapTuplesPerPage];
        itemIdSort  itemidptr = itemidbase;

        totallen = 0;
        for (i = 0; i < nline; i++)
        {
            lp = PageGetItemId(page, i + 1);
            if (ItemIdHasStorage(lp))
            {
                itemidptr->offsetindex = i;
                itemidptr->itemoff = ItemIdGetOffset(lp);
                if (itemidptr->itemoff < (int) pd_upper ||
                    itemidptr->itemoff >= (int) pd_special)
                    ereport(ERROR,
                            (errcode(ERRCODE_DATA_CORRUPTED),
                             errmsg("corrupted item pointer: %u",
                                    itemidptr->itemoff)));
                itemidptr->alignedlen = MAXALIGN(ItemIdGetLength(lp));
                totallen += itemidptr->alignedlen;
                itemidptr++;
            }
        }

        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);
}

void PageRestoreTempPage	(	Page	tempPage,
		Page	oldPage
	)

Definition at line 407 of file bufpage.c.

References PageGetPageSize, and pfree().

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

{
    Size        pageSize;

    pageSize = PageGetPageSize(tempPage);
    memcpy((char *) oldPage, (char *) tempPage, pageSize);

    pfree(tempPage);
}

char* PageSetChecksumCopy	(	Page	page,
		BlockNumber	blkno
	)

Definition at line 1170 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;
}

void PageSetChecksumInplace	(	Page	page,
		BlockNumber	blkno
	)

Definition at line 1199 of file bufpage.c.

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

Referenced by _bt_blwritepage(), blbuildempty(), btbuildempty(), copy_relation_data(), end_heap_rewrite(), FlushRelationBuffers(), fsm_extend(), LocalBufferAlloc(), raw_heap_insert(), 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);
}

static bool PageValidateSpecialPointer ( Page  page )

inlinestatic

Definition at line 309 of file bufpage.h.

References Assert, PageIsValid, and SizeOfPageHeaderData.

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

    return true;
}