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

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, 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)

Oid	RelationMapOidToFilenode (Oid relationId, bool shared)

Oid	RelationMapFilenodeToOid (Oid filenode, bool shared)

Oid	RelationMapOidToFilenodeForDatabase (char *dbpath, Oid relationId)

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

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

void	RelationMapRemoveMapping (Oid relationId)

void	RelationMapInvalidate (bool shared)

void	RelationMapInvalidateAll (void)

void	AtCCI_RelationMap (void)

void	AtEOXact_RelationMap (bool isCommit, bool isParallelWorker)

void	AtPrepare_RelationMap (void)

void	CheckPointRelationMap (void)

void	RelationMapFinishBootstrap (void)

void	RelationMapInitialize (void)

void	RelationMapInitializePhase2 (void)

void	RelationMapInitializePhase3 (void)

Size	EstimateRelationMapSpace (void)

void	SerializeRelationMap (Size maxSize, char *startAddress)

void	RestoreRelationMap (char *startAddress)

void	relmap_redo (XLogReaderState *record)

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.

◆ RELMAPPER_FILEMAGIC

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

Definition at line 75 of file relmapper.c.

◆ RELMAPPER_FILENAME

#define RELMAPPER_FILENAME "pg_filenode.map"

Definition at line 73 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,
		Oid	fileNode,
		bool	add_okay
	)

static

Definition at line 378 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].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++;
 }

References elog, ERROR, i, RelMapping::mapfilenode, 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 498 of file relmapper.c.

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

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

Referenced by AtCCI_LocalCache().

◆ AtEOXact_RelationMap()

void AtEOXact_RelationMap	(	bool	isCommit,
		bool	isParallelWorker
	)

Definition at line 535 of file relmapper.c.

 {
     if (isCommit && !isParallelWorker)
     {
         /*
          * We should not get here with any "pending" updates.  (We could
          * logically choose to treat such as committed, but in the current
          * code this should never happen.)
          */
         Assert(pending_shared_updates.num_mappings == 0);
         Assert(pending_local_updates.num_mappings == 0);
  
         /*
          * Write any active updates to the actual map files, then reset them.
          */
         if (active_shared_updates.num_mappings != 0)
         {
             perform_relmap_update(true, &active_shared_updates);
             active_shared_updates.num_mappings = 0;
         }
         if (active_local_updates.num_mappings != 0)
         {
             perform_relmap_update(false, &active_local_updates);
             active_local_updates.num_mappings = 0;
         }
     }
     else
     {
         /* Abort or parallel worker --- drop all local and pending updates */
         Assert(!isParallelWorker || pending_shared_updates.num_mappings == 0);
         Assert(!isParallelWorker || pending_local_updates.num_mappings == 0);
  
         active_shared_updates.num_mappings = 0;
         active_local_updates.num_mappings = 0;
         pending_shared_updates.num_mappings = 0;
         pending_local_updates.num_mappings = 0;
     }
 }

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

Referenced by AbortTransaction(), and CommitTransaction().

◆ AtPrepare_RelationMap()

void AtPrepare_RelationMap ( void )

Definition at line 582 of file relmapper.c.

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

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

Referenced by PrepareTransaction().

◆ CheckPointRelationMap()

void CheckPointRelationMap ( void )

Definition at line 605 of file relmapper.c.

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

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

Referenced by CheckPointGuts().

◆ EstimateRelationMapSpace()

Size EstimateRelationMapSpace ( void )

Definition at line 705 of file relmapper.c.

 {
     return sizeof(SerializedActiveRelMaps);
 }

Referenced by InitializeParallelDSM(), and SerializeRelationMap().

◆ load_relmap_file()

static void load_relmap_file	(	bool	shared,
		bool	lock_held
	)

static

Definition at line 757 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 410 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].mapfilenode,
                          add_okay);
     }
 }

References apply_map_update(), i, RelMapping::mapfilenode, 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 1006 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 776 of file relmapper.c.

 {
     char        mapfilename[MAXPGPATH];
     pg_crc32c   crc;
     int         fd;
     int         r;
  
     Assert(elevel >= ERROR);
  
     /* Open the target file. */
     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)));
  
     /*
      * 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);
  
     /* 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 (!lock_held)
         LWLockRelease(RelationMappingLock);
  
     if (CloseTransientFile(fd) != 0)
         ereport(elevel,
                 (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(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, offsetof, OpenTransientFile(), PG_BINARY, pgstat_report_wait_end(), pgstat_report_wait_start(), read, RELMAPPER_FILEMAGIC, RELMAPPER_FILENAME, snprintf, and WAIT_EVENT_RELATION_MAP_READ.

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

◆ RelationMapCopy()

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

Definition at line 288 of file relmapper.c.

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

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

Referenced by CreateDatabaseUsingWalLog().

◆ RelationMapFilenodeToOid()

Oid RelationMapFilenodeToOid	(	Oid	filenode,
		bool	shared
	)

Definition at line 214 of file relmapper.c.

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

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

Referenced by RelidByRelfilenode().

◆ RelationMapFinishBootstrap()

void RelationMapFinishBootstrap ( void )

Definition at line 619 of file relmapper.c.

 {
     Assert(IsBootstrapProcessingMode());
  
     /* Shouldn't be anything "pending" ... */
     Assert(active_shared_updates.num_mappings == 0);
     Assert(active_local_updates.num_mappings == 0);
     Assert(pending_shared_updates.num_mappings == 0);
     Assert(pending_local_updates.num_mappings == 0);
  
     /* Write the files; no WAL or sinval needed */
     write_relmap_file(&shared_map, false, false, false,
                       InvalidOid, GLOBALTABLESPACE_OID, "global");
     write_relmap_file(&local_map, false, false, false,
                       MyDatabaseId, MyDatabaseTableSpace, DatabasePath);
 }

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

Referenced by BootstrapModeMain().

◆ RelationMapInitialize()

void RelationMapInitialize ( void )

Definition at line 643 of file relmapper.c.

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

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

Referenced by RelationCacheInitialize().

◆ RelationMapInitializePhase2()

void RelationMapInitializePhase2 ( void )

Definition at line 663 of file relmapper.c.

 {
     /*
      * In bootstrap mode, the map file isn't there yet, so do nothing.
      */
     if (IsBootstrapProcessingMode())
         return;
  
     /*
      * Load the shared map file, die on error.
      */
     load_relmap_file(true, false);
 }

References IsBootstrapProcessingMode, and load_relmap_file().

Referenced by RelationCacheInitializePhase2().

◆ RelationMapInitializePhase3()

void RelationMapInitializePhase3 ( void )

Definition at line 684 of file relmapper.c.

 {
     /*
      * In bootstrap mode, the map file isn't there yet, so do nothing.
      */
     if (IsBootstrapProcessingMode())
         return;
  
     /*
      * Load the local map file, die on error.
      */
     load_relmap_file(false, false);
 }

References IsBootstrapProcessingMode, and load_relmap_file().

Referenced by RelationCacheInitializePhase3().

◆ RelationMapInvalidate()

void RelationMapInvalidate ( bool shared )

Definition at line 462 of file relmapper.c.

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

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

Referenced by LocalExecuteInvalidationMessage().

◆ RelationMapInvalidateAll()

void RelationMapInvalidateAll ( void )

Definition at line 484 of file relmapper.c.

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

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

Referenced by RelationCacheInvalidate().

◆ RelationMapOidToFilenode()

Oid RelationMapOidToFilenode	(	Oid	relationId,
		bool	shared
	)

Definition at line 161 of file relmapper.c.

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

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

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

◆ RelationMapOidToFilenodeForDatabase()

Oid RelationMapOidToFilenodeForDatabase	(	char *	dbpath,
		Oid	relationId
	)

Definition at line 261 of file relmapper.c.

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

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

Referenced by ScanSourceDatabasePgClass(), and ScanSourceDatabasePgClassTuple().

◆ RelationMapRemoveMapping()

void RelationMapRemoveMapping ( Oid relationId )

Definition at line 432 of file relmapper.c.

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

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

Referenced by finish_heap_swap().

◆ RelationMapUpdateMap()

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

Definition at line 320 of file relmapper.c.

 {
     RelMapFile *map;
  
     if (IsBootstrapProcessingMode())
     {
         /*
          * In bootstrap mode, the mapping gets installed in permanent map.
          */
         if (shared)
             map = &shared_map;
         else
             map = &local_map;
     }
     else
     {
         /*
          * We don't currently support map changes within subtransactions, or
          * when in parallel mode.  This could be done with more bookkeeping
          * infrastructure, but it doesn't presently seem worth it.
          */
         if (GetCurrentTransactionNestLevel() > 1)
             elog(ERROR, "cannot change relation mapping within subtransaction");
  
         if (IsInParallelMode())
             elog(ERROR, "cannot change relation mapping in parallel mode");
  
         if (immediate)
         {
             /* Make it active, but only locally */
             if (shared)
                 map = &active_shared_updates;
             else
                 map = &active_local_updates;
         }
         else
         {
             /* Make it pending */
             if (shared)
                 map = &pending_shared_updates;
             else
                 map = &pending_local_updates;
         }
     }
     apply_map_update(map, relationId, fileNode, true);
 }

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

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

◆ relmap_redo()

void relmap_redo ( XLogReaderState * record )

Definition at line 1063 of file relmapper.c.

 {
     uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
  
     /* Backup blocks are not used in relmap records */
     Assert(!XLogRecHasAnyBlockRefs(record));
  
     if (info == XLOG_RELMAP_UPDATE)
     {
         xl_relmap_update *xlrec = (xl_relmap_update *) XLogRecGetData(record);
         RelMapFile  newmap;
         char       *dbpath;
  
         if (xlrec->nbytes != sizeof(RelMapFile))
             elog(PANIC, "relmap_redo: wrong size %u in relmap update record",
                  xlrec->nbytes);
         memcpy(&newmap, xlrec->data, sizeof(newmap));
  
         /* We need to construct the pathname for this database */
         dbpath = GetDatabasePath(xlrec->dbid, xlrec->tsid);
  
         /*
          * Write out the new map and send sinval, but of course don't write a
          * new WAL entry.  There's no surrounding transaction to tell to
          * preserve files, either.
          *
          * There shouldn't be anyone else updating relmaps during WAL replay,
          * but grab the lock to interlock against load_relmap_file().
          *
          * Note that we use the same WAL record for updating the relmap of an
          * existing database as we do for creating a new database. In the
          * latter case, taking the relmap log and sending sinval messages is
          * unnecessary, but harmless. If we wanted to avoid it, we could add a
          * flag to the WAL record to indicate which operation is being
          * performed.
          */
         LWLockAcquire(RelationMappingLock, LW_EXCLUSIVE);
         write_relmap_file(&newmap, false, true, false,
                           xlrec->dbid, xlrec->tsid, dbpath);
         LWLockRelease(RelationMappingLock);
  
         pfree(dbpath);
     }
     else
         elog(PANIC, "relmap_redo: unknown op code %u", info);
 }

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

◆ RestoreRelationMap()

void RestoreRelationMap ( char * startAddress )

Definition at line 733 of file relmapper.c.

 {
     SerializedActiveRelMaps *relmaps;
  
     if (active_shared_updates.num_mappings != 0 ||
         active_local_updates.num_mappings != 0 ||
         pending_shared_updates.num_mappings != 0 ||
         pending_local_updates.num_mappings != 0)
         elog(ERROR, "parallel worker has existing mappings");
  
     relmaps = (SerializedActiveRelMaps *) startAddress;
     active_shared_updates = relmaps->active_shared_updates;
     active_local_updates = relmaps->active_local_updates;
 }

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

Referenced by ParallelWorkerMain().

◆ SerializeRelationMap()

void SerializeRelationMap	(	Size	maxSize,
		char *	startAddress
	)

Definition at line 716 of file relmapper.c.

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

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

Referenced by InitializeParallelDSM().

◆ 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 873 of file relmapper.c.

 {
     int         fd;
     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.
      */
     snprintf(mapfilename, sizeof(mapfilename), "%s/%s",
              dbpath, RELMAPPER_FILENAME);
     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);
         }
     }
  
     /* Critical section done */
     if (write_wal)
         END_CRIT_SECTION();
 }

References CacheInvalidateRelmap(), CloseTransientFile(), COMP_CRC32C, RelMapFile::crc, 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, RelMapFile::magic, RelMapping::mapfilenode, RelMapFile::mappings, 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, 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(), RelationMapCopy(), RelationMapFinishBootstrap(), and relmap_redo().

Variable Documentation

◆ active_local_updates

RelMapFile active_local_updates

static

Definition at line 129 of file relmapper.c.

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

◆ active_shared_updates

RelMapFile active_shared_updates

static

Definition at line 128 of file relmapper.c.

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

◆ local_map

RelMapFile local_map

static

Definition at line 110 of file relmapper.c.

Referenced by load_relmap_file(), perform_relmap_update(), RelationMapFilenodeToOid(), RelationMapFinishBootstrap(), RelationMapInitialize(), RelationMapInvalidate(), RelationMapInvalidateAll(), RelationMapOidToFilenode(), and RelationMapUpdateMap().

◆ pending_local_updates

RelMapFile pending_local_updates

static

Definition at line 131 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 130 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 109 of file relmapper.c.

Referenced by load_relmap_file(), perform_relmap_update(), RelationMapFilenodeToOid(), RelationMapFinishBootstrap(), RelationMapInitialize(), RelationMapInvalidate(), RelationMapInvalidateAll(), RelationMapOidToFilenode(), and RelationMapUpdateMap().

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ MAX_MAPPINGS

◆ RELMAPPER_FILEMAGIC

◆ RELMAPPER_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()

◆ RelationMapFilenodeToOid()

◆ RelationMapFinishBootstrap()

◆ RelationMapInitialize()

◆ RelationMapInitializePhase2()

◆ RelationMapInitializePhase3()

◆ RelationMapInvalidate()

◆ RelationMapInvalidateAll()

◆ RelationMapOidToFilenode()

◆ RelationMapOidToFilenodeForDatabase()

◆ 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