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/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_TEMP_FILENAME   "pg_filenode.map.tmp"
#define	RELMAPPER_FILEMAGIC   0x592717 /* version ID value */
#define	MAX_MAPPINGS   64

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

Functions
static void	apply_map_update (RelMapFile *map, Oid relationId, RelFileNumber fileNumber, bool add_okay)
static void	merge_map_updates (RelMapFile *map, const RelMapFile *updates, bool add_okay)
static void	load_relmap_file (bool shared, bool lock_held)
static void	read_relmap_file (RelMapFile *map, char *dbpath, bool lock_held, int elevel)
static void	write_relmap_file (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)
RelFileNumber	RelationMapOidToFilenumber (Oid relationId, bool shared)
Oid	RelationMapFilenumberToOid (RelFileNumber filenumber, bool shared)
RelFileNumber	RelationMapOidToFilenumberForDatabase (char *dbpath, Oid relationId)
void	RelationMapCopy (Oid dbid, Oid tsid, char *srcdbpath, char *dstdbpath)
void	RelationMapUpdateMap (Oid relationId, RelFileNumber fileNumber, 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   64

Definition at line 81 of file relmapper.c.

RELMAPPER_FILEMAGIC

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

Definition at line 73 of file relmapper.c.

RELMAPPER_FILENAME

#define RELMAPPER_FILENAME   "pg_filenode.map"

Definition at line 70 of file relmapper.c.

RELMAPPER_TEMP_FILENAME

#define RELMAPPER_TEMP_FILENAME   "pg_filenode.map.tmp"

Definition at line 71 of file relmapper.c.

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, RelFileNumber  fileNumber, bool  add_okay  )

static

Definition at line 383 of file relmapper.c.

{
    int32       i;
 
    /* Replace any existing mapping */
    for (i = 0; i < map->num_mappings; i++)
    {
        if (relationId == map->mappings[i].mapoid)
        {
            map->mappings[i].mapfilenumber = fileNumber;
            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].mapfilenumber = fileNumber;
    map->num_mappings++;
}

References elog, ERROR, fb(), i, RelMapping::mapfilenumber, RelMapping::mapoid, RelMapFile::mappings, MAX_MAPPINGS, and RelMapFile::num_mappings.

Referenced by merge_map_updates(), and RelationMapUpdateMap().

AtCCI_RelationMap()

void AtCCI_RelationMap

(

void

)

Definition at line 504 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 541 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, fb(), 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 588 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, fb(), RelMapFile::num_mappings, pending_local_updates, and pending_shared_updates.

Referenced by PrepareTransaction().

CheckPointRelationMap()

void CheckPointRelationMap

(

void

)

Definition at line 611 of file relmapper.c.

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

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

Referenced by CheckPointGuts().

EstimateRelationMapSpace()

Size EstimateRelationMapSpace

(

void

)

Definition at line 713 of file relmapper.c.

{
    return sizeof(SerializedActiveRelMaps);
}

Referenced by InitializeParallelDSM(), and SerializeRelationMap().

load_relmap_file()

static void load_relmap_file ( bool  shared, bool  lock_held  )

static

Definition at line 765 of file relmapper.c.

{
    if (shared)
        read_relmap_file(&shared_map, "global", lock_held, FATAL);
    else
        read_relmap_file(&local_map, DatabasePath, lock_held, FATAL);
}

References DatabasePath, FATAL, fb(), local_map, read_relmap_file(), and shared_map.

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

merge_map_updates()

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

static

Definition at line 416 of file relmapper.c.

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

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

Referenced by AtCCI_RelationMap(), and perform_relmap_update().

perform_relmap_update()

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

static

Definition at line 1039 of file relmapper.c.

{
    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, true);
 
    /* 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(&newmap, true, true, true,
                      (shared ? InvalidOid : MyDatabaseId),
                      (shared ? GLOBALTABLESPACE_OID : MyDatabaseTableSpace),
                      (shared ? "global" : DatabasePath));
 
    /*
     * We successfully wrote the updated file, so it's now safe to rely on the
     * new values in this process, too.
     */
    if (shared)
        memcpy(&shared_map, &newmap, sizeof(RelMapFile));
    else
        memcpy(&local_map, &newmap, sizeof(RelMapFile));
 
    /* Now we can release the lock */
    LWLockRelease(RelationMappingLock);
}

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

Referenced by AtEOXact_RelationMap().

read_relmap_file()

static void read_relmap_file ( RelMapFile *  map, char *  dbpath, bool  lock_held, int  elevel  )

static

Definition at line 784 of file relmapper.c.

{
    char        mapfilename[MAXPGPATH];
    pg_crc32c   crc;
    int         fd;
    int         r;
 
    Assert(elevel >= ERROR);
 
    /*
     * Grab the lock to prevent the file from being updated while we read it,
     * unless the caller is already holding the lock.  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.
     */
    if (!lock_held)
        LWLockAcquire(RelationMappingLock, LW_SHARED);
 
    /*
     * Open the target file.
     *
     * Because Windows isn't happy about the idea of renaming over a file that
     * someone has open, we only open this file after acquiring the lock, and
     * for the same reason, we close it before releasing the lock. That way,
     * by the time write_relmap_file() acquires an exclusive lock, no one else
     * will have it open.
     */
    snprintf(mapfilename, sizeof(mapfilename), "%s/%s", dbpath,
             RELMAPPER_FILENAME);
    fd = OpenTransientFile(mapfilename, O_RDONLY | PG_BINARY);
    if (fd < 0)
        ereport(elevel,
                (errcode_for_file_access(),
                 errmsg("could not open file \"%s\": %m",
                        mapfilename)));
 
    /* Now read the data. */
    pgstat_report_wait_start(WAIT_EVENT_RELATION_MAP_READ);
    r = read(fd, map, sizeof(RelMapFile));
    if (r != sizeof(RelMapFile))
    {
        if (r < 0)
            ereport(elevel,
                    (errcode_for_file_access(),
                     errmsg("could not read file \"%s\": %m", mapfilename)));
        else
            ereport(elevel,
                    (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(elevel,
                (errcode_for_file_access(),
                 errmsg("could not close file \"%s\": %m",
                        mapfilename)));
 
    if (!lock_held)
        LWLockRelease(RelationMappingLock);
 
    /* check for correct magic number, etc */
    if (map->magic != RELMAPPER_FILEMAGIC ||
        map->num_mappings < 0 ||
        map->num_mappings > MAX_MAPPINGS)
        ereport(elevel,
                (errmsg("relation mapping file \"%s\" contains invalid data",
                        mapfilename)));
 
    /* verify the CRC */
    INIT_CRC32C(crc);
    COMP_CRC32C(crc, map, offsetof(RelMapFile, crc));
    FIN_CRC32C(crc);
 
    if (!EQ_CRC32C(crc, map->crc))
        ereport(elevel,
                (errmsg("relation mapping file \"%s\" contains incorrect checksum",
                        mapfilename)));
}

References Assert, CloseTransientFile(), COMP_CRC32C, RelMapFile::crc, crc, EQ_CRC32C, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errcode_for_file_access(), errmsg(), ERROR, fb(), fd(), FIN_CRC32C, INIT_CRC32C, LW_SHARED, LWLockAcquire(), LWLockRelease(), RelMapFile::magic, MAX_MAPPINGS, MAXPGPATH, RelMapFile::num_mappings, OpenTransientFile(), PG_BINARY, pgstat_report_wait_end(), pgstat_report_wait_start(), read, RELMAPPER_FILEMAGIC, RELMAPPER_FILENAME, and snprintf.

Referenced by load_relmap_file(), RelationMapCopy(), and RelationMapOidToFilenumberForDatabase().

RelationMapCopy()

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

Definition at line 292 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.
     *
     * 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.
     */
    LWLockAcquire(RelationMappingLock, LW_EXCLUSIVE);
    write_relmap_file(&map, true, false, false, dbid, tsid, dstdbpath);
    LWLockRelease(RelationMappingLock);
}

References ERROR, fb(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), read_relmap_file(), and write_relmap_file().

Referenced by CreateDatabaseUsingWalLog().

RelationMapFilenumberToOid()

Oid RelationMapFilenumberToOid	(	RelFileNumber	filenumber,
		bool	shared
	)

Definition at line 218 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 (filenumber == map->mappings[i].mapfilenumber)
                return map->mappings[i].mapoid;
        }
        map = &shared_map;
        for (i = 0; i < map->num_mappings; i++)
        {
            if (filenumber == map->mappings[i].mapfilenumber)
                return map->mappings[i].mapoid;
        }
    }
    else
    {
        map = &active_local_updates;
        for (i = 0; i < map->num_mappings; i++)
        {
            if (filenumber == map->mappings[i].mapfilenumber)
                return map->mappings[i].mapoid;
        }
        map = &local_map;
        for (i = 0; i < map->num_mappings; i++)
        {
            if (filenumber == map->mappings[i].mapfilenumber)
                return map->mappings[i].mapoid;
        }
    }
 
    return InvalidOid;
}

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

Referenced by RelidByRelfilenumber().

RelationMapFinishBootstrap()

void RelationMapFinishBootstrap

(

void

)

Definition at line 625 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 */
    LWLockAcquire(RelationMappingLock, LW_EXCLUSIVE);
    write_relmap_file(&shared_map, false, false, false,
                      InvalidOid, GLOBALTABLESPACE_OID, "global");
    write_relmap_file(&local_map, false, false, false,
                      MyDatabaseId, MyDatabaseTableSpace, DatabasePath);
    LWLockRelease(RelationMappingLock);
}

References active_local_updates, active_shared_updates, Assert, DatabasePath, fb(), InvalidOid, IsBootstrapProcessingMode, local_map, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), 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 651 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 671 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 692 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 468 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 490 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().

RelationMapOidToFilenumber()

RelFileNumber RelationMapOidToFilenumber	(	Oid	relationId,
		bool	shared
	)

Definition at line 165 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].mapfilenumber;
        }
        map = &shared_map;
        for (i = 0; i < map->num_mappings; i++)
        {
            if (relationId == map->mappings[i].mapoid)
                return map->mappings[i].mapfilenumber;
        }
    }
    else
    {
        map = &active_local_updates;
        for (i = 0; i < map->num_mappings; i++)
        {
            if (relationId == map->mappings[i].mapoid)
                return map->mappings[i].mapfilenumber;
        }
        map = &local_map;
        for (i = 0; i < map->num_mappings; i++)
        {
            if (relationId == map->mappings[i].mapoid)
                return map->mappings[i].mapfilenumber;
        }
    }
 
    return InvalidRelFileNumber;
}

References active_local_updates, active_shared_updates, fb(), i, InvalidRelFileNumber, local_map, RelMapping::mapfilenumber, RelMapping::mapoid, RelMapFile::mappings, RelMapFile::num_mappings, and shared_map.

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

RelationMapOidToFilenumberForDatabase()

RelFileNumber RelationMapOidToFilenumberForDatabase	(	char *	dbpath,
		Oid	relationId
	)

Definition at line 265 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].mapfilenumber;
    }
 
    return InvalidRelFileNumber;
}

References ERROR, fb(), i, InvalidRelFileNumber, RelMapping::mapfilenumber, RelMapping::mapoid, RelMapFile::mappings, RelMapFile::num_mappings, and read_relmap_file().

Referenced by ScanSourceDatabasePgClass(), and ScanSourceDatabasePgClassTuple().

RelationMapRemoveMapping()

void RelationMapRemoveMapping

(

Oid

relationId

)

Definition at line 438 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, fb(), i, RelMapping::mapoid, RelMapFile::mappings, and RelMapFile::num_mappings.

Referenced by finish_heap_swap().

RelationMapUpdateMap()

void RelationMapUpdateMap	(	Oid	relationId,
		RelFileNumber	fileNumber,
		bool	shared,
		bool	immediate
	)

Definition at line 325 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, fileNumber, true);
}

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

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

relmap_redo()

void relmap_redo

(

XLogReaderState *

record

)

Definition at line 1096 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, elog, fb(), GetDatabasePath(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PANIC, pfree(), write_relmap_file(), XLOG_RELMAP_UPDATE, XLogRecGetData, XLogRecGetInfo, and XLogRecHasAnyBlockRefs.

RestoreRelationMap()

void RestoreRelationMap

(

char *

startAddress

)

Definition at line 741 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 active_local_updates, active_shared_updates, elog, ERROR, fb(), RelMapFile::num_mappings, pending_local_updates, and pending_shared_updates.

Referenced by ParallelWorkerMain().

SerializeRelationMap()

void SerializeRelationMap	(	Size	maxSize,
		char *	startAddress
	)

Definition at line 724 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 active_local_updates, active_shared_updates, Assert, EstimateRelationMapSpace(), and fb().

Referenced by InitializeParallelDSM().

write_relmap_file()

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

static

Definition at line 889 of file relmapper.c.

{
    int         fd;
    char        mapfilename[MAXPGPATH];
    char        maptempfilename[MAXPGPATH];
 
    /*
     * Even without concurrent use of this map, CheckPointRelationMap() relies
     * on this locking.  Without it, a restore of a base backup taken after
     * this function's XLogInsert() and before its durable_rename() would not
     * have the changes.  wal_level=minimal doesn't need the lock, but this
     * isn't performance-critical enough for such a micro-optimization.
     */
    Assert(LWLockHeldByMeInMode(RelationMappingLock, LW_EXCLUSIVE));
 
    /*
     * 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, newmap, offsetof(RelMapFile, crc));
    FIN_CRC32C(newmap->crc);
 
    /*
     * Construct filenames -- a temporary file that we'll create to write the
     * data initially, and then the permanent name to which we will rename it.
     */
    snprintf(mapfilename, sizeof(mapfilename), "%s/%s",
             dbpath, RELMAPPER_FILENAME);
    snprintf(maptempfilename, sizeof(maptempfilename), "%s/%s",
             dbpath, RELMAPPER_TEMP_FILENAME);
 
    /*
     * Open a temporary file. If a file already exists with this name, it must
     * be left over from a previous crash, so we can overwrite it. Concurrent
     * calls to this function are not allowed.
     */
    fd = OpenTransientFile(maptempfilename,
                           O_WRONLY | O_CREAT | O_TRUNC | PG_BINARY);
    if (fd < 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not open file \"%s\": %m",
                        maptempfilename)));
 
    /* Write new data to the file. */
    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",
                        maptempfilename)));
    }
    pgstat_report_wait_end();
 
    /* And close the file. */
    if (CloseTransientFile(fd) != 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not close file \"%s\": %m",
                        maptempfilename)));
 
    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(&xlrec, MinSizeOfRelmapUpdate);
        XLogRegisterData(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);
    }
 
    /*
     * durable_rename() does all the hard work of making sure that we rename
     * the temporary file into place in a crash-safe manner.
     *
     * NB: Although we instruct durable_rename() to use ERROR, we will often
     * be in a critical section at this point; if so, ERROR will become PANIC.
     */
    pgstat_report_wait_start(WAIT_EVENT_RELATION_MAP_REPLACE);
    durable_rename(maptempfilename, mapfilename, ERROR);
    pgstat_report_wait_end();
 
    /*
     * 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++)
        {
            RelFileLocator rlocator;
 
            rlocator.spcOid = tsid;
            rlocator.dbOid = dbid;
            rlocator.relNumber = newmap->mappings[i].mapfilenumber;
            RelationPreserveStorage(rlocator, false);
        }
    }
 
    /* Critical section done */
    if (write_wal)
        END_CRIT_SECTION();
}

References Assert, CacheInvalidateRelmap(), CloseTransientFile(), COMP_CRC32C, crc, RelFileLocator::dbOid, durable_rename(), elog, END_CRIT_SECTION, ereport, errcode_for_file_access(), errmsg(), ERROR, fb(), fd(), FIN_CRC32C, i, INIT_CRC32C, LW_EXCLUSIVE, LWLockHeldByMeInMode(), MAX_MAPPINGS, MAXPGPATH, MinSizeOfRelmapUpdate, OpenTransientFile(), PG_BINARY, pgstat_report_wait_end(), pgstat_report_wait_start(), RelationPreserveStorage(), RELMAPPER_FILEMAGIC, RELMAPPER_FILENAME, RELMAPPER_TEMP_FILENAME, RelFileLocator::relNumber, snprintf, RelFileLocator::spcOid, START_CRIT_SECTION, write, XLOG_RELMAP_UPDATE, XLogBeginInsert(), XLogFlush(), XLogInsert(), and XLogRegisterData().

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

Variable Documentation

active_local_updates

RelMapFile active_local_updates

static

Definition at line 132 of file relmapper.c.

Referenced by AtCCI_RelationMap(), AtEOXact_RelationMap(), AtPrepare_RelationMap(), RelationMapFilenumberToOid(), RelationMapFinishBootstrap(), RelationMapInitialize(), RelationMapOidToFilenumber(), RelationMapRemoveMapping(), RelationMapUpdateMap(), RestoreRelationMap(), and SerializeRelationMap().

active_shared_updates

RelMapFile active_shared_updates

static

Definition at line 131 of file relmapper.c.

Referenced by AtCCI_RelationMap(), AtEOXact_RelationMap(), AtPrepare_RelationMap(), RelationMapFilenumberToOid(), RelationMapFinishBootstrap(), RelationMapInitialize(), RelationMapOidToFilenumber(), RelationMapUpdateMap(), RestoreRelationMap(), and SerializeRelationMap().

local_map

RelMapFile local_map

static

Definition at line 113 of file relmapper.c.

Referenced by load_relmap_file(), perform_relmap_update(), RelationMapFilenumberToOid(), RelationMapFinishBootstrap(), RelationMapInitialize(), RelationMapInvalidate(), RelationMapInvalidateAll(), RelationMapOidToFilenumber(), and RelationMapUpdateMap().

pending_local_updates

RelMapFile pending_local_updates

static

Definition at line 134 of file relmapper.c.

Referenced by AtCCI_RelationMap(), AtEOXact_RelationMap(), AtPrepare_RelationMap(), RelationMapFinishBootstrap(), RelationMapInitialize(), RelationMapUpdateMap(), and RestoreRelationMap().

pending_shared_updates

RelMapFile pending_shared_updates

static

Definition at line 133 of file relmapper.c.

Referenced by AtCCI_RelationMap(), AtEOXact_RelationMap(), AtPrepare_RelationMap(), RelationMapFinishBootstrap(), RelationMapInitialize(), RelationMapUpdateMap(), and RestoreRelationMap().

shared_map

RelMapFile shared_map

static

Definition at line 112 of file relmapper.c.

Referenced by load_relmap_file(), perform_relmap_update(), RelationMapFilenumberToOid(), RelationMapFinishBootstrap(), RelationMapInitialize(), RelationMapInvalidate(), RelationMapInvalidateAll(), RelationMapOidToFilenumber(), and RelationMapUpdateMap().