pg_visibility.c File Reference

#include "postgres.h"
#include "access/heapam.h"
#include "access/htup_details.h"
#include "access/visibilitymap.h"
#include "access/xloginsert.h"
#include "catalog/pg_type.h"
#include "catalog/storage_xlog.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "storage/bufmgr.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "storage/read_stream.h"
#include "storage/smgr.h"
#include "utils/rel.h"
#include "utils/snapmgr.h"

Include dependency graph for pg_visibility.c:

Go to the source code of this file.

Data Structures
struct	vbits
struct	corrupt_items
struct	collect_corrupt_items_read_stream_private

Typedefs
typedef struct vbits	vbits
typedef struct corrupt_items	corrupt_items

Functions
	PG_FUNCTION_INFO_V1 (pg_visibility_map)
	PG_FUNCTION_INFO_V1 (pg_visibility_map_rel)
	PG_FUNCTION_INFO_V1 (pg_visibility)
	PG_FUNCTION_INFO_V1 (pg_visibility_rel)
	PG_FUNCTION_INFO_V1 (pg_visibility_map_summary)
	PG_FUNCTION_INFO_V1 (pg_check_frozen)
	PG_FUNCTION_INFO_V1 (pg_check_visible)
	PG_FUNCTION_INFO_V1 (pg_truncate_visibility_map)
static TupleDesc	pg_visibility_tupdesc (bool include_blkno, bool include_pd)
static vbits *	collect_visibility_data (Oid relid, bool include_pd)
static corrupt_items *	collect_corrupt_items (Oid relid, bool all_visible, bool all_frozen)
static void	record_corrupt_item (corrupt_items *items, ItemPointer tid)
static bool	tuple_all_visible (HeapTuple tup, TransactionId OldestXmin, Buffer buffer)
static void	check_relation_relkind (Relation rel)
Datum	pg_visibility_map (PG_FUNCTION_ARGS)
Datum	pg_visibility (PG_FUNCTION_ARGS)
Datum	pg_visibility_map_rel (PG_FUNCTION_ARGS)
Datum	pg_visibility_rel (PG_FUNCTION_ARGS)
Datum	pg_visibility_map_summary (PG_FUNCTION_ARGS)
Datum	pg_check_frozen (PG_FUNCTION_ARGS)
Datum	pg_check_visible (PG_FUNCTION_ARGS)
Datum	pg_truncate_visibility_map (PG_FUNCTION_ARGS)
static TransactionId	GetStrictOldestNonRemovableTransactionId (Relation rel)
static BlockNumber	collect_corrupt_items_read_stream_next_block (ReadStream *stream, void *callback_private_data, void *per_buffer_data)

Variables
	PG_MODULE_MAGIC

Typedef Documentation

corrupt_items

typedef struct corrupt_items corrupt_items

vbits

typedef struct vbits vbits

Function Documentation

check_relation_relkind()

static void check_relation_relkind ( Relation  rel )

static

Definition at line 920 of file pg_visibility.c.

{
    if (!RELKIND_HAS_TABLE_AM(rel->rd_rel->relkind))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("relation \"%s\" is of wrong relation kind",
                        RelationGetRelationName(rel)),
                 errdetail_relkind_not_supported(rel->rd_rel->relkind)));
}

References ereport, errcode(), errdetail_relkind_not_supported(), errmsg(), ERROR, RelationData::rd_rel, collect_corrupt_items_read_stream_private::rel, and RelationGetRelationName.

Referenced by collect_corrupt_items(), collect_visibility_data(), pg_truncate_visibility_map(), pg_visibility(), pg_visibility_map(), and pg_visibility_map_summary().

collect_corrupt_items()

static corrupt_items * collect_corrupt_items ( Oid  relid, bool  all_visible, bool  all_frozen  )

static

Definition at line 693 of file pg_visibility.c.

{
    Relation    rel;
    corrupt_items *items;
    Buffer      vmbuffer = InvalidBuffer;
    BufferAccessStrategy bstrategy = GetAccessStrategy(BAS_BULKREAD);
    TransactionId OldestXmin = InvalidTransactionId;
    struct collect_corrupt_items_read_stream_private p;
    ReadStream *stream;
    Buffer      buffer;
 
    rel = relation_open(relid, AccessShareLock);
 
    /* Only some relkinds have a visibility map */
    check_relation_relkind(rel);
 
    if (all_visible)
        OldestXmin = GetStrictOldestNonRemovableTransactionId(rel);
 
    /*
     * Guess an initial array size. We don't expect many corrupted tuples, so
     * start with a small array.  This function uses the "next" field to track
     * the next offset where we can store an item (which is the same thing as
     * the number of items found so far) and the "count" field to track the
     * number of entries allocated.  We'll repurpose these fields before
     * returning.
     */
    items = palloc0(sizeof(corrupt_items));
    items->next = 0;
    items->count = 64;
    items->tids = palloc(items->count * sizeof(ItemPointerData));
 
    p.current_blocknum = 0;
    p.last_exclusive = RelationGetNumberOfBlocks(rel);
    p.rel = rel;
    p.vmbuffer = InvalidBuffer;
    p.all_frozen = all_frozen;
    p.all_visible = all_visible;
    stream = read_stream_begin_relation(READ_STREAM_FULL,
                                        bstrategy,
                                        rel,
                                        MAIN_FORKNUM,
                                        collect_corrupt_items_read_stream_next_block,
                                        &p,
                                        0);
 
    /* Loop over every block in the relation. */
    while ((buffer = read_stream_next_buffer(stream, NULL)) != InvalidBuffer)
    {
        bool        check_frozen = all_frozen;
        bool        check_visible = all_visible;
        Page        page;
        OffsetNumber offnum,
                    maxoff;
        BlockNumber blkno;
 
        /* Make sure we are interruptible. */
        CHECK_FOR_INTERRUPTS();
 
        LockBuffer(buffer, BUFFER_LOCK_SHARE);
 
        page = BufferGetPage(buffer);
        maxoff = PageGetMaxOffsetNumber(page);
        blkno = BufferGetBlockNumber(buffer);
 
        /*
         * The visibility map bits might have changed while we were acquiring
         * the page lock.  Recheck to avoid returning spurious results.
         */
        if (check_frozen && !VM_ALL_FROZEN(rel, blkno, &vmbuffer))
            check_frozen = false;
        if (check_visible && !VM_ALL_VISIBLE(rel, blkno, &vmbuffer))
            check_visible = false;
        if (!check_visible && !check_frozen)
        {
            UnlockReleaseBuffer(buffer);
            continue;
        }
 
        /* Iterate over each tuple on the page. */
        for (offnum = FirstOffsetNumber;
             offnum <= maxoff;
             offnum = OffsetNumberNext(offnum))
        {
            HeapTupleData tuple;
            ItemId      itemid;
 
            itemid = PageGetItemId(page, offnum);
 
            /* Unused or redirect line pointers are of no interest. */
            if (!ItemIdIsUsed(itemid) || ItemIdIsRedirected(itemid))
                continue;
 
            /* Dead line pointers are neither all-visible nor frozen. */
            if (ItemIdIsDead(itemid))
            {
                ItemPointerSet(&(tuple.t_self), blkno, offnum);
                record_corrupt_item(items, &tuple.t_self);
                continue;
            }
 
            /* Initialize a HeapTupleData structure for checks below. */
            ItemPointerSet(&(tuple.t_self), blkno, offnum);
            tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
            tuple.t_len = ItemIdGetLength(itemid);
            tuple.t_tableOid = relid;
 
            /*
             * If we're checking whether the page is all-visible, we expect
             * the tuple to be all-visible.
             */
            if (check_visible &&
                !tuple_all_visible(&tuple, OldestXmin, buffer))
            {
                TransactionId RecomputedOldestXmin;
 
                /*
                 * Time has passed since we computed OldestXmin, so it's
                 * possible that this tuple is all-visible in reality even
                 * though it doesn't appear so based on our
                 * previously-computed value.  Let's compute a new value so we
                 * can be certain whether there is a problem.
                 *
                 * From a concurrency point of view, it sort of sucks to
                 * retake ProcArrayLock here while we're holding the buffer
                 * exclusively locked, but it should be safe against
                 * deadlocks, because surely
                 * GetStrictOldestNonRemovableTransactionId() should never
                 * take a buffer lock. And this shouldn't happen often, so
                 * it's worth being careful so as to avoid false positives.
                 */
                RecomputedOldestXmin = GetStrictOldestNonRemovableTransactionId(rel);
 
                if (!TransactionIdPrecedes(OldestXmin, RecomputedOldestXmin))
                    record_corrupt_item(items, &tuple.t_self);
                else
                {
                    OldestXmin = RecomputedOldestXmin;
                    if (!tuple_all_visible(&tuple, OldestXmin, buffer))
                        record_corrupt_item(items, &tuple.t_self);
                }
            }
 
            /*
             * If we're checking whether the page is all-frozen, we expect the
             * tuple to be in a state where it will never need freezing.
             */
            if (check_frozen)
            {
                if (heap_tuple_needs_eventual_freeze(tuple.t_data))
                    record_corrupt_item(items, &tuple.t_self);
            }
        }
 
        UnlockReleaseBuffer(buffer);
    }
    read_stream_end(stream);
 
    /* Clean up. */
    if (vmbuffer != InvalidBuffer)
        ReleaseBuffer(vmbuffer);
    if (p.vmbuffer != InvalidBuffer)
        ReleaseBuffer(p.vmbuffer);
    relation_close(rel, AccessShareLock);
 
    /*
     * Before returning, repurpose the fields to match caller's expectations.
     * next is now the next item that should be read (rather than written) and
     * count is now the number of items we wrote (rather than the number we
     * allocated).
     */
    items->count = items->next;
    items->next = 0;
 
    return items;
}

References AccessShareLock, collect_corrupt_items_read_stream_private::all_frozen, collect_corrupt_items_read_stream_private::all_visible, BAS_BULKREAD, BUFFER_LOCK_SHARE, BufferGetBlockNumber(), BufferGetPage(), CHECK_FOR_INTERRUPTS, check_relation_relkind(), collect_corrupt_items_read_stream_next_block(), collect_corrupt_items_read_stream_private::current_blocknum, FirstOffsetNumber, GetAccessStrategy(), GetStrictOldestNonRemovableTransactionId(), heap_tuple_needs_eventual_freeze(), InvalidBuffer, InvalidTransactionId, ItemIdGetLength, ItemIdIsDead, ItemIdIsRedirected, ItemIdIsUsed, ItemPointerSet(), items, collect_corrupt_items_read_stream_private::last_exclusive, LockBuffer(), MAIN_FORKNUM, OffsetNumberNext, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), palloc(), palloc0(), read_stream_begin_relation(), read_stream_end(), READ_STREAM_FULL, read_stream_next_buffer(), record_corrupt_item(), collect_corrupt_items_read_stream_private::rel, relation_close(), relation_open(), RelationGetNumberOfBlocks, ReleaseBuffer(), HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TransactionIdPrecedes(), tuple_all_visible(), UnlockReleaseBuffer(), VM_ALL_FROZEN, VM_ALL_VISIBLE, and collect_corrupt_items_read_stream_private::vmbuffer.

Referenced by pg_check_frozen(), and pg_check_visible().

collect_corrupt_items_read_stream_next_block()

static BlockNumber collect_corrupt_items_read_stream_next_block ( ReadStream *  stream, void *  callback_private_data, void *  per_buffer_data  )

static

Definition at line 651 of file pg_visibility.c.

{
    struct collect_corrupt_items_read_stream_private *p = callback_private_data;
 
    for (; p->current_blocknum < p->last_exclusive; p->current_blocknum++)
    {
        bool        check_frozen = false;
        bool        check_visible = false;
 
        /* Make sure we are interruptible. */
        CHECK_FOR_INTERRUPTS();
 
        if (p->all_frozen && VM_ALL_FROZEN(p->rel, p->current_blocknum, &p->vmbuffer))
            check_frozen = true;
        if (p->all_visible && VM_ALL_VISIBLE(p->rel, p->current_blocknum, &p->vmbuffer))
            check_visible = true;
        if (!check_visible && !check_frozen)
            continue;
 
        return p->current_blocknum++;
    }
 
    return InvalidBlockNumber;
}

References collect_corrupt_items_read_stream_private::all_frozen, collect_corrupt_items_read_stream_private::all_visible, CHECK_FOR_INTERRUPTS, collect_corrupt_items_read_stream_private::current_blocknum, InvalidBlockNumber, collect_corrupt_items_read_stream_private::last_exclusive, collect_corrupt_items_read_stream_private::rel, VM_ALL_FROZEN, VM_ALL_VISIBLE, and collect_corrupt_items_read_stream_private::vmbuffer.

Referenced by collect_corrupt_items().

collect_visibility_data()

static vbits * collect_visibility_data ( Oid  relid, bool  include_pd  )

static

Definition at line 485 of file pg_visibility.c.

{
    Relation    rel;
    BlockNumber nblocks;
    vbits      *info;
    BlockNumber blkno;
    Buffer      vmbuffer = InvalidBuffer;
    BufferAccessStrategy bstrategy = GetAccessStrategy(BAS_BULKREAD);
    BlockRangeReadStreamPrivate p;
    ReadStream *stream = NULL;
 
    rel = relation_open(relid, AccessShareLock);
 
    /* Only some relkinds have a visibility map */
    check_relation_relkind(rel);
 
    nblocks = RelationGetNumberOfBlocks(rel);
    info = palloc0(offsetof(vbits, bits) + nblocks);
    info->next = 0;
    info->count = nblocks;
 
    /* Create a stream if reading main fork. */
    if (include_pd)
    {
        p.current_blocknum = 0;
        p.last_exclusive = nblocks;
        stream = read_stream_begin_relation(READ_STREAM_FULL,
                                            bstrategy,
                                            rel,
                                            MAIN_FORKNUM,
                                            block_range_read_stream_cb,
                                            &p,
                                            0);
    }
 
    for (blkno = 0; blkno < nblocks; ++blkno)
    {
        int32       mapbits;
 
        /* Make sure we are interruptible. */
        CHECK_FOR_INTERRUPTS();
 
        /* Get map info. */
        mapbits = (int32) visibilitymap_get_status(rel, blkno, &vmbuffer);
        if ((mapbits & VISIBILITYMAP_ALL_VISIBLE) != 0)
            info->bits[blkno] |= (1 << 0);
        if ((mapbits & VISIBILITYMAP_ALL_FROZEN) != 0)
            info->bits[blkno] |= (1 << 1);
 
        /*
         * Page-level data requires reading every block, so only get it if the
         * caller needs it.  Use a buffer access strategy, too, to prevent
         * cache-trashing.
         */
        if (include_pd)
        {
            Buffer      buffer;
            Page        page;
 
            buffer = read_stream_next_buffer(stream, NULL);
            LockBuffer(buffer, BUFFER_LOCK_SHARE);
 
            page = BufferGetPage(buffer);
            if (PageIsAllVisible(page))
                info->bits[blkno] |= (1 << 2);
 
            UnlockReleaseBuffer(buffer);
        }
    }
 
    if (include_pd)
    {
        Assert(read_stream_next_buffer(stream, NULL) == InvalidBuffer);
        read_stream_end(stream);
    }
 
    /* Clean up. */
    if (vmbuffer != InvalidBuffer)
        ReleaseBuffer(vmbuffer);
    relation_close(rel, AccessShareLock);
 
    return info;
}

References AccessShareLock, Assert, BAS_BULKREAD, vbits::bits, block_range_read_stream_cb(), BUFFER_LOCK_SHARE, BufferGetPage(), CHECK_FOR_INTERRUPTS, check_relation_relkind(), vbits::count, BlockRangeReadStreamPrivate::current_blocknum, GetAccessStrategy(), InvalidBuffer, BlockRangeReadStreamPrivate::last_exclusive, LockBuffer(), MAIN_FORKNUM, vbits::next, PageIsAllVisible(), palloc0(), read_stream_begin_relation(), read_stream_end(), READ_STREAM_FULL, read_stream_next_buffer(), relation_close(), relation_open(), RelationGetNumberOfBlocks, ReleaseBuffer(), UnlockReleaseBuffer(), VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, and visibilitymap_get_status().

Referenced by pg_visibility_map_rel(), and pg_visibility_rel().

GetStrictOldestNonRemovableTransactionId()

static TransactionId GetStrictOldestNonRemovableTransactionId ( Relation  rel )

static

Definition at line 602 of file pg_visibility.c.

{
    RunningTransactions runningTransactions;
 
    if (RecoveryInProgress())
    {
        TransactionId result;
 
        /* As we ignore KnownAssignedXids on standby, just pick nextXid */
        LWLockAcquire(XidGenLock, LW_SHARED);
        result = XidFromFullTransactionId(TransamVariables->nextXid);
        LWLockRelease(XidGenLock);
        return result;
    }
    else if (rel == NULL || rel->rd_rel->relisshared)
    {
        /* Shared relation: take into account all running xids */
        runningTransactions = GetRunningTransactionData();
        LWLockRelease(ProcArrayLock);
        LWLockRelease(XidGenLock);
        return runningTransactions->oldestRunningXid;
    }
    else if (!RELATION_IS_LOCAL(rel))
    {
        /*
         * Normal relation: take into account xids running within the current
         * database
         */
        runningTransactions = GetRunningTransactionData();
        LWLockRelease(ProcArrayLock);
        LWLockRelease(XidGenLock);
        return runningTransactions->oldestDatabaseRunningXid;
    }
    else
    {
        /*
         * For temporary relations, ComputeXidHorizons() uses only
         * TransamVariables->latestCompletedXid and MyProc->xid.  These two
         * shouldn't go backwards.  So we're fine with this horizon.
         */
        return GetOldestNonRemovableTransactionId(rel);
    }
}

References GetOldestNonRemovableTransactionId(), GetRunningTransactionData(), LW_SHARED, LWLockAcquire(), LWLockRelease(), TransamVariablesData::nextXid, RunningTransactionsData::oldestDatabaseRunningXid, RunningTransactionsData::oldestRunningXid, RelationData::rd_rel, RecoveryInProgress(), RELATION_IS_LOCAL, TransamVariables, and XidFromFullTransactionId.

Referenced by collect_corrupt_items().

pg_check_frozen()

Datum pg_check_frozen

(

PG_FUNCTION_ARGS

)

Definition at line 322 of file pg_visibility.c.

{
    FuncCallContext *funcctx;
    corrupt_items *items;
 
    if (SRF_IS_FIRSTCALL())
    {
        Oid         relid = PG_GETARG_OID(0);
        MemoryContext oldcontext;
 
        funcctx = SRF_FIRSTCALL_INIT();
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
        /* collect_corrupt_items will verify the relkind */
        funcctx->user_fctx = collect_corrupt_items(relid, false, true);
        MemoryContextSwitchTo(oldcontext);
    }
 
    funcctx = SRF_PERCALL_SETUP();
    items = (corrupt_items *) funcctx->user_fctx;
 
    if (items->next < items->count)
        SRF_RETURN_NEXT(funcctx, PointerGetDatum(&items->tids[items->next++]));
 
    SRF_RETURN_DONE(funcctx);
}

References collect_corrupt_items(), if(), items, MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, PG_GETARG_OID, PointerGetDatum(), SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, and FuncCallContext::user_fctx.

pg_check_visible()

Datum pg_check_visible

(

PG_FUNCTION_ARGS

)

Definition at line 354 of file pg_visibility.c.

{
    FuncCallContext *funcctx;
    corrupt_items *items;
 
    if (SRF_IS_FIRSTCALL())
    {
        Oid         relid = PG_GETARG_OID(0);
        MemoryContext oldcontext;
 
        funcctx = SRF_FIRSTCALL_INIT();
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
        /* collect_corrupt_items will verify the relkind */
        funcctx->user_fctx = collect_corrupt_items(relid, true, false);
        MemoryContextSwitchTo(oldcontext);
    }
 
    funcctx = SRF_PERCALL_SETUP();
    items = (corrupt_items *) funcctx->user_fctx;
 
    if (items->next < items->count)
        SRF_RETURN_NEXT(funcctx, PointerGetDatum(&items->tids[items->next++]));
 
    SRF_RETURN_DONE(funcctx);
}

References collect_corrupt_items(), if(), items, MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, PG_GETARG_OID, PointerGetDatum(), SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, and FuncCallContext::user_fctx.

PG_FUNCTION_INFO_V1() [1/8]

PG_FUNCTION_INFO_V1

(

pg_check_frozen

)

PG_FUNCTION_INFO_V1() [2/8]

PG_FUNCTION_INFO_V1

(

pg_check_visible

)

PG_FUNCTION_INFO_V1() [3/8]

PG_FUNCTION_INFO_V1

(

pg_truncate_visibility_map

)

PG_FUNCTION_INFO_V1() [4/8]

PG_FUNCTION_INFO_V1

(

pg_visibility

)

PG_FUNCTION_INFO_V1() [5/8]

PG_FUNCTION_INFO_V1

(

pg_visibility_map

)

PG_FUNCTION_INFO_V1() [6/8]

PG_FUNCTION_INFO_V1

(

pg_visibility_map_rel

)

PG_FUNCTION_INFO_V1() [7/8]

PG_FUNCTION_INFO_V1

(

pg_visibility_map_summary

)

PG_FUNCTION_INFO_V1() [8/8]

PG_FUNCTION_INFO_V1

(

pg_visibility_rel

)

pg_truncate_visibility_map()

Datum pg_truncate_visibility_map

(

PG_FUNCTION_ARGS

)

Definition at line 389 of file pg_visibility.c.

{
    Oid         relid = PG_GETARG_OID(0);
    Relation    rel;
    ForkNumber  fork;
    BlockNumber block;
 
    rel = relation_open(relid, AccessExclusiveLock);
 
    /* Only some relkinds have a visibility map */
    check_relation_relkind(rel);
 
    /* Forcibly reset cached file size */
    RelationGetSmgr(rel)->smgr_cached_nblocks[VISIBILITYMAP_FORKNUM] = InvalidBlockNumber;
 
    block = visibilitymap_prepare_truncate(rel, 0);
    if (BlockNumberIsValid(block))
    {
        fork = VISIBILITYMAP_FORKNUM;
        smgrtruncate(RelationGetSmgr(rel), &fork, 1, &block);
    }
 
    if (RelationNeedsWAL(rel))
    {
        xl_smgr_truncate xlrec;
 
        xlrec.blkno = 0;
        xlrec.rlocator = rel->rd_locator;
        xlrec.flags = SMGR_TRUNCATE_VM;
 
        XLogBeginInsert();
        XLogRegisterData((char *) &xlrec, sizeof(xlrec));
 
        XLogInsert(RM_SMGR_ID, XLOG_SMGR_TRUNCATE | XLR_SPECIAL_REL_UPDATE);
    }
 
    /*
     * Release the lock right away, not at commit time.
     *
     * It would be a problem to release the lock prior to commit if this
     * truncate operation sends any transactional invalidation messages. Other
     * backends would potentially be able to lock the relation without
     * processing them in the window of time between when we release the lock
     * here and when we sent the messages at our eventual commit.  However,
     * we're currently only sending a non-transactional smgr invalidation,
     * which will have been posted to shared memory immediately from within
     * smgr_truncate.  Therefore, there should be no race here.
     *
     * The reason why it's desirable to release the lock early here is because
     * of the possibility that someone will need to use this to blow away many
     * visibility map forks at once.  If we can't release the lock until
     * commit time, the transaction doing this will accumulate
     * AccessExclusiveLocks on all of those relations at the same time, which
     * is undesirable. However, if this turns out to be unsafe we may have no
     * choice...
     */
    relation_close(rel, AccessExclusiveLock);
 
    /* Nothing to return. */
    PG_RETURN_VOID();
}

References AccessExclusiveLock, xl_smgr_truncate::blkno, BlockNumberIsValid(), check_relation_relkind(), xl_smgr_truncate::flags, InvalidBlockNumber, PG_GETARG_OID, PG_RETURN_VOID, RelationData::rd_locator, relation_close(), relation_open(), RelationGetSmgr(), RelationNeedsWAL, xl_smgr_truncate::rlocator, SMgrRelationData::smgr_cached_nblocks, SMGR_TRUNCATE_VM, smgrtruncate(), VISIBILITYMAP_FORKNUM, visibilitymap_prepare_truncate(), XLOG_SMGR_TRUNCATE, XLogBeginInsert(), XLogInsert(), XLogRegisterData(), and XLR_SPECIAL_REL_UPDATE.

pg_visibility()

Datum pg_visibility

(

PG_FUNCTION_ARGS

)

Definition at line 121 of file pg_visibility.c.

{
    Oid         relid = PG_GETARG_OID(0);
    int64       blkno = PG_GETARG_INT64(1);
    int32       mapbits;
    Relation    rel;
    Buffer      vmbuffer = InvalidBuffer;
    Buffer      buffer;
    Page        page;
    TupleDesc   tupdesc;
    Datum       values[3];
    bool        nulls[3] = {0};
 
    rel = relation_open(relid, AccessShareLock);
 
    /* Only some relkinds have a visibility map */
    check_relation_relkind(rel);
 
    if (blkno < 0 || blkno > MaxBlockNumber)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid block number")));
 
    tupdesc = pg_visibility_tupdesc(false, true);
 
    mapbits = (int32) visibilitymap_get_status(rel, blkno, &vmbuffer);
    if (vmbuffer != InvalidBuffer)
        ReleaseBuffer(vmbuffer);
    values[0] = BoolGetDatum((mapbits & VISIBILITYMAP_ALL_VISIBLE) != 0);
    values[1] = BoolGetDatum((mapbits & VISIBILITYMAP_ALL_FROZEN) != 0);
 
    /* Here we have to explicitly check rel size ... */
    if (blkno < RelationGetNumberOfBlocks(rel))
    {
        buffer = ReadBuffer(rel, blkno);
        LockBuffer(buffer, BUFFER_LOCK_SHARE);
 
        page = BufferGetPage(buffer);
        values[2] = BoolGetDatum(PageIsAllVisible(page));
 
        UnlockReleaseBuffer(buffer);
    }
    else
    {
        /* As with the vismap, silently return 0 for pages past EOF */
        values[2] = BoolGetDatum(false);
    }
 
    relation_close(rel, AccessShareLock);
 
    PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
}

References AccessShareLock, BoolGetDatum(), BUFFER_LOCK_SHARE, BufferGetPage(), check_relation_relkind(), ereport, errcode(), errmsg(), ERROR, heap_form_tuple(), HeapTupleGetDatum(), InvalidBuffer, LockBuffer(), MaxBlockNumber, PageIsAllVisible(), PG_GETARG_INT64, PG_GETARG_OID, PG_RETURN_DATUM, pg_visibility_tupdesc(), ReadBuffer(), relation_close(), relation_open(), RelationGetNumberOfBlocks, ReleaseBuffer(), UnlockReleaseBuffer(), values, VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, and visibilitymap_get_status().

pg_visibility_map()

Datum pg_visibility_map

(

PG_FUNCTION_ARGS

)

Definition at line 82 of file pg_visibility.c.

{
    Oid         relid = PG_GETARG_OID(0);
    int64       blkno = PG_GETARG_INT64(1);
    int32       mapbits;
    Relation    rel;
    Buffer      vmbuffer = InvalidBuffer;
    TupleDesc   tupdesc;
    Datum       values[2];
    bool        nulls[2] = {0};
 
    rel = relation_open(relid, AccessShareLock);
 
    /* Only some relkinds have a visibility map */
    check_relation_relkind(rel);
 
    if (blkno < 0 || blkno > MaxBlockNumber)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid block number")));
 
    tupdesc = pg_visibility_tupdesc(false, false);
 
    mapbits = (int32) visibilitymap_get_status(rel, blkno, &vmbuffer);
    if (vmbuffer != InvalidBuffer)
        ReleaseBuffer(vmbuffer);
    values[0] = BoolGetDatum((mapbits & VISIBILITYMAP_ALL_VISIBLE) != 0);
    values[1] = BoolGetDatum((mapbits & VISIBILITYMAP_ALL_FROZEN) != 0);
 
    relation_close(rel, AccessShareLock);
 
    PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
}

References AccessShareLock, BoolGetDatum(), check_relation_relkind(), ereport, errcode(), errmsg(), ERROR, heap_form_tuple(), HeapTupleGetDatum(), InvalidBuffer, MaxBlockNumber, PG_GETARG_INT64, PG_GETARG_OID, PG_RETURN_DATUM, pg_visibility_tupdesc(), relation_close(), relation_open(), ReleaseBuffer(), values, VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, and visibilitymap_get_status().

pg_visibility_map_rel()

Datum pg_visibility_map_rel

(

PG_FUNCTION_ARGS

)

Definition at line 178 of file pg_visibility.c.

{
    FuncCallContext *funcctx;
    vbits      *info;
 
    if (SRF_IS_FIRSTCALL())
    {
        Oid         relid = PG_GETARG_OID(0);
        MemoryContext oldcontext;
 
        funcctx = SRF_FIRSTCALL_INIT();
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
        funcctx->tuple_desc = pg_visibility_tupdesc(true, false);
        /* collect_visibility_data will verify the relkind */
        funcctx->user_fctx = collect_visibility_data(relid, false);
        MemoryContextSwitchTo(oldcontext);
    }
 
    funcctx = SRF_PERCALL_SETUP();
    info = (vbits *) funcctx->user_fctx;
 
    if (info->next < info->count)
    {
        Datum       values[3];
        bool        nulls[3] = {0};
        HeapTuple   tuple;
 
        values[0] = Int64GetDatum(info->next);
        values[1] = BoolGetDatum((info->bits[info->next] & (1 << 0)) != 0);
        values[2] = BoolGetDatum((info->bits[info->next] & (1 << 1)) != 0);
        info->next++;
 
        tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
        SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple));
    }
 
    SRF_RETURN_DONE(funcctx);
}

References vbits::bits, BoolGetDatum(), collect_visibility_data(), vbits::count, heap_form_tuple(), HeapTupleGetDatum(), if(), Int64GetDatum(), MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, vbits::next, PG_GETARG_OID, pg_visibility_tupdesc(), SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, FuncCallContext::tuple_desc, FuncCallContext::user_fctx, and values.

pg_visibility_map_summary()

Datum pg_visibility_map_summary

(

PG_FUNCTION_ARGS

)

Definition at line 267 of file pg_visibility.c.

{
    Oid         relid = PG_GETARG_OID(0);
    Relation    rel;
    BlockNumber nblocks;
    BlockNumber blkno;
    Buffer      vmbuffer = InvalidBuffer;
    int64       all_visible = 0;
    int64       all_frozen = 0;
    TupleDesc   tupdesc;
    Datum       values[2];
    bool        nulls[2] = {0};
 
    rel = relation_open(relid, AccessShareLock);
 
    /* Only some relkinds have a visibility map */
    check_relation_relkind(rel);
 
    nblocks = RelationGetNumberOfBlocks(rel);
 
    for (blkno = 0; blkno < nblocks; ++blkno)
    {
        int32       mapbits;
 
        /* Make sure we are interruptible. */
        CHECK_FOR_INTERRUPTS();
 
        /* Get map info. */
        mapbits = (int32) visibilitymap_get_status(rel, blkno, &vmbuffer);
        if ((mapbits & VISIBILITYMAP_ALL_VISIBLE) != 0)
            ++all_visible;
        if ((mapbits & VISIBILITYMAP_ALL_FROZEN) != 0)
            ++all_frozen;
    }
 
    /* Clean up. */
    if (vmbuffer != InvalidBuffer)
        ReleaseBuffer(vmbuffer);
    relation_close(rel, AccessShareLock);
 
    if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    values[0] = Int64GetDatum(all_visible);
    values[1] = Int64GetDatum(all_frozen);
 
    PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
}

References AccessShareLock, CHECK_FOR_INTERRUPTS, check_relation_relkind(), elog, ERROR, get_call_result_type(), heap_form_tuple(), HeapTupleGetDatum(), Int64GetDatum(), InvalidBuffer, PG_GETARG_OID, PG_RETURN_DATUM, relation_close(), relation_open(), RelationGetNumberOfBlocks, ReleaseBuffer(), TYPEFUNC_COMPOSITE, values, VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, and visibilitymap_get_status().

pg_visibility_rel()

Datum pg_visibility_rel

(

PG_FUNCTION_ARGS

)

Definition at line 222 of file pg_visibility.c.

{
    FuncCallContext *funcctx;
    vbits      *info;
 
    if (SRF_IS_FIRSTCALL())
    {
        Oid         relid = PG_GETARG_OID(0);
        MemoryContext oldcontext;
 
        funcctx = SRF_FIRSTCALL_INIT();
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
        funcctx->tuple_desc = pg_visibility_tupdesc(true, true);
        /* collect_visibility_data will verify the relkind */
        funcctx->user_fctx = collect_visibility_data(relid, true);
        MemoryContextSwitchTo(oldcontext);
    }
 
    funcctx = SRF_PERCALL_SETUP();
    info = (vbits *) funcctx->user_fctx;
 
    if (info->next < info->count)
    {
        Datum       values[4];
        bool        nulls[4] = {0};
        HeapTuple   tuple;
 
        values[0] = Int64GetDatum(info->next);
        values[1] = BoolGetDatum((info->bits[info->next] & (1 << 0)) != 0);
        values[2] = BoolGetDatum((info->bits[info->next] & (1 << 1)) != 0);
        values[3] = BoolGetDatum((info->bits[info->next] & (1 << 2)) != 0);
        info->next++;
 
        tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
        SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple));
    }
 
    SRF_RETURN_DONE(funcctx);
}

References vbits::bits, BoolGetDatum(), collect_visibility_data(), vbits::count, heap_form_tuple(), HeapTupleGetDatum(), if(), Int64GetDatum(), MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, vbits::next, PG_GETARG_OID, pg_visibility_tupdesc(), SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, FuncCallContext::tuple_desc, FuncCallContext::user_fctx, and values.

pg_visibility_tupdesc()

static TupleDesc pg_visibility_tupdesc ( bool  include_blkno, bool  include_pd  )

static

Definition at line 456 of file pg_visibility.c.

{
    TupleDesc   tupdesc;
    AttrNumber  maxattr = 2;
    AttrNumber  a = 0;
 
    if (include_blkno)
        ++maxattr;
    if (include_pd)
        ++maxattr;
    tupdesc = CreateTemplateTupleDesc(maxattr);
    if (include_blkno)
        TupleDescInitEntry(tupdesc, ++a, "blkno", INT8OID, -1, 0);
    TupleDescInitEntry(tupdesc, ++a, "all_visible", BOOLOID, -1, 0);
    TupleDescInitEntry(tupdesc, ++a, "all_frozen", BOOLOID, -1, 0);
    if (include_pd)
        TupleDescInitEntry(tupdesc, ++a, "pd_all_visible", BOOLOID, -1, 0);
    Assert(a == maxattr);
 
    return BlessTupleDesc(tupdesc);
}

References a, Assert, BlessTupleDesc(), CreateTemplateTupleDesc(), and TupleDescInitEntry().

Referenced by pg_visibility(), pg_visibility_map(), pg_visibility_map_rel(), and pg_visibility_rel().

record_corrupt_item()

static void record_corrupt_item ( corrupt_items *  items, ItemPointer  tid  )

static

Definition at line 874 of file pg_visibility.c.

{
    /* enlarge output array if needed. */
    if (items->next >= items->count)
    {
        items->count *= 2;
        items->tids = repalloc(items->tids,
                               items->count * sizeof(ItemPointerData));
    }
    /* and add the new item */
    items->tids[items->next++] = *tid;
}

References items, and repalloc().

Referenced by collect_corrupt_items().

tuple_all_visible()

static bool tuple_all_visible ( HeapTuple  tup, TransactionId  OldestXmin, Buffer  buffer  )

static

Definition at line 892 of file pg_visibility.c.

{
    HTSV_Result state;
    TransactionId xmin;
 
    state = HeapTupleSatisfiesVacuum(tup, OldestXmin, buffer);
    if (state != HEAPTUPLE_LIVE)
        return false;           /* all-visible implies live */
 
    /*
     * Neither lazy_scan_heap nor heap_page_is_all_visible will mark a page
     * all-visible unless every tuple is hinted committed. However, those hint
     * bits could be lost after a crash, so we can't be certain that they'll
     * be set here.  So just check the xmin.
     */
 
    xmin = HeapTupleHeaderGetXmin(tup->t_data);
    if (!TransactionIdPrecedes(xmin, OldestXmin))
        return false;           /* xmin not old enough for all to see */
 
    return true;
}

References HEAPTUPLE_LIVE, HeapTupleHeaderGetXmin, HeapTupleSatisfiesVacuum(), HeapTupleData::t_data, and TransactionIdPrecedes().

Referenced by collect_corrupt_items().

Variable Documentation

PG_MODULE_MAGIC

PG_MODULE_MAGIC

Definition at line 29 of file pg_visibility.c.