relmapper.h File Reference

#include "access/xlogreader.h"
#include "lib/stringinfo.h"

Include dependency graph for relmapper.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	xl_relmap_update

Macros
#define	XLOG_RELMAP_UPDATE   0x00
#define	MinSizeOfRelmapUpdate   offsetof(xl_relmap_update, data)

Typedefs
typedef struct xl_relmap_update	xl_relmap_update

Functions
Oid	RelationMapOidToFilenode (Oid relationId, bool shared)
Oid	RelationMapFilenodeToOid (Oid relationId, bool shared)
void	RelationMapUpdateMap (Oid relationId, Oid fileNode, bool shared, bool immediate)
void	RelationMapRemoveMapping (Oid relationId)
void	RelationMapInvalidate (bool shared)
void	RelationMapInvalidateAll (void)
void	AtCCI_RelationMap (void)
void	AtEOXact_RelationMap (bool isCommit, bool isParallelWorker)
void	AtPrepare_RelationMap (void)
void	CheckPointRelationMap (void)
void	RelationMapFinishBootstrap (void)
void	RelationMapInitialize (void)
void	RelationMapInitializePhase2 (void)
void	RelationMapInitializePhase3 (void)
Size	EstimateRelationMapSpace (void)
void	SerializeRelationMap (Size maxSize, char *startAddress)
void	RestoreRelationMap (char *startAddress)
void	relmap_redo (XLogReaderState *record)
void	relmap_desc (StringInfo buf, XLogReaderState *record)
const char *	relmap_identify (uint8 info)

Macro Definition Documentation

MinSizeOfRelmapUpdate

#define MinSizeOfRelmapUpdate   offsetof(xl_relmap_update, data)

Definition at line 35 of file relmapper.h.

Referenced by write_relmap_file().

XLOG_RELMAP_UPDATE

#define XLOG_RELMAP_UPDATE   0x00

Definition at line 25 of file relmapper.h.

Referenced by relmap_desc(), relmap_identify(), relmap_redo(), and write_relmap_file().

Typedef Documentation

xl_relmap_update

typedef struct xl_relmap_update xl_relmap_update

Function Documentation

AtCCI_RelationMap()

void AtCCI_RelationMap

(

void

)

Definition at line 439 of file relmapper.c.

References merge_map_updates(), and RelMapFile::num_mappings.

Referenced by AtCCI_LocalCache().

{
    if (pending_shared_updates.num_mappings != 0)
    {
        merge_map_updates(&active_shared_updates,
                          &pending_shared_updates,
                          true);
        pending_shared_updates.num_mappings = 0;
    }
    if (pending_local_updates.num_mappings != 0)
    {
        merge_map_updates(&active_local_updates,
                          &pending_local_updates,
                          true);
        pending_local_updates.num_mappings = 0;
    }
}

AtEOXact_RelationMap()

void AtEOXact_RelationMap	(	bool	isCommit,
		bool	isParallelWorker
	)

Definition at line 476 of file relmapper.c.

References Assert, RelMapFile::num_mappings, and perform_relmap_update().

Referenced by AbortTransaction(), and CommitTransaction().

{
    if (isCommit && !isParallelWorker)
    {
        /*
         * We should not get here with any "pending" updates.  (We could
         * logically choose to treat such as committed, but in the current
         * code this should never happen.)
         */
        Assert(pending_shared_updates.num_mappings == 0);
        Assert(pending_local_updates.num_mappings == 0);

        /*
         * Write any active updates to the actual map files, then reset them.
         */
        if (active_shared_updates.num_mappings != 0)
        {
            perform_relmap_update(true, &active_shared_updates);
            active_shared_updates.num_mappings = 0;
        }
        if (active_local_updates.num_mappings != 0)
        {
            perform_relmap_update(false, &active_local_updates);
            active_local_updates.num_mappings = 0;
        }
    }
    else
    {
        /* Abort or parallel worker --- drop all local and pending updates */
        Assert(!isParallelWorker || pending_shared_updates.num_mappings == 0);
        Assert(!isParallelWorker || pending_local_updates.num_mappings == 0);

        active_shared_updates.num_mappings = 0;
        active_local_updates.num_mappings = 0;
        pending_shared_updates.num_mappings = 0;
        pending_local_updates.num_mappings = 0;
    }
}

AtPrepare_RelationMap()

void AtPrepare_RelationMap

(

void

)

Definition at line 523 of file relmapper.c.

References ereport, errcode(), errmsg(), ERROR, and RelMapFile::num_mappings.

Referenced by PrepareTransaction().

{
    if (active_shared_updates.num_mappings != 0 ||
        active_local_updates.num_mappings != 0 ||
        pending_shared_updates.num_mappings != 0 ||
        pending_local_updates.num_mappings != 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot PREPARE a transaction that modified relation mapping")));
}

CheckPointRelationMap()

void CheckPointRelationMap

(

void

)

Definition at line 546 of file relmapper.c.

References LW_SHARED, LWLockAcquire(), and LWLockRelease().

Referenced by CheckPointGuts().

{
    LWLockAcquire(RelationMappingLock, LW_SHARED);
    LWLockRelease(RelationMappingLock);
}

EstimateRelationMapSpace()

Size EstimateRelationMapSpace

(

void

)

Definition at line 646 of file relmapper.c.

Referenced by InitializeParallelDSM(), and SerializeRelationMap().

{
    return sizeof(SerializedActiveRelMaps);
}

RelationMapFilenodeToOid()

Oid RelationMapFilenodeToOid	(	Oid	relationId,
		bool	shared
	)

Definition at line 212 of file relmapper.c.

References active_local_updates, active_shared_updates, i, InvalidOid, local_map, RelMapping::mapfilenode, RelMapping::mapoid, RelMapFile::mappings, RelMapFile::num_mappings, and shared_map.

Referenced by RelidByRelfilenode().

{
    const RelMapFile *map;
    int32       i;

    /* If there are active updates, believe those over the main maps */
    if (shared)
    {
        map = &active_shared_updates;
        for (i = 0; i < map->num_mappings; i++)
        {
            if (filenode == map->mappings[i].mapfilenode)
                return map->mappings[i].mapoid;
        }
        map = &shared_map;
        for (i = 0; i < map->num_mappings; i++)
        {
            if (filenode == map->mappings[i].mapfilenode)
                return map->mappings[i].mapoid;
        }
    }
    else
    {
        map = &active_local_updates;
        for (i = 0; i < map->num_mappings; i++)
        {
            if (filenode == map->mappings[i].mapfilenode)
                return map->mappings[i].mapoid;
        }
        map = &local_map;
        for (i = 0; i < map->num_mappings; i++)
        {
            if (filenode == map->mappings[i].mapfilenode)
                return map->mappings[i].mapoid;
        }
    }

    return InvalidOid;
}

RelationMapFinishBootstrap()

void RelationMapFinishBootstrap

(

void

)

Definition at line 560 of file relmapper.c.

References Assert, DatabasePath, InvalidOid, IsBootstrapProcessingMode, MyDatabaseId, MyDatabaseTableSpace, RelMapFile::num_mappings, and write_relmap_file().

Referenced by BootstrapModeMain().

{
    Assert(IsBootstrapProcessingMode());

    /* Shouldn't be anything "pending" ... */
    Assert(active_shared_updates.num_mappings == 0);
    Assert(active_local_updates.num_mappings == 0);
    Assert(pending_shared_updates.num_mappings == 0);
    Assert(pending_local_updates.num_mappings == 0);

    /* Write the files; no WAL or sinval needed */
    write_relmap_file(true, &shared_map, false, false, false,
                      InvalidOid, GLOBALTABLESPACE_OID, NULL);
    write_relmap_file(false, &local_map, false, false, false,
                      MyDatabaseId, MyDatabaseTableSpace, DatabasePath);
}

RelationMapInitialize()

void RelationMapInitialize

(

void

)

Definition at line 584 of file relmapper.c.

References RelMapFile::magic, and RelMapFile::num_mappings.

Referenced by RelationCacheInitialize().

{
    /* The static variables should initialize to zeroes, but let's be sure */
    shared_map.magic = 0;       /* mark it not loaded */
    local_map.magic = 0;
    shared_map.num_mappings = 0;
    local_map.num_mappings = 0;
    active_shared_updates.num_mappings = 0;
    active_local_updates.num_mappings = 0;
    pending_shared_updates.num_mappings = 0;
    pending_local_updates.num_mappings = 0;
}

RelationMapInitializePhase2()

void RelationMapInitializePhase2

(

void

)

Definition at line 604 of file relmapper.c.

References IsBootstrapProcessingMode, and load_relmap_file().

Referenced by RelationCacheInitializePhase2().

{
    /*
     * In bootstrap mode, the map file isn't there yet, so do nothing.
     */
    if (IsBootstrapProcessingMode())
        return;

    /*
     * Load the shared map file, die on error.
     */
    load_relmap_file(true, false);
}

RelationMapInitializePhase3()

void RelationMapInitializePhase3

(

void

)

Definition at line 625 of file relmapper.c.

References IsBootstrapProcessingMode, and load_relmap_file().

Referenced by RelationCacheInitializePhase3().

{
    /*
     * In bootstrap mode, the map file isn't there yet, so do nothing.
     */
    if (IsBootstrapProcessingMode())
        return;

    /*
     * Load the local map file, die on error.
     */
    load_relmap_file(false, false);
}

RelationMapInvalidate()

void RelationMapInvalidate

(

bool

shared

)

Definition at line 403 of file relmapper.c.

References load_relmap_file(), RelMapFile::magic, and RELMAPPER_FILEMAGIC.

Referenced by LocalExecuteInvalidationMessage().

{
    if (shared)
    {
        if (shared_map.magic == RELMAPPER_FILEMAGIC)
            load_relmap_file(true, false);
    }
    else
    {
        if (local_map.magic == RELMAPPER_FILEMAGIC)
            load_relmap_file(false, false);
    }
}

RelationMapInvalidateAll()

void RelationMapInvalidateAll

(

void

)

Definition at line 425 of file relmapper.c.

References load_relmap_file(), RelMapFile::magic, and RELMAPPER_FILEMAGIC.

Referenced by RelationCacheInvalidate().

{
    if (shared_map.magic == RELMAPPER_FILEMAGIC)
        load_relmap_file(true, false);
    if (local_map.magic == RELMAPPER_FILEMAGIC)
        load_relmap_file(false, false);
}

RelationMapOidToFilenode()

Oid RelationMapOidToFilenode	(	Oid	relationId,
		bool	shared
	)

Definition at line 159 of file relmapper.c.

References active_local_updates, active_shared_updates, i, InvalidOid, local_map, RelMapping::mapfilenode, RelMapping::mapoid, RelMapFile::mappings, RelMapFile::num_mappings, and shared_map.

Referenced by pg_relation_filenode(), pg_relation_filepath(), RelationInitPhysicalAddr(), and swap_relation_files().

{
    const RelMapFile *map;
    int32       i;

    /* If there are active updates, believe those over the main maps */
    if (shared)
    {
        map = &active_shared_updates;
        for (i = 0; i < map->num_mappings; i++)
        {
            if (relationId == map->mappings[i].mapoid)
                return map->mappings[i].mapfilenode;
        }
        map = &shared_map;
        for (i = 0; i < map->num_mappings; i++)
        {
            if (relationId == map->mappings[i].mapoid)
                return map->mappings[i].mapfilenode;
        }
    }
    else
    {
        map = &active_local_updates;
        for (i = 0; i < map->num_mappings; i++)
        {
            if (relationId == map->mappings[i].mapoid)
                return map->mappings[i].mapfilenode;
        }
        map = &local_map;
        for (i = 0; i < map->num_mappings; i++)
        {
            if (relationId == map->mappings[i].mapoid)
                return map->mappings[i].mapfilenode;
        }
    }

    return InvalidOid;
}

RelationMapRemoveMapping()

void RelationMapRemoveMapping

(

Oid

relationId

)

Definition at line 373 of file relmapper.c.

References active_local_updates, elog, ERROR, i, RelMapping::mapoid, RelMapFile::mappings, and RelMapFile::num_mappings.

Referenced by finish_heap_swap().

{
    RelMapFile *map = &active_local_updates;
    int32       i;

    for (i = 0; i < map->num_mappings; i++)
    {
        if (relationId == map->mappings[i].mapoid)
        {
            /* Found it, collapse it out */
            map->mappings[i] = map->mappings[map->num_mappings - 1];
            map->num_mappings--;
            return;
        }
    }
    elog(ERROR, "could not find temporary mapping for relation %u",
         relationId);
}

RelationMapUpdateMap()

void RelationMapUpdateMap	(	Oid	relationId,
		Oid	fileNode,
		bool	shared,
		bool	immediate
	)

Definition at line 261 of file relmapper.c.

References active_local_updates, active_shared_updates, apply_map_update(), elog, ERROR, GetCurrentTransactionNestLevel(), IsBootstrapProcessingMode, IsInParallelMode(), local_map, pending_local_updates, pending_shared_updates, and shared_map.

Referenced by formrdesc(), RelationBuildLocalRelation(), RelationSetNewRelfilenode(), and swap_relation_files().

{
    RelMapFile *map;

    if (IsBootstrapProcessingMode())
    {
        /*
         * In bootstrap mode, the mapping gets installed in permanent map.
         */
        if (shared)
            map = &shared_map;
        else
            map = &local_map;
    }
    else
    {
        /*
         * We don't currently support map changes within subtransactions, or
         * when in parallel mode.  This could be done with more bookkeeping
         * infrastructure, but it doesn't presently seem worth it.
         */
        if (GetCurrentTransactionNestLevel() > 1)
            elog(ERROR, "cannot change relation mapping within subtransaction");

        if (IsInParallelMode())
            elog(ERROR, "cannot change relation mapping in parallel mode");

        if (immediate)
        {
            /* Make it active, but only locally */
            if (shared)
                map = &active_shared_updates;
            else
                map = &active_local_updates;
        }
        else
        {
            /* Make it pending */
            if (shared)
                map = &pending_shared_updates;
            else
                map = &pending_local_updates;
        }
    }
    apply_map_update(map, relationId, fileNode, true);
}

relmap_desc()

void relmap_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 20 of file relmapdesc.c.

References appendStringInfo(), xl_relmap_update::dbid, xl_relmap_update::nbytes, xl_relmap_update::tsid, XLOG_RELMAP_UPDATE, XLogRecGetData, XLogRecGetInfo, and XLR_INFO_MASK.

{
    char       *rec = XLogRecGetData(record);
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;

    if (info == XLOG_RELMAP_UPDATE)
    {
        xl_relmap_update *xlrec = (xl_relmap_update *) rec;

        appendStringInfo(buf, "database %u tablespace %u size %u",
                         xlrec->dbid, xlrec->tsid, xlrec->nbytes);
    }
}

relmap_identify()

const char* relmap_identify

(

uint8

info

)

Definition at line 35 of file relmapdesc.c.

References XLOG_RELMAP_UPDATE, and XLR_INFO_MASK.

{
    const char *id = NULL;

    switch (info & ~XLR_INFO_MASK)
    {
        case XLOG_RELMAP_UPDATE:
            id = "UPDATE";
            break;
    }

    return id;
}

relmap_redo()

void relmap_redo

(

XLogReaderState *

record

)

Definition at line 1006 of file relmapper.c.

References Assert, xl_relmap_update::data, xl_relmap_update::dbid, elog, GetDatabasePath(), InvalidOid, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), xl_relmap_update::nbytes, PANIC, pfree(), xl_relmap_update::tsid, write_relmap_file(), XLOG_RELMAP_UPDATE, XLogRecGetData, XLogRecGetInfo, XLogRecHasAnyBlockRefs, and XLR_INFO_MASK.

{
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;

    /* Backup blocks are not used in relmap records */
    Assert(!XLogRecHasAnyBlockRefs(record));

    if (info == XLOG_RELMAP_UPDATE)
    {
        xl_relmap_update *xlrec = (xl_relmap_update *) XLogRecGetData(record);
        RelMapFile  newmap;
        char       *dbpath;

        if (xlrec->nbytes != sizeof(RelMapFile))
            elog(PANIC, "relmap_redo: wrong size %u in relmap update record",
                 xlrec->nbytes);
        memcpy(&newmap, xlrec->data, sizeof(newmap));

        /* We need to construct the pathname for this database */
        dbpath = GetDatabasePath(xlrec->dbid, xlrec->tsid);

        /*
         * Write out the new map and send sinval, but of course don't write a
         * new WAL entry.  There's no surrounding transaction to tell to
         * preserve files, either.
         *
         * There shouldn't be anyone else updating relmaps during WAL replay,
         * but grab the lock to interlock against load_relmap_file().
         */
        LWLockAcquire(RelationMappingLock, LW_EXCLUSIVE);
        write_relmap_file((xlrec->dbid == InvalidOid), &newmap,
                          false, true, false,
                          xlrec->dbid, xlrec->tsid, dbpath);
        LWLockRelease(RelationMappingLock);

        pfree(dbpath);
    }
    else
        elog(PANIC, "relmap_redo: unknown op code %u", info);
}

RestoreRelationMap()

void RestoreRelationMap

(

char *

startAddress

)

Definition at line 674 of file relmapper.c.

References SerializedActiveRelMaps::active_local_updates, SerializedActiveRelMaps::active_shared_updates, elog, ERROR, and RelMapFile::num_mappings.

Referenced by ParallelWorkerMain().

{
    SerializedActiveRelMaps *relmaps;

    if (active_shared_updates.num_mappings != 0 ||
        active_local_updates.num_mappings != 0 ||
        pending_shared_updates.num_mappings != 0 ||
        pending_local_updates.num_mappings != 0)
        elog(ERROR, "parallel worker has existing mappings");

    relmaps = (SerializedActiveRelMaps *) startAddress;
    active_shared_updates = relmaps->active_shared_updates;
    active_local_updates = relmaps->active_local_updates;
}

SerializeRelationMap()

void SerializeRelationMap	(	Size	maxSize,
		char *	startAddress
	)

Definition at line 657 of file relmapper.c.

References SerializedActiveRelMaps::active_local_updates, active_local_updates, SerializedActiveRelMaps::active_shared_updates, active_shared_updates, Assert, and EstimateRelationMapSpace().

Referenced by InitializeParallelDSM().

{
    SerializedActiveRelMaps *relmaps;

    Assert(maxSize >= EstimateRelationMapSpace());

    relmaps = (SerializedActiveRelMaps *) startAddress;
    relmaps->active_shared_updates = active_shared_updates;
    relmaps->active_local_updates = active_local_updates;
}