bufpage.h File Reference

#include "access/xlogdefs.h"
#include "storage/block.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	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	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	PIV_ZERO_BUFFERS_ON_ERROR   (1 << 3)
#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 (const volatile PageXLogRecPtr *val)
static void	PageXLogRecPtrSet (volatile PageXLogRecPtr *ptr, XLogRecPtr lsn)
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 void *	PageGetItem (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)
static TransactionId	PageGetPruneXid (const PageData *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, const void *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, const void *newtup, Size newsize)
void	PageSetChecksum (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 504 of file bufpage.h.

                                                     : 0) | \

PageClearPrunable

#define PageClearPrunable

(

page

)

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

Definition at line 485 of file bufpage.h.

PageGetSpecialPointer

#define PageGetSpecialPointer

(

page

)

Value:

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

Definition at line 363 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 478 of file bufpage.h.

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

PAI_IS_HEAP

#define PAI_IS_HEAP   (1 << 1)

Definition at line 496 of file bufpage.h.

PAI_OVERWRITE

#define PAI_OVERWRITE   (1 << 0)

Definition at line 495 of file bufpage.h.

PD_ALL_VISIBLE

#define PD_ALL_VISIBLE

Value:

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

Definition at line 215 of file bufpage.h.

PD_HAS_FREE_LINES

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

Definition at line 213 of file bufpage.h.

PD_PAGE_FULL

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

Definition at line 214 of file bufpage.h.

PD_VALID_FLAG_BITS

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

Definition at line 217 of file bufpage.h.

PG_PAGE_LAYOUT_VERSION

#define PG_PAGE_LAYOUT_VERSION   4

Definition at line 231 of file bufpage.h.

PIV_IGNORE_CHECKSUM_FAILURE

#define PIV_IGNORE_CHECKSUM_FAILURE   (1 << 2)

Definition at line 501 of file bufpage.h.

PIV_LOG_LOG

#define PIV_LOG_LOG   (1 << 1)

Definition at line 500 of file bufpage.h.

PIV_LOG_WARNING

#define PIV_LOG_WARNING   (1 << 0)

Definition at line 499 of file bufpage.h.

PIV_ZERO_BUFFERS_ON_ERROR

#define PIV_ZERO_BUFFERS_ON_ERROR   (1 << 3)

Definition at line 502 of file bufpage.h.

SizeOfPageHeaderData

#define SizeOfPageHeaderData   (offsetof(PageHeaderData, pd_linp))

Definition at line 241 of file bufpage.h.

Typedef Documentation

LocationIndex

typedef uint16 LocationIndex

Definition at line 90 of file bufpage.h.

Page

typedef PageData* Page

Definition at line 81 of file bufpage.h.

PageData

typedef char PageData

Definition at line 80 of file bufpage.h.

PageHeader

typedef PageHeaderData* PageHeader

Definition at line 199 of file bufpage.h.

PageHeaderData

typedef struct PageHeaderData PageHeaderData

Function Documentation

PageAddItemExtended()

OffsetNumber PageAddItemExtended ( Page  page, const void *  item, Size  size, OffsetNumber  offsetNumber, int  flags  )

extern

Definition at line 203 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, fb(), FirstOffsetNumber, InvalidOffsetNumber, ItemIdHasStorage, ItemIdIsUsed, ItemIdSetNormal, lower(), MAXALIGN, MaxHeapTuplesPerPage, memcpy(), 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 464 of file bufpage.h.

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

References fb().

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

PageClearFull()

static void PageClearFull ( Page  page )

inlinestatic

Definition at line 448 of file bufpage.h.

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

References fb().

Referenced by heap_page_prune_and_freeze(), and mask_page_hint_bits().

PageClearHasFreeLinePointers()

static void PageClearHasFreeLinePointers ( Page  page )

inlinestatic

Definition at line 432 of file bufpage.h.

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

References fb().

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

PageGetContents()

static char * PageGetContents ( Page  page )

inlinestatic

Definition at line 282 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 )

extern

Definition at line 967 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 fb(), 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 )

extern

Definition at line 916 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 fb(), 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(), PageGetHeapFreeSpace(), and terminate_brin_buildstate().

PageGetFreeSpaceForMultipleTuples()

Size PageGetFreeSpaceForMultipleTuples ( const PageData *  page, int  ntups  )

extern

Definition at line 943 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 fb(), PageHeaderData::pd_lower, and PageHeaderData::pd_upper.

Referenced by _hash_splitbucket(), and _hash_squeezebucket().

PageGetHeapFreeSpace()

Size PageGetHeapFreeSpace ( const PageData *  page )

extern

Definition at line 1000 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 fb(), 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 void * PageGetItem ( PageData *  page, const ItemIdData *  itemId  )

inlinestatic

Definition at line 378 of file bufpage.h.

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

References Assert, fb(), 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_items(), heap_page_prune_execute(), heap_page_would_be_all_visible(), 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(), prune_freeze_plan(), 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 268 of file bufpage.h.

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

References fb().

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_items(), heap_page_prune_execute(), heap_page_would_be_all_visible(), 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(), PageGetItemIdCareful(), PageIndexMultiDelete(), PageIndexTupleDelete(), PageIndexTupleDeleteNoCompact(), PageIndexTupleOverwrite(), PageRepairFragmentation(), PageTruncateLinePointerArray(), pgstat_index_page(), processPendingPage(), prune_freeze_fast_path(), prune_freeze_plan(), 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 410 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(), log_heap_prune_and_freeze(), nextval_internal(), page_header(), pg_get_sequence_data(), verify_page_checksum(), verifyBackupPageConsistency(), XLogCheckBufferNeedsBackup(), XLogReadBufferForRedoExtended(), XLogRecordAssemble(), and XLogSaveBufferForHint().

PageGetMaxOffsetNumber()

static OffsetNumber PageGetMaxOffsetNumber ( const PageData *  page )

inlinestatic

Definition at line 396 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 fb(), 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_items(), heap_page_would_be_all_visible(), 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(), prune_freeze_fast_path(), prune_freeze_plan(), 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 311 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 301 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().

PageGetPruneXid()

static TransactionId PageGetPruneXid ( const PageData *  page )

inlinestatic

Definition at line 470 of file bufpage.h.

{
    return ((const PageHeaderData *) page)->pd_prune_xid;

Referenced by heap_page_prune_and_freeze(), heap_page_prune_opt(), and prune_freeze_fast_path().

PageGetSpecialSize()

static uint16 PageGetSpecialSize ( const PageData *  page )

inlinestatic

Definition at line 341 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_btree_page(), pgstat_gist_page(), pgstat_hash_page(), pgstathashindex(), verify_brin_page(), verify_gist_page(), and verify_hash_page().

PageGetTempPage()

Page PageGetTempPage ( const PageData *  page )

extern

Definition at line 374 of file bufpage.c.

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

References fb(), PageGetPageSize(), and palloc().

Referenced by dataSplitPageInternal(), and ginPlaceToPage().

PageGetTempPageCopy()

Page PageGetTempPageCopy ( const PageData *  page )

extern

Definition at line 391 of file bufpage.c.

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

References fb(), memcpy(), PageGetPageSize(), and palloc().

Referenced by entrySplitPage(), and ginVacuumEntryPage().

PageGetTempPageCopySpecial()

Page PageGetTempPageCopySpecial ( const PageData *  page )

extern

Definition at line 411 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 fb(), memcpy(), 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 422 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  )

extern

Definition at line 1170 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 = %zu",
                            offset, 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 %zu, available space %u",
                        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 Assert, compactify_tuples(), elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg, ERROR, fb(), FirstOffsetNumber, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, MAXALIGN, MaxIndexTuplesPerPage, memcpy(), nitems, 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  )

extern

Definition at line 1061 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 = %zu",
                        offset, 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, fb(), i, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, ItemIdData::lp_off, MAXALIGN, PageGetItemId(), PageGetMaxOffsetNumber(), PageIsEmpty(), PageHeaderData::pd_linp, PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, and SizeOfPageHeaderData.

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

PageIndexTupleDeleteNoCompact()

void PageIndexTupleDeleteNoCompact ( Page  page, OffsetNumber  offnum  )

extern

Definition at line 1304 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 = %zu",
                        offset, 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, fb(), i, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, ItemIdSetUnused, ItemIdData::lp_off, MAXALIGN, PageGetItemId(), PageGetMaxOffsetNumber(), PageIsEmpty(), PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, and SizeOfPageHeaderData.

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

PageIndexTupleOverwrite()

bool PageIndexTupleOverwrite ( Page  page, OffsetNumber  offnum, const void *  newtup, Size  newsize  )

extern

Definition at line 1414 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 = %d",
                        offset, 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, fb(), FirstOffsetNumber, i, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, ItemIdData::lp_off, MAXALIGN, memcpy(), 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  )

extern

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, fb(), 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_prune_freeze(), heap_xlog_update(), 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 454 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_page_fix_vm_corruption(), heap_page_prune_and_freeze(), heap_prepare_pagescan(), heap_prune_record_dead_or_unused(), heap_prune_record_prunable(), heap_prune_record_unchanged_lp_dead(), heap_update(), heapam_scan_sample_next_tuple(), lazy_scan_new_or_empty(), pg_visibility(), and RelationGetBufferForTuple().

PageIsEmpty()

static bool PageIsEmpty ( const PageData *  page )

inlinestatic

Definition at line 248 of file bufpage.h.

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

References PageHeaderData::pd_lower, and SizeOfPageHeaderData.

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

PageIsFull()

static bool PageIsFull ( const PageData *  page )

inlinestatic

Definition at line 438 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 258 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_multi_insert(), heap_xlog_prune_freeze(), lazy_scan_new_or_empty(), log_newpage(), log_newpage_range(), log_newpages(), page_checksum_internal(), PageIsVerified(), PageSetChecksum(), pg_checksum_page(), pgstat_btree_page(), pgstat_gist_page(), pgstat_hash_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  )

extern

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))
    {
        /*
         * There shouldn't be any check for interrupt calls happening in this
         * codepath, but just to be on the safe side we hold interrupts since
         * if they did happen the data checksum state could change during
         * verifying checksums, which could lead to incorrect verification
         * results.
         */
        HOLD_INTERRUPTS();
        if (DataChecksumsNeedVerify())
        {
            checksum = pg_checksum_page(page, blkno);
 
            if (checksum != p->pd_checksum)
            {
                checksum_failure = true;
                if (checksum_failure_p)
                    *checksum_failure_p = true;
            }
        }
        RESUME_INTERRUPTS();
 
        /*
         * 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%s",
                            checksum, p->pd_checksum,
                            (flags & PIV_ZERO_BUFFERS_ON_ERROR ? ", buffer will be zeroed" : ""))));
 
        if (header_sane && (flags & PIV_IGNORE_CHECKSUM_FAILURE))
            return true;
    }
 
    return false;
}

References checksum_failure, DataChecksumsNeedVerify(), ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg, fb(), HOLD_INTERRUPTS, 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, PIV_ZERO_BUFFERS_ON_ERROR, RESUME_INTERRUPTS, and WARNING.

Referenced by buffer_readv_complete_one(), and RelationCopyStorage().

PageRepairFragmentation()

void PageRepairFragmentation ( Page  page )

extern

Definition at line 708 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 %zu, available space %u",
                            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 Assert, compactify_tuples(), ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg, ERROR, fb(), FirstOffsetNumber, i, InvalidOffsetNumber, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, ItemIdIsUsed, ItemIdSetUnused, MAXALIGN, MaxHeapTuplesPerPage, PageClearHasFreeLinePointers(), PageGetItemId(), PageGetMaxOffsetNumber(), PageSetHasFreeLinePointers(), SizeOfPageHeaderData, and unlikely.

Referenced by heap_page_prune_execute().

PageRestoreTempPage()

void PageRestoreTempPage ( Page  tempPage, Page  oldPage  )

extern

Definition at line 433 of file bufpage.c.

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

References fb(), memcpy(), PageGetPageSize(), and pfree().

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

PageSetAllVisible()

static void PageSetAllVisible ( Page  page )

inlinestatic

Definition at line 459 of file bufpage.h.

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

References PD_ALL_VISIBLE.

Referenced by heap_multi_insert(), heap_page_prune_and_freeze(), heap_xlog_multi_insert(), heap_xlog_prune_freeze(), lazy_scan_new_or_empty(), and lazy_vacuum_heap_page().

PageSetChecksum()

void PageSetChecksum ( Page  page, BlockNumber  blkno  )

extern

Definition at line 1518 of file bufpage.c.

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

References DataChecksumsNeedWrite(), HOLD_INTERRUPTS, PageIsNew(), pg_checksum_page(), and RESUME_INTERRUPTS.

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

PageSetFull()

static void PageSetFull ( Page  page )

inlinestatic

Definition at line 443 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 427 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 416 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(), doPickSplit(), fill_seq_fork_with_data(), generic_redo(), GenericXLogFinish(), ginDeletePostingPage(), 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(), log_heap_prune_and_freeze(), log_newpage(), log_newpage_range(), log_newpages(), log_split_page(), MarkSharedBufferDirtyHint(), moveLeafs(), nextval_internal(), revmap_physical_extend(), seq_redo(), SetSequence(), shiftList(), spgAddNodeAction(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoMoveLeafs(), spgRedoPickSplit(), spgRedoSplitTuple(), spgRedoVacuumLeaf(), spgRedoVacuumRedirect(), spgRedoVacuumRoot(), spgSplitNodeAction(), vacuumLeafPage(), vacuumLeafRoot(), vacuumRedirectAndPlaceholder(), writeListPage(), XLogReadBufferForRedoExtended(), and xlogVacuumPage().

PageSetPageSizeAndVersion()

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

inlinestatic

Definition at line 324 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 )

extern

Definition at line 844 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, fb(), 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 352 of file bufpage.h.

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

References Assert, fb(), and SizeOfPageHeaderData.

PageXLogRecPtrGet()

static XLogRecPtr PageXLogRecPtrGet ( const volatile PageXLogRecPtr *  val )

inlinestatic

Definition at line 123 of file bufpage.h.

{
    PageXLogRecPtr tmp = {val->lsn};
 
    return (tmp.lsn << 32) | (tmp.lsn >> 32);
}

References PageXLogRecPtr::lsn, and val.

Referenced by PageGetLSN().

PageXLogRecPtrSet()

static void PageXLogRecPtrSet ( volatile PageXLogRecPtr *  ptr, XLogRecPtr  lsn  )

inlinestatic

Definition at line 131 of file bufpage.h.

{
    ptr->lsn = (lsn << 32) | (lsn >> 32);
}

References PageXLogRecPtr::lsn.

Referenced by mask_page_lsn_and_checksum(), and PageSetLSN().

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().