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	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	SizeOfPageHeaderData   (offsetof(PageHeaderData, pd_linp))
#define	PageGetSpecialPointer(page)
#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	PIV_LOG_WARNING   (1 << 0)
#define	PIV_LOG_LOG   (1 << 1)
#define	PIV_IGNORE_CHECKSUM_FAILURE   (1 << 2)
#define	PageAddItem(page, item, size, offsetNumber, overwrite, is_heap)

Typedefs
typedef char	PageData
typedef PageData *	Page
typedef uint16	LocationIndex
typedef struct PageHeaderData	PageHeaderData
typedef PageHeaderData *	PageHeader

Functions
static XLogRecPtr	PageXLogRecPtrGet (PageXLogRecPtr val)
static bool	PageIsEmpty (const PageData *page)
static bool	PageIsNew (const PageData *page)
static ItemId	PageGetItemId (Page page, OffsetNumber offsetNumber)
static char *	PageGetContents (Page page)
static Size	PageGetPageSize (const PageData *page)
static uint8	PageGetPageLayoutVersion (const PageData *page)
static void	PageSetPageSizeAndVersion (Page page, Size size, uint8 version)
static uint16	PageGetSpecialSize (const PageData *page)
static void	PageValidateSpecialPointer (const PageData *page)
static Item	PageGetItem (const PageData *page, const ItemIdData *itemId)
static OffsetNumber	PageGetMaxOffsetNumber (const PageData *page)
static XLogRecPtr	PageGetLSN (const PageData *page)
static void	PageSetLSN (Page page, XLogRecPtr lsn)
static bool	PageHasFreeLinePointers (const PageData *page)
static void	PageSetHasFreeLinePointers (Page page)
static void	PageClearHasFreeLinePointers (Page page)
static bool	PageIsFull (const PageData *page)
static void	PageSetFull (Page page)
static void	PageClearFull (Page page)
static bool	PageIsAllVisible (const PageData *page)
static void	PageSetAllVisible (Page page)
static void	PageClearAllVisible (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 (PageData *page, BlockNumber blkno, int flags, bool *checksum_failure_p)
OffsetNumber	PageAddItemExtended (Page page, Item item, Size size, OffsetNumber offsetNumber, int flags)
Page	PageGetTempPage (const PageData *page)
Page	PageGetTempPageCopy (const PageData *page)
Page	PageGetTempPageCopySpecial (const PageData *page)
void	PageRestoreTempPage (Page tempPage, Page oldPage)
void	PageRepairFragmentation (Page page)
void	PageTruncateLinePointerArray (Page page)
Size	PageGetFreeSpace (const PageData *page)
Size	PageGetFreeSpaceForMultipleTuples (const PageData *page, int ntups)
Size	PageGetExactFreeSpace (const PageData *page)
Size	PageGetHeapFreeSpace (const PageData *page)
void	PageIndexTupleDelete (Page page, OffsetNumber offnum)
void	PageIndexMultiDelete (Page page, OffsetNumber *itemnos, int nitems)
void	PageIndexTupleDeleteNoCompact (Page page, OffsetNumber offnum)
bool	PageIndexTupleOverwrite (Page page, OffsetNumber offnum, Item newtup, Size newsize)
char *	PageSetChecksumCopy (Page page, BlockNumber blkno)
void	PageSetChecksumInplace (Page page, BlockNumber blkno)

Variables
PGDLLIMPORT bool	ignore_checksum_failure

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

PageClearPrunable

#define PageClearPrunable

(

page

)

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

Definition at line 454 of file bufpage.h.

PageGetSpecialPointer

#define PageGetSpecialPointer

(

page

)

Value:

( \
    PageValidateSpecialPointer(page), \
    ((page) + ((PageHeader) (page))->pd_special) \
)

Definition at line 339 of file bufpage.h.

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

PageXLogRecPtrSet

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

Definition at line 110 of file bufpage.h.

PAI_IS_HEAP

#define PAI_IS_HEAP   (1 << 1)

Definition at line 465 of file bufpage.h.

PAI_OVERWRITE

#define PAI_OVERWRITE   (1 << 0)

Definition at line 464 of file bufpage.h.

PD_ALL_VISIBLE

#define PD_ALL_VISIBLE

Value:

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

Definition at line 190 of file bufpage.h.

PD_HAS_FREE_LINES

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

Definition at line 188 of file bufpage.h.

PD_PAGE_FULL

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

Definition at line 189 of file bufpage.h.

PD_VALID_FLAG_BITS

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

Definition at line 192 of file bufpage.h.

PG_DATA_CHECKSUM_VERSION

#define PG_DATA_CHECKSUM_VERSION   1

Definition at line 207 of file bufpage.h.

PG_PAGE_LAYOUT_VERSION

#define PG_PAGE_LAYOUT_VERSION   4

Definition at line 206 of file bufpage.h.

PIV_IGNORE_CHECKSUM_FAILURE

#define PIV_IGNORE_CHECKSUM_FAILURE   (1 << 2)

Definition at line 470 of file bufpage.h.

PIV_LOG_LOG

#define PIV_LOG_LOG   (1 << 1)

Definition at line 469 of file bufpage.h.

PIV_LOG_WARNING

#define PIV_LOG_WARNING   (1 << 0)

Definition at line 468 of file bufpage.h.

SizeOfPageHeaderData

#define SizeOfPageHeaderData   (offsetof(PageHeaderData, pd_linp))

Definition at line 217 of file bufpage.h.

Typedef Documentation

LocationIndex

typedef uint16 LocationIndex

Definition at line 91 of file bufpage.h.

Page

typedef PageData* Page

Definition at line 82 of file bufpage.h.

PageData

typedef char PageData

Definition at line 81 of file bufpage.h.

PageHeader

typedef PageHeaderData* PageHeader

Definition at line 174 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 193 of file bufpage.c.

{
    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(page, 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(page))
        {
            /*
             * Scan line pointer array to locate a "recyclable" (unused)
             * ItemId.
             *
             * Always use earlier items first.  PageTruncateLinePointerArray
             * can only truncate unused items when they appear as a contiguous
             * group at the end of the line pointer array.
             */
            for (offsetNumber = FirstOffsetNumber;
                 offsetNumber < limit;  /* limit is maxoff+1 */
                 offsetNumber++)
            {
                itemId = PageGetItemId(page, offsetNumber);
 
                /*
                 * We check for no storage as well, just to be paranoid;
                 * unused items should never have storage.  Assert() that the
                 * invariant is respected too.
                 */
                Assert(ItemIdIsUsed(itemId) || !ItemIdHasStorage(itemId));
 
                if (!ItemIdIsUsed(itemId) && !ItemIdHasStorage(itemId))
                    break;
            }
            if (offsetNumber >= limit)
            {
                /* the hint is wrong, so reset it */
                PageClearHasFreeLinePointers(page);
            }
        }
        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(page, 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;
}

References Assert(), elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), FirstOffsetNumber, 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.

PageClearAllVisible()

static void PageClearAllVisible ( Page  page )

inlinestatic

Definition at line 439 of file bufpage.h.

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

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

PageClearFull()

static void PageClearFull ( Page  page )

inlinestatic

Definition at line 423 of file bufpage.h.

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

Referenced by heap_page_prune_and_freeze(), and mask_page_hint_bits().

PageClearHasFreeLinePointers()

static void PageClearHasFreeLinePointers ( Page  page )

inlinestatic

Definition at line 407 of file bufpage.h.

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

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

PageGetContents()

static char * PageGetContents ( Page  page )

inlinestatic

Definition at line 258 of file bufpage.h.

{
    return (char *) page + MAXALIGN(SizeOfPageHeaderData);

References MAXALIGN, and SizeOfPageHeaderData.

Referenced by brin_metapage_info(), brin_metapage_init(), brin_revmap_data(), brin_xlog_revmap_extend(), brinGetStats(), brinGetTupleForHeapBlock(), brinRevmapDesummarizeRange(), brinRevmapInitialize(), brinSetHeapBlockItemptr(), BTPageGetDeleteXid(), BTPageSetDeleted(), 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(), GistPageGetDeleteXid(), GistPageSetDeleted(), revmap_physical_extend(), visibilitymap_clear(), visibilitymap_count(), visibilitymap_get_status(), visibilitymap_prepare_truncate(), and visibilitymap_set().

PageGetExactFreeSpace()

Size PageGetExactFreeSpace

(

const PageData *

page

)

Definition at line 957 of file bufpage.c.

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

References PageHeaderData::pd_lower, and PageHeaderData::pd_upper.

Referenced by _bt_bottomupdel_pass(), _bt_dedup_pass(), _bt_findsplitloc(), allocNewBuffer(), brin_can_do_samepage_update(), doPickSplit(), GetHashPageStats(), ginHeapTupleFastInsert(), pgstat_heap(), pgstat_index_page(), pgstatindex_impl(), spgAddNodeAction(), SpGistGetBuffer(), SpGistPageAddNewItem(), SpGistSetLastUsedPage(), statapprox_heap(), and writeListPage().

PageGetFreeSpace()

Size PageGetFreeSpace

(

const PageData *

page

)

Definition at line 906 of file bufpage.c.

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

References PageHeaderData::pd_lower, and PageHeaderData::pd_upper.

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

PageGetFreeSpaceForMultipleTuples()

Size PageGetFreeSpaceForMultipleTuples	(	const PageData *	page,
		int	ntups
	)

Definition at line 933 of file bufpage.c.

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

References PageHeaderData::pd_lower, and PageHeaderData::pd_upper.

Referenced by _hash_splitbucket(), and _hash_squeezebucket().

PageGetHeapFreeSpace()

Size PageGetHeapFreeSpace

(

const PageData *

page

)

Definition at line 990 of file bufpage.c.

{
    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(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(unconstify(PageData *, 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;
}

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

Referenced by heap_multi_insert(), heap_page_prune_opt(), heap_update(), heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_prune_freeze(), heap_xlog_update(), lazy_scan_heap(), lazy_scan_new_or_empty(), lazy_vacuum_heap_rel(), raw_heap_insert(), and RelationGetBufferForTuple().

PageGetItem()

static Item PageGetItem ( const PageData *  page, const ItemIdData *  itemId  )

inlinestatic

Definition at line 354 of file bufpage.h.

{
    Assert(page);
    Assert(ItemIdHasStorage(itemId));
 
    return (Item) (((const char *) page) + ItemIdGetOffset(itemId));

References Assert(), ItemIdGetOffset, and ItemIdHasStorage.

Referenced by _bt_afternewitemoff(), _bt_binsrch_posting(), _bt_bottomupdel_finish_pending(), _bt_bottomupdel_pass(), _bt_buildadd(), _bt_check_natts(), _bt_check_unique(), _bt_checkkeys_look_ahead(), _bt_compare(), _bt_deadblocks(), _bt_dedup_pass(), _bt_delitems_delete_check(), _bt_do_singleval(), _bt_get_endpoint(), _bt_getstackbuf(), _bt_insert_parent(), _bt_insertonpg(), _bt_killitems(), _bt_mark_page_halfdead(), _bt_newlevel(), _bt_pagedel(), _bt_readpage(), _bt_recsplitloc(), _bt_search(), _bt_set_startikey(), _bt_simpledel_pass(), _bt_split(), _bt_split_firstright(), _bt_split_lastleft(), _bt_strategy(), _bt_unlink_halfdead_page(), _hash_binsearch(), _hash_binsearch_last(), _hash_finish_split(), _hash_kill_items(), _hash_load_qualified_items(), _hash_pgaddtup(), _hash_splitbucket(), _hash_squeezebucket(), addLeafTuple(), addOrReplaceTuple(), BitmapHeapScanNextBlock(), brin_doupdate(), brin_evacuate_page(), brin_page_items(), brinGetTupleForHeapBlock(), 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_updates(), btvacuumpage(), checkSplitConditions(), collect_corrupt_items(), collectMatchBitmap(), collectMatchesForHeapRow(), doPickSplit(), entryFindChildPtr(), entryGetLeftMostPage(), entryIsEnoughSpace(), entryLocateEntry(), entryLocateLeafEntry(), entryPreparePage(), entrySplitPage(), GetBTPageStatistics(), getRightMostTuple(), gin_check_parent_keys_consistency(), gin_refind_parent(), ginbulkdelete(), ginEntryInsert(), ginRedoInsertEntry(), ginVacuumEntryPage(), gist_page_items(), gist_page_items_bytea(), 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_delete(), heap_fetch(), heap_finish_speculative(), heap_force_common(), heap_freeze_prepared_tuples(), heap_get_latest_tid(), heap_get_root_tuples(), heap_hot_search_buffer(), heap_index_delete_tuples(), heap_lock_tuple(), heap_page_is_all_visible(), heap_page_items(), heap_page_prune_and_freeze(), heap_page_prune_execute(), heap_pre_freeze_checks(), heap_prune_chain(), heap_prune_record_unchanged_lp_normal(), heap_update(), heap_xlog_confirm(), heap_xlog_delete(), heap_xlog_inplace(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_prune_freeze(), heap_xlog_update(), heapam_scan_analyze_next_tuple(), heapam_scan_bitmap_next_tuple(), heapam_scan_sample_next_tuple(), heapgettup(), heapgettup_pagemode(), index_compute_xid_horizon_for_tuples(), index_delete_check_htid(), invariant_l_nontarget_offset(), invariant_l_offset(), lazy_scan_noprune(), matchPartialInPendingList(), moveLeafs(), page_collect_tuples(), page_verify_redirects(), PageIndexTupleOverwrite(), processPendingPage(), raw_heap_insert(), read_seq_tuple(), RelationPutHeapTuple(), saveNodeLink(), scanGetCandidate(), ScanSourceDatabasePgClassPage(), setRedirectionTuple(), spgdoinsert(), SpGistPageAddNewItem(), spgprocesspending(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoMoveLeafs(), spgRedoPickSplit(), spgRedoVacuumLeaf(), spgRedoVacuumRedirect(), spgSplitNodeAction(), spgTestLeafTuple(), spgWalk(), startScanEntry(), statapprox_heap(), vacuumLeafPage(), vacuumLeafRoot(), vacuumRedirectAndPlaceholder(), and verify_heapam().

PageGetItemId()

static ItemId PageGetItemId ( Page  page, OffsetNumber  offsetNumber  )

inlinestatic

Definition at line 244 of file bufpage.h.

{
    return &((PageHeader) page)->pd_linp[offsetNumber - 1];

Referenced by _bt_afternewitemoff(), _bt_binsrch_posting(), _bt_bottomupdel_finish_pending(), _bt_bottomupdel_pass(), _bt_buildadd(), _bt_check_natts(), _bt_check_unique(), _bt_checkkeys_look_ahead(), _bt_compare(), _bt_deadblocks(), _bt_dedup_pass(), _bt_delete_or_dedup_one_page(), _bt_delitems_delete_check(), _bt_do_singleval(), _bt_findsplitloc(), _bt_get_endpoint(), _bt_getstackbuf(), _bt_insert_parent(), _bt_insertonpg(), _bt_killitems(), _bt_mark_page_halfdead(), _bt_newlevel(), _bt_pagedel(), _bt_readpage(), _bt_recsplitloc(), _bt_search(), _bt_set_startikey(), _bt_simpledel_pass(), _bt_slideleft(), _bt_split(), _bt_split_firstright(), _bt_split_lastleft(), _bt_split_penalty(), _bt_strategy(), _bt_unlink_halfdead_page(), _hash_binsearch(), _hash_binsearch_last(), _hash_finish_split(), _hash_kill_items(), _hash_load_qualified_items(), _hash_pgaddtup(), _hash_splitbucket(), _hash_squeezebucket(), _hash_vacuum_one_page(), addLeafTuple(), addOrReplaceTuple(), BitmapHeapScanNextBlock(), 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_updates(), 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(), gist_page_items(), gist_page_items_bytea(), 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_delete(), heap_fetch(), heap_finish_speculative(), heap_force_common(), heap_freeze_prepared_tuples(), heap_get_latest_tid(), heap_get_root_tuples(), heap_hot_search_buffer(), heap_index_delete_tuples(), heap_lock_tuple(), heap_mask(), heap_page_is_all_visible(), heap_page_items(), heap_page_prune_and_freeze(), heap_page_prune_execute(), heap_pre_freeze_checks(), heap_prune_chain(), heap_prune_record_unchanged_lp_normal(), heap_update(), heap_xlog_confirm(), heap_xlog_delete(), heap_xlog_inplace(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_prune_freeze(), heap_xlog_update(), heapam_scan_analyze_next_tuple(), heapam_scan_bitmap_next_tuple(), heapam_scan_sample_next_tuple(), heapgettup(), heapgettup_pagemode(), index_compute_xid_horizon_for_tuples(), index_delete_check_htid(), lazy_scan_noprune(), lazy_vacuum_heap_page(), mask_lp_flags(), matchPartialInPendingList(), moveLeafs(), page_collect_tuples(), page_verify_redirects(), PageAddItemExtended(), PageGetHeapFreeSpace(), PageGetItemIdCareful(), PageIndexMultiDelete(), PageIndexTupleDelete(), PageIndexTupleDeleteNoCompact(), PageIndexTupleOverwrite(), PageRepairFragmentation(), PageTruncateLinePointerArray(), pgstat_index_page(), processPendingPage(), raw_heap_insert(), read_seq_tuple(), RelationPutHeapTuple(), saveNodeLink(), scanGetCandidate(), ScanSourceDatabasePgClassPage(), setRedirectionTuple(), spgdoinsert(), SpGistPageAddNewItem(), spgprocesspending(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoMoveLeafs(), spgRedoPickSplit(), spgRedoVacuumLeaf(), spgRedoVacuumRedirect(), spgSplitNodeAction(), spgTestLeafTuple(), spgWalk(), startScanEntry(), statapprox_heap(), vacuumLeafPage(), vacuumLeafRoot(), vacuumRedirectAndPlaceholder(), and verify_heapam().

PageGetLSN()

static XLogRecPtr PageGetLSN ( const PageData *  page )

inlinestatic

Definition at line 386 of file bufpage.h.

{
    return PageXLogRecPtrGet(((const PageHeaderData *) page)->pd_lsn);

References PageXLogRecPtrGet().

Referenced by _bt_dedup_pass(), _bt_split(), bt_check_level_from_leftmost(), bt_downlink_missing_check(), bt_leftmost_ignoring_half_dead(), BufferGetLSNAtomic(), gist_page_opaque_info(), gistdoinsert(), gistFindCorrectParent(), lazy_scan_new_or_empty(), nextval_internal(), page_header(), verify_page_checksum(), verifyBackupPageConsistency(), XLogCheckBufferNeedsBackup(), XLogReadBufferForRedoExtended(), and XLogRecordAssemble().

PageGetMaxOffsetNumber()

static OffsetNumber PageGetMaxOffsetNumber ( const PageData *  page )

inlinestatic

Definition at line 372 of file bufpage.h.

{
    const PageHeaderData *pageheader = (const PageHeaderData *) page;
 
    if (pageheader->pd_lower <= SizeOfPageHeaderData)
        return 0;
    else
        return (pageheader->pd_lower - SizeOfPageHeaderData) / sizeof(ItemIdData);

References PageHeaderData::pd_lower, and SizeOfPageHeaderData.

Referenced by _bt_binsrch(), _bt_binsrch_insert(), _bt_bottomupdel_pass(), _bt_check_natts(), _bt_check_unique(), _bt_dedup_finish_pending(), _bt_dedup_pass(), _bt_delete_or_dedup_one_page(), _bt_do_singleval(), _bt_endpoint(), _bt_findinsertloc(), _bt_findsplitloc(), _bt_get_endpoint(), _bt_getstackbuf(), _bt_killitems(), _bt_lock_subtree_parent(), _bt_mark_page_halfdead(), _bt_pagedel(), _bt_readnextpage(), _bt_readpage(), _bt_search_insert(), _bt_slideleft(), _bt_split(), _bt_unlink_halfdead_page(), _hash_binsearch(), _hash_binsearch_last(), _hash_finish_split(), _hash_kill_items(), _hash_load_qualified_items(), _hash_pgaddtup(), _hash_splitbucket(), _hash_squeezebucket(), _hash_vacuum_one_page(), addOrReplaceTuple(), BitmapHeapScanNextBlock(), 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_bytea(), bt_page_items_internal(), bt_right_page_check_scankey(), bt_rootdescend(), bt_target_page_check(), btree_xlog_dedup(), btvacuumpage(), check_index_page(), checkSplitConditions(), collect_corrupt_items(), compactify_tuples(), count_nondeletable_pages(), doPickSplit(), entryFindChildPtr(), entryGetLeftMostPage(), entryLocateEntry(), entryLocateLeafEntry(), entrySplitPage(), GetBTPageStatistics(), GetHashPageStatistics(), GetHashPageStats(), getRightMostTuple(), gin_check_parent_keys_consistency(), gin_refind_parent(), ginbulkdelete(), ginHeapTupleFastInsert(), ginInsertCleanup(), ginRedoInsertEntry(), ginRedoUpdateMetapage(), ginvacuumcleanup(), ginVacuumEntryPage(), ginVacuumPostingTreeLeaves(), gist_page_items(), gist_page_items_bytea(), 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_force_common(), heap_get_latest_tid(), heap_get_root_tuples(), heap_hot_search_buffer(), heap_index_delete_tuples(), heap_insert(), heap_mask(), heap_multi_insert(), heap_page_is_all_visible(), heap_page_items(), heap_page_prune_and_freeze(), heap_prepare_pagescan(), 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_sample_next_tuple(), heapgettup_continue_page(), heapgettup_start_page(), lazy_scan_noprune(), log_heap_update(), mask_lp_flags(), moveLeafs(), moveRightIfItNeeded(), page_verify_redirects(), PageAddItemExtended(), PageGetHeapFreeSpace(), PageIndexMultiDelete(), PageIndexTupleDelete(), PageIndexTupleDeleteNoCompact(), PageIndexTupleOverwrite(), PageRepairFragmentation(), PageTruncateLinePointerArray(), palloc_btree_page(), pgstat_btree_page(), pgstat_gist_page(), pgstat_hash_page(), processPendingPage(), RelationGetBufferForTuple(), scanGetCandidate(), ScanSourceDatabasePgClassPage(), SpGistPageAddNewItem(), spgRedoVacuumRedirect(), spgWalk(), statapprox_heap(), vacuumLeafPage(), vacuumLeafRoot(), vacuumRedirectAndPlaceholder(), and verify_heapam().

PageGetPageLayoutVersion()

static uint8 PageGetPageLayoutVersion ( const PageData *  page )

inlinestatic

Definition at line 287 of file bufpage.h.

{
    return (((const PageHeaderData *) page)->pd_pagesize_version & 0x00FF);

Referenced by page_header().

PageGetPageSize()

static Size PageGetPageSize ( const PageData *  page )

inlinestatic

Definition at line 277 of file bufpage.h.

{
    return (Size) (((const PageHeaderData *) page)->pd_pagesize_version & (uint16) 0xFF00);

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

PageGetSpecialSize()

static uint16 PageGetSpecialSize ( const PageData *  page )

inlinestatic

Definition at line 317 of file bufpage.h.

{
    return (PageGetPageSize(page) - ((const PageHeaderData *) page)->pd_special);

References PageGetPageSize().

Referenced by _bt_checkpage(), _hash_checkpage(), brin_page_type(), bt_page_items_bytea(), check_index_page(), gin_leafpage_items(), gin_metapage_info(), gin_page_opaque_info(), gistcheckpage(), PageGetTempPageCopySpecial(), pgstat_hash_page(), pgstathashindex(), verify_brin_page(), verify_gist_page(), and verify_hash_page().

PageGetTempPage()

Page PageGetTempPage

(

const PageData *

page

)

Definition at line 364 of file bufpage.c.

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

References PageGetPageSize(), and palloc().

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

PageGetTempPageCopy()

Page PageGetTempPageCopy

(

const PageData *

page

)

Definition at line 381 of file bufpage.c.

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

References PageGetPageSize(), and palloc().

Referenced by entrySplitPage(), and ginVacuumEntryPage().

PageGetTempPageCopySpecial()

Page PageGetTempPageCopySpecial

(

const PageData *

page

)

Definition at line 401 of file bufpage.c.

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

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

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

PageHasFreeLinePointers()

static bool PageHasFreeLinePointers ( const PageData *  page )

inlinestatic

Definition at line 397 of file bufpage.h.

{
    return ((const PageHeaderData *) page)->pd_flags & PD_HAS_FREE_LINES;

References PD_HAS_FREE_LINES.

Referenced by PageAddItemExtended(), and PageGetHeapFreeSpace().

PageIndexMultiDelete()

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

Definition at line 1160 of file bufpage.c.

{
    PageHeader  phdr = (PageHeader) page;
    Offset      pd_lower = phdr->pd_lower;
    Offset      pd_upper = phdr->pd_upper;
    Offset      pd_special = phdr->pd_special;
    Offset      last_offset;
    itemIdCompactData itemidbase[MaxIndexTuplesPerPage];
    ItemIdData  newitemids[MaxIndexTuplesPerPage];
    itemIdCompact itemidptr;
    ItemId      lp;
    int         nline,
                nused;
    Size        totallen;
    Size        size;
    unsigned    offset;
    int         nextitm;
    OffsetNumber offnum;
    bool        presorted = true;   /* For now */
 
    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;
    last_offset = pd_special;
    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;
 
            if (last_offset > itemidptr->itemoff)
                last_offset = itemidptr->itemoff;
            else
                presorted = false;
 
            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 */
    if (nused > 0)
        compactify_tuples(itemidbase, nused, page, presorted);
    else
        phdr->pd_upper = pd_special;
}

References itemIdCompactData::alignedlen, Assert(), compactify_tuples(), elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), ERROR, FirstOffsetNumber, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, itemIdCompactData::itemoff, MAXALIGN, MaxIndexTuplesPerPage, nitems, itemIdCompactData::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().

PageIndexTupleDelete()

void PageIndexTupleDelete	(	Page	page,
		OffsetNumber	offnum
	)

Definition at line 1051 of file bufpage.c.

{
    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(&(phdr->pd_linp[offidx]),
                &(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(page, i);
 
            Assert(ItemIdHasStorage(ii));
            if (ItemIdGetOffset(ii) <= offset)
                ii->lp_off += size;
        }
    }
}

References Assert(), elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), ERROR, i, if(), 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().

PageIndexTupleDeleteNoCompact()

void PageIndexTupleDeleteNoCompact	(	Page	page,
		OffsetNumber	offnum
	)

Definition at line 1294 of file bufpage.c.

{
    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(page, i);
 
            if (ItemIdHasStorage(ii) && ItemIdGetOffset(ii) <= offset)
                ii->lp_off += size;
        }
    }
}

References Assert(), elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), ERROR, i, if(), 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().

PageIndexTupleOverwrite()

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

Definition at line 1404 of file bufpage.c.

{
    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(page, 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;
}

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_delete(), _bt_delitems_vacuum(), _bt_mark_page_halfdead(), brin_doupdate(), brin_xlog_samepage_update(), btree_xlog_updates(), gistplacetopage(), and gistRedoPageUpdateRecord().

PageInit()

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

Definition at line 42 of file bufpage.c.

{
    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 */
}

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_fork_with_data(), fsm_readbuf(), GinInitPage(), gistinitpage(), heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_update(), heap_xlog_visible(), modify_rel_block(), PageGetTempPageCopySpecial(), raw_heap_insert(), RelationAddBlocks(), RelationGetBufferForTuple(), seq_redo(), SpGistInitPage(), vm_readbuf(), and XLogRecordPageWithFreeSpace().

PageIsAllVisible()

static bool PageIsAllVisible ( const PageData *  page )

inlinestatic

Definition at line 429 of file bufpage.h.

{
    return ((const PageHeaderData *) page)->pd_flags & PD_ALL_VISIBLE;

References PD_ALL_VISIBLE.

Referenced by collect_visibility_data(), GetVisibilityMapPins(), heap_abort_speculative(), heap_delete(), heap_force_common(), heap_insert(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_multi_insert(), heap_prepare_pagescan(), heap_update(), heapam_scan_sample_next_tuple(), lazy_scan_new_or_empty(), lazy_scan_prune(), lazy_vacuum_heap_page(), pg_visibility(), RelationGetBufferForTuple(), and visibilitymap_set().

PageIsEmpty()

static bool PageIsEmpty ( const PageData *  page )

inlinestatic

Definition at line 224 of file bufpage.h.

{
    return ((const PageHeaderData *) page)->pd_lower <= SizeOfPageHeaderData;

References SizeOfPageHeaderData.

Referenced by _hash_squeezebucket(), count_nondeletable_pages(), ginHeapTupleFastInsert(), ginRedoUpdateMetapage(), gistfillbuffer(), GistPageSetDeleted(), gistRedoPageUpdateRecord(), lazy_scan_new_or_empty(), modify_rel_block(), PageIndexTupleDelete(), PageIndexTupleDeleteNoCompact(), ScanSourceDatabasePgClass(), SpGistGetBuffer(), SpGistNewBuffer(), spgvacuumpage(), and statapprox_heap().

PageIsFull()

static bool PageIsFull ( const PageData *  page )

inlinestatic

Definition at line 413 of file bufpage.h.

{
    return ((const PageHeaderData *) page)->pd_flags & PD_PAGE_FULL;

References PD_PAGE_FULL.

Referenced by heap_page_prune_and_freeze(), and heap_page_prune_opt().

PageIsNew()

static bool PageIsNew ( const PageData *  page )

inlinestatic

Definition at line 234 of file bufpage.h.

{
    return ((const PageHeaderData *) page)->pd_upper == 0;

Referenced by _bt_allocbuf(), _bt_checkpage(), _hash_checkpage(), blbulkdelete(), blgetbitmap(), blinsert(), BloomNewBuffer(), BloomPageAddItem(), blvacuumcleanup(), brin_metapage_info(), brin_page_cleanup(), brin_page_items(), brin_page_type(), brin_revmap_data(), brin_start_evacuating_page(), bt_page_items_bytea(), BTPageGetDeleteXid(), BTPageIsRecyclable(), btvacuumpage(), check_index_page(), count_nondeletable_pages(), ExtendBufferedRelShared(), fsm_page_contents(), fsm_readbuf(), gin_leafpage_items(), gin_metapage_info(), gin_page_opaque_info(), GinPageIsRecyclable(), gist_page_items(), gist_page_items_bytea(), gist_page_opaque_info(), gistcheckpage(), gistdeletepage(), gistNewBuffer(), gistPageRecyclable(), gistvacuum_delete_empty_pages(), hash_page_type(), heap_xlog_visible(), lazy_scan_new_or_empty(), log_newpage(), log_newpage_range(), log_newpages(), page_checksum_internal(), PageIsVerified(), PageSetChecksumCopy(), PageSetChecksumInplace(), pg_checksum_page(), pgstat_btree_page(), pgstathashindex(), RelationAddBlocks(), RelationGetBufferForTuple(), revmap_physical_extend(), scan_file(), ScanSourceDatabasePgClass(), SpGistGetBuffer(), SpGistNewBuffer(), spgprocesspending(), spgvacuumpage(), statapprox_heap(), verify_brin_page(), verify_gist_page(), verify_hash_page(), verify_page_checksum(), vm_readbuf(), XLogReadBufferExtended(), XLogReadBufferForRedoExtended(), and XLogRecordPageWithFreeSpace().

PageIsVerified()

bool PageIsVerified	(	PageData *	page,
		BlockNumber	blkno,
		int	flags,
		bool *	checksum_failure_p
	)

Definition at line 94 of file bufpage.c.

{
    const PageHeaderData *p = (const PageHeaderData *) page;
    size_t     *pagebytes;
    bool        checksum_failure = false;
    bool        header_sane = false;
    uint16      checksum = 0;
 
    if (checksum_failure_p)
        *checksum_failure_p = false;
 
    /*
     * Don't verify page data unless the page passes basic non-zero test
     */
    if (!PageIsNew(page))
    {
        if (DataChecksumsEnabled())
        {
            checksum = pg_checksum_page(page, blkno);
 
            if (checksum != p->pd_checksum)
            {
                checksum_failure = true;
                if (checksum_failure_p)
                    *checksum_failure_p = 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 */
    pagebytes = (size_t *) page;
 
    if (pg_memory_is_all_zeros(pagebytes, BLCKSZ))
        return true;
 
    /*
     * Throw a WARNING/LOG, as instructed by PIV_LOG_*, if the checksum fails,
     * but only after we've checked for the all-zeroes case.
     */
    if (checksum_failure)
    {
        if ((flags & (PIV_LOG_WARNING | PIV_LOG_LOG)) != 0)
            ereport(flags & PIV_LOG_WARNING ? WARNING : LOG,
                    (errcode(ERRCODE_DATA_CORRUPTED),
                     errmsg("page verification failed, calculated checksum %u but expected %u",
                            checksum, p->pd_checksum)));
 
        if (header_sane && (flags & PIV_IGNORE_CHECKSUM_FAILURE))
            return true;
    }
 
    return false;
}

References checksum_failure, DataChecksumsEnabled(), ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), LOG, MAXALIGN, PageIsNew(), PageHeaderData::pd_checksum, PageHeaderData::pd_flags, PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, PD_VALID_FLAG_BITS, pg_checksum_page(), pg_memory_is_all_zeros(), PIV_IGNORE_CHECKSUM_FAILURE, PIV_LOG_LOG, PIV_LOG_WARNING, and WARNING.

Referenced by buffer_readv_complete_one(), and RelationCopyStorage().

PageRepairFragmentation()

void PageRepairFragmentation

(

Page

page

)

Definition at line 698 of file bufpage.c.

{
    Offset      pd_lower = ((PageHeader) page)->pd_lower;
    Offset      pd_upper = ((PageHeader) page)->pd_upper;
    Offset      pd_special = ((PageHeader) page)->pd_special;
    Offset      last_offset;
    itemIdCompactData itemidbase[MaxHeapTuplesPerPage];
    itemIdCompact itemidptr;
    ItemId      lp;
    int         nline,
                nstorage,
                nunused;
    OffsetNumber finalusedlp = InvalidOffsetNumber;
    int         i;
    Size        totallen;
    bool        presorted = true;   /* For now */
 
    /*
     * 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;
    last_offset = pd_special;
    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 (last_offset > itemidptr->itemoff)
                    last_offset = itemidptr->itemoff;
                else
                    presorted = false;
 
                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++;
            }
 
            finalusedlp = i;    /* Could be the final non-LP_UNUSED item */
        }
        else
        {
            /* Unused entries should have lp_len = 0, but make sure */
            Assert(!ItemIdHasStorage(lp));
            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, presorted);
    }
 
    if (finalusedlp != nline)
    {
        /* The last line pointer is not the last used line pointer */
        int         nunusedend = nline - finalusedlp;
 
        Assert(nunused >= nunusedend && nunusedend > 0);
 
        /* remove trailing unused line pointers from the count */
        nunused -= nunusedend;
        /* truncate the line pointer array */
        ((PageHeader) page)->pd_lower -= (sizeof(ItemIdData) * nunusedend);
    }
 
    /* Set hint bit for PageAddItemExtended */
    if (nunused > 0)
        PageSetHasFreeLinePointers(page);
    else
        PageClearHasFreeLinePointers(page);
}

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

Referenced by heap_page_prune_execute().

PageRestoreTempPage()

void PageRestoreTempPage	(	Page	tempPage,
		Page	oldPage
	)

Definition at line 423 of file bufpage.c.

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

References PageGetPageSize(), and pfree().

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

PageSetAllVisible()

static void PageSetAllVisible ( Page  page )

inlinestatic

Definition at line 434 of file bufpage.h.

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

References PD_ALL_VISIBLE.

Referenced by heap_multi_insert(), heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_visible(), lazy_scan_new_or_empty(), lazy_scan_prune(), and lazy_vacuum_heap_page().

PageSetChecksumCopy()

char * PageSetChecksumCopy	(	Page	page,
		BlockNumber	blkno
	)

Definition at line 1509 of file bufpage.c.

{
    static char *pageCopy = NULL;
 
    /* If we don't need a checksum, just return the passed-in data */
    if (PageIsNew(page) || !DataChecksumsEnabled())
        return 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 = MemoryContextAllocAligned(TopMemoryContext,
                                             BLCKSZ,
                                             PG_IO_ALIGN_SIZE,
                                             0);
 
    memcpy(pageCopy, page, BLCKSZ);
    ((PageHeader) pageCopy)->pd_checksum = pg_checksum_page(pageCopy, blkno);
    return pageCopy;
}

References DataChecksumsEnabled(), MemoryContextAllocAligned(), PageIsNew(), pg_checksum_page(), PG_IO_ALIGN_SIZE, and TopMemoryContext.

Referenced by FlushBuffer().

PageSetChecksumInplace()

void PageSetChecksumInplace	(	Page	page,
		BlockNumber	blkno
	)

Definition at line 1541 of file bufpage.c.

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

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

Referenced by _hash_alloc_buckets(), FlushLocalBuffer(), modify_rel_block(), and smgr_bulk_flush().

PageSetFull()

static void PageSetFull ( Page  page )

inlinestatic

Definition at line 418 of file bufpage.h.

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

References PD_PAGE_FULL.

Referenced by heap_update().

PageSetHasFreeLinePointers()

static void PageSetHasFreeLinePointers ( Page  page )

inlinestatic

Definition at line 402 of file bufpage.h.

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

References PD_HAS_FREE_LINES.

Referenced by PageRepairFragmentation(), and PageTruncateLinePointerArray().

PageSetLSN()

static void PageSetLSN ( Page  page, XLogRecPtr  lsn  )

inlinestatic

Definition at line 391 of file bufpage.h.

{
    PageXLogRecPtrSet(((PageHeader) page)->pd_lsn, lsn);

References PageXLogRecPtrSet.

Referenced by _bt_clear_incomplete_split(), _bt_dedup_pass(), _bt_delitems_delete(), _bt_delitems_vacuum(), _bt_getroot(), _bt_insertonpg(), _bt_mark_page_halfdead(), _bt_newlevel(), _bt_restore_meta(), _bt_set_cleanup_info(), _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_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_fork_with_data(), generic_redo(), GenericXLogFinish(), ginDeletePage(), ginHeapTupleFastInsert(), ginPlaceToPage(), ginRedoClearIncompleteSplit(), ginRedoCreatePTree(), ginRedoDeleteListPages(), ginRedoDeletePage(), ginRedoInsert(), ginRedoInsertListPage(), ginRedoUpdateMetapage(), ginRedoVacuumDataLeafPage(), ginUpdateStats(), ginVacuumPostingTreeLeaf(), gist_indexsortbuild(), gist_indexsortbuild_levelstate_flush(), 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_and_unlock(), heap_insert(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_multi_insert(), heap_update(), 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_prune_freeze(), heap_xlog_update(), heap_xlog_visible(), log_heap_prune_and_freeze(), log_newpage(), log_newpage_range(), log_newpages(), 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()

static void PageSetPageSizeAndVersion ( Page  page, Size  size, uint8  version  )

inlinestatic

Definition at line 300 of file bufpage.h.

{
    Assert((size & 0xFF00) == size);
    Assert((version & 0x00FF) == version);
 
    ((PageHeader) page)->pd_pagesize_version = size | version;

References Assert().

Referenced by PageInit().

PageTruncateLinePointerArray()

void PageTruncateLinePointerArray

(

Page

page

)

Definition at line 834 of file bufpage.c.

{
    PageHeader  phdr = (PageHeader) page;
    bool        countdone = false,
                sethint = false;
    int         nunusedend = 0;
 
    /* Scan line pointer array back-to-front */
    for (int i = PageGetMaxOffsetNumber(page); i >= FirstOffsetNumber; i--)
    {
        ItemId      lp = PageGetItemId(page, i);
 
        if (!countdone && i > FirstOffsetNumber)
        {
            /*
             * Still determining which line pointers from the end of the array
             * will be truncated away.  Either count another line pointer as
             * safe to truncate, or notice that it's not safe to truncate
             * additional line pointers (stop counting line pointers).
             */
            if (!ItemIdIsUsed(lp))
                nunusedend++;
            else
                countdone = true;
        }
        else
        {
            /*
             * Once we've stopped counting we still need to figure out if
             * there are any remaining LP_UNUSED line pointers somewhere more
             * towards the front of the array.
             */
            if (!ItemIdIsUsed(lp))
            {
                /*
                 * This is an unused line pointer that we won't be truncating
                 * away -- so there is at least one.  Set hint on page.
                 */
                sethint = true;
                break;
            }
        }
    }
 
    if (nunusedend > 0)
    {
        phdr->pd_lower -= sizeof(ItemIdData) * nunusedend;
 
#ifdef CLOBBER_FREED_MEMORY
        memset((char *) page + phdr->pd_lower, 0x7F,
               sizeof(ItemIdData) * nunusedend);
#endif
    }
    else
        Assert(sethint);
 
    /* Set hint bit for PageAddItemExtended */
    if (sethint)
        PageSetHasFreeLinePointers(page);
    else
        PageClearHasFreeLinePointers(page);
}

References Assert(), FirstOffsetNumber, i, ItemIdIsUsed, PageClearHasFreeLinePointers(), PageGetItemId(), PageGetMaxOffsetNumber(), PageSetHasFreeLinePointers(), and PageHeaderData::pd_lower.

Referenced by heap_page_prune_execute(), and lazy_vacuum_heap_page().

PageValidateSpecialPointer()

static void PageValidateSpecialPointer ( const PageData *  page )

inlinestatic

Definition at line 328 of file bufpage.h.

{
    Assert(page);
    Assert(((const PageHeaderData *) page)->pd_special <= BLCKSZ);
    Assert(((const PageHeaderData *) page)->pd_special >= SizeOfPageHeaderData);

References Assert(), and SizeOfPageHeaderData.

PageXLogRecPtrGet()

static XLogRecPtr PageXLogRecPtrGet ( PageXLogRecPtr  val )

inlinestatic

Definition at line 105 of file bufpage.h.

{
    return (uint64) val.xlogid << 32 | val.xrecoff;
}

References val.

Referenced by PageGetLSN().

StaticAssertDecl()

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

Variable Documentation

ignore_checksum_failure

PGDLLIMPORT bool ignore_checksum_failure

extern

Definition at line 27 of file bufpage.c.

Referenced by AsyncReadBuffers(), read_rel_block_ll(), and RelationCopyStorage().