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)
Oid	RelationMapOidToFilenodeForDatabase (char *dbpath, Oid relationId)
void	RelationMapCopy (Oid dbid, Oid tsid, char *srcdbpath, char *dstdbpath)
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.

XLOG_RELMAP_UPDATE

#define XLOG_RELMAP_UPDATE   0x00

Definition at line 25 of file relmapper.h.

Typedef Documentation

xl_relmap_update

typedef struct xl_relmap_update xl_relmap_update

Function Documentation

AtCCI_RelationMap()

void AtCCI_RelationMap

(

void

)

Definition at line 498 of file relmapper.c.

{
    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;
    }
}

References active_local_updates, active_shared_updates, merge_map_updates(), RelMapFile::num_mappings, pending_local_updates, and pending_shared_updates.

Referenced by AtCCI_LocalCache().

AtEOXact_RelationMap()

void AtEOXact_RelationMap	(	bool	isCommit,
		bool	isParallelWorker
	)

Definition at line 535 of file relmapper.c.

{
    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;
    }
}

References active_local_updates, active_shared_updates, Assert(), RelMapFile::num_mappings, pending_local_updates, pending_shared_updates, and perform_relmap_update().

Referenced by AbortTransaction(), and CommitTransaction().

AtPrepare_RelationMap()

void AtPrepare_RelationMap

(

void

)

Definition at line 582 of file relmapper.c.

{
    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")));
}

References active_local_updates, active_shared_updates, ereport, errcode(), errmsg(), ERROR, RelMapFile::num_mappings, pending_local_updates, and pending_shared_updates.

Referenced by PrepareTransaction().

CheckPointRelationMap()

void CheckPointRelationMap

(

void

)

Definition at line 605 of file relmapper.c.

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

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

Referenced by CheckPointGuts().

EstimateRelationMapSpace()

Size EstimateRelationMapSpace

(

void

)

Definition at line 705 of file relmapper.c.

{
    return sizeof(SerializedActiveRelMaps);
}

Referenced by InitializeParallelDSM(), and SerializeRelationMap().

RelationMapCopy()

void RelationMapCopy	(	Oid	dbid,
		Oid	tsid,
		char *	srcdbpath,
		char *	dstdbpath
	)

Definition at line 288 of file relmapper.c.

{
    RelMapFile  map;
 
    /*
     * Read the relmap file from the source database.
     */
    read_relmap_file(&map, srcdbpath, false, ERROR);
 
    /*
     * Write the same data into the destination database's relmap file.
     *
     * No sinval is needed because no one can be connected to the destination
     * database yet. For the same reason, there is no need to acquire
     * RelationMappingLock.
     *
     * There's no point in trying to preserve files here. The new database
     * isn't usable yet anyway, and won't ever be if we can't install a relmap
     * file.
     */
    write_relmap_file(&map, true, false, false, dbid, tsid, dstdbpath);
}

References ERROR, read_relmap_file(), and write_relmap_file().

Referenced by CreateDatabaseUsingWalLog().

RelationMapFilenodeToOid()

Oid RelationMapFilenodeToOid	(	Oid	relationId,
		bool	shared
	)

Definition at line 214 of file relmapper.c.

{
    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;
}

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().

RelationMapFinishBootstrap()

void RelationMapFinishBootstrap

(

void

)

Definition at line 619 of file relmapper.c.

{
    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(&shared_map, false, false, false,
                      InvalidOid, GLOBALTABLESPACE_OID, "global");
    write_relmap_file(&local_map, false, false, false,
                      MyDatabaseId, MyDatabaseTableSpace, DatabasePath);
}

References active_local_updates, active_shared_updates, Assert(), DatabasePath, InvalidOid, IsBootstrapProcessingMode, local_map, MyDatabaseId, MyDatabaseTableSpace, RelMapFile::num_mappings, pending_local_updates, pending_shared_updates, shared_map, and write_relmap_file().

Referenced by BootstrapModeMain().

RelationMapInitialize()

void RelationMapInitialize

(

void

)

Definition at line 643 of file relmapper.c.

{
    /* 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;
}

References active_local_updates, active_shared_updates, local_map, RelMapFile::magic, RelMapFile::num_mappings, pending_local_updates, pending_shared_updates, and shared_map.

Referenced by RelationCacheInitialize().

RelationMapInitializePhase2()

void RelationMapInitializePhase2

(

void

)

Definition at line 663 of file relmapper.c.

{
    /*
     * 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);
}

References IsBootstrapProcessingMode, and load_relmap_file().

Referenced by RelationCacheInitializePhase2().

RelationMapInitializePhase3()

void RelationMapInitializePhase3

(

void

)

Definition at line 684 of file relmapper.c.

{
    /*
     * 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);
}

References IsBootstrapProcessingMode, and load_relmap_file().

Referenced by RelationCacheInitializePhase3().

RelationMapInvalidate()

void RelationMapInvalidate

(

bool

shared

)

Definition at line 462 of file relmapper.c.

{
    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);
    }
}

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

Referenced by LocalExecuteInvalidationMessage().

RelationMapInvalidateAll()

void RelationMapInvalidateAll

(

void

)

Definition at line 484 of file relmapper.c.

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

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

Referenced by RelationCacheInvalidate().

RelationMapOidToFilenode()

Oid RelationMapOidToFilenode	(	Oid	relationId,
		bool	shared
	)

Definition at line 161 of file relmapper.c.

{
    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;
}

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().

RelationMapOidToFilenodeForDatabase()

Oid RelationMapOidToFilenodeForDatabase	(	char *	dbpath,
		Oid	relationId
	)

Definition at line 261 of file relmapper.c.

{
    RelMapFile  map;
    int         i;
 
    /* Read the relmap file from the source database. */
    read_relmap_file(&map, dbpath, false, ERROR);
 
    /* Iterate over the relmap entries to find the input relation OID. */
    for (i = 0; i < map.num_mappings; i++)
    {
        if (relationId == map.mappings[i].mapoid)
            return map.mappings[i].mapfilenode;
    }
 
    return InvalidOid;
}

References ERROR, i, InvalidOid, RelMapping::mapfilenode, RelMapping::mapoid, RelMapFile::mappings, RelMapFile::num_mappings, and read_relmap_file().

Referenced by ScanSourceDatabasePgClass(), and ScanSourceDatabasePgClassTuple().

RelationMapRemoveMapping()

void RelationMapRemoveMapping

(

Oid

relationId

)

Definition at line 432 of file relmapper.c.

{
    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);
}

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

Referenced by finish_heap_swap().

RelationMapUpdateMap()

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

Definition at line 320 of file relmapper.c.

{
    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);
}

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().

relmap_desc()

void relmap_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 20 of file relmapdesc.c.

{
    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 %d",
                         xlrec->dbid, xlrec->tsid, xlrec->nbytes);
    }
}

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

relmap_identify()

const char* relmap_identify

(

uint8

info

)

Definition at line 35 of file relmapdesc.c.

{
    const char *id = NULL;
 
    switch (info & ~XLR_INFO_MASK)
    {
        case XLOG_RELMAP_UPDATE:
            id = "UPDATE";
            break;
    }
 
    return id;
}

References XLOG_RELMAP_UPDATE, and XLR_INFO_MASK.

relmap_redo()

void relmap_redo

(

XLogReaderState *

record

)

Definition at line 1063 of file relmapper.c.

{
    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().
         *
         * Note that we use the same WAL record for updating the relmap of an
         * existing database as we do for creating a new database. In the
         * latter case, taking the relmap log and sending sinval messages is
         * unnecessary, but harmless. If we wanted to avoid it, we could add a
         * flag to the WAL record to indicate which operation is being
         * performed.
         */
        LWLockAcquire(RelationMappingLock, LW_EXCLUSIVE);
        write_relmap_file(&newmap, false, true, false,
                          xlrec->dbid, xlrec->tsid, dbpath);
        LWLockRelease(RelationMappingLock);
 
        pfree(dbpath);
    }
    else
        elog(PANIC, "relmap_redo: unknown op code %u", info);
}

References Assert(), xl_relmap_update::data, xl_relmap_update::dbid, elog, GetDatabasePath(), 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.

RestoreRelationMap()

void RestoreRelationMap

(

char *

startAddress

)

Definition at line 733 of file relmapper.c.

{
    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;
}

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

Referenced by ParallelWorkerMain().

SerializeRelationMap()

void SerializeRelationMap	(	Size	maxSize,
		char *	startAddress
	)

Definition at line 716 of file relmapper.c.

{
    SerializedActiveRelMaps *relmaps;
 
    Assert(maxSize >= EstimateRelationMapSpace());
 
    relmaps = (SerializedActiveRelMaps *) startAddress;
    relmaps->active_shared_updates = active_shared_updates;
    relmaps->active_local_updates = active_local_updates;
}

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

Referenced by InitializeParallelDSM().