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	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_REPORT_STAT   (1 << 1)
#define	PageAddItem(page, item, size, offsetNumber, overwrite, is_heap)
#define	PageIsVerified(page, blkno)

Typedefs
typedef Pointer	Page
typedef uint16	LocationIndex
typedef struct PageHeaderData	PageHeaderData
typedef PageHeaderData *	PageHeader

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

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

PageClearPrunable

#define PageClearPrunable

(

page

)

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

Definition at line 451 of file bufpage.h.

PageIsVerified

#define PageIsVerified	(		page,
			blkno
	)

Value:

    PageIsVerifiedExtended(page, blkno, \
                           PIV_LOG_WARNING | PIV_REPORT_STAT)

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

PageXLogRecPtrSet

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

Definition at line 106 of file bufpage.h.

PAI_IS_HEAP

#define PAI_IS_HEAP   (1 << 1)

Definition at line 462 of file bufpage.h.

PAI_OVERWRITE

#define PAI_OVERWRITE   (1 << 0)

Definition at line 461 of file bufpage.h.

PD_ALL_VISIBLE

#define PD_ALL_VISIBLE

Value:

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

Definition at line 186 of file bufpage.h.

PD_HAS_FREE_LINES

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

Definition at line 184 of file bufpage.h.

PD_PAGE_FULL

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

Definition at line 185 of file bufpage.h.

PD_VALID_FLAG_BITS

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

Definition at line 188 of file bufpage.h.

PG_DATA_CHECKSUM_VERSION

#define PG_DATA_CHECKSUM_VERSION   1

Definition at line 203 of file bufpage.h.

PG_PAGE_LAYOUT_VERSION

#define PG_PAGE_LAYOUT_VERSION   4

Definition at line 202 of file bufpage.h.

PIV_LOG_WARNING

#define PIV_LOG_WARNING   (1 << 0)

Definition at line 465 of file bufpage.h.

PIV_REPORT_STAT

#define PIV_REPORT_STAT   (1 << 1)

Definition at line 466 of file bufpage.h.

SizeOfPageHeaderData

#define SizeOfPageHeaderData   (offsetof(PageHeaderData, pd_linp))

Definition at line 213 of file bufpage.h.

Typedef Documentation

LocationIndex

typedef uint16 LocationIndex

Definition at line 87 of file bufpage.h.

Page

typedef Pointer Page

Definition at line 78 of file bufpage.h.

PageHeader

typedef PageHeaderData* PageHeader

Definition at line 170 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 194 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 436 of file bufpage.h.

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

References 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_heap(), and mask_page_hint_bits().

PageClearFull()

static void PageClearFull ( Page  page )

inlinestatic

Definition at line 420 of file bufpage.h.

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

References PD_PAGE_FULL.

Referenced by heap_page_prune(), and mask_page_hint_bits().

PageClearHasFreeLinePointers()

static void PageClearHasFreeLinePointers ( Page  page )

inlinestatic

Definition at line 404 of file bufpage.h.

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

References PD_HAS_FREE_LINES.

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

PageGetContents()

static char* PageGetContents ( Page  page )

inlinestatic

Definition at line 254 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

(

Page

page

)

Definition at line 958 of file bufpage.c.

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

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

PageGetFreeSpace()

Size PageGetFreeSpace

(

Page

page

)

Definition at line 907 of file bufpage.c.

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

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(), pgstat_index_page(), pgstatindex_impl(), and terminate_brin_buildstate().

PageGetFreeSpaceForMultipleTuples()

Size PageGetFreeSpaceForMultipleTuples	(	Page	page,
		int	ntups
	)

Definition at line 934 of file bufpage.c.

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

Referenced by _hash_splitbucket(), and _hash_squeezebucket().

PageGetHeapFreeSpace()

Size PageGetHeapFreeSpace

(

Page

page

)

Definition at line 991 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(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(), and PageHasFreeLinePointers().

Referenced by heap_multi_insert(), heap_page_prune_opt(), heap_update(), heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_prune(), heap_xlog_update(), heap_xlog_vacuum(), lazy_scan_heap(), lazy_scan_new_or_empty(), lazy_vacuum_heap_rel(), pgstat_heap(), raw_heap_insert(), RelationGetBufferForTuple(), and statapprox_heap().

PageGetItem()

static Item PageGetItem ( Page  page, ItemId  itemId  )

inlinestatic

Definition at line 351 of file bufpage.h.

{
    Assert(page);
    Assert(ItemIdHasStorage(itemId));
 
    return (Item) (((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_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_newroot(), _bt_pagedel(), _bt_readpage(), _bt_recsplitloc(), _bt_search(), _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_splitbucket(), _hash_squeezebucket(), addLeafTuple(), addOrReplaceTuple(), 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(), 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_get_latest_tid(), heap_get_root_tuples(), heap_hot_search_buffer(), heap_index_delete_tuples(), heap_inplace_update(), heap_lock_tuple(), heap_page_is_all_visible(), heap_page_items(), heap_page_prune(), heap_page_prune_execute(), heap_prune_chain(), heap_update(), heap_xlog_confirm(), heap_xlog_delete(), heap_xlog_freeze_page(), heap_xlog_inplace(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_update(), heapam_scan_analyze_next_tuple(), heapam_scan_bitmap_next_block(), heapam_scan_bitmap_next_tuple(), heapam_scan_sample_next_tuple(), heapgetpage(), heapgettup(), heapgettup_pagemode(), index_compute_xid_horizon_for_tuples(), index_delete_check_htid(), invariant_l_nontarget_offset(), invariant_l_offset(), lazy_scan_noprune(), lazy_scan_prune(), matchPartialInPendingList(), moveLeafs(), 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 240 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_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_newroot(), _bt_pagedel(), _bt_readpage(), _bt_recsplitloc(), _bt_search(), _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_splitbucket(), _hash_squeezebucket(), _hash_vacuum_one_page(), addLeafTuple(), addOrReplaceTuple(), brin_doupdate(), brin_evacuate_page(), brin_page_items(), brin_start_evacuating_page(), brinGetTupleForHeapBlock(), brininsert(), brinRevmapDesummarizeRange(), bt_page_print_tuples(), btree_xlog_dedup(), btree_xlog_insert(), btree_xlog_mark_page_halfdead(), btree_xlog_split(), btree_xlog_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_get_latest_tid(), heap_get_root_tuples(), heap_hot_search_buffer(), heap_index_delete_tuples(), heap_inplace_update(), heap_lock_tuple(), heap_mask(), heap_page_is_all_visible(), heap_page_items(), heap_page_prune(), heap_page_prune_execute(), heap_prune_chain(), heap_update(), heap_xlog_confirm(), heap_xlog_delete(), heap_xlog_freeze_page(), heap_xlog_inplace(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_update(), heap_xlog_vacuum(), heapam_scan_analyze_next_tuple(), heapam_scan_bitmap_next_block(), heapam_scan_bitmap_next_tuple(), heapam_scan_sample_next_tuple(), heapgetpage(), heapgettup(), heapgettup_pagemode(), index_compute_xid_horizon_for_tuples(), index_delete_check_htid(), lazy_scan_noprune(), lazy_scan_prune(), lazy_vacuum_heap_page(), mask_lp_flags(), matchPartialInPendingList(), moveLeafs(), 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 ( Page  page )

inlinestatic

Definition at line 383 of file bufpage.h.

{
    return PageXLogRecPtrGet(((PageHeader) page)->pd_lsn);

References PageXLogRecPtrGet().

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

PageGetMaxOffsetNumber()

static OffsetNumber PageGetMaxOffsetNumber ( Page  page )

inlinestatic

Definition at line 369 of file bufpage.h.

{
    PageHeader  pageheader = (PageHeader) 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_splitbucket(), _hash_squeezebucket(), _hash_vacuum_one_page(), addOrReplaceTuple(), brin_doupdate(), brin_evacuate_page(), brin_page_items(), brin_start_evacuating_page(), brin_xlog_insert_update(), brinGetTupleForHeapBlock(), brinRevmapDesummarizeRange(), bt_child_check(), bt_child_highkey_check(), bt_page_items_bytea(), bt_page_items_internal(), bt_right_page_check_scankey(), bt_rootdescend(), bt_target_page_check(), btree_xlog_dedup(), btvacuumpage(), checkSplitConditions(), collect_corrupt_items(), compactify_tuples(), count_nondeletable_pages(), doPickSplit(), entryFindChildPtr(), entryGetLeftMostPage(), entryLocateEntry(), entryLocateLeafEntry(), entrySplitPage(), GetBTPageStatistics(), GetHashPageStatistics(), GetHashPageStats(), getRightMostTuple(), 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_inplace_update(), heap_insert(), heap_mask(), heap_multi_insert(), heap_page_is_all_visible(), heap_page_items(), heap_page_prune(), heap_prune_chain(), heap_xlog_confirm(), heap_xlog_delete(), heap_xlog_inplace(), heap_xlog_insert(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_multi_insert(), heap_xlog_update(), heapam_scan_analyze_next_tuple(), heapam_scan_bitmap_next_block(), heapam_scan_sample_next_tuple(), heapgetpage(), heapgettup(), lazy_scan_noprune(), lazy_scan_prune(), 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 ( Page  page )

inlinestatic

Definition at line 283 of file bufpage.h.

{
    return (((PageHeader) page)->pd_pagesize_version & 0x00FF);

Referenced by page_header().

PageGetPageSize()

static Size PageGetPageSize ( Page  page )

inlinestatic

Definition at line 273 of file bufpage.h.

{
    return (Size) (((PageHeader) 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().

PageGetSpecialPointer()

static char* PageGetSpecialPointer ( Page  page )

inlinestatic

Definition at line 336 of file bufpage.h.

{
    PageValidateSpecialPointer(page);
    return (char *) page + ((PageHeader) page)->pd_special;

References PageValidateSpecialPointer().

Referenced by fill_seq_fork_with_data(), ginRedoRecompress(), PageGetTempPageCopySpecial(), read_seq_tuple(), and seq_redo().

PageGetSpecialSize()

static uint16 PageGetSpecialSize ( Page  page )

inlinestatic

Definition at line 313 of file bufpage.h.

{
    return (PageGetPageSize(page) - ((PageHeader) page)->pd_special);

References PageGetPageSize().

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

PageGetTempPage()

Page PageGetTempPage

(

Page

page

)

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

(

Page

page

)

Definition at line 382 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

(

Page

page

)

Definition at line 402 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 ( Page  page )

inlinestatic

Definition at line 394 of file bufpage.h.

{
    return ((PageHeader) 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 1161 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, 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 1052 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((char *) &(phdr->pd_linp[offidx]),
                (char *) &(phdr->pd_linp[offidx + 1]),
                nbytes);
 
    /*
     * Now move everything between the old upper bound (beginning of tuple
     * space) and the beginning of the deleted tuple forward, so that space in
     * the middle of the page is left free.  If we've just deleted the tuple
     * at the beginning of tuple space, then there's no need to do the copy.
     */
 
    /* beginning of tuple space */
    addr = (char *) page + phdr->pd_upper;
 
    if (offset > phdr->pd_upper)
        memmove(addr + size, addr, offset - phdr->pd_upper);
 
    /* adjust free space boundary pointers */
    phdr->pd_upper += size;
    phdr->pd_lower -= sizeof(ItemIdData);
 
    /*
     * Finally, we need to adjust the linp entries that remain.
     *
     * Anything that used to be before the deleted tuple's data was moved
     * forward by the size of the deleted tuple.
     */
    if (!PageIsEmpty(page))
    {
        int         i;
 
        nline--;                /* there's one less than when we started */
        for (i = 1; i <= nline; i++)
        {
            ItemId      ii = PageGetItemId(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 1295 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 1405 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_extend(), fsm_readbuf(), GinInitPage(), gistinitpage(), heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_update(), heap_xlog_visible(), PageGetTempPageCopySpecial(), raw_heap_insert(), RelationGetBufferForTuple(), seq_redo(), SpGistInitPage(), vm_extend(), vm_readbuf(), and XLogRecordPageWithFreeSpace().

PageIsAllVisible()

static bool PageIsAllVisible ( Page  page )

inlinestatic

Definition at line 426 of file bufpage.h.

{
    return ((PageHeader) 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_update(), heapam_scan_sample_next_tuple(), heapgetpage(), lazy_scan_heap(), lazy_scan_new_or_empty(), lazy_vacuum_heap_page(), pg_visibility(), RelationGetBufferForTuple(), and visibilitymap_set().

PageIsEmpty()

static bool PageIsEmpty ( Page  page )

inlinestatic

Definition at line 220 of file bufpage.h.

{
    return ((PageHeader) page)->pd_lower <= SizeOfPageHeaderData;

References SizeOfPageHeaderData.

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

PageIsFull()

static bool PageIsFull ( Page  page )

inlinestatic

Definition at line 410 of file bufpage.h.

{
    return ((PageHeader) page)->pd_flags & PD_PAGE_FULL;

References PD_PAGE_FULL.

Referenced by heap_page_prune(), and heap_page_prune_opt().

PageIsNew()

static bool PageIsNew ( Page  page )

inlinestatic

Definition at line 230 of file bufpage.h.

{
    return ((PageHeader) page)->pd_upper == 0;

Referenced by _bt_checkpage(), _bt_getbuf(), _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(), count_nondeletable_pages(), 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(), PageIsVerifiedExtended(), PageSetChecksumCopy(), PageSetChecksumInplace(), pg_checksum_page(), pgstat_btree_page(), pgstathashindex(), ReadBuffer_common(), RelationAddExtraBlocks(), RelationGetBufferForTuple(), revmap_physical_extend(), scan_file(), ScanSourceDatabasePgClass(), sendFile(), SpGistGetBuffer(), SpGistNewBuffer(), spgprocesspending(), spgvacuumpage(), statapprox_heap(), verify_brin_page(), verify_hash_page(), vm_readbuf(), XLogReadBufferExtended(), XLogReadBufferForRedoExtended(), and XLogRecordPageWithFreeSpace().

PageIsVerifiedExtended()

bool PageIsVerifiedExtended	(	Page	page,
		BlockNumber	blkno,
		int	flags
	)

Definition at line 88 of file bufpage.c.

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

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

Referenced by ReadBuffer_common(), and RelationCopyStorage().

PageRepairFragmentation()

void PageRepairFragmentation

(

Page

page

)

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

{
    Size        pageSize;
 
    pageSize = PageGetPageSize(tempPage);
    memcpy((char *) oldPage, (char *) 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 431 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_heap(), lazy_scan_new_or_empty(), and lazy_vacuum_heap_page().

PageSetChecksumCopy()

char* PageSetChecksumCopy	(	Page	page,
		BlockNumber	blkno
	)

Definition at line 1510 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 (char *) page;
 
    /*
     * We allocate the copy space once and use it over on each subsequent
     * call.  The point of palloc'ing here, rather than having a static char
     * array, is first to ensure adequate alignment for the checksumming code
     * and second to avoid wasting space in processes that never call this.
     */
    if (pageCopy == NULL)
        pageCopy = MemoryContextAlloc(TopMemoryContext, BLCKSZ);
 
    memcpy(pageCopy, (char *) page, BLCKSZ);
    ((PageHeader) pageCopy)->pd_checksum = pg_checksum_page(pageCopy, blkno);
    return pageCopy;
}

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

Referenced by FlushBuffer().

PageSetChecksumInplace()

void PageSetChecksumInplace	(	Page	page,
		BlockNumber	blkno
	)

Definition at line 1539 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((char *) page, blkno);
}

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

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

PageSetFull()

static void PageSetFull ( Page  page )

inlinestatic

Definition at line 415 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 399 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 388 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_newroot(), _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_flush_ready_pages(), gistbuild(), gistdeletepage(), gistplacetopage(), gistprunepage(), gistRedoClearFollowRight(), gistRedoDeleteRecord(), gistRedoPageDelete(), gistRedoPageSplitRecord(), gistRedoPageUpdateRecord(), gistvacuumpage(), hash_xlog_add_ovfl_page(), hash_xlog_delete(), hash_xlog_init_bitmap_page(), hash_xlog_init_meta_page(), hash_xlog_insert(), hash_xlog_move_page_contents(), hash_xlog_split_allocate_page(), hash_xlog_split_cleanup(), hash_xlog_split_complete(), hash_xlog_squeeze_page(), hash_xlog_update_meta_page(), hash_xlog_vacuum_one_page(), hashbucketcleanup(), hashbulkdelete(), heap_abort_speculative(), heap_delete(), heap_finish_speculative(), heap_inplace_update(), heap_insert(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_multi_insert(), heap_page_prune(), heap_update(), heap_xlog_confirm(), heap_xlog_delete(), heap_xlog_freeze_page(), heap_xlog_inplace(), heap_xlog_insert(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_multi_insert(), heap_xlog_prune(), heap_xlog_update(), heap_xlog_vacuum(), lazy_scan_prune(), lazy_vacuum_heap_page(), 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 296 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 835 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_xlog_vacuum(), and lazy_vacuum_heap_page().

PageValidateSpecialPointer()

static void PageValidateSpecialPointer ( Page  page )

inlinestatic

Definition at line 324 of file bufpage.h.

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

References Assert(), and SizeOfPageHeaderData.

Referenced by PageGetSpecialPointer().

PageXLogRecPtrGet()

static XLogRecPtr PageXLogRecPtrGet ( PageXLogRecPtr  val )

inlinestatic

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