relfilenodemap.c File Reference

#include "postgres.h"
#include "access/genam.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "catalog/indexing.h"
#include "catalog/pg_class.h"
#include "catalog/pg_tablespace.h"
#include "miscadmin.h"
#include "utils/builtins.h"
#include "utils/catcache.h"
#include "utils/fmgroids.h"
#include "utils/hsearch.h"
#include "utils/inval.h"
#include "utils/rel.h"
#include "utils/relfilenodemap.h"
#include "utils/relmapper.h"

Include dependency graph for relfilenodemap.c:

Go to the source code of this file.

Data Structures
struct	RelfilenodeMapKey
struct	RelfilenodeMapEntry

Functions
static void	RelfilenodeMapInvalidateCallback (Datum arg, Oid relid)
static void	InitializeRelfilenodeMap (void)
Oid	RelidByRelfilenode (Oid reltablespace, Oid relfilenode)

Variables
static HTAB *	RelfilenodeMapHash = NULL
static ScanKeyData	relfilenode_skey [2]

Function Documentation

InitializeRelfilenodeMap()

static void InitializeRelfilenodeMap ( void  )

static

Definition at line 89 of file relfilenodemap.c.

References BTEqualStrategyNumber, CacheMemoryContext, CacheRegisterRelcacheCallback(), CreateCacheMemoryContext(), HASHCTL::entrysize, fmgr_info_cxt(), HASH_BLOBS, HASH_CONTEXT, hash_create(), HASH_ELEM, HASHCTL::hcxt, i, InvalidOid, HASHCTL::keysize, MemSet, RelfilenodeMapInvalidateCallback(), ScanKeyData::sk_attno, ScanKeyData::sk_collation, ScanKeyData::sk_strategy, and ScanKeyData::sk_subtype.

Referenced by RelidByRelfilenode().

{
    HASHCTL     ctl;
    int         i;

    /* Make sure we've initialized CacheMemoryContext. */
    if (CacheMemoryContext == NULL)
        CreateCacheMemoryContext();

    /* build skey */
    MemSet(&relfilenode_skey, 0, sizeof(relfilenode_skey));

    for (i = 0; i < 2; i++)
    {
        fmgr_info_cxt(F_OIDEQ,
                      &relfilenode_skey[i].sk_func,
                      CacheMemoryContext);
        relfilenode_skey[i].sk_strategy = BTEqualStrategyNumber;
        relfilenode_skey[i].sk_subtype = InvalidOid;
        relfilenode_skey[i].sk_collation = InvalidOid;
    }

    relfilenode_skey[0].sk_attno = Anum_pg_class_reltablespace;
    relfilenode_skey[1].sk_attno = Anum_pg_class_relfilenode;

    /* Initialize the hash table. */
    MemSet(&ctl, 0, sizeof(ctl));
    ctl.keysize = sizeof(RelfilenodeMapKey);
    ctl.entrysize = sizeof(RelfilenodeMapEntry);
    ctl.hcxt = CacheMemoryContext;

    /*
     * Only create the RelfilenodeMapHash now, so we don't end up partially
     * initialized when fmgr_info_cxt() above ERRORs out with an out of memory
     * error.
     */
    RelfilenodeMapHash =
        hash_create("RelfilenodeMap cache", 64, &ctl,
                    HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);

    /* Watch for invalidation events. */
    CacheRegisterRelcacheCallback(RelfilenodeMapInvalidateCallback,
                                  (Datum) 0);
}

RelfilenodeMapInvalidateCallback()

static void RelfilenodeMapInvalidateCallback ( Datum  arg, Oid  relid  )

static

Definition at line 55 of file relfilenodemap.c.

References Assert, elog, ERROR, HASH_REMOVE, hash_search(), hash_seq_init(), hash_seq_search(), InvalidOid, RelfilenodeMapEntry::key, RelfilenodeMapEntry::relid, and status().

Referenced by InitializeRelfilenodeMap().

{
    HASH_SEQ_STATUS status;
    RelfilenodeMapEntry *entry;

    /* callback only gets registered after creating the hash */
    Assert(RelfilenodeMapHash != NULL);

    hash_seq_init(&status, RelfilenodeMapHash);
    while ((entry = (RelfilenodeMapEntry *) hash_seq_search(&status)) != NULL)
    {
        /*
         * If relid is InvalidOid, signalling a complete reset, we must remove
         * all entries, otherwise just remove the specific relation's entry.
         * Always remove negative cache entries.
         */
        if (relid == InvalidOid ||  /* complete reset */
            entry->relid == InvalidOid ||   /* negative cache entry */
            entry->relid == relid)  /* individual flushed relation */
        {
            if (hash_search(RelfilenodeMapHash,
                            (void *) &entry->key,
                            HASH_REMOVE,
                            NULL) == NULL)
                elog(ERROR, "hash table corrupted");
        }
    }
}

RelidByRelfilenode()

Oid RelidByRelfilenode	(	Oid	reltablespace,
		Oid	relfilenode
	)

Definition at line 141 of file relfilenodemap.c.

References AccessShareLock, Assert, ClassTblspcRelfilenodeIndexId, elog, ERROR, GETSTRUCT, HASH_ENTER, HASH_FIND, hash_search(), HeapTupleIsValid, InitializeRelfilenodeMap(), InvalidOid, sort-test::key, MemSet, MyDatabaseTableSpace, ObjectIdGetDatum, RelationMapFilenodeToOid(), RelfilenodeMapKey::relfilenode, RelfilenodeMapEntry::relid, RelfilenodeMapKey::reltablespace, ScanKeyData::sk_argument, systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by autoprewarm_database_main(), pg_filenode_relation(), and ReorderBufferCommit().

{
    RelfilenodeMapKey key;
    RelfilenodeMapEntry *entry;
    bool        found;
    SysScanDesc scandesc;
    Relation    relation;
    HeapTuple   ntp;
    ScanKeyData skey[2];
    Oid         relid;

    if (RelfilenodeMapHash == NULL)
        InitializeRelfilenodeMap();

    /* pg_class will show 0 when the value is actually MyDatabaseTableSpace */
    if (reltablespace == MyDatabaseTableSpace)
        reltablespace = 0;

    MemSet(&key, 0, sizeof(key));
    key.reltablespace = reltablespace;
    key.relfilenode = relfilenode;

    /*
     * Check cache and return entry if one is found. Even if no target
     * relation can be found later on we store the negative match and return a
     * InvalidOid from cache. That's not really necessary for performance
     * since querying invalid values isn't supposed to be a frequent thing,
     * but it's basically free.
     */
    entry = hash_search(RelfilenodeMapHash, (void *) &key, HASH_FIND, &found);

    if (found)
        return entry->relid;

    /* ok, no previous cache entry, do it the hard way */

    /* initialize empty/negative cache entry before doing the actual lookups */
    relid = InvalidOid;

    if (reltablespace == GLOBALTABLESPACE_OID)
    {
        /*
         * Ok, shared table, check relmapper.
         */
        relid = RelationMapFilenodeToOid(relfilenode, true);
    }
    else
    {
        /*
         * Not a shared table, could either be a plain relation or a
         * non-shared, nailed one, like e.g. pg_class.
         */

        /* check for plain relations by looking in pg_class */
        relation = table_open(RelationRelationId, AccessShareLock);

        /* copy scankey to local copy, it will be modified during the scan */
        memcpy(skey, relfilenode_skey, sizeof(skey));

        /* set scan arguments */
        skey[0].sk_argument = ObjectIdGetDatum(reltablespace);
        skey[1].sk_argument = ObjectIdGetDatum(relfilenode);

        scandesc = systable_beginscan(relation,
                                      ClassTblspcRelfilenodeIndexId,
                                      true,
                                      NULL,
                                      2,
                                      skey);

        found = false;

        while (HeapTupleIsValid(ntp = systable_getnext(scandesc)))
        {
            Form_pg_class classform = (Form_pg_class) GETSTRUCT(ntp);

            if (found)
                elog(ERROR,
                     "unexpected duplicate for tablespace %u, relfilenode %u",
                     reltablespace, relfilenode);
            found = true;

            Assert(classform->reltablespace == reltablespace);
            Assert(classform->relfilenode == relfilenode);
            relid = classform->oid;
        }

        systable_endscan(scandesc);
        table_close(relation, AccessShareLock);

        /* check for tables that are mapped but not shared */
        if (!found)
            relid = RelationMapFilenodeToOid(relfilenode, false);
    }

    /*
     * Only enter entry into cache now, our opening of pg_class could have
     * caused cache invalidations to be executed which would have deleted a
     * new entry if we had entered it above.
     */
    entry = hash_search(RelfilenodeMapHash, (void *) &key, HASH_ENTER, &found);
    if (found)
        elog(ERROR, "corrupted hashtable");
    entry->relid = relid;

    return relid;
}

Variable Documentation

relfilenode_skey

ScanKeyData relfilenode_skey[2]

static

Definition at line 36 of file relfilenodemap.c.

RelfilenodeMapHash

HTAB* RelfilenodeMapHash = NULL

static

Definition at line 33 of file relfilenodemap.c.