#include "postgres_fe.h"
#include <sys/stat.h>
#include <unistd.h>
#include "catalog/pg_tablespace_d.h"
#include "common/file_utils.h"
#include "common/hashfn_unstable.h"
#include "common/string.h"
#include "datapagemap.h"
#include "filemap.h"
#include "pg_rewind.h"
#include "lib/simplehash.h"

Include dependency graph for filemap.c:

Data Structures
struct	exclude_list_item

Macros
#define	SH_PREFIX filehash

#define	SH_ELEMENT_TYPE file_entry_t

#define	SH_KEY_TYPE const char *

#define	SH_KEY path

#define	SH_HASH_KEY(tb, key) hash_string(key)

#define	SH_EQUAL(tb, a, b) (strcmp(a, b) == 0)

#define	SH_SCOPE static inline

#define	SH_RAW_ALLOCATOR pg_malloc0

#define	SH_DECLARE

#define	SH_DEFINE

#define	FILEHASH_INITIAL_SIZE 1000

Functions
static bool	isRelDataFile (const char *path)

static char *	datasegpath (RelFileLocator rlocator, ForkNumber forknum, BlockNumber segno)

static file_entry_t *	insert_filehash_entry (const char *path)

static file_entry_t *	lookup_filehash_entry (const char *path)

static int	final_filemap_cmp (const void a, const void b)

static bool	check_file_excluded (const char *path, bool is_source)

void	filehash_init (void)

void	process_source_file (const char path, file_type_t type, size_t size, const char link_target)

void	process_target_file (const char path, file_type_t type, size_t size, const char link_target)

void	process_target_wal_block_change (ForkNumber forknum, RelFileLocator rlocator, BlockNumber blkno)

static const char *	action_to_str (file_action_t action)

void	calculate_totals (filemap_t *filemap)

void	print_filemap (filemap_t *filemap)

static file_action_t	decide_file_action (file_entry_t *entry)

filemap_t *	decide_file_actions (void)

Variables
static filehash_hash *	filehash

static const char *const	excludeDirContents []

static const struct exclude_list_item	excludeFiles []

Macro Definition Documentation

◆ FILEHASH_INITIAL_SIZE

#define FILEHASH_INITIAL_SIZE 1000

Definition at line 53 of file filemap.c.

◆ SH_DECLARE

#define SH_DECLARE

Definition at line 49 of file filemap.c.

◆ SH_DEFINE

#define SH_DEFINE

Definition at line 50 of file filemap.c.

◆ SH_ELEMENT_TYPE

#define SH_ELEMENT_TYPE file_entry_t

Definition at line 42 of file filemap.c.

◆ SH_EQUAL

#define SH_EQUAL	(	tb,
		a,
		b
	)	(strcmp(a, b) == 0)

Definition at line 46 of file filemap.c.

◆ SH_HASH_KEY

#define SH_HASH_KEY	(	tb,
		key
	)	hash_string(key)

Definition at line 45 of file filemap.c.

◆ SH_KEY

#define SH_KEY path

Definition at line 44 of file filemap.c.

◆ SH_KEY_TYPE

#define SH_KEY_TYPE const char *

Definition at line 43 of file filemap.c.

◆ SH_PREFIX

#define SH_PREFIX filehash

Definition at line 41 of file filemap.c.

◆ SH_RAW_ALLOCATOR

#define SH_RAW_ALLOCATOR pg_malloc0

Definition at line 48 of file filemap.c.

◆ SH_SCOPE

#define SH_SCOPE static inline

Definition at line 47 of file filemap.c.

Function Documentation

◆ action_to_str()

static const char* action_to_str ( file_action_t action )

static

Definition at line 411 of file filemap.c.

 {
     switch (action)
     {
         case FILE_ACTION_NONE:
             return "NONE";
         case FILE_ACTION_COPY:
             return "COPY";
         case FILE_ACTION_TRUNCATE:
             return "TRUNCATE";
         case FILE_ACTION_COPY_TAIL:
             return "COPY_TAIL";
         case FILE_ACTION_CREATE:
             return "CREATE";
         case FILE_ACTION_REMOVE:
             return "REMOVE";
  
         default:
             return "unknown";
     }
 }

References generate_unaccent_rules::action, FILE_ACTION_COPY, FILE_ACTION_COPY_TAIL, FILE_ACTION_CREATE, FILE_ACTION_NONE, FILE_ACTION_REMOVE, and FILE_ACTION_TRUNCATE.

Referenced by print_filemap().

◆ calculate_totals()

void calculate_totals ( filemap_t * filemap )

Definition at line 437 of file filemap.c.

 {
     file_entry_t *entry;
     int         i;
  
     filemap->total_size = 0;
     filemap->fetch_size = 0;
  
     for (i = 0; i < filemap->nentries; i++)
     {
         entry = filemap->entries[i];
  
         if (entry->source_type != FILE_TYPE_REGULAR)
             continue;
  
         filemap->total_size += entry->source_size;
  
         if (entry->action == FILE_ACTION_COPY)
         {
             filemap->fetch_size += entry->source_size;
             continue;
         }
  
         if (entry->action == FILE_ACTION_COPY_TAIL)
             filemap->fetch_size += (entry->source_size - entry->target_size);
  
         if (entry->target_pages_to_overwrite.bitmapsize > 0)
         {
             datapagemap_iterator_t *iter;
             BlockNumber blk;
  
             iter = datapagemap_iterate(&entry->target_pages_to_overwrite);
             while (datapagemap_next(iter, &blk))
                 filemap->fetch_size += BLCKSZ;
  
             pg_free(iter);
         }
     }
 }

References file_entry_t::action, datapagemap::bitmapsize, datapagemap_iterate(), datapagemap_next(), filemap_t::entries, filemap_t::fetch_size, FILE_ACTION_COPY, FILE_ACTION_COPY_TAIL, FILE_TYPE_REGULAR, i, filemap_t::nentries, pg_free(), file_entry_t::source_size, file_entry_t::source_type, file_entry_t::target_pages_to_overwrite, file_entry_t::target_size, and filemap_t::total_size.

Referenced by main().

◆ check_file_excluded()

static bool check_file_excluded	(	const char *	path,
		bool	is_source
	)

static

Definition at line 347 of file filemap.c.

 {
     char        localpath[MAXPGPATH];
     int         excludeIdx;
     const char *filename;
  
     /*
      * Skip all temporary files, .../pgsql_tmp/... and .../pgsql_tmp.*
      */
     if (strstr(path, "/" PG_TEMP_FILE_PREFIX) != NULL ||
         strstr(path, "/" PG_TEMP_FILES_DIR "/") != NULL)
     {
         return true;
     }
  
     /* check individual files... */
     for (excludeIdx = 0; excludeFiles[excludeIdx].name != NULL; excludeIdx++)
     {
         int         cmplen = strlen(excludeFiles[excludeIdx].name);
  
         filename = last_dir_separator(path);
         if (filename == NULL)
             filename = path;
         else
             filename++;
  
         if (!excludeFiles[excludeIdx].match_prefix)
             cmplen++;
         if (strncmp(filename, excludeFiles[excludeIdx].name, cmplen) == 0)
         {
             if (is_source)
                 pg_log_debug("entry \"%s\" excluded from source file list",
                              path);
             else
                 pg_log_debug("entry \"%s\" excluded from target file list",
                              path);
             return true;
         }
     }
  
     /*
      * ... And check some directories.  Note that this includes any contents
      * within the directories themselves.
      */
     for (excludeIdx = 0; excludeDirContents[excludeIdx] != NULL; excludeIdx++)
     {
         snprintf(localpath, sizeof(localpath), "%s/",
                  excludeDirContents[excludeIdx]);
         if (strstr(path, localpath) == path)
         {
             if (is_source)
                 pg_log_debug("entry \"%s\" excluded from source file list",
                              path);
             else
                 pg_log_debug("entry \"%s\" excluded from target file list",
                              path);
             return true;
         }
     }
  
     return false;
 }

References excludeDirContents, excludeFiles, filename, last_dir_separator(), exclude_list_item::match_prefix, MAXPGPATH, exclude_list_item::name, name, pg_log_debug, PG_TEMP_FILE_PREFIX, PG_TEMP_FILES_DIR, and snprintf.

Referenced by decide_file_action().

◆ datasegpath()

static char * datasegpath	(	RelFileLocator	rlocator,
		ForkNumber	forknum,
		BlockNumber	segno
	)

static

Definition at line 591 of file filemap.c.

 {
     char       *path;
     char       *segpath;
  
     path = relpathperm(rlocator, forknum);
     if (segno > 0)
     {
         segpath = psprintf("%s.%u", path, segno);
         pfree(path);
         return segpath;
     }
     else
         return path;
 }

References pfree(), psprintf(), and relpathperm.

Referenced by isRelDataFile(), and process_target_wal_block_change().

◆ decide_file_action()

static file_action_t decide_file_action ( file_entry_t * entry )

static

Definition at line 638 of file filemap.c.

 {
     const char *path = entry->path;
  
     /*
      * Don't touch the control file. It is handled specially, after copying
      * all the other files.
      */
     if (strcmp(path, "global/pg_control") == 0)
         return FILE_ACTION_NONE;
  
     /* Skip macOS system files */
     if (strstr(path, ".DS_Store") != NULL)
         return FILE_ACTION_NONE;
  
     /*
      * Remove all files matching the exclusion filters in the target.
      */
     if (check_file_excluded(path, true))
     {
         if (entry->target_exists)
             return FILE_ACTION_REMOVE;
         else
             return FILE_ACTION_NONE;
     }
  
     /*
      * Handle cases where the file is missing from one of the systems.
      */
     if (!entry->target_exists && entry->source_exists)
     {
         /*
          * File exists in source, but not in target. Copy it in toto. (If it's
          * a relation data file, WAL replay after rewinding should re-create
          * it anyway. But there's no harm in copying it now.)
          */
         switch (entry->source_type)
         {
             case FILE_TYPE_DIRECTORY:
             case FILE_TYPE_SYMLINK:
                 return FILE_ACTION_CREATE;
             case FILE_TYPE_REGULAR:
                 return FILE_ACTION_COPY;
             case FILE_TYPE_UNDEFINED:
                 pg_fatal("unknown file type for \"%s\"", entry->path);
                 break;
         }
     }
     else if (entry->target_exists && !entry->source_exists)
     {
         /* File exists in target, but not source. Remove it. */
         return FILE_ACTION_REMOVE;
     }
     else if (!entry->target_exists && !entry->source_exists)
     {
         /*
          * Doesn't exist in either server. Why does it have an entry in the
          * first place??
          */
         Assert(false);
         return FILE_ACTION_NONE;
     }
  
     /*
      * Otherwise, the file exists on both systems
      */
     Assert(entry->target_exists && entry->source_exists);
  
     if (entry->source_type != entry->target_type)
     {
         /* But it's a different kind of object. Strange.. */
         pg_fatal("file \"%s\" is of different type in source and target", entry->path);
     }
  
     /*
      * PG_VERSION files should be identical on both systems, but avoid
      * overwriting them for paranoia.
      */
     if (pg_str_endswith(entry->path, "PG_VERSION"))
         return FILE_ACTION_NONE;
  
     switch (entry->source_type)
     {
         case FILE_TYPE_DIRECTORY:
             return FILE_ACTION_NONE;
  
         case FILE_TYPE_SYMLINK:
  
             /*
              * XXX: Should we check if it points to the same target?
              */
             return FILE_ACTION_NONE;
  
         case FILE_TYPE_REGULAR:
             if (!entry->isrelfile)
             {
                 /*
                  * It's a non-data file that we have no special processing
                  * for. Copy it in toto.
                  */
                 return FILE_ACTION_COPY;
             }
             else
             {
                 /*
                  * It's a data file that exists in both systems.
                  *
                  * If it's larger in target, we can truncate it. There will
                  * also be a WAL record of the truncation in the source
                  * system, so WAL replay would eventually truncate the target
                  * too, but we might as well do it now.
                  *
                  * If it's smaller in the target, it means that it has been
                  * truncated in the target, or enlarged in the source, or
                  * both. If it was truncated in the target, we need to copy
                  * the missing tail from the source system. If it was enlarged
                  * in the source system, there will be WAL records in the
                  * source system for the new blocks, so we wouldn't need to
                  * copy them here. But we don't know which scenario we're
                  * dealing with, and there's no harm in copying the missing
                  * blocks now, so do it now.
                  *
                  * If it's the same size, do nothing here. Any blocks modified
                  * in the target will be copied based on parsing the target
                  * system's WAL, and any blocks modified in the source will be
                  * updated after rewinding, when the source system's WAL is
                  * replayed.
                  */
                 if (entry->target_size < entry->source_size)
                     return FILE_ACTION_COPY_TAIL;
                 else if (entry->target_size > entry->source_size)
                     return FILE_ACTION_TRUNCATE;
                 else
                     return FILE_ACTION_NONE;
             }
             break;
  
         case FILE_TYPE_UNDEFINED:
             pg_fatal("unknown file type for \"%s\"", path);
             break;
     }
  
     /* unreachable */
     pg_fatal("could not decide what to do with file \"%s\"", path);
 }

References Assert, check_file_excluded(), FILE_ACTION_COPY, FILE_ACTION_COPY_TAIL, FILE_ACTION_CREATE, FILE_ACTION_NONE, FILE_ACTION_REMOVE, FILE_ACTION_TRUNCATE, FILE_TYPE_DIRECTORY, FILE_TYPE_REGULAR, FILE_TYPE_SYMLINK, FILE_TYPE_UNDEFINED, file_entry_t::isrelfile, file_entry_t::path, pg_fatal, pg_str_endswith(), file_entry_t::source_exists, file_entry_t::source_size, file_entry_t::source_type, file_entry_t::target_exists, file_entry_t::target_size, and file_entry_t::target_type.

Referenced by decide_file_actions().

◆ decide_file_actions()

filemap_t* decide_file_actions ( void )

Definition at line 791 of file filemap.c.

 {
     int         i;
     filehash_iterator it;
     file_entry_t *entry;
     filemap_t  *filemap;
  
     filehash_start_iterate(filehash, &it);
     while ((entry = filehash_iterate(filehash, &it)) != NULL)
     {
         entry->action = decide_file_action(entry);
     }
  
     /*
      * Turn the hash table into an array, and sort in the order that the
      * actions should be performed.
      */
     filemap = pg_malloc(offsetof(filemap_t, entries) +
                         filehash->members * sizeof(file_entry_t *));
     filemap->nentries = filehash->members;
     filehash_start_iterate(filehash, &it);
     i = 0;
     while ((entry = filehash_iterate(filehash, &it)) != NULL)
     {
         filemap->entries[i++] = entry;
     }
  
     qsort(&filemap->entries, filemap->nentries, sizeof(file_entry_t *),
           final_filemap_cmp);
  
     return filemap;
 }

References file_entry_t::action, decide_file_action(), filemap_t::entries, filehash, final_filemap_cmp(), i, filemap_t::nentries, pg_malloc(), and qsort.

Referenced by main().

◆ filehash_init()

void filehash_init ( void )

Definition at line 167 of file filemap.c.

 {
     filehash = filehash_create(FILEHASH_INITIAL_SIZE, NULL);
 }

References filehash, and FILEHASH_INITIAL_SIZE.

Referenced by main().

◆ final_filemap_cmp()

static int final_filemap_cmp	(	const void *	a,
		const void *	b
	)

static

Definition at line 618 of file filemap.c.

 {
     file_entry_t *fa = *((file_entry_t **) a);
     file_entry_t *fb = *((file_entry_t **) b);
  
     if (fa->action > fb->action)
         return 1;
     if (fa->action < fb->action)
         return -1;
  
     if (fa->action == FILE_ACTION_REMOVE)
         return strcmp(fb->path, fa->path);
     else
         return strcmp(fa->path, fb->path);
 }

References a, b, fa(), fb(), and FILE_ACTION_REMOVE.

Referenced by decide_file_actions().

◆ insert_filehash_entry()

static file_entry_t * insert_filehash_entry ( const char * path )

static

Definition at line 174 of file filemap.c.

 {
     file_entry_t *entry;
     bool        found;
  
     entry = filehash_insert(filehash, path, &found);
     if (!found)
     {
         entry->path = pg_strdup(path);
         entry->isrelfile = isRelDataFile(path);
  
         entry->target_exists = false;
         entry->target_type = FILE_TYPE_UNDEFINED;
         entry->target_size = 0;
         entry->target_link_target = NULL;
         entry->target_pages_to_overwrite.bitmap = NULL;
         entry->target_pages_to_overwrite.bitmapsize = 0;
  
         entry->source_exists = false;
         entry->source_type = FILE_TYPE_UNDEFINED;
         entry->source_size = 0;
         entry->source_link_target = NULL;
  
         entry->action = FILE_ACTION_UNDECIDED;
     }
  
     return entry;
 }

References file_entry_t::action, datapagemap::bitmap, datapagemap::bitmapsize, FILE_ACTION_UNDECIDED, FILE_TYPE_UNDEFINED, filehash, isRelDataFile(), file_entry_t::isrelfile, file_entry_t::path, pg_strdup(), file_entry_t::source_exists, file_entry_t::source_link_target, file_entry_t::source_size, file_entry_t::source_type, file_entry_t::target_exists, file_entry_t::target_link_target, file_entry_t::target_pages_to_overwrite, file_entry_t::target_size, and file_entry_t::target_type.

Referenced by process_source_file(), and process_target_file().

◆ isRelDataFile()

static bool isRelDataFile ( const char * path )

static

Definition at line 508 of file filemap.c.

 {
     RelFileLocator rlocator;
     unsigned int segNo;
     int         nmatch;
     bool        matched;
  
     /*----
      * Relation data files can be in one of the following directories:
      *
      * global/
      *      shared relations
      *
      * base/<db oid>/
      *      regular relations, default tablespace
      *
      * pg_tblspc/<tblspc oid>/<tblspc version>/
      *      within a non-default tablespace (the name of the directory
      *      depends on version)
      *
      * And the relation data files themselves have a filename like:
      *
      * <oid>.<segment number>
      *
      *----
      */
     rlocator.spcOid = InvalidOid;
     rlocator.dbOid = InvalidOid;
     rlocator.relNumber = InvalidRelFileNumber;
     segNo = 0;
     matched = false;
  
     nmatch = sscanf(path, "global/%u.%u", &rlocator.relNumber, &segNo);
     if (nmatch == 1 || nmatch == 2)
     {
         rlocator.spcOid = GLOBALTABLESPACE_OID;
         rlocator.dbOid = 0;
         matched = true;
     }
     else
     {
         nmatch = sscanf(path, "base/%u/%u.%u",
                         &rlocator.dbOid, &rlocator.relNumber, &segNo);
         if (nmatch == 2 || nmatch == 3)
         {
             rlocator.spcOid = DEFAULTTABLESPACE_OID;
             matched = true;
         }
         else
         {
             nmatch = sscanf(path, "pg_tblspc/%u/" TABLESPACE_VERSION_DIRECTORY "/%u/%u.%u",
                             &rlocator.spcOid, &rlocator.dbOid, &rlocator.relNumber,
                             &segNo);
             if (nmatch == 3 || nmatch == 4)
                 matched = true;
         }
     }
  
     /*
      * The sscanf tests above can match files that have extra characters at
      * the end. To eliminate such cases, cross-check that GetRelationPath
      * creates the exact same filename, when passed the RelFileLocator
      * information we extracted from the filename.
      */
     if (matched)
     {
         char       *check_path = datasegpath(rlocator, MAIN_FORKNUM, segNo);
  
         if (strcmp(check_path, path) != 0)
             matched = false;
  
         pfree(check_path);
     }
  
     return matched;
 }

References datasegpath(), RelFileLocator::dbOid, InvalidOid, InvalidRelFileNumber, MAIN_FORKNUM, pfree(), RelFileLocator::relNumber, RelFileLocator::spcOid, and TABLESPACE_VERSION_DIRECTORY.

Referenced by insert_filehash_entry(), and process_source_file().

◆ lookup_filehash_entry()

static file_entry_t * lookup_filehash_entry ( const char * path )

static

Definition at line 204 of file filemap.c.

 {
     return filehash_lookup(filehash, path);
 }

References filehash.

Referenced by process_target_wal_block_change().

◆ print_filemap()

void print_filemap ( filemap_t * filemap )

Definition at line 478 of file filemap.c.

 {
     file_entry_t *entry;
     int         i;
  
     for (i = 0; i < filemap->nentries; i++)
     {
         entry = filemap->entries[i];
         if (entry->action != FILE_ACTION_NONE ||
             entry->target_pages_to_overwrite.bitmapsize > 0)
         {
             pg_log_debug("%s (%s)", entry->path,
                          action_to_str(entry->action));
  
             if (entry->target_pages_to_overwrite.bitmapsize > 0)
                 datapagemap_print(&entry->target_pages_to_overwrite);
         }
     }
     fflush(stdout);
 }

References file_entry_t::action, action_to_str(), datapagemap::bitmapsize, datapagemap_print(), filemap_t::entries, fflush(), FILE_ACTION_NONE, i, filemap_t::nentries, file_entry_t::path, pg_log_debug, generate_unaccent_rules::stdout, and file_entry_t::target_pages_to_overwrite.

Referenced by main().

◆ process_source_file()

void process_source_file	(	const char *	path,
		file_type_t	type,
		size_t	size,
		const char *	link_target
	)

Definition at line 217 of file filemap.c.

 {
     file_entry_t *entry;
  
     /*
      * Pretend that pg_wal is a directory, even if it's really a symlink. We
      * don't want to mess with the symlink itself, nor complain if it's a
      * symlink in source but not in target or vice versa.
      */
     if (strcmp(path, "pg_wal") == 0 && type == FILE_TYPE_SYMLINK)
         type = FILE_TYPE_DIRECTORY;
  
     /*
      * sanity check: a filename that looks like a data file better be a
      * regular file
      */
     if (type != FILE_TYPE_REGULAR && isRelDataFile(path))
         pg_fatal("data file \"%s\" in source is not a regular file", path);
  
     /* Remember this source file */
     entry = insert_filehash_entry(path);
     if (entry->source_exists)
         pg_fatal("duplicate source file \"%s\"", path);
     entry->source_exists = true;
     entry->source_type = type;
     entry->source_size = size;
     entry->source_link_target = link_target ? pg_strdup(link_target) : NULL;
 }

References FILE_TYPE_DIRECTORY, FILE_TYPE_REGULAR, FILE_TYPE_SYMLINK, insert_filehash_entry(), isRelDataFile(), pg_fatal, pg_strdup(), size, file_entry_t::source_exists, file_entry_t::source_link_target, file_entry_t::source_size, file_entry_t::source_type, and type.

Referenced by main().

◆ process_target_file()

void process_target_file	(	const char *	path,
		file_type_t	type,
		size_t	size,
		const char *	link_target
	)

Definition at line 253 of file filemap.c.

 {
     file_entry_t *entry;
  
     /*
      * Do not apply any exclusion filters here.  This has advantage to remove
      * from the target data folder all paths which have been filtered out from
      * the source data folder when processing the source files.
      */
  
     /*
      * Like in process_source_file, pretend that pg_wal is always a directory.
      */
     if (strcmp(path, "pg_wal") == 0 && type == FILE_TYPE_SYMLINK)
         type = FILE_TYPE_DIRECTORY;
  
     /* Remember this target file */
     entry = insert_filehash_entry(path);
     if (entry->target_exists)
         pg_fatal("duplicate source file \"%s\"", path);
     entry->target_exists = true;
     entry->target_type = type;
     entry->target_size = size;
     entry->target_link_target = link_target ? pg_strdup(link_target) : NULL;
 }

References FILE_TYPE_DIRECTORY, FILE_TYPE_SYMLINK, insert_filehash_entry(), pg_fatal, pg_strdup(), size, file_entry_t::target_exists, file_entry_t::target_link_target, file_entry_t::target_size, file_entry_t::target_type, and type.

Referenced by main().

◆ process_target_wal_block_change()

void process_target_wal_block_change	(	ForkNumber	forknum,
		RelFileLocator	rlocator,
		BlockNumber	blkno
	)

Definition at line 290 of file filemap.c.

 {
     char       *path;
     file_entry_t *entry;
     BlockNumber blkno_inseg;
     int         segno;
  
     segno = blkno / RELSEG_SIZE;
     blkno_inseg = blkno % RELSEG_SIZE;
  
     path = datasegpath(rlocator, forknum, segno);
     entry = lookup_filehash_entry(path);
     pfree(path);
  
     /*
      * If the block still exists in both systems, remember it. Otherwise we
      * can safely ignore it.
      *
      * If the block is beyond the EOF in the source system, or the file
      * doesn't exist in the source at all, we're going to truncate/remove it
      * away from the target anyway. Likewise, if it doesn't exist in the
      * target anymore, we will copy it over with the "tail" from the source
      * system, anyway.
      *
      * It is possible to find WAL for a file that doesn't exist on either
      * system anymore. It means that the relation was dropped later in the
      * target system, and independently on the source system too, or that it
      * was created and dropped in the target system and it never existed in
      * the source. Either way, we can safely ignore it.
      */
     if (entry)
     {
         Assert(entry->isrelfile);
  
         if (entry->target_exists)
         {
             if (entry->target_type != FILE_TYPE_REGULAR)
                 pg_fatal("unexpected page modification for non-regular file \"%s\"",
                          entry->path);
  
             if (entry->source_exists)
             {
                 off_t       end_offset;
  
                 end_offset = (blkno_inseg + 1) * BLCKSZ;
                 if (end_offset <= entry->source_size && end_offset <= entry->target_size)
                     datapagemap_add(&entry->target_pages_to_overwrite, blkno_inseg);
             }
         }
     }
 }

References Assert, datapagemap_add(), datasegpath(), FILE_TYPE_REGULAR, file_entry_t::isrelfile, lookup_filehash_entry(), file_entry_t::path, pfree(), pg_fatal, file_entry_t::source_exists, file_entry_t::target_exists, file_entry_t::target_pages_to_overwrite, and file_entry_t::target_type.

Referenced by extractPageInfo().

Variable Documentation

◆ excludeDirContents

const char* const excludeDirContents[]

static

Initial value:

=
{
    
    "pg_stat_tmp",              
 
    "pg_replslot",
 
    "pg_dynshmem",              
 
    "pg_notify",
 
    "pg_serial",
 
    "pg_snapshots",
 
    "pg_subtrans",
 
    NULL
}

Definition at line 87 of file filemap.c.

Referenced by check_file_excluded().

◆ excludeFiles

const struct exclude_list_item excludeFiles[]

static

Initial value:

=
{
    
    {"postgresql.auto.conf.tmp", false},    
 
    {"current_logfiles.tmp", false},    
 
    {"pg_internal.init", true}, 
 
    {"backup_label", false},    
    {"tablespace_map", false},  
 
    {"backup_manifest", false},
 
    {"postmaster.pid", false},
    {"postmaster.opts", false},
 
    {NULL, false}
}

Definition at line 87 of file filemap.c.

Referenced by check_file_excluded().

◆ filehash

filehash_hash* filehash

static

Definition at line 55 of file filemap.c.

Referenced by decide_file_actions(), filehash_init(), insert_filehash_entry(), and lookup_filehash_entry().

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

◆ FILEHASH_INITIAL_SIZE

◆ SH_DECLARE

◆ SH_DEFINE

◆ SH_ELEMENT_TYPE

◆ SH_EQUAL

◆ SH_HASH_KEY

◆ SH_KEY

◆ SH_KEY_TYPE

◆ SH_PREFIX

◆ SH_RAW_ALLOCATOR

◆ SH_SCOPE

Function Documentation

◆ action_to_str()

◆ calculate_totals()

◆ check_file_excluded()

◆ datasegpath()

◆ decide_file_action()

◆ decide_file_actions()

◆ filehash_init()

◆ final_filemap_cmp()

◆ insert_filehash_entry()

◆ isRelDataFile()

◆ lookup_filehash_entry()

◆ print_filemap()

◆ process_source_file()

◆ process_target_file()

◆ process_target_wal_block_change()

Variable Documentation

◆ excludeDirContents

◆ excludeFiles

◆ filehash