#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:

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, 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, 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, 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 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, 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(), i, RelMapping::mapfilenumber, RelMapping::mapoid, RelMapFile::mappings, and RelMapFile::num_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, 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, (char *) 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, 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, 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, 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, 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, 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, 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, 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, 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 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 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 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 SerializedActiveRelMaps::active_local_updates, active_local_updates, SerializedActiveRelMaps::active_shared_updates, active_shared_updates, Assert, and EstimateRelationMapSpace().

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, (char *) 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((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);
     }
  
     /*
      * 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, RelMapFile::crc, crc, xl_relmap_update::dbid, RelFileLocator::dbOid, durable_rename(), elog, END_CRIT_SECTION, ereport, errcode_for_file_access(), errmsg(), ERROR, fd(), FIN_CRC32C, i, INIT_CRC32C, LW_EXCLUSIVE, LWLockHeldByMeInMode(), RelMapFile::magic, RelMapping::mapfilenumber, RelMapFile::mappings, MAX_MAPPINGS, MAXPGPATH, MinSizeOfRelmapUpdate, xl_relmap_update::nbytes, RelMapFile::num_mappings, 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, xl_relmap_update::tsid, 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().

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ MAX_MAPPINGS

◆ RELMAPPER_FILEMAGIC

◆ RELMAPPER_FILENAME

◆ RELMAPPER_TEMP_FILENAME

Typedef Documentation

◆ RelMapFile

◆ RelMapping

◆ SerializedActiveRelMaps

Function Documentation

◆ apply_map_update()

◆ AtCCI_RelationMap()

◆ AtEOXact_RelationMap()

◆ AtPrepare_RelationMap()

◆ CheckPointRelationMap()

◆ EstimateRelationMapSpace()

◆ load_relmap_file()

◆ merge_map_updates()

◆ perform_relmap_update()

◆ read_relmap_file()

◆ RelationMapCopy()

◆ RelationMapFilenumberToOid()

◆ RelationMapFinishBootstrap()

◆ RelationMapInitialize()

◆ RelationMapInitializePhase2()

◆ RelationMapInitializePhase3()

◆ RelationMapInvalidate()

◆ RelationMapInvalidateAll()

◆ RelationMapOidToFilenumber()

◆ RelationMapOidToFilenumberForDatabase()

◆ RelationMapRemoveMapping()

◆ RelationMapUpdateMap()

◆ relmap_redo()

◆ RestoreRelationMap()

◆ SerializeRelationMap()

◆ write_relmap_file()

Variable Documentation

◆ active_local_updates

◆ active_shared_updates

◆ local_map

◆ pending_local_updates

◆ pending_shared_updates

◆ shared_map