verify_common.c File Reference

#include "postgres.h"
#include "access/genam.h"
#include "access/table.h"
#include "access/tableam.h"
#include "verify_common.h"
#include "catalog/index.h"
#include "catalog/pg_am.h"
#include "commands/tablecmds.h"
#include "utils/guc.h"
#include "utils/syscache.h"

Include dependency graph for verify_common.c:

Go to the source code of this file.

Functions
static bool	amcheck_index_mainfork_expected (Relation rel)
void	amcheck_lock_relation_and_check (Oid indrelid, Oid am_id, IndexDoCheckCallback check, LOCKMODE lockmode, void *state)
bool	index_checkable (Relation rel, Oid am_id)

Function Documentation

amcheck_index_mainfork_expected()

static bool amcheck_index_mainfork_expected ( Relation  rel )

static

Definition at line 36 of file verify_common.c.

{
    if (rel->rd_rel->relpersistence != RELPERSISTENCE_UNLOGGED ||
        !RecoveryInProgress())
        return true;
 
    ereport(NOTICE,
            (errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
             errmsg("cannot verify unlogged index \"%s\" during recovery, skipping",
                    RelationGetRelationName(rel))));
 
    return false;
}

References ereport, errcode(), errmsg(), NOTICE, RelationData::rd_rel, RecoveryInProgress(), and RelationGetRelationName.

Referenced by index_checkable().

amcheck_lock_relation_and_check()

void amcheck_lock_relation_and_check	(	Oid	indrelid,
		Oid	am_id,
		IndexDoCheckCallback	check,
		LOCKMODE	lockmode,
		void *	state
	)

Definition at line 60 of file verify_common.c.

{
    Oid         heapid;
    Relation    indrel;
    Relation    heaprel;
    Oid         save_userid;
    int         save_sec_context;
    int         save_nestlevel;
 
    /*
     * We must lock table before index to avoid deadlocks.  However, if the
     * passed indrelid isn't an index then IndexGetRelation() will fail.
     * Rather than emitting a not-very-helpful error message, postpone
     * complaining, expecting that the is-it-an-index test below will fail.
     *
     * In hot standby mode this will raise an error when parentcheck is true.
     */
    heapid = IndexGetRelation(indrelid, true);
    if (OidIsValid(heapid))
    {
        heaprel = table_open(heapid, lockmode);
 
        /*
         * Switch to the table owner's userid, so that any index functions are
         * run as that user.  Also lock down security-restricted operations
         * and arrange to make GUC variable changes local to this command.
         */
        GetUserIdAndSecContext(&save_userid, &save_sec_context);
        SetUserIdAndSecContext(heaprel->rd_rel->relowner,
                               save_sec_context | SECURITY_RESTRICTED_OPERATION);
        save_nestlevel = NewGUCNestLevel();
    }
    else
    {
        heaprel = NULL;
        /* Set these just to suppress "uninitialized variable" warnings */
        save_userid = InvalidOid;
        save_sec_context = -1;
        save_nestlevel = -1;
    }
 
    /*
     * Open the target index relations separately (like relation_openrv(), but
     * with heap relation locked first to prevent deadlocking).  In hot
     * standby mode this will raise an error when parentcheck is true.
     *
     * There is no need for the usual indcheckxmin usability horizon test
     * here, even in the heapallindexed case, because index undergoing
     * verification only needs to have entries for a new transaction snapshot.
     * (If this is a parentcheck verification, there is no question about
     * committed or recently dead heap tuples lacking index entries due to
     * concurrent activity.)
     */
    indrel = index_open(indrelid, lockmode);
 
    /*
     * Since we did the IndexGetRelation call above without any lock, it's
     * barely possible that a race against an index drop/recreation could have
     * netted us the wrong table.
     */
    if (heaprel == NULL || heapid != IndexGetRelation(indrelid, false))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_TABLE),
                 errmsg("could not open parent table of index \"%s\"",
                        RelationGetRelationName(indrel))));
 
    /* Check that relation suitable for checking */
    if (index_checkable(indrel, am_id))
        check(indrel, heaprel, state, lockmode == ShareLock);
 
    /* Roll back any GUC changes executed by index functions */
    AtEOXact_GUC(false, save_nestlevel);
 
    /* Restore userid and security context */
    SetUserIdAndSecContext(save_userid, save_sec_context);
 
    /*
     * Release locks early. That's ok here because nothing in the called
     * routines will trigger shared cache invalidations to be sent, so we can
     * relax the usual pattern of only releasing locks after commit.
     */
    index_close(indrel, lockmode);
    if (heaprel)
        table_close(heaprel, lockmode);
}

References AtEOXact_GUC(), ereport, errcode(), ERRCODE_UNDEFINED_TABLE, errmsg(), ERROR, GetUserIdAndSecContext(), index_checkable(), index_close(), index_open(), IndexGetRelation(), InvalidOid, NewGUCNestLevel(), OidIsValid, RelationData::rd_rel, RelationGetRelationName, SECURITY_RESTRICTED_OPERATION, SetUserIdAndSecContext(), ShareLock, table_close(), and table_open().

Referenced by bt_index_check(), bt_index_parent_check(), and gin_index_check().

index_checkable()

bool index_checkable	(	Relation	rel,
		Oid	am_id
	)

Definition at line 159 of file verify_common.c.

{
    if (rel->rd_rel->relkind != RELKIND_INDEX ||
        rel->rd_rel->relam != am_id)
    {
        HeapTuple   amtup;
        HeapTuple   amtuprel;
 
        amtup = SearchSysCache1(AMOID, ObjectIdGetDatum(am_id));
        amtuprel = SearchSysCache1(AMOID, ObjectIdGetDatum(rel->rd_rel->relam));
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("expected \"%s\" index as targets for verification", NameStr(((Form_pg_am) GETSTRUCT(amtup))->amname)),
                 errdetail("Relation \"%s\" is a %s index.",
                           RelationGetRelationName(rel), NameStr(((Form_pg_am) GETSTRUCT(amtuprel))->amname))));
    }
 
    if (RELATION_IS_OTHER_TEMP(rel))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot access temporary tables of other sessions"),
                 errdetail("Index \"%s\" is associated with temporary relation.",
                           RelationGetRelationName(rel))));
 
    if (!rel->rd_index->indisvalid)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot check index \"%s\"",
                        RelationGetRelationName(rel)),
                 errdetail("Index is not valid.")));
 
    return amcheck_index_mainfork_expected(rel);
}

References amcheck_index_mainfork_expected(), ereport, errcode(), errdetail(), errmsg(), ERROR, GETSTRUCT(), NameStr, ObjectIdGetDatum(), RelationData::rd_index, RelationData::rd_rel, RELATION_IS_OTHER_TEMP, RelationGetRelationName, and SearchSysCache1().

Referenced by amcheck_lock_relation_and_check().