relmapper.c File Reference

#include "postgres.h"
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include "access/xact.h"
#include "access/xlog.h"
#include "access/xloginsert.h"
#include "catalog/catalog.h"
#include "catalog/pg_tablespace.h"
#include "catalog/storage.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "storage/fd.h"
#include "storage/lwlock.h"
#include "utils/inval.h"
#include "utils/relmapper.h"

Include dependency graph for relmapper.c:

Go to the source code of this file.

Data Structures
struct	RelMapping
struct	RelMapFile
struct	SerializedActiveRelMaps

Macros
#define	RELMAPPER_FILENAME   "pg_filenode.map"
#define	RELMAPPER_FILEMAGIC   0x592717 /* version ID value */
#define	MAX_MAPPINGS   62 /* 62 * 8 + 16 = 512 */

Typedefs
typedef struct RelMapping	RelMapping
typedef struct RelMapFile	RelMapFile
typedef struct SerializedActiveRelMaps	SerializedActiveRelMaps

Functions
static void	apply_map_update (RelMapFile *map, Oid relationId, Oid fileNode, bool add_okay)
static void	merge_map_updates (RelMapFile *map, const RelMapFile *updates, bool add_okay)
static void	load_relmap_file (bool shared)
static void	write_relmap_file (bool shared, RelMapFile *newmap, bool write_wal, bool send_sinval, bool preserve_files, Oid dbid, Oid tsid, const char *dbpath)
static void	perform_relmap_update (bool shared, const RelMapFile *updates)
Oid	RelationMapOidToFilenode (Oid relationId, bool shared)
Oid	RelationMapFilenodeToOid (Oid filenode, 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)

Variables
static RelMapFile	shared_map
static RelMapFile	local_map
static RelMapFile	active_shared_updates
static RelMapFile	active_local_updates
static RelMapFile	pending_shared_updates
static RelMapFile	pending_local_updates

Macro Definition Documentation

MAX_MAPPINGS

#define MAX_MAPPINGS   62 /* 62 * 8 + 16 = 512 */

Definition at line 77 of file relmapper.c.

Referenced by apply_map_update(), load_relmap_file(), and write_relmap_file().

RELMAPPER_FILEMAGIC

#define RELMAPPER_FILEMAGIC   0x592717 /* version ID value */

Definition at line 75 of file relmapper.c.

Referenced by load_relmap_file(), RelationMapInvalidate(), RelationMapInvalidateAll(), and write_relmap_file().

RELMAPPER_FILENAME

#define RELMAPPER_FILENAME   "pg_filenode.map"

Definition at line 73 of file relmapper.c.

Referenced by load_relmap_file(), and write_relmap_file().

Typedef Documentation

RelMapFile

typedef struct RelMapFile RelMapFile

RelMapping

typedef struct RelMapping RelMapping

SerializedActiveRelMaps

typedef struct SerializedActiveRelMaps SerializedActiveRelMaps

Function Documentation

apply_map_update()

static void apply_map_update ( RelMapFile *  map, Oid  relationId, Oid  fileNode, bool  add_okay  )

static

Definition at line 319 of file relmapper.c.

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

Referenced by merge_map_updates(), and RelationMapUpdateMap().

{
    int32       i;

    /* Replace any existing mapping */
    for (i = 0; i < map->num_mappings; i++)
    {
        if (relationId == map->mappings[i].mapoid)
        {
            map->mappings[i].mapfilenode = fileNode;
            return;
        }
    }

    /* Nope, need to add a new mapping */
    if (!add_okay)
        elog(ERROR, "attempt to apply a mapping to unmapped relation %u",
             relationId);
    if (map->num_mappings >= MAX_MAPPINGS)
        elog(ERROR, "ran out of space in relation map");
    map->mappings[map->num_mappings].mapoid = relationId;
    map->mappings[map->num_mappings].mapfilenode = fileNode;
    map->num_mappings++;
}

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

load_relmap_file()

static void load_relmap_file ( bool  shared )

static

Definition at line 698 of file relmapper.c.

References CloseTransientFile(), COMP_CRC32C, DatabasePath, EQ_CRC32C, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errcode_for_file_access(), errmsg(), FATAL, fd(), FIN_CRC32C, INIT_CRC32C, local_map, RelMapFile::magic, MAX_MAPPINGS, MAXPGPATH, RelMapFile::num_mappings, offsetof, OpenTransientFile(), PG_BINARY, pgstat_report_wait_end(), pgstat_report_wait_start(), read, RELMAPPER_FILEMAGIC, RELMAPPER_FILENAME, shared_map, snprintf, and WAIT_EVENT_RELATION_MAP_READ.

Referenced by perform_relmap_update(), RelationMapInitializePhase2(), RelationMapInitializePhase3(), RelationMapInvalidate(), and RelationMapInvalidateAll().

{
    RelMapFile *map;
    char        mapfilename[MAXPGPATH];
    pg_crc32c   crc;
    int         fd;
    int         r;

    if (shared)
    {
        snprintf(mapfilename, sizeof(mapfilename), "global/%s",
                 RELMAPPER_FILENAME);
        map = &shared_map;
    }
    else
    {
        snprintf(mapfilename, sizeof(mapfilename), "%s/%s",
                 DatabasePath, RELMAPPER_FILENAME);
        map = &local_map;
    }

    /* Read data ... */
    fd = OpenTransientFile(mapfilename, O_RDONLY | PG_BINARY);
    if (fd < 0)
        ereport(FATAL,
                (errcode_for_file_access(),
                 errmsg("could not open file \"%s\": %m",
                        mapfilename)));

    /*
     * Note: we could take RelationMappingLock in shared mode here, but it
     * seems unnecessary since our read() should be atomic against any
     * concurrent updater's write().  If the file is updated shortly after we
     * look, the sinval signaling mechanism will make us re-read it before we
     * are able to access any relation that's affected by the change.
     */
    pgstat_report_wait_start(WAIT_EVENT_RELATION_MAP_READ);
    r = read(fd, map, sizeof(RelMapFile));
    if (r != sizeof(RelMapFile))
    {
        if (r < 0)
            ereport(FATAL,
                    (errcode_for_file_access(),
                     errmsg("could not read file \"%s\": %m", mapfilename)));
        else
            ereport(FATAL,
                    (errcode(ERRCODE_DATA_CORRUPTED),
                     errmsg("could not read file \"%s\": read %d of %zu",
                            mapfilename, r, sizeof(RelMapFile))));
    }
    pgstat_report_wait_end();

    if (CloseTransientFile(fd) != 0)
        ereport(FATAL,
                (errcode_for_file_access(),
                 errmsg("could not close file \"%s\": %m",
                        mapfilename)));

    /* check for correct magic number, etc */
    if (map->magic != RELMAPPER_FILEMAGIC ||
        map->num_mappings < 0 ||
        map->num_mappings > MAX_MAPPINGS)
        ereport(FATAL,
                (errmsg("relation mapping file \"%s\" contains invalid data",
                        mapfilename)));

    /* verify the CRC */
    INIT_CRC32C(crc);
    COMP_CRC32C(crc, (char *) map, offsetof(RelMapFile, crc));
    FIN_CRC32C(crc);

    if (!EQ_CRC32C(crc, map->crc))
        ereport(FATAL,
                (errmsg("relation mapping file \"%s\" contains incorrect checksum",
                        mapfilename)));
}

merge_map_updates()

static void merge_map_updates ( RelMapFile *  map, const RelMapFile *  updates, bool  add_okay  )

static

Definition at line 351 of file relmapper.c.

References apply_map_update(), i, RelMapping::mapfilenode, RelMapping::mapoid, RelMapFile::mappings, and RelMapFile::num_mappings.

Referenced by AtCCI_RelationMap(), and perform_relmap_update().

{
    int32       i;

    for (i = 0; i < updates->num_mappings; i++)
    {
        apply_map_update(map,
                         updates->mappings[i].mapoid,
                         updates->mappings[i].mapfilenode,
                         add_okay);
    }
}

perform_relmap_update()

static void perform_relmap_update ( bool  shared, const RelMapFile *  updates  )

static

Definition at line 952 of file relmapper.c.

References allowSystemTableMods, DatabasePath, InvalidOid, load_relmap_file(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), merge_map_updates(), MyDatabaseId, MyDatabaseTableSpace, and write_relmap_file().

Referenced by AtEOXact_RelationMap().

{
    RelMapFile  newmap;

    /*
     * Anyone updating a relation's mapping info should take exclusive lock on
     * that rel and hold it until commit.  This ensures that there will not be
     * concurrent updates on the same mapping value; but there could easily be
     * concurrent updates on different values in the same file. We cover that
     * by acquiring the RelationMappingLock, re-reading the target file to
     * ensure it's up to date, applying the updates, and writing the data
     * before releasing RelationMappingLock.
     *
     * There is only one RelationMappingLock.  In principle we could try to
     * have one per mapping file, but it seems unlikely to be worth the
     * trouble.
     */
    LWLockAcquire(RelationMappingLock, LW_EXCLUSIVE);

    /* Be certain we see any other updates just made */
    load_relmap_file(shared);

    /* Prepare updated data in a local variable */
    if (shared)
        memcpy(&newmap, &shared_map, sizeof(RelMapFile));
    else
        memcpy(&newmap, &local_map, sizeof(RelMapFile));

    /*
     * Apply the updates to newmap.  No new mappings should appear, unless
     * somebody is adding indexes to system catalogs.
     */
    merge_map_updates(&newmap, updates, allowSystemTableMods);

    /* Write out the updated map and do other necessary tasks */
    write_relmap_file(shared, &newmap, true, true, true,
                      (shared ? InvalidOid : MyDatabaseId),
                      (shared ? GLOBALTABLESPACE_OID : MyDatabaseTableSpace),
                      DatabasePath);

    /* Now we can release the lock */
    LWLockRelease(RelationMappingLock);
}

RelationMapFilenodeToOid()

Oid RelationMapFilenodeToOid	(	Oid	filenode,
		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);
}

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

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);
    }
    else
    {
        if (local_map.magic == RELMAPPER_FILEMAGIC)
            load_relmap_file(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);
    if (local_map.magic == RELMAPPER_FILEMAGIC)
        load_relmap_file(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_redo()

void relmap_redo

(

XLogReaderState *

record

)

Definition at line 1000 of file relmapper.c.

References Assert, xl_relmap_update::data, xl_relmap_update::dbid, elog, GetDatabasePath(), InvalidOid, 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,
         * so we don't bother to take the RelationMappingLock.  We would need
         * to do so if load_relmap_file needed to interlock against writers.
         */
        write_relmap_file((xlrec->dbid == InvalidOid), &newmap,
                          false, true, false,
                          xlrec->dbid, xlrec->tsid, dbpath);

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

write_relmap_file()

static void write_relmap_file ( bool  shared, RelMapFile *  newmap, bool  write_wal, bool  send_sinval, bool  preserve_files, Oid  dbid, Oid  tsid, const char *  dbpath  )

static

Definition at line 796 of file relmapper.c.

References Assert, CacheInvalidateRelmap(), CloseTransientFile(), COMP_CRC32C, RelMapFile::crc, data_sync_elevel(), xl_relmap_update::dbid, RelFileNode::dbNode, elog, END_CRIT_SECTION, ereport, errcode_for_file_access(), errmsg(), ERROR, fd(), FIN_CRC32C, i, INIT_CRC32C, local_map, RelMapFile::magic, MAX_MAPPINGS, MAXPGPATH, MinSizeOfRelmapUpdate, xl_relmap_update::nbytes, RelMapFile::num_mappings, offsetof, OpenTransientFile(), PG_BINARY, pg_fsync(), pgstat_report_wait_end(), pgstat_report_wait_start(), RelationPreserveStorage(), RELMAPPER_FILEMAGIC, RELMAPPER_FILENAME, RelFileNode::relNode, shared_map, snprintf, RelFileNode::spcNode, START_CRIT_SECTION, xl_relmap_update::tsid, WAIT_EVENT_RELATION_MAP_SYNC, WAIT_EVENT_RELATION_MAP_WRITE, write, XLOG_RELMAP_UPDATE, XLogBeginInsert(), XLogFlush(), XLogInsert(), and XLogRegisterData().

Referenced by perform_relmap_update(), RelationMapFinishBootstrap(), and relmap_redo().

{
    int         fd;
    RelMapFile *realmap;
    char        mapfilename[MAXPGPATH];

    /*
     * Fill in the overhead fields and update CRC.
     */
    newmap->magic = RELMAPPER_FILEMAGIC;
    if (newmap->num_mappings < 0 || newmap->num_mappings > MAX_MAPPINGS)
        elog(ERROR, "attempt to write bogus relation mapping");

    INIT_CRC32C(newmap->crc);
    COMP_CRC32C(newmap->crc, (char *) newmap, offsetof(RelMapFile, crc));
    FIN_CRC32C(newmap->crc);

    /*
     * Open the target file.  We prefer to do this before entering the
     * critical section, so that an open() failure need not force PANIC.
     */
    if (shared)
    {
        snprintf(mapfilename, sizeof(mapfilename), "global/%s",
                 RELMAPPER_FILENAME);
        realmap = &shared_map;
    }
    else
    {
        snprintf(mapfilename, sizeof(mapfilename), "%s/%s",
                 dbpath, RELMAPPER_FILENAME);
        realmap = &local_map;
    }

    fd = OpenTransientFile(mapfilename, O_WRONLY | O_CREAT | PG_BINARY);
    if (fd < 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not open file \"%s\": %m",
                        mapfilename)));

    if (write_wal)
    {
        xl_relmap_update xlrec;
        XLogRecPtr  lsn;

        /* now errors are fatal ... */
        START_CRIT_SECTION();

        xlrec.dbid = dbid;
        xlrec.tsid = tsid;
        xlrec.nbytes = sizeof(RelMapFile);

        XLogBeginInsert();
        XLogRegisterData((char *) (&xlrec), MinSizeOfRelmapUpdate);
        XLogRegisterData((char *) newmap, sizeof(RelMapFile));

        lsn = XLogInsert(RM_RELMAP_ID, XLOG_RELMAP_UPDATE);

        /* As always, WAL must hit the disk before the data update does */
        XLogFlush(lsn);
    }

    errno = 0;
    pgstat_report_wait_start(WAIT_EVENT_RELATION_MAP_WRITE);
    if (write(fd, newmap, sizeof(RelMapFile)) != sizeof(RelMapFile))
    {
        /* if write didn't set errno, assume problem is no disk space */
        if (errno == 0)
            errno = ENOSPC;
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not write file \"%s\": %m",
                        mapfilename)));
    }
    pgstat_report_wait_end();

    /*
     * We choose to fsync the data to disk before considering the task done.
     * It would be possible to relax this if it turns out to be a performance
     * issue, but it would complicate checkpointing --- see notes for
     * CheckPointRelationMap.
     */
    pgstat_report_wait_start(WAIT_EVENT_RELATION_MAP_SYNC);
    if (pg_fsync(fd) != 0)
        ereport(data_sync_elevel(ERROR),
                (errcode_for_file_access(),
                 errmsg("could not fsync file \"%s\": %m",
                        mapfilename)));
    pgstat_report_wait_end();

    if (CloseTransientFile(fd) != 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not close file \"%s\": %m",
                        mapfilename)));

    /*
     * Now that the file is safely on disk, send sinval message to let other
     * backends know to re-read it.  We must do this inside the critical
     * section: if for some reason we fail to send the message, we have to
     * force a database-wide PANIC.  Otherwise other backends might continue
     * execution with stale mapping information, which would be catastrophic
     * as soon as others began to use the now-committed data.
     */
    if (send_sinval)
        CacheInvalidateRelmap(dbid);

    /*
     * Make sure that the files listed in the map are not deleted if the outer
     * transaction aborts.  This had better be within the critical section
     * too: it's not likely to fail, but if it did, we'd arrive at transaction
     * abort with the files still vulnerable.  PANICing will leave things in a
     * good state on-disk.
     *
     * Note: we're cheating a little bit here by assuming that mapped files
     * are either in pg_global or the database's default tablespace.
     */
    if (preserve_files)
    {
        int32       i;

        for (i = 0; i < newmap->num_mappings; i++)
        {
            RelFileNode rnode;

            rnode.spcNode = tsid;
            rnode.dbNode = dbid;
            rnode.relNode = newmap->mappings[i].mapfilenode;
            RelationPreserveStorage(rnode, false);
        }
    }

    /*
     * Success, update permanent copy.  During bootstrap, we might be working
     * on the permanent copy itself, in which case skip the memcpy() to avoid
     * invoking nominally-undefined behavior.
     */
    if (realmap != newmap)
        memcpy(realmap, newmap, sizeof(RelMapFile));
    else
        Assert(!send_sinval);   /* must be bootstrapping */

    /* Critical section done */
    if (write_wal)
        END_CRIT_SECTION();
}

Variable Documentation

active_local_updates

RelMapFile active_local_updates

static

Definition at line 129 of file relmapper.c.

Referenced by RelationMapFilenodeToOid(), RelationMapOidToFilenode(), RelationMapRemoveMapping(), RelationMapUpdateMap(), and SerializeRelationMap().

active_shared_updates

RelMapFile active_shared_updates

static

Definition at line 128 of file relmapper.c.

Referenced by RelationMapFilenodeToOid(), RelationMapOidToFilenode(), RelationMapUpdateMap(), and SerializeRelationMap().

local_map

RelMapFile local_map

static

Definition at line 110 of file relmapper.c.

Referenced by load_relmap_file(), RelationMapFilenodeToOid(), RelationMapOidToFilenode(), RelationMapUpdateMap(), and write_relmap_file().

pending_local_updates

RelMapFile pending_local_updates

static

Definition at line 131 of file relmapper.c.

Referenced by RelationMapUpdateMap().

pending_shared_updates

RelMapFile pending_shared_updates

static

Definition at line 130 of file relmapper.c.

Referenced by RelationMapUpdateMap().

shared_map

RelMapFile shared_map

static

Definition at line 109 of file relmapper.c.

Referenced by load_relmap_file(), RelationMapFilenodeToOid(), RelationMapOidToFilenode(), RelationMapUpdateMap(), and write_relmap_file().