#include <unistd.h>
#include <assert.h>
#include <sys/stat.h>
#include <sys/time.h>
#include "libpq-fe.h"

Include dependency graph for pg_upgrade.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	RelInfo

struct	RelInfoArr

struct	FileNameMap

struct	DbInfo

struct	DbInfoArr

struct	ControlData

struct	ClusterInfo

struct	LogOpts

struct	UserOpts

struct	LibraryInfo

struct	OSInfo

Macros
#define	DEF_PGUPORT 50432

#define	MAX_STRING 1024

#define	QUERY_ALLOC 8192

#define	MESSAGE_WIDTH 60

#define	GET_MAJOR_VERSION(v) ((v) / 100)

#define	GLOBALS_DUMP_FILE "pg_upgrade_dump_globals.sql"

#define	DB_DUMP_FILE_MASK "pg_upgrade_dump_%u.custom"

#define	DB_DUMP_LOG_FILE_MASK "pg_upgrade_dump_%u.log"

#define	SERVER_LOG_FILE "pg_upgrade_server.log"

#define	UTILITY_LOG_FILE "pg_upgrade_utility.log"

#define	INTERNAL_LOG_FILE "pg_upgrade_internal.log"

#define	SERVER_START_LOG_FILE SERVER_LOG_FILE

#define	SERVER_STOP_LOG_FILE SERVER_LOG_FILE

#define	pg_mv_file rename

#define	pg_link_file link

#define	PATH_SEPARATOR '/'

#define	PATH_QUOTE '\''

#define	RM_CMD "rm -f"

#define	RMDIR_CMD "rm -rf"

#define	SCRIPT_PREFIX "./"

#define	SCRIPT_EXT "sh"

#define	ECHO_QUOTE "'"

#define	ECHO_BLANK ""

#define	BINARY_UPGRADE_SERVER_FLAG_CAT_VER 201104251

#define	VISIBILITY_MAP_CRASHSAFE_CAT_VER 201107031

#define	VISIBILITY_MAP_FROZEN_BIT_CAT_VER 201603011

#define	MULTIXACT_FORMATCHANGE_CAT_VER 201301231

#define	LARGE_OBJECT_SIZE_PG_CONTROL_VER 942

#define	JSONB_FORMAT_CHANGE_CAT_VER 201409291

#define	EXEC_PSQL_ARGS "--echo-queries --set ON_ERROR_STOP=on --no-psqlrc --dbname=template1"

#define	fopen_priv(path, mode) fopen(path, mode)

Typedefs
typedef long	pgpid_t

Enumerations
enum	transferMode { TRANSFER_MODE_CLONE, TRANSFER_MODE_COPY, TRANSFER_MODE_LINK }

enum	eLogType { PG_VERBOSE, PG_STATUS, PG_REPORT, PG_WARNING, PG_FATAL }

Functions
void	output_check_banner (bool live_check)

void	check_and_dump_old_cluster (bool live_check)

void	check_new_cluster (void)

void	report_clusters_compatible (void)

void	issue_warnings_and_set_wal_level (void)

void	output_completion_banner (char analyze_script_file_name, char deletion_script_file_name)

void	check_cluster_versions (void)

void	check_cluster_compatibility (bool live_check)

void	create_script_for_old_cluster_deletion (char **deletion_script_file_name)

void	create_script_for_cluster_analyze (char **analyze_script_file_name)

void	get_control_data (ClusterInfo *cluster, bool live_check)

void	check_control_data (ControlData oldctrl, ControlData newctrl)

void	disable_old_cluster (void)

void	generate_old_dump (void)

bool	exec_prog (const char log_file, const char opt_log_file, bool report_error, bool exit_on_error, const char *fmt,...) pg_attribute_printf(5

bool void	verify_directories (void)

bool	pid_lock_file_exists (const char *datadir)

void	cloneFile (const char src, const char dst, const char schemaName, const char relName)

void	copyFile (const char src, const char dst, const char schemaName, const char relName)

void	linkFile (const char src, const char dst, const char schemaName, const char relName)

void	rewriteVisibilityMap (const char fromfile, const char tofile, const char schemaName, const char relName)

void	check_file_clone (void)

void	check_hard_link (void)

void	get_loadable_libraries (void)

void	check_loadable_libraries (void)

FileNameMap *	gen_db_file_maps (DbInfo old_db, DbInfo new_db, int nmaps, const char old_pgdata, const char *new_pgdata)

void	get_db_and_rel_infos (ClusterInfo *cluster)

void	print_maps (FileNameMap maps, int n, const char db_name)

void	parseCommandLine (int argc, char *argv[])

void	adjust_data_dir (ClusterInfo *cluster)

void	get_sock_dir (ClusterInfo *cluster, bool live_check)

void	transfer_all_new_tablespaces (DbInfoArr old_db_arr, DbInfoArr new_db_arr, char old_pgdata, char new_pgdata)

void	transfer_all_new_dbs (DbInfoArr old_db_arr, DbInfoArr new_db_arr, char old_pgdata, char new_pgdata, char *old_tablespace)

void	init_tablespaces (void)

PGconn *	connectToServer (ClusterInfo cluster, const char db_name)

PGresult *	executeQueryOrDie (PGconn conn, const char fmt,...) pg_attribute_printf(2

PGresult char *	cluster_conn_opts (ClusterInfo *cluster)

bool	start_postmaster (ClusterInfo *cluster, bool report_and_exit_on_error)

void	stop_postmaster (bool in_atexit)

uint32	get_major_server_version (ClusterInfo *cluster)

void	check_pghost_envvar (void)

char *	quote_identifier (const char *s)

int	get_user_info (char **user_name_p)

void	check_ok (void)

void	report_status (eLogType type, const char *fmt,...) pg_attribute_printf(2

void void	pg_log (eLogType type, const char *fmt,...) pg_attribute_printf(2

void void void	pg_fatal (const char *fmt,...) pg_attribute_printf(1

void void void	pg_attribute_noreturn ()

void	end_progress_output (void)

void	prep_status (const char *fmt,...) pg_attribute_printf(1

unsigned int	str2uint (const char *str)

void	pg_putenv (const char var, const char val)

void	new_9_0_populate_pg_largeobject_metadata (ClusterInfo *cluster, bool check_mode)

void	old_9_3_check_for_line_data_type_usage (ClusterInfo *cluster)

void	old_9_6_check_for_unknown_data_type_usage (ClusterInfo *cluster)

void	old_9_6_invalidate_hash_indexes (ClusterInfo *cluster, bool check_mode)

void	old_11_check_for_sql_identifier_data_type_usage (ClusterInfo *cluster)

void	parallel_exec_prog (const char log_file, const char opt_log_file, const char *fmt,...) pg_attribute_printf(3

void void	parallel_transfer_all_new_dbs (DbInfoArr old_db_arr, DbInfoArr new_db_arr, char old_pgdata, char new_pgdata, char *old_tablespace)

bool	reap_child (bool wait_for_child)

Variables
char *	output_files []

LogOpts	log_opts

UserOpts	user_opts

ClusterInfo	old_cluster

ClusterInfo	new_cluster

OSInfo	os_info

Macro Definition Documentation

◆ BINARY_UPGRADE_SERVER_FLAG_CAT_VER

#define BINARY_UPGRADE_SERVER_FLAG_CAT_VER 201104251

Definition at line 96 of file pg_upgrade.h.

Referenced by start_postmaster().

◆ DB_DUMP_FILE_MASK

#define DB_DUMP_FILE_MASK "pg_upgrade_dump_%u.custom"

Definition at line 27 of file pg_upgrade.h.

Referenced by cleanup(), create_new_objects(), and generate_old_dump().

◆ DB_DUMP_LOG_FILE_MASK

#define DB_DUMP_LOG_FILE_MASK "pg_upgrade_dump_%u.log"

Definition at line 29 of file pg_upgrade.h.

Referenced by cleanup(), create_new_objects(), and generate_old_dump().

◆ DEF_PGUPORT

#define DEF_PGUPORT 50432

Definition at line 16 of file pg_upgrade.h.

Referenced by check_cluster_compatibility(), get_sock_dir(), and parseCommandLine().

◆ ECHO_BLANK

#define ECHO_BLANK ""

Definition at line 76 of file pg_upgrade.h.

Referenced by create_script_for_cluster_analyze().

◆ ECHO_QUOTE

#define ECHO_QUOTE "'"

Definition at line 75 of file pg_upgrade.h.

Referenced by create_script_for_cluster_analyze().

◆ EXEC_PSQL_ARGS

#define EXEC_PSQL_ARGS "--echo-queries --set ON_ERROR_STOP=on --no-psqlrc --dbname=template1"

Definition at line 360 of file pg_upgrade.h.

Referenced by prepare_new_globals().

◆ fopen_priv

#define fopen_priv	(	path,
		mode
	)	fopen(path, mode)

Definition at line 382 of file pg_upgrade.h.

Referenced by check_for_data_type_usage(), check_for_isn_and_int8_passing_mismatch(), check_for_jsonb_9_4_usage(), check_for_reg_data_type_usage(), check_for_tables_with_oids(), check_loadable_libraries(), create_script_for_cluster_analyze(), create_script_for_old_cluster_deletion(), new_9_0_populate_pg_largeobject_metadata(), old_9_6_invalidate_hash_indexes(), and parseCommandLine().

◆ GET_MAJOR_VERSION

#define GET_MAJOR_VERSION ( v ) ((v) / 100)

◆ GLOBALS_DUMP_FILE

#define GLOBALS_DUMP_FILE "pg_upgrade_dump_globals.sql"

Definition at line 26 of file pg_upgrade.h.

Referenced by cleanup(), generate_old_dump(), prepare_new_globals(), and verify_directories().

◆ INTERNAL_LOG_FILE

#define INTERNAL_LOG_FILE "pg_upgrade_internal.log"

Definition at line 32 of file pg_upgrade.h.

Referenced by parseCommandLine().

◆ JSONB_FORMAT_CHANGE_CAT_VER

#define JSONB_FORMAT_CHANGE_CAT_VER 201409291

Definition at line 126 of file pg_upgrade.h.

Referenced by check_and_dump_old_cluster().

◆ LARGE_OBJECT_SIZE_PG_CONTROL_VER

#define LARGE_OBJECT_SIZE_PG_CONTROL_VER 942

Definition at line 121 of file pg_upgrade.h.

Referenced by get_control_data().

◆ MAX_STRING

#define MAX_STRING 1024

Definition at line 18 of file pg_upgrade.h.

Referenced by adjust_data_dir(), get_bin_version(), get_control_data(), parallel_exec_prog(), prep_status(), and report_status().

◆ MESSAGE_WIDTH

#define MESSAGE_WIDTH 60

Definition at line 21 of file pg_upgrade.h.

Referenced by pg_log_v(), and prep_status().

◆ MULTIXACT_FORMATCHANGE_CAT_VER

#define MULTIXACT_FORMATCHANGE_CAT_VER 201301231

Definition at line 115 of file pg_upgrade.h.

Referenced by copy_xact_xlog_xid(), and get_control_data().

◆ PATH_QUOTE

#define PATH_QUOTE '\''

Definition at line 70 of file pg_upgrade.h.

Referenced by create_script_for_old_cluster_deletion().

◆ PATH_SEPARATOR

#define PATH_SEPARATOR '/'

Definition at line 69 of file pg_upgrade.h.

Referenced by create_script_for_old_cluster_deletion().

◆ pg_link_file

#define pg_link_file link

Definition at line 68 of file pg_upgrade.h.

Referenced by check_hard_link(), and linkFile().

◆ pg_mv_file

#define pg_mv_file rename

Definition at line 67 of file pg_upgrade.h.

Referenced by disable_old_cluster().

◆ QUERY_ALLOC

#define QUERY_ALLOC 8192

Definition at line 19 of file pg_upgrade.h.

Referenced by executeQueryOrDie(), get_db_infos(), get_rel_infos(), get_tablespace_paths(), and pg_log_v().

◆ RM_CMD

#define RM_CMD "rm -f"

Definition at line 71 of file pg_upgrade.h.

Referenced by create_script_for_old_cluster_deletion().

◆ RMDIR_CMD

#define RMDIR_CMD "rm -rf"

Definition at line 72 of file pg_upgrade.h.

Referenced by create_script_for_old_cluster_deletion().

◆ SCRIPT_EXT

#define SCRIPT_EXT "sh"

Definition at line 74 of file pg_upgrade.h.

Referenced by create_script_for_cluster_analyze(), and create_script_for_old_cluster_deletion().

◆ SCRIPT_PREFIX

#define SCRIPT_PREFIX "./"

Definition at line 73 of file pg_upgrade.h.

Referenced by create_script_for_cluster_analyze(), and create_script_for_old_cluster_deletion().

◆ SERVER_LOG_FILE

#define SERVER_LOG_FILE "pg_upgrade_server.log"

Definition at line 30 of file pg_upgrade.h.

Referenced by start_postmaster().

◆ SERVER_START_LOG_FILE

#define SERVER_START_LOG_FILE SERVER_LOG_FILE

Definition at line 53 of file pg_upgrade.h.

Referenced by start_postmaster().

◆ SERVER_STOP_LOG_FILE

#define SERVER_STOP_LOG_FILE SERVER_LOG_FILE

Definition at line 54 of file pg_upgrade.h.

Referenced by stop_postmaster().

◆ UTILITY_LOG_FILE

#define UTILITY_LOG_FILE "pg_upgrade_utility.log"

Definition at line 31 of file pg_upgrade.h.

Referenced by copy_subdir_files(), copy_xact_xlog_xid(), generate_old_dump(), main(), prepare_new_cluster(), and prepare_new_globals().

◆ VISIBILITY_MAP_CRASHSAFE_CAT_VER

#define VISIBILITY_MAP_CRASHSAFE_CAT_VER 201107031

Definition at line 102 of file pg_upgrade.h.

Referenced by transfer_single_new_db().

◆ VISIBILITY_MAP_FROZEN_BIT_CAT_VER

#define VISIBILITY_MAP_FROZEN_BIT_CAT_VER 201603011

Definition at line 107 of file pg_upgrade.h.

Referenced by transfer_single_new_db().

Typedef Documentation

◆ pgpid_t

typedef long pgpid_t

Definition at line 249 of file pg_upgrade.h.

Enumeration Type Documentation

◆ eLogType

enum eLogType

Enumerator
PG_VERBOSE
PG_STATUS
PG_REPORT
PG_WARNING
PG_FATAL

Definition at line 239 of file pg_upgrade.h.

 {
     PG_VERBOSE,
     PG_STATUS,
     PG_REPORT,
     PG_WARNING,
     PG_FATAL
 } eLogType;

◆ transferMode

enum transferMode

Enumerator
TRANSFER_MODE_CLONE
TRANSFER_MODE_COPY
TRANSFER_MODE_LINK

Definition at line 229 of file pg_upgrade.h.

 {
     TRANSFER_MODE_CLONE,
     TRANSFER_MODE_COPY,
     TRANSFER_MODE_LINK
 } transferMode;

Function Documentation

◆ adjust_data_dir()

void adjust_data_dir ( ClusterInfo * cluster )

Definition at line 403 of file option.c.

References ClusterInfo::bindir, check_ok(), filename, MAX_STRING, MAXPGPATH, old_cluster, output(), pg_fatal, pg_strdup(), pg_strip_crlf(), ClusterInfo::pgconfig, ClusterInfo::pgdata, prep_status(), snprintf, and strerror.

 {
     char        filename[MAXPGPATH];
     char        cmd[MAXPGPATH],
                 cmd_output[MAX_STRING];
     FILE       *fp,
                *output;
 
     /* Initially assume config dir and data dir are the same */
     cluster->pgconfig = pg_strdup(cluster->pgdata);
 
     /* If there is no postgresql.conf, it can't be a config-only dir */
     snprintf(filename, sizeof(filename), "%s/postgresql.conf", cluster->pgconfig);
     if ((fp = fopen(filename, "r")) == NULL)
         return;
     fclose(fp);
 
     /* If PG_VERSION exists, it can't be a config-only dir */
     snprintf(filename, sizeof(filename), "%s/PG_VERSION", cluster->pgconfig);
     if ((fp = fopen(filename, "r")) != NULL)
     {
         fclose(fp);
         return;
     }
 
     /* Must be a configuration directory, so find the real data directory. */
 
     if (cluster == &old_cluster)
         prep_status("Finding the real data directory for the source cluster");
     else
         prep_status("Finding the real data directory for the target cluster");
 
     /*
      * We don't have a data directory yet, so we can't check the PG version,
      * so this might fail --- only works for PG 9.2+.   If this fails,
      * pg_upgrade will fail anyway because the data files will not be found.
      */
     snprintf(cmd, sizeof(cmd), "\"%s/postgres\" -D \"%s\" -C data_directory",
              cluster->bindir, cluster->pgconfig);
 
     if ((output = popen(cmd, "r")) == NULL ||
         fgets(cmd_output, sizeof(cmd_output), output) == NULL)
         pg_fatal("could not get data directory using %s: %s\n",
                  cmd, strerror(errno));
 
     pclose(output);
 
     /* strip trailing newline and carriage return */
     (void) pg_strip_crlf(cmd_output);
 
     cluster->pgdata = pg_strdup(cmd_output);
 
     check_ok();
 }

◆ check_and_dump_old_cluster()

void check_and_dump_old_cluster ( bool live_check )

Definition at line 79 of file check.c.

References ControlData::cat_ver, UserOpts::check, check_for_isn_and_int8_passing_mismatch(), check_for_jsonb_9_4_usage(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_for_reg_data_type_usage(), check_for_tables_with_oids(), check_is_install_user(), check_proper_datallowconn(), ClusterInfo::controldata, generate_old_dump(), get_db_and_rel_infos(), get_loadable_libraries(), GET_MAJOR_VERSION, init_tablespaces(), JSONB_FORMAT_CHANGE_CAT_VER, ClusterInfo::major_version, new_9_0_populate_pg_largeobject_metadata(), old_11_check_for_sql_identifier_data_type_usage(), old_9_3_check_for_line_data_type_usage(), old_9_6_check_for_unknown_data_type_usage(), old_9_6_invalidate_hash_indexes(), old_cluster, start_postmaster(), stop_postmaster(), and user_opts.

Referenced by main().

 {
     /* -- OLD -- */
 
     if (!live_check)
         start_postmaster(&old_cluster, true);
 
     /* Extract a list of databases and tables from the old cluster */
     get_db_and_rel_infos(&old_cluster);
 
     init_tablespaces();
 
     get_loadable_libraries();
 
 
     /*
      * Check for various failure cases
      */
     check_is_install_user(&old_cluster);
     check_proper_datallowconn(&old_cluster);
     check_for_prepared_transactions(&old_cluster);
     check_for_reg_data_type_usage(&old_cluster);
     check_for_isn_and_int8_passing_mismatch(&old_cluster);
 
     /*
      * Pre-PG 12 allowed tables to be declared WITH OIDS, which is not
      * supported anymore. Verify there are none, iff applicable.
      */
     if (GET_MAJOR_VERSION(old_cluster.major_version) <= 1100)
         check_for_tables_with_oids(&old_cluster);
 
     /*
      * PG 12 changed the 'sql_identifier' type storage to be based on name,
      * not varchar, which breaks on-disk format for existing data. So we need
      * to prevent upgrade when used in user objects (tables, indexes, ...).
      */
     if (GET_MAJOR_VERSION(old_cluster.major_version) <= 1100)
         old_11_check_for_sql_identifier_data_type_usage(&old_cluster);
 
     /*
      * Pre-PG 10 allowed tables with 'unknown' type columns and non WAL logged
      * hash indexes
      */
     if (GET_MAJOR_VERSION(old_cluster.major_version) <= 906)
     {
         old_9_6_check_for_unknown_data_type_usage(&old_cluster);
         if (user_opts.check)
             old_9_6_invalidate_hash_indexes(&old_cluster, true);
     }
 
     /* 9.5 and below should not have roles starting with pg_ */
     if (GET_MAJOR_VERSION(old_cluster.major_version) <= 905)
         check_for_pg_role_prefix(&old_cluster);
 
     if (GET_MAJOR_VERSION(old_cluster.major_version) == 904 &&
         old_cluster.controldata.cat_ver < JSONB_FORMAT_CHANGE_CAT_VER)
         check_for_jsonb_9_4_usage(&old_cluster);
 
     /* Pre-PG 9.4 had a different 'line' data type internal format */
     if (GET_MAJOR_VERSION(old_cluster.major_version) <= 903)
         old_9_3_check_for_line_data_type_usage(&old_cluster);
 
     /* Pre-PG 9.0 had no large object permissions */
     if (GET_MAJOR_VERSION(old_cluster.major_version) <= 804)
         new_9_0_populate_pg_largeobject_metadata(&old_cluster, true);
 
     /*
      * While not a check option, we do this now because this is the only time
      * the old server is running.
      */
     if (!user_opts.check)
         generate_old_dump();
 
     if (!live_check)
         stop_postmaster(false);
 }

◆ check_cluster_compatibility()

void check_cluster_compatibility ( bool live_check )

Definition at line 299 of file check.c.

References check_control_data(), ClusterInfo::controldata, DEF_PGUPORT, get_control_data(), GET_MAJOR_VERSION, ClusterInfo::major_version, new_cluster, old_cluster, pg_fatal, and ClusterInfo::port.

Referenced by main().

 {
     /* get/check pg_control data of servers */
     get_control_data(&old_cluster, live_check);
     get_control_data(&new_cluster, false);
     check_control_data(&old_cluster.controldata, &new_cluster.controldata);
 
     /* We read the real port number for PG >= 9.1 */
     if (live_check && GET_MAJOR_VERSION(old_cluster.major_version) < 901 &&
         old_cluster.port == DEF_PGUPORT)
         pg_fatal("When checking a pre-PG 9.1 live old server, "
                  "you must specify the old server's port number.\n");
 
     if (live_check && old_cluster.port == new_cluster.port)
         pg_fatal("When checking a live server, "
                  "the old and new port numbers must be different.\n");
 }

◆ check_cluster_versions()

void check_cluster_versions ( void )

Definition at line 257 of file check.c.

References Assert, ClusterInfo::bin_version, check_ok(), GET_MAJOR_VERSION, ClusterInfo::major_version, new_cluster, old_cluster, pg_fatal, and prep_status().

Referenced by main().

 {
     prep_status("Checking cluster versions");
 
     /* cluster versions should already have been obtained */
     Assert(old_cluster.major_version != 0);
     Assert(new_cluster.major_version != 0);
 
     /*
      * We allow upgrades from/to the same major version for alpha/beta
      * upgrades
      */
 
     if (GET_MAJOR_VERSION(old_cluster.major_version) < 804)
         pg_fatal("This utility can only upgrade from PostgreSQL version 8.4 and later.\n");
 
     /* Only current PG version is supported as a target */
     if (GET_MAJOR_VERSION(new_cluster.major_version) != GET_MAJOR_VERSION(PG_VERSION_NUM))
         pg_fatal("This utility can only upgrade to PostgreSQL version %s.\n",
                  PG_MAJORVERSION);
 
     /*
      * We can't allow downgrading because we use the target pg_dump, and
      * pg_dump cannot operate on newer database versions, only current and
      * older versions.
      */
     if (old_cluster.major_version > new_cluster.major_version)
         pg_fatal("This utility cannot be used to downgrade to older major PostgreSQL versions.\n");
 
     /* Ensure binaries match the designated data directories */
     if (GET_MAJOR_VERSION(old_cluster.major_version) !=
         GET_MAJOR_VERSION(old_cluster.bin_version))
         pg_fatal("Old cluster data and binary directories are from different major versions.\n");
     if (GET_MAJOR_VERSION(new_cluster.major_version) !=
         GET_MAJOR_VERSION(new_cluster.bin_version))
         pg_fatal("New cluster data and binary directories are from different major versions.\n");
 
     check_ok();
 }

◆ check_control_data()

void check_control_data	(	ControlData *	oldctrl,
		ControlData *	newctrl
	)

Definition at line 619 of file controldata.c.

References ControlData::align, ControlData::blocksz, ControlData::data_checksum_version, ControlData::date_is_int, ControlData::ident, ControlData::index, ControlData::large_object, ControlData::largesz, pg_fatal, ControlData::toast, ControlData::walseg, and ControlData::walsz.

Referenced by check_cluster_compatibility().

 {
     if (oldctrl->align == 0 || oldctrl->align != newctrl->align)
         pg_fatal("old and new pg_controldata alignments are invalid or do not match\n"
                  "Likely one cluster is a 32-bit install, the other 64-bit\n");
 
     if (oldctrl->blocksz == 0 || oldctrl->blocksz != newctrl->blocksz)
         pg_fatal("old and new pg_controldata block sizes are invalid or do not match\n");
 
     if (oldctrl->largesz == 0 || oldctrl->largesz != newctrl->largesz)
         pg_fatal("old and new pg_controldata maximum relation segment sizes are invalid or do not match\n");
 
     if (oldctrl->walsz == 0 || oldctrl->walsz != newctrl->walsz)
         pg_fatal("old and new pg_controldata WAL block sizes are invalid or do not match\n");
 
     if (oldctrl->walseg == 0 || oldctrl->walseg != newctrl->walseg)
         pg_fatal("old and new pg_controldata WAL segment sizes are invalid or do not match\n");
 
     if (oldctrl->ident == 0 || oldctrl->ident != newctrl->ident)
         pg_fatal("old and new pg_controldata maximum identifier lengths are invalid or do not match\n");
 
     if (oldctrl->index == 0 || oldctrl->index != newctrl->index)
         pg_fatal("old and new pg_controldata maximum indexed columns are invalid or do not match\n");
 
     if (oldctrl->toast == 0 || oldctrl->toast != newctrl->toast)
         pg_fatal("old and new pg_controldata maximum TOAST chunk sizes are invalid or do not match\n");
 
     /* large_object added in 9.5, so it might not exist in the old cluster */
     if (oldctrl->large_object != 0 &&
         oldctrl->large_object != newctrl->large_object)
         pg_fatal("old and new pg_controldata large-object chunk sizes are invalid or do not match\n");
 
     if (oldctrl->date_is_int != newctrl->date_is_int)
         pg_fatal("old and new pg_controldata date/time storage types do not match\n");
 
     /*
      * float8_pass_by_value does not need to match, but is used in
      * check_for_isn_and_int8_passing_mismatch().
      */
 
     /*
      * We might eventually allow upgrades from checksum to no-checksum
      * clusters.
      */
     if (oldctrl->data_checksum_version == 0 &&
         newctrl->data_checksum_version != 0)
         pg_fatal("old cluster does not use data checksums but the new one does\n");
     else if (oldctrl->data_checksum_version != 0 &&
              newctrl->data_checksum_version == 0)
         pg_fatal("old cluster uses data checksums but the new one does not\n");
     else if (oldctrl->data_checksum_version != newctrl->data_checksum_version)
         pg_fatal("old and new cluster pg_controldata checksum versions do not match\n");
 }

◆ check_file_clone()

void check_file_clone ( void )

Definition at line 321 of file file.c.

References close, MAXPGPATH, new_cluster, old_cluster, PG_BINARY, pg_fatal, pg_file_create_mode, ClusterInfo::pgdata, snprintf, and strerror.

Referenced by check_new_cluster().

 {
     char        existing_file[MAXPGPATH];
     char        new_link_file[MAXPGPATH];
 
     snprintf(existing_file, sizeof(existing_file), "%s/PG_VERSION", old_cluster.pgdata);
     snprintf(new_link_file, sizeof(new_link_file), "%s/PG_VERSION.clonetest", new_cluster.pgdata);
     unlink(new_link_file);      /* might fail */
 
 #if defined(HAVE_COPYFILE) && defined(COPYFILE_CLONE_FORCE)
     if (copyfile(existing_file, new_link_file, NULL, COPYFILE_CLONE_FORCE) < 0)
         pg_fatal("could not clone file between old and new data directories: %s\n",
                  strerror(errno));
 #elif defined(__linux__) && defined(FICLONE)
     {
         int         src_fd;
         int         dest_fd;
 
         if ((src_fd = open(existing_file, O_RDONLY | PG_BINARY, 0)) < 0)
             pg_fatal("could not open file \"%s\": %s\n",
                      existing_file, strerror(errno));
 
         if ((dest_fd = open(new_link_file, O_RDWR | O_CREAT | O_EXCL | PG_BINARY,
                             pg_file_create_mode)) < 0)
             pg_fatal("could not create file \"%s\": %s\n",
                      new_link_file, strerror(errno));
 
         if (ioctl(dest_fd, FICLONE, src_fd) < 0)
             pg_fatal("could not clone file between old and new data directories: %s\n",
                      strerror(errno));
 
         close(src_fd);
         close(dest_fd);
     }
 #else
     pg_fatal("file cloning not supported on this platform\n");
 #endif
 
     unlink(new_link_file);
 }

◆ check_hard_link()

void check_hard_link ( void )

Definition at line 363 of file file.c.

References _dosmaperr(), MAXPGPATH, new_cluster, old_cluster, pg_fatal, pg_link_file, ClusterInfo::pgdata, snprintf, and strerror.

Referenced by check_new_cluster().

 {
     char        existing_file[MAXPGPATH];
     char        new_link_file[MAXPGPATH];
 
     snprintf(existing_file, sizeof(existing_file), "%s/PG_VERSION", old_cluster.pgdata);
     snprintf(new_link_file, sizeof(new_link_file), "%s/PG_VERSION.linktest", new_cluster.pgdata);
     unlink(new_link_file);      /* might fail */
 
     if (pg_link_file(existing_file, new_link_file) < 0)
         pg_fatal("could not create hard link between old and new data directories: %s\n"
                  "In link mode the old and new data directories must be on the same file system.\n",
                  strerror(errno));
 
     unlink(new_link_file);
 }

◆ check_loadable_libraries()

void check_loadable_libraries ( void )

Definition at line 180 of file function.c.

References _, check_ok(), conn, connectToServer(), DbInfo::db_name, ClusterInfo::dbarr, LibraryInfo::dbnum, DbInfoArr::dbs, fopen_priv, fprintf, GET_MAJOR_VERSION, OSInfo::libraries, library_name_compare(), ClusterInfo::major_version, MAXPGPATH, LibraryInfo::name, new_cluster, OSInfo::num_libraries, old_cluster, os_info, pg_fatal, pg_log(), PG_REPORT, PGRES_COMMAND_OK, PQclear(), PQerrorMessage(), PQescapeStringConn(), PQexec(), PQfinish(), PQresultStatus(), prep_status(), qsort, snprintf, and strerror.

Referenced by check_new_cluster().

 {
     PGconn     *conn = connectToServer(&new_cluster, "template1");
     int         libnum;
     int         was_load_failure = false;
     FILE       *script = NULL;
     bool        found = false;
     char        output_path[MAXPGPATH];
 
     prep_status("Checking for presence of required libraries");
 
     snprintf(output_path, sizeof(output_path), "loadable_libraries.txt");
 
     /*
      * Now we want to sort the library names into order.  This avoids multiple
      * probes of the same library, and ensures that libraries are probed in a
      * consistent order, which is important for reproducible behavior if one
      * library depends on another.
      */
     qsort((void *) os_info.libraries, os_info.num_libraries,
           sizeof(LibraryInfo), library_name_compare);
 
     for (libnum = 0; libnum < os_info.num_libraries; libnum++)
     {
         char       *lib = os_info.libraries[libnum].name;
         int         llen = strlen(lib);
         char        cmd[7 + 2 * MAXPGPATH + 1];
         PGresult   *res;
 
         /* Did the library name change?  Probe it. */
         if (libnum == 0 || strcmp(lib, os_info.libraries[libnum - 1].name) != 0)
         {
             /*
              * In Postgres 9.0, Python 3 support was added, and to do that, a
              * plpython2u language was created with library name plpython2.so
              * as a symbolic link to plpython.so.  In Postgres 9.1, only the
              * plpython2.so library was created, and both plpythonu and
              * plpython2u point to it.  For this reason, any reference to
              * library name "plpython" in an old PG <= 9.1 cluster must look
              * for "plpython2" in the new cluster.
              */
             if (GET_MAJOR_VERSION(old_cluster.major_version) < 901 &&
                 strcmp(lib, "$libdir/plpython") == 0)
             {
                 lib = "$libdir/plpython2";
                 llen = strlen(lib);
             }
 
             strcpy(cmd, "LOAD '");
             PQescapeStringConn(conn, cmd + strlen(cmd), lib, llen, NULL);
             strcat(cmd, "'");
 
             res = PQexec(conn, cmd);
 
             if (PQresultStatus(res) != PGRES_COMMAND_OK)
             {
                 found = true;
                 was_load_failure = true;
 
                 if (script == NULL && (script = fopen_priv(output_path, "w")) == NULL)
                     pg_fatal("could not open file \"%s\": %s\n",
                              output_path, strerror(errno));
                 fprintf(script, _("could not load library \"%s\": %s"),
                         lib,
                         PQerrorMessage(conn));
             }
             else
                 was_load_failure = false;
 
             PQclear(res);
         }
 
         if (was_load_failure)
             fprintf(script, _("In database: %s\n"),
                     old_cluster.dbarr.dbs[os_info.libraries[libnum].dbnum].db_name);
     }
 
     PQfinish(conn);
 
     if (found)
     {
         fclose(script);
         pg_log(PG_REPORT, "fatal\n");
         pg_fatal("Your installation references loadable libraries that are missing from the\n"
                  "new installation.  You can add these libraries to the new installation,\n"
                  "or remove the functions using them from the old installation.  A list of\n"
                  "problem libraries is in the file:\n"
                  "    %s\n\n", output_path);
     }
     else
         check_ok();
 }

◆ check_new_cluster()

void check_new_cluster ( void )

Definition at line 158 of file check.c.

References check_databases_are_compatible(), check_file_clone(), check_for_prepared_transactions(), check_hard_link(), check_is_install_user(), check_loadable_libraries(), check_new_cluster_is_empty(), get_db_and_rel_infos(), new_cluster, UserOpts::transfer_mode, TRANSFER_MODE_CLONE, TRANSFER_MODE_COPY, TRANSFER_MODE_LINK, and user_opts.

Referenced by main().

 {
     get_db_and_rel_infos(&new_cluster);
 
     check_new_cluster_is_empty();
     check_databases_are_compatible();
 
     check_loadable_libraries();
 
     switch (user_opts.transfer_mode)
     {
         case TRANSFER_MODE_CLONE:
             check_file_clone();
             break;
         case TRANSFER_MODE_COPY:
             break;
         case TRANSFER_MODE_LINK:
             check_hard_link();
             break;
     }
 
     check_is_install_user(&new_cluster);
 
     check_for_prepared_transactions(&new_cluster);
 }

◆ check_ok()

void void check_ok ( void )

Definition at line 171 of file util.c.

References PG_REPORT, report_status(), and generate_unaccent_rules::stdout.

 {
     /* all seems well */
     report_status(PG_REPORT, "ok");
     fflush(stdout);
 }

◆ check_pghost_envvar()

void check_pghost_envvar ( void )

Definition at line 354 of file server.c.

References _PQconninfoOption::envvar, _PQconninfoOption::keyword, pg_fatal, PQconndefaults(), PQconninfoFree(), and value.

Referenced by setup().

 {
     PQconninfoOption *option;
     PQconninfoOption *start;
 
     /* Get valid libpq env vars from the PQconndefaults function */
 
     start = PQconndefaults();
 
     if (!start)
         pg_fatal("out of memory\n");
 
     for (option = start; option->keyword != NULL; option++)
     {
         if (option->envvar && (strcmp(option->envvar, "PGHOST") == 0 ||
                                strcmp(option->envvar, "PGHOSTADDR") == 0))
         {
             const char *value = getenv(option->envvar);
 
             if (value && strlen(value) > 0 &&
             /* check for 'local' host values */
                 (strcmp(value, "localhost") != 0 && strcmp(value, "127.0.0.1") != 0 &&
                  strcmp(value, "::1") != 0 && value[0] != '/'))
                 pg_fatal("libpq environment variable %s has a non-local server value: %s\n",
                          option->envvar, value);
         }
     }
 
     /* Free the memory that libpq allocated on our behalf */
     PQconninfoFree(start);
 }

◆ cloneFile()

void cloneFile	(	const char *	src,
		const char *	dst,
		const char *	schemaName,
		const char *	relName
	)

Definition at line 42 of file file.c.

References close, PG_BINARY, pg_fatal, pg_file_create_mode, and strerror.

Referenced by transfer_relfile().

 {
 #if defined(HAVE_COPYFILE) && defined(COPYFILE_CLONE_FORCE)
     if (copyfile(src, dst, NULL, COPYFILE_CLONE_FORCE) < 0)
         pg_fatal("error while cloning relation \"%s.%s\" (\"%s\" to \"%s\"): %s\n",
                  schemaName, relName, src, dst, strerror(errno));
 #elif defined(__linux__) && defined(FICLONE)
     int         src_fd;
     int         dest_fd;
 
     if ((src_fd = open(src, O_RDONLY | PG_BINARY, 0)) < 0)
         pg_fatal("error while cloning relation \"%s.%s\": could not open file \"%s\": %s\n",
                  schemaName, relName, src, strerror(errno));
 
     if ((dest_fd = open(dst, O_RDWR | O_CREAT | O_EXCL | PG_BINARY,
                         pg_file_create_mode)) < 0)
         pg_fatal("error while cloning relation \"%s.%s\": could not create file \"%s\": %s\n",
                  schemaName, relName, dst, strerror(errno));
 
     if (ioctl(dest_fd, FICLONE, src_fd) < 0)
     {
         unlink(dst);
         pg_fatal("error while cloning relation \"%s.%s\" (\"%s\" to \"%s\"): %s\n",
                  schemaName, relName, src, dst, strerror(errno));
     }
 
     close(src_fd);
     close(dest_fd);
 #endif
 }

◆ cluster_conn_opts()

PGresult char* cluster_conn_opts ( ClusterInfo * cluster )

Definition at line 90 of file server.c.

References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendShellString(), buf, createPQExpBuffer(), PQExpBufferData::data, os_info, ClusterInfo::port, resetPQExpBuffer(), ClusterInfo::sockdir, and OSInfo::user.

Referenced by create_new_objects(), generate_old_dump(), prepare_new_cluster(), and prepare_new_globals().

 {
     static PQExpBuffer buf;
 
     if (buf == NULL)
         buf = createPQExpBuffer();
     else
         resetPQExpBuffer(buf);
 
     if (cluster->sockdir)
     {
         appendPQExpBufferStr(buf, "--host ");
         appendShellString(buf, cluster->sockdir);
         appendPQExpBufferChar(buf, ' ');
     }
     appendPQExpBuffer(buf, "--port %d --username ", cluster->port);
     appendShellString(buf, os_info.user);
 
     return buf->data;
 }

◆ connectToServer()

PGconn* connectToServer	(	ClusterInfo *	cluster,
		const char *	db_name
	)

Definition at line 27 of file server.c.

References _, ALWAYS_SECURE_SEARCH_PATH_SQL, conn, CONNECTION_OK, executeQueryOrDie(), get_db_conn(), pg_log(), PG_REPORT, PQclear(), PQerrorMessage(), PQfinish(), PQstatus(), and printf.

Referenced by check_for_data_type_usage(), check_for_isn_and_int8_passing_mismatch(), check_for_jsonb_9_4_usage(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_for_reg_data_type_usage(), check_for_tables_with_oids(), check_is_install_user(), check_loadable_libraries(), check_proper_datallowconn(), get_db_infos(), get_loadable_libraries(), get_rel_infos(), get_tablespace_paths(), new_9_0_populate_pg_largeobject_metadata(), old_9_6_invalidate_hash_indexes(), and set_frozenxids().

 {
     PGconn     *conn = get_db_conn(cluster, db_name);
 
     if (conn == NULL || PQstatus(conn) != CONNECTION_OK)
     {
         pg_log(PG_REPORT, "connection to database failed: %s",
                PQerrorMessage(conn));
 
         if (conn)
             PQfinish(conn);
 
         printf(_("Failure, exiting\n"));
         exit(1);
     }
 
     PQclear(executeQueryOrDie(conn, ALWAYS_SECURE_SEARCH_PATH_SQL));
 
     return conn;
 }

◆ copyFile()

void copyFile	(	const char *	src,
		const char *	dst,
		const char *	schemaName,
		const char *	relName
	)

Definition at line 82 of file file.c.

References _dosmaperr(), close, COPY_BUF_SIZE, PG_BINARY, pg_fatal, pg_file_create_mode, pg_free(), pg_malloc(), read, strerror, and write.

Referenced by transfer_relfile().

 {
 #ifndef WIN32
     int         src_fd;
     int         dest_fd;
     char       *buffer;
 
     if ((src_fd = open(src, O_RDONLY | PG_BINARY, 0)) < 0)
         pg_fatal("error while copying relation \"%s.%s\": could not open file \"%s\": %s\n",
                  schemaName, relName, src, strerror(errno));
 
     if ((dest_fd = open(dst, O_RDWR | O_CREAT | O_EXCL | PG_BINARY,
                         pg_file_create_mode)) < 0)
         pg_fatal("error while copying relation \"%s.%s\": could not create file \"%s\": %s\n",
                  schemaName, relName, dst, strerror(errno));
 
     /* copy in fairly large chunks for best efficiency */
 #define COPY_BUF_SIZE (50 * BLCKSZ)
 
     buffer = (char *) pg_malloc(COPY_BUF_SIZE);
 
     /* perform data copying i.e read src source, write to destination */
     while (true)
     {
         ssize_t     nbytes = read(src_fd, buffer, COPY_BUF_SIZE);
 
         if (nbytes < 0)
             pg_fatal("error while copying relation \"%s.%s\": could not read file \"%s\": %s\n",
                      schemaName, relName, src, strerror(errno));
 
         if (nbytes == 0)
             break;
 
         errno = 0;
         if (write(dest_fd, buffer, nbytes) != nbytes)
         {
             /* if write didn't set errno, assume problem is no disk space */
             if (errno == 0)
                 errno = ENOSPC;
             pg_fatal("error while copying relation \"%s.%s\": could not write file \"%s\": %s\n",
                      schemaName, relName, dst, strerror(errno));
         }
     }
 
     pg_free(buffer);
     close(src_fd);
     close(dest_fd);
 
 #else                           /* WIN32 */
 
     if (CopyFile(src, dst, true) == 0)
     {
         _dosmaperr(GetLastError());
         pg_fatal("error while copying relation \"%s.%s\" (\"%s\" to \"%s\"): %s\n",
                  schemaName, relName, src, dst, strerror(errno));
     }
 
 #endif                          /* WIN32 */
 }

◆ create_script_for_cluster_analyze()

void create_script_for_cluster_analyze ( char ** analyze_script_file_name )

Definition at line 453 of file check.c.

References appendPQExpBufferChar(), appendPQExpBufferStr(), appendShellString(), ClusterInfo::bindir, check_ok(), PQExpBufferData::data, ECHO_BLANK, ECHO_QUOTE, fopen_priv, fprintf, GET_MAJOR_VERSION, initPQExpBuffer(), ClusterInfo::major_version, new_cluster, old_cluster, os_info, pg_fatal, prep_status(), psprintf(), S_IRWXU, SCRIPT_EXT, SCRIPT_PREFIX, strerror, termPQExpBuffer(), OSInfo::user, and OSInfo::user_specified.

Referenced by main().

 {
     FILE       *script = NULL;
     PQExpBufferData user_specification;
 
     prep_status("Creating script to analyze new cluster");
 
     initPQExpBuffer(&user_specification);
     if (os_info.user_specified)
     {
         appendPQExpBufferStr(&user_specification, "-U ");
         appendShellString(&user_specification, os_info.user);
         appendPQExpBufferChar(&user_specification, ' ');
     }
 
     *analyze_script_file_name = psprintf("%sanalyze_new_cluster.%s",
                                          SCRIPT_PREFIX, SCRIPT_EXT);
 
     if ((script = fopen_priv(*analyze_script_file_name, "w")) == NULL)
         pg_fatal("could not open file \"%s\": %s\n",
                  *analyze_script_file_name, strerror(errno));
 
 #ifndef WIN32
     /* add shebang header */
     fprintf(script, "#!/bin/sh\n\n");
 #else
     /* suppress command echoing */
     fprintf(script, "@echo off\n");
 #endif
 
     fprintf(script, "echo %sThis script will generate minimal optimizer statistics rapidly%s\n",
             ECHO_QUOTE, ECHO_QUOTE);
     fprintf(script, "echo %sso your system is usable, and then gather statistics twice more%s\n",
             ECHO_QUOTE, ECHO_QUOTE);
     fprintf(script, "echo %swith increasing accuracy.  When it is done, your system will%s\n",
             ECHO_QUOTE, ECHO_QUOTE);
     fprintf(script, "echo %shave the default level of optimizer statistics.%s\n",
             ECHO_QUOTE, ECHO_QUOTE);
     fprintf(script, "echo%s\n\n", ECHO_BLANK);
 
     fprintf(script, "echo %sIf you have used ALTER TABLE to modify the statistics target for%s\n",
             ECHO_QUOTE, ECHO_QUOTE);
     fprintf(script, "echo %sany tables, you might want to remove them and restore them after%s\n",
             ECHO_QUOTE, ECHO_QUOTE);
     fprintf(script, "echo %srunning this script because they will delay fast statistics generation.%s\n",
             ECHO_QUOTE, ECHO_QUOTE);
     fprintf(script, "echo%s\n\n", ECHO_BLANK);
 
     fprintf(script, "echo %sIf you would like default statistics as quickly as possible, cancel%s\n",
             ECHO_QUOTE, ECHO_QUOTE);
     fprintf(script, "echo %sthis script and run:%s\n",
             ECHO_QUOTE, ECHO_QUOTE);
     fprintf(script, "echo %s    \"%s/vacuumdb\" %s--all %s%s\n", ECHO_QUOTE,
             new_cluster.bindir, user_specification.data,
     /* Did we copy the free space files? */
             (GET_MAJOR_VERSION(old_cluster.major_version) >= 804) ?
             "--analyze-only" : "--analyze", ECHO_QUOTE);
     fprintf(script, "echo%s\n\n", ECHO_BLANK);
 
     fprintf(script, "\"%s/vacuumdb\" %s--all --analyze-in-stages\n",
             new_cluster.bindir, user_specification.data);
     /* Did we copy the free space files? */
     if (GET_MAJOR_VERSION(old_cluster.major_version) < 804)
         fprintf(script, "\"%s/vacuumdb\" %s--all\n", new_cluster.bindir,
                 user_specification.data);
 
     fprintf(script, "echo%s\n\n", ECHO_BLANK);
     fprintf(script, "echo %sDone%s\n",
             ECHO_QUOTE, ECHO_QUOTE);
 
     fclose(script);
 
 #ifndef WIN32
     if (chmod(*analyze_script_file_name, S_IRWXU) != 0)
         pg_fatal("could not add execute permission to file \"%s\": %s\n",
                  *analyze_script_file_name, strerror(errno));
 #endif
 
     termPQExpBuffer(&user_specification);
 
     check_ok();
 }

◆ create_script_for_old_cluster_deletion()

void create_script_for_old_cluster_deletion ( char ** deletion_script_file_name )

Definition at line 543 of file check.c.

References canonicalize_path(), check_ok(), DbInfo::db_oid, ClusterInfo::dbarr, DbInfoArr::dbs, fix_path_separator(), fopen_priv, fprintf, GET_MAJOR_VERSION, ClusterInfo::major_version, MAXPGPATH, DbInfoArr::ndbs, new_cluster, OSInfo::num_old_tablespaces, old_cluster, OSInfo::old_tablespaces, os_info, path_is_prefix_of_path(), PATH_QUOTE, PATH_SEPARATOR, pfree(), pg_fatal, pg_free(), pg_log(), pg_strdup(), PG_WARNING, ClusterInfo::pgdata, prep_status(), psprintf(), RM_CMD, RMDIR_CMD, S_IRWXU, SCRIPT_EXT, SCRIPT_PREFIX, strerror, strlcpy(), and ClusterInfo::tablespace_suffix.

Referenced by main().

 {
     FILE       *script = NULL;
     int         tblnum;
     char        old_cluster_pgdata[MAXPGPATH],
                 new_cluster_pgdata[MAXPGPATH];
 
     *deletion_script_file_name = psprintf("%sdelete_old_cluster.%s",
                                           SCRIPT_PREFIX, SCRIPT_EXT);
 
     strlcpy(old_cluster_pgdata, old_cluster.pgdata, MAXPGPATH);
     canonicalize_path(old_cluster_pgdata);
 
     strlcpy(new_cluster_pgdata, new_cluster.pgdata, MAXPGPATH);
     canonicalize_path(new_cluster_pgdata);
 
     /* Some people put the new data directory inside the old one. */
     if (path_is_prefix_of_path(old_cluster_pgdata, new_cluster_pgdata))
     {
         pg_log(PG_WARNING,
                "\nWARNING:  new data directory should not be inside the old data directory, e.g. %s\n", old_cluster_pgdata);
 
         /* Unlink file in case it is left over from a previous run. */
         unlink(*deletion_script_file_name);
         pg_free(*deletion_script_file_name);
         *deletion_script_file_name = NULL;
         return;
     }
 
     /*
      * Some users (oddly) create tablespaces inside the cluster data
      * directory.  We can't create a proper old cluster delete script in that
      * case.
      */
     for (tblnum = 0; tblnum < os_info.num_old_tablespaces; tblnum++)
     {
         char        old_tablespace_dir[MAXPGPATH];
 
         strlcpy(old_tablespace_dir, os_info.old_tablespaces[tblnum], MAXPGPATH);
         canonicalize_path(old_tablespace_dir);
         if (path_is_prefix_of_path(old_cluster_pgdata, old_tablespace_dir))
         {
             /* reproduce warning from CREATE TABLESPACE that is in the log */
             pg_log(PG_WARNING,
                    "\nWARNING:  user-defined tablespace locations should not be inside the data directory, e.g. %s\n", old_tablespace_dir);
 
             /* Unlink file in case it is left over from a previous run. */
             unlink(*deletion_script_file_name);
             pg_free(*deletion_script_file_name);
             *deletion_script_file_name = NULL;
             return;
         }
     }
 
     prep_status("Creating script to delete old cluster");
 
     if ((script = fopen_priv(*deletion_script_file_name, "w")) == NULL)
         pg_fatal("could not open file \"%s\": %s\n",
                  *deletion_script_file_name, strerror(errno));
 
 #ifndef WIN32
     /* add shebang header */
     fprintf(script, "#!/bin/sh\n\n");
 #endif
 
     /* delete old cluster's default tablespace */
     fprintf(script, RMDIR_CMD " %c%s%c\n", PATH_QUOTE,
             fix_path_separator(old_cluster.pgdata), PATH_QUOTE);
 
     /* delete old cluster's alternate tablespaces */
     for (tblnum = 0; tblnum < os_info.num_old_tablespaces; tblnum++)
     {
         /*
          * Do the old cluster's per-database directories share a directory
          * with a new version-specific tablespace?
          */
         if (strlen(old_cluster.tablespace_suffix) == 0)
         {
             /* delete per-database directories */
             int         dbnum;
 
             fprintf(script, "\n");
             /* remove PG_VERSION? */
             if (GET_MAJOR_VERSION(old_cluster.major_version) <= 804)
                 fprintf(script, RM_CMD " %s%cPG_VERSION\n",
                         fix_path_separator(os_info.old_tablespaces[tblnum]),
                         PATH_SEPARATOR);
 
             for (dbnum = 0; dbnum < old_cluster.dbarr.ndbs; dbnum++)
                 fprintf(script, RMDIR_CMD " %c%s%c%d%c\n", PATH_QUOTE,
                         fix_path_separator(os_info.old_tablespaces[tblnum]),
                         PATH_SEPARATOR, old_cluster.dbarr.dbs[dbnum].db_oid,
                         PATH_QUOTE);
         }
         else
         {
             char       *suffix_path = pg_strdup(old_cluster.tablespace_suffix);
 
             /*
              * Simply delete the tablespace directory, which might be ".old"
              * or a version-specific subdirectory.
              */
             fprintf(script, RMDIR_CMD " %c%s%s%c\n", PATH_QUOTE,
                     fix_path_separator(os_info.old_tablespaces[tblnum]),
                     fix_path_separator(suffix_path), PATH_QUOTE);
             pfree(suffix_path);
         }
     }
 
     fclose(script);
 
 #ifndef WIN32
     if (chmod(*deletion_script_file_name, S_IRWXU) != 0)
         pg_fatal("could not add execute permission to file \"%s\": %s\n",
                  *deletion_script_file_name, strerror(errno));
 #endif
 
     check_ok();
 }

◆ disable_old_cluster()

void disable_old_cluster ( void )

Definition at line 676 of file controldata.c.

References check_ok(), MAXPGPATH, old_cluster, pg_fatal, pg_log(), pg_mv_file, PG_REPORT, ClusterInfo::pgdata, prep_status(), and snprintf.

Referenced by main().

 {
     char        old_path[MAXPGPATH],
                 new_path[MAXPGPATH];
 
     /* rename pg_control so old server cannot be accidentally started */
     prep_status("Adding \".old\" suffix to old global/pg_control");
 
     snprintf(old_path, sizeof(old_path), "%s/global/pg_control", old_cluster.pgdata);
     snprintf(new_path, sizeof(new_path), "%s/global/pg_control.old", old_cluster.pgdata);
     if (pg_mv_file(old_path, new_path) != 0)
         pg_fatal("Unable to rename %s to %s.\n", old_path, new_path);
     check_ok();
 
     pg_log(PG_REPORT, "\n"
            "If you want to start the old cluster, you will need to remove\n"
            "the \".old\" suffix from %s/global/pg_control.old.\n"
            "Because \"link\" mode was used, the old cluster cannot be safely\n"
            "started once the new cluster has been started.\n\n", old_cluster.pgdata);
 }

◆ end_progress_output()

void end_progress_output ( void )

Definition at line 43 of file util.c.

References prep_status().

Referenced by create_new_objects(), generate_old_dump(), and transfer_all_new_tablespaces().

 {
     /*
      * In case nothing printed; pass a space so gcc doesn't complain about
      * empty format string.
      */
     prep_status(" ");
 }

◆ exec_prog()

bool exec_prog	(	const char *	log_file,
		const char *	opt_log_file,
		bool	report_error,
		bool	exit_on_error,
		const char *	fmt,
			...
	)

◆ executeQueryOrDie()

PGresult* executeQueryOrDie	(	PGconn *	conn,
		const char *	fmt,
			...
	)

Referenced by check_for_data_type_usage(), check_for_isn_and_int8_passing_mismatch(), check_for_jsonb_9_4_usage(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_for_reg_data_type_usage(), check_for_tables_with_oids(), check_is_install_user(), check_proper_datallowconn(), get_db_infos(), get_loadable_libraries(), get_rel_infos(), get_tablespace_paths(), new_9_0_populate_pg_largeobject_metadata(), old_9_6_invalidate_hash_indexes(), and set_frozenxids().

◆ gen_db_file_maps()

FileNameMap* gen_db_file_maps	(	DbInfo *	old_db,
		DbInfo *	new_db,
		int *	nmaps,
		const char *	old_pgdata,
		const char *	new_pgdata
	)

Definition at line 39 of file info.c.

References create_rel_filename_map(), DbInfo::db_name, GET_MAJOR_VERSION, ClusterInfo::major_version, maps, RelInfoArr::nrels, RelInfo::nspname, old_cluster, pg_fatal, pg_log(), pg_malloc(), PG_WARNING, DbInfo::rel_arr, RelInfo::relname, RelInfo::reloid, RelInfoArr::rels, and report_unmatched_relation().

Referenced by transfer_all_new_dbs().

 {
     FileNameMap *maps;
     int         old_relnum,
                 new_relnum;
     int         num_maps = 0;
     bool        all_matched = true;
 
     /* There will certainly not be more mappings than there are old rels */
     maps = (FileNameMap *) pg_malloc(sizeof(FileNameMap) *
                                      old_db->rel_arr.nrels);
 
     /*
      * Each of the RelInfo arrays should be sorted by OID.  Scan through them
      * and match them up.  If we fail to match everything, we'll abort, but
      * first print as much info as we can about mismatches.
      */
     old_relnum = new_relnum = 0;
     while (old_relnum < old_db->rel_arr.nrels ||
            new_relnum < new_db->rel_arr.nrels)
     {
         RelInfo    *old_rel = (old_relnum < old_db->rel_arr.nrels) ?
         &old_db->rel_arr.rels[old_relnum] : NULL;
         RelInfo    *new_rel = (new_relnum < new_db->rel_arr.nrels) ?
         &new_db->rel_arr.rels[new_relnum] : NULL;
 
         /* handle running off one array before the other */
         if (!new_rel)
         {
             /*
              * old_rel is unmatched.  This should never happen, because we
              * force new rels to have TOAST tables if the old one did.
              */
             report_unmatched_relation(old_rel, old_db, false);
             all_matched = false;
             old_relnum++;
             continue;
         }
         if (!old_rel)
         {
             /*
              * new_rel is unmatched.  This shouldn't really happen either, but
              * if it's a TOAST table, we can ignore it and continue
              * processing, assuming that the new server made a TOAST table
              * that wasn't needed.
              */
             if (strcmp(new_rel->nspname, "pg_toast") != 0)
             {
                 report_unmatched_relation(new_rel, new_db, true);
                 all_matched = false;
             }
             new_relnum++;
             continue;
         }
 
         /* check for mismatched OID */
         if (old_rel->reloid < new_rel->reloid)
         {
             /* old_rel is unmatched, see comment above */
             report_unmatched_relation(old_rel, old_db, false);
             all_matched = false;
             old_relnum++;
             continue;
         }
         else if (old_rel->reloid > new_rel->reloid)
         {
             /* new_rel is unmatched, see comment above */
             if (strcmp(new_rel->nspname, "pg_toast") != 0)
             {
                 report_unmatched_relation(new_rel, new_db, true);
                 all_matched = false;
             }
             new_relnum++;
             continue;
         }
 
         /*
          * Verify that rels of same OID have same name.  The namespace name
          * should always match, but the relname might not match for TOAST
          * tables (and, therefore, their indexes).
          *
          * TOAST table names initially match the heap pg_class oid, but
          * pre-9.0 they can change during certain commands such as CLUSTER, so
          * don't insist on a match if old cluster is < 9.0.
          */
         if (strcmp(old_rel->nspname, new_rel->nspname) != 0 ||
             (strcmp(old_rel->relname, new_rel->relname) != 0 &&
              (GET_MAJOR_VERSION(old_cluster.major_version) >= 900 ||
               strcmp(old_rel->nspname, "pg_toast") != 0)))
         {
             pg_log(PG_WARNING, "Relation names for OID %u in database \"%s\" do not match: "
                    "old name \"%s.%s\", new name \"%s.%s\"\n",
                    old_rel->reloid, old_db->db_name,
                    old_rel->nspname, old_rel->relname,
                    new_rel->nspname, new_rel->relname);
             all_matched = false;
             old_relnum++;
             new_relnum++;
             continue;
         }
 
         /* OK, create a mapping entry */
         create_rel_filename_map(old_pgdata, new_pgdata, old_db, new_db,
                                 old_rel, new_rel, maps + num_maps);
         num_maps++;
         old_relnum++;
         new_relnum++;
     }
 
     if (!all_matched)
         pg_fatal("Failed to match up old and new tables in database \"%s\"\n",
                  old_db->db_name);
 
     *nmaps = num_maps;
     return maps;
 }

◆ generate_old_dump()

void generate_old_dump ( void )

Definition at line 16 of file dump.c.

References appendConnStrVal(), appendPQExpBufferStr(), appendShellString(), ClusterInfo::bindir, check_ok(), cluster_conn_opts(), connstr, PQExpBufferData::data, DB_DUMP_FILE_MASK, DB_DUMP_LOG_FILE_MASK, DbInfo::db_name, DbInfo::db_oid, ClusterInfo::dbarr, DbInfoArr::dbs, end_progress_output(), exec_prog(), GLOBALS_DUMP_FILE, initPQExpBuffer(), log_opts, MAXPGPATH, DbInfoArr::ndbs, new_cluster, old_cluster, parallel_exec_prog(), pg_log(), PG_STATUS, prep_status(), reap_child(), snprintf, termPQExpBuffer(), UTILITY_LOG_FILE, and LogOpts::verbose.

Referenced by check_and_dump_old_cluster().

 {
     int         dbnum;
 
     prep_status("Creating dump of global objects");
 
     /* run new pg_dumpall binary for globals */
     exec_prog(UTILITY_LOG_FILE, NULL, true, true,
               "\"%s/pg_dumpall\" %s --globals-only --quote-all-identifiers "
               "--binary-upgrade %s -f %s",
               new_cluster.bindir, cluster_conn_opts(&old_cluster),
               log_opts.verbose ? "--verbose" : "",
               GLOBALS_DUMP_FILE);
     check_ok();
 
     prep_status("Creating dump of database schemas\n");
 
     /* create per-db dump files */
     for (dbnum = 0; dbnum < old_cluster.dbarr.ndbs; dbnum++)
     {
         char        sql_file_name[MAXPGPATH],
                     log_file_name[MAXPGPATH];
         DbInfo     *old_db = &old_cluster.dbarr.dbs[dbnum];
         PQExpBufferData connstr,
                     escaped_connstr;
 
         initPQExpBuffer(&connstr);
         appendPQExpBufferStr(&connstr, "dbname=");
         appendConnStrVal(&connstr, old_db->db_name);
         initPQExpBuffer(&escaped_connstr);
         appendShellString(&escaped_connstr, connstr.data);
         termPQExpBuffer(&connstr);
 
         pg_log(PG_STATUS, "%s", old_db->db_name);
         snprintf(sql_file_name, sizeof(sql_file_name), DB_DUMP_FILE_MASK, old_db->db_oid);
         snprintf(log_file_name, sizeof(log_file_name), DB_DUMP_LOG_FILE_MASK, old_db->db_oid);
 
         parallel_exec_prog(log_file_name, NULL,
                            "\"%s/pg_dump\" %s --schema-only --quote-all-identifiers "
                            "--binary-upgrade --format=custom %s --file=\"%s\" %s",
                            new_cluster.bindir, cluster_conn_opts(&old_cluster),
                            log_opts.verbose ? "--verbose" : "",
                            sql_file_name, escaped_connstr.data);
 
         termPQExpBuffer(&escaped_connstr);
     }
 
     /* reap all children */
     while (reap_child(true) == true)
         ;
 
     end_progress_output();
     check_ok();
 }

◆ get_control_data()

void get_control_data	(	ClusterInfo *	cluster,
		bool	live_check
	)

Definition at line 34 of file controldata.c.

References ControlData::align, ClusterInfo::bin_version, ClusterInfo::bindir, ControlData::blocksz, ControlData::cat_ver, ControlData::chkpnt_nxtepoch, ControlData::chkpnt_nxtmulti, ControlData::chkpnt_nxtmxoff, ControlData::chkpnt_nxtoid, ControlData::chkpnt_nxtxid, ControlData::chkpnt_oldstMulti, ClusterInfo::controldata, ControlData::ctrl_ver, ControlData::data_checksum_version, ControlData::date_is_int, ControlData::float8_pass_by_value, GET_MAJOR_VERSION, ControlData::ident, ControlData::index, ControlData::large_object, LARGE_OBJECT_SIZE_PG_CONTROL_VER, ControlData::largesz, lc_collate, lc_ctype, lc_messages, lc_monetary, lc_numeric, lc_time, ClusterInfo::major_version, MAX_STRING, MAXPGPATH, MULTIXACT_FORMATCHANGE_CAT_VER, new_cluster, ControlData::nextxlogfile, old_cluster, output(), pg_fatal, pg_free(), pg_log(), pg_putenv(), PG_REPORT, pg_strdup(), PG_VERBOSE, ClusterInfo::pgdata, snprintf, generate_unaccent_rules::stdout, str2uint(), strerror, strlcpy(), ControlData::toast, ControlData::walseg, and ControlData::walsz.

Referenced by check_cluster_compatibility().

 {
     char        cmd[MAXPGPATH];
     char        bufin[MAX_STRING];
     FILE       *output;
     char       *p;
     bool        got_tli = false;
     bool        got_log_id = false;
     bool        got_log_seg = false;
     bool        got_xid = false;
     bool        got_oid = false;
     bool        got_multi = false;
     bool        got_oldestmulti = false;
     bool        got_mxoff = false;
     bool        got_nextxlogfile = false;
     bool        got_float8_pass_by_value = false;
     bool        got_align = false;
     bool        got_blocksz = false;
     bool        got_largesz = false;
     bool        got_walsz = false;
     bool        got_walseg = false;
     bool        got_ident = false;
     bool        got_index = false;
     bool        got_toast = false;
     bool        got_large_object = false;
     bool        got_date_is_int = false;
     bool        got_data_checksum_version = false;
     bool        got_cluster_state = false;
     char       *lc_collate = NULL;
     char       *lc_ctype = NULL;
     char       *lc_monetary = NULL;
     char       *lc_numeric = NULL;
     char       *lc_time = NULL;
     char       *lang = NULL;
     char       *language = NULL;
     char       *lc_all = NULL;
     char       *lc_messages = NULL;
     uint32      tli = 0;
     uint32      logid = 0;
     uint32      segno = 0;
     char       *resetwal_bin;
 
 
     /*
      * Because we test the pg_resetwal output as strings, it has to be in
      * English.  Copied from pg_regress.c.
      */
     if (getenv("LC_COLLATE"))
         lc_collate = pg_strdup(getenv("LC_COLLATE"));
     if (getenv("LC_CTYPE"))
         lc_ctype = pg_strdup(getenv("LC_CTYPE"));
     if (getenv("LC_MONETARY"))
         lc_monetary = pg_strdup(getenv("LC_MONETARY"));
     if (getenv("LC_NUMERIC"))
         lc_numeric = pg_strdup(getenv("LC_NUMERIC"));
     if (getenv("LC_TIME"))
         lc_time = pg_strdup(getenv("LC_TIME"));
     if (getenv("LANG"))
         lang = pg_strdup(getenv("LANG"));
     if (getenv("LANGUAGE"))
         language = pg_strdup(getenv("LANGUAGE"));
     if (getenv("LC_ALL"))
         lc_all = pg_strdup(getenv("LC_ALL"));
     if (getenv("LC_MESSAGES"))
         lc_messages = pg_strdup(getenv("LC_MESSAGES"));
 
     pg_putenv("LC_COLLATE", NULL);
     pg_putenv("LC_CTYPE", NULL);
     pg_putenv("LC_MONETARY", NULL);
     pg_putenv("LC_NUMERIC", NULL);
     pg_putenv("LC_TIME", NULL);
 #ifndef WIN32
     pg_putenv("LANG", NULL);
 #else
     /* On Windows the default locale may not be English, so force it */
     pg_putenv("LANG", "en");
 #endif
     pg_putenv("LANGUAGE", NULL);
     pg_putenv("LC_ALL", NULL);
     pg_putenv("LC_MESSAGES", "C");
 
     /*
      * Check for clean shutdown
      */
     if (!live_check || cluster == &new_cluster)
     {
         /* only pg_controldata outputs the cluster state */
         snprintf(cmd, sizeof(cmd), "\"%s/pg_controldata\" \"%s\"",
                  cluster->bindir, cluster->pgdata);
         fflush(stdout);
         fflush(stderr);
 
         if ((output = popen(cmd, "r")) == NULL)
             pg_fatal("could not get control data using %s: %s\n",
                      cmd, strerror(errno));
 
         /* we have the result of cmd in "output". so parse it line by line now */
         while (fgets(bufin, sizeof(bufin), output))
         {
             if ((p = strstr(bufin, "Database cluster state:")) != NULL)
             {
                 p = strchr(p, ':');
 
                 if (p == NULL || strlen(p) <= 1)
                     pg_fatal("%d: database cluster state problem\n", __LINE__);
 
                 p++;            /* remove ':' char */
 
                 /*
                  * We checked earlier for a postmaster lock file, and if we
                  * found one, we tried to start/stop the server to replay the
                  * WAL.  However, pg_ctl -m immediate doesn't leave a lock
                  * file, but does require WAL replay, so we check here that
                  * the server was shut down cleanly, from the controldata
                  * perspective.
                  */
                 /* remove leading spaces */
                 while (*p == ' ')
                     p++;
                 if (strcmp(p, "shut down in recovery\n") == 0)
                 {
                     if (cluster == &old_cluster)
                         pg_fatal("The source cluster was shut down while in recovery mode.  To upgrade, use \"rsync\" as documented or shut it down as a primary.\n");
                     else
                         pg_fatal("The target cluster was shut down while in recovery mode.  To upgrade, use \"rsync\" as documented or shut it down as a primary.\n");
                 }
                 else if (strcmp(p, "shut down\n") != 0)
                 {
                     if (cluster == &old_cluster)
                         pg_fatal("The source cluster was not shut down cleanly.\n");
                     else
                         pg_fatal("The target cluster was not shut down cleanly.\n");
                 }
                 got_cluster_state = true;
             }
         }
 
         pclose(output);
 
         if (!got_cluster_state)
         {
             if (cluster == &old_cluster)
                 pg_fatal("The source cluster lacks cluster state information:\n");
             else
                 pg_fatal("The target cluster lacks cluster state information:\n");
         }
     }
 
     /* pg_resetxlog has been renamed to pg_resetwal in version 10 */
     if (GET_MAJOR_VERSION(cluster->bin_version) < 1000)
         resetwal_bin = "pg_resetxlog\" -n";
     else
         resetwal_bin = "pg_resetwal\" -n";
     snprintf(cmd, sizeof(cmd), "\"%s/%s \"%s\"",
              cluster->bindir,
              live_check ? "pg_controldata\"" : resetwal_bin,
              cluster->pgdata);
     fflush(stdout);
     fflush(stderr);
 
     if ((output = popen(cmd, "r")) == NULL)
         pg_fatal("could not get control data using %s: %s\n",
                  cmd, strerror(errno));
 
     /* Only in <= 9.2 */
     if (GET_MAJOR_VERSION(cluster->major_version) <= 902)
     {
         cluster->controldata.data_checksum_version = 0;
         got_data_checksum_version = true;
     }
 
     /* we have the result of cmd in "output". so parse it line by line now */
     while (fgets(bufin, sizeof(bufin), output))
     {
         pg_log(PG_VERBOSE, "%s", bufin);
 
         if ((p = strstr(bufin, "pg_control version number:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: pg_resetwal problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.ctrl_ver = str2uint(p);
         }
         else if ((p = strstr(bufin, "Catalog version number:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.cat_ver = str2uint(p);
         }
         else if ((p = strstr(bufin, "Latest checkpoint's TimeLineID:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             tli = str2uint(p);
             got_tli = true;
         }
         else if ((p = strstr(bufin, "First log file ID after reset:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             logid = str2uint(p);
             got_log_id = true;
         }
         else if ((p = strstr(bufin, "First log file segment after reset:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             segno = str2uint(p);
             got_log_seg = true;
         }
         else if ((p = strstr(bufin, "Latest checkpoint's NextXID:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.chkpnt_nxtepoch = str2uint(p);
 
             /*
              * Delimiter changed from '/' to ':' in 9.6.  We don't test for
              * the catalog version of the change because the catalog version
              * is pulled from pg_controldata too, and it isn't worth adding an
              * order dependency for this --- we just check the string.
              */
             if (strchr(p, '/') != NULL)
                 p = strchr(p, '/');
             else if (GET_MAJOR_VERSION(cluster->major_version) >= 906)
                 p = strchr(p, ':');
             else
                 p = NULL;
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove '/' or ':' char */
             cluster->controldata.chkpnt_nxtxid = str2uint(p);
             got_xid = true;
         }
         else if ((p = strstr(bufin, "Latest checkpoint's NextOID:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.chkpnt_nxtoid = str2uint(p);
             got_oid = true;
         }
         else if ((p = strstr(bufin, "Latest checkpoint's NextMultiXactId:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.chkpnt_nxtmulti = str2uint(p);
             got_multi = true;
         }
         else if ((p = strstr(bufin, "Latest checkpoint's oldestMultiXid:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.chkpnt_oldstMulti = str2uint(p);
             got_oldestmulti = true;
         }
         else if ((p = strstr(bufin, "Latest checkpoint's NextMultiOffset:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.chkpnt_nxtmxoff = str2uint(p);
             got_mxoff = true;
         }
         else if ((p = strstr(bufin, "First log segment after reset:")) != NULL)
         {
             /* Skip the colon and any whitespace after it */
             p = strchr(p, ':');
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
             p = strpbrk(p, "01234567890ABCDEF");
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             /* Make sure it looks like a valid WAL file name */
             if (strspn(p, "0123456789ABCDEF") != 24)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             strlcpy(cluster->controldata.nextxlogfile, p, 25);
             got_nextxlogfile = true;
         }
         else if ((p = strstr(bufin, "Float8 argument passing:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             /* used later for contrib check */
             cluster->controldata.float8_pass_by_value = strstr(p, "by value") != NULL;
             got_float8_pass_by_value = true;
         }
         else if ((p = strstr(bufin, "Maximum data alignment:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.align = str2uint(p);
             got_align = true;
         }
         else if ((p = strstr(bufin, "Database block size:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.blocksz = str2uint(p);
             got_blocksz = true;
         }
         else if ((p = strstr(bufin, "Blocks per segment of large relation:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.largesz = str2uint(p);
             got_largesz = true;
         }
         else if ((p = strstr(bufin, "WAL block size:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.walsz = str2uint(p);
             got_walsz = true;
         }
         else if ((p = strstr(bufin, "Bytes per WAL segment:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.walseg = str2uint(p);
             got_walseg = true;
         }
         else if ((p = strstr(bufin, "Maximum length of identifiers:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.ident = str2uint(p);
             got_ident = true;
         }
         else if ((p = strstr(bufin, "Maximum columns in an index:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.index = str2uint(p);
             got_index = true;
         }
         else if ((p = strstr(bufin, "Maximum size of a TOAST chunk:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.toast = str2uint(p);
             got_toast = true;
         }
         else if ((p = strstr(bufin, "Size of a large-object chunk:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.large_object = str2uint(p);
             got_large_object = true;
         }
         else if ((p = strstr(bufin, "Date/time type storage:")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             cluster->controldata.date_is_int = strstr(p, "64-bit integers") != NULL;
             got_date_is_int = true;
         }
         else if ((p = strstr(bufin, "checksum")) != NULL)
         {
             p = strchr(p, ':');
 
             if (p == NULL || strlen(p) <= 1)
                 pg_fatal("%d: controldata retrieval problem\n", __LINE__);
 
             p++;                /* remove ':' char */
             /* used later for contrib check */
             cluster->controldata.data_checksum_version = str2uint(p);
             got_data_checksum_version = true;
         }
     }
 
     pclose(output);
 
     /*
      * Restore environment variables
      */
     pg_putenv("LC_COLLATE", lc_collate);
     pg_putenv("LC_CTYPE", lc_ctype);
     pg_putenv("LC_MONETARY", lc_monetary);
     pg_putenv("LC_NUMERIC", lc_numeric);
     pg_putenv("LC_TIME", lc_time);
     pg_putenv("LANG", lang);
     pg_putenv("LANGUAGE", language);
     pg_putenv("LC_ALL", lc_all);
     pg_putenv("LC_MESSAGES", lc_messages);
 
     pg_free(lc_collate);
     pg_free(lc_ctype);
     pg_free(lc_monetary);
     pg_free(lc_numeric);
     pg_free(lc_time);
     pg_free(lang);
     pg_free(language);
     pg_free(lc_all);
     pg_free(lc_messages);
 
     /*
      * Before 9.3, pg_resetwal reported the xlogid and segno of the first log
      * file after reset as separate lines. Starting with 9.3, it reports the
      * WAL file name. If the old cluster is older than 9.3, we construct the
      * WAL file name from the xlogid and segno.
      */
     if (GET_MAJOR_VERSION(cluster->major_version) <= 902)
     {
         if (got_tli && got_log_id && got_log_seg)
         {
             snprintf(cluster->controldata.nextxlogfile, 25, "%08X%08X%08X",
                      tli, logid, segno);
             got_nextxlogfile = true;
         }
     }
 
     /* verify that we got all the mandatory pg_control data */
     if (!got_xid || !got_oid ||
         !got_multi ||
         (!got_oldestmulti &&
          cluster->controldata.cat_ver >= MULTIXACT_FORMATCHANGE_CAT_VER) ||
         !got_mxoff || (!live_check && !got_nextxlogfile) ||
         !got_float8_pass_by_value || !got_align || !got_blocksz ||
         !got_largesz || !got_walsz || !got_walseg || !got_ident ||
         !got_index || !got_toast ||
         (!got_large_object &&
          cluster->controldata.ctrl_ver >= LARGE_OBJECT_SIZE_PG_CONTROL_VER) ||
         !got_date_is_int || !got_data_checksum_version)
     {
         if (cluster == &old_cluster)
             pg_log(PG_REPORT,
                    "The source cluster lacks some required control information:\n");
         else
             pg_log(PG_REPORT,
                    "The target cluster lacks some required control information:\n");
 
         if (!got_xid)
             pg_log(PG_REPORT, "  checkpoint next XID\n");
 
         if (!got_oid)
             pg_log(PG_REPORT, "  latest checkpoint next OID\n");
 
         if (!got_multi)
             pg_log(PG_REPORT, "  latest checkpoint next MultiXactId\n");
 
         if (!got_oldestmulti &&
             cluster->controldata.cat_ver >= MULTIXACT_FORMATCHANGE_CAT_VER)
             pg_log(PG_REPORT, "  latest checkpoint oldest MultiXactId\n");
 
         if (!got_mxoff)
             pg_log(PG_REPORT, "  latest checkpoint next MultiXactOffset\n");
 
         if (!live_check && !got_nextxlogfile)
             pg_log(PG_REPORT, "  first WAL segment after reset\n");
 
         if (!got_float8_pass_by_value)
             pg_log(PG_REPORT, "  float8 argument passing method\n");
 
         if (!got_align)
             pg_log(PG_REPORT, "  maximum alignment\n");
 
         if (!got_blocksz)
             pg_log(PG_REPORT, "  block size\n");
 
         if (!got_largesz)
             pg_log(PG_REPORT, "  large relation segment size\n");
 
         if (!got_walsz)
             pg_log(PG_REPORT, "  WAL block size\n");
 
         if (!got_walseg)
             pg_log(PG_REPORT, "  WAL segment size\n");
 
         if (!got_ident)
             pg_log(PG_REPORT, "  maximum identifier length\n");
 
         if (!got_index)
             pg_log(PG_REPORT, "  maximum number of indexed columns\n");
 
         if (!got_toast)
             pg_log(PG_REPORT, "  maximum TOAST chunk size\n");
 
         if (!got_large_object &&
             cluster->controldata.ctrl_ver >= LARGE_OBJECT_SIZE_PG_CONTROL_VER)
             pg_log(PG_REPORT, "  large-object chunk size\n");
 
         if (!got_date_is_int)
             pg_log(PG_REPORT, "  dates/times are integers?\n");
 
         /* value added in Postgres 9.3 */
         if (!got_data_checksum_version)
             pg_log(PG_REPORT, "  data checksum version\n");
 
         pg_fatal("Cannot continue without required control information, terminating\n");
     }
 }

◆ get_db_and_rel_infos()

void get_db_and_rel_infos ( ClusterInfo * cluster )

Definition at line 309 of file info.c.

References ClusterInfo::dbarr, DbInfoArr::dbs, free_db_and_rel_infos(), get_db_infos(), get_rel_infos(), log_opts, DbInfoArr::ndbs, old_cluster, pg_log(), PG_VERBOSE, print_db_infos(), and LogOpts::verbose.

Referenced by check_and_dump_old_cluster(), check_new_cluster(), and create_new_objects().

 {
     int         dbnum;
 
     if (cluster->dbarr.dbs != NULL)
         free_db_and_rel_infos(&cluster->dbarr);
 
     get_db_infos(cluster);
 
     for (dbnum = 0; dbnum < cluster->dbarr.ndbs; dbnum++)
         get_rel_infos(cluster, &cluster->dbarr.dbs[dbnum]);
 
     if (cluster == &old_cluster)
         pg_log(PG_VERBOSE, "\nsource databases:\n");
     else
         pg_log(PG_VERBOSE, "\ntarget databases:\n");
 
     if (log_opts.verbose)
         print_db_infos(&cluster->dbarr);
 }

◆ get_loadable_libraries()

void get_loadable_libraries ( void )

Definition at line 53 of file function.c.

References conn, connectToServer(), DbInfo::db_name, ClusterInfo::dbarr, LibraryInfo::dbnum, DbInfoArr::dbs, executeQueryOrDie(), FirstNormalObjectId, GET_MAJOR_VERSION, OSInfo::libraries, ClusterInfo::major_version, LibraryInfo::name, DbInfoArr::ndbs, OSInfo::num_libraries, old_cluster, os_info, pg_fatal, pg_free(), pg_log(), pg_malloc(), pg_strdup(), PG_WARNING, PQclear(), PQfinish(), PQgetvalue(), and PQntuples().

Referenced by check_and_dump_old_cluster().

 {
     PGresult  **ress;
     int         totaltups;
     int         dbnum;
     bool        found_public_plpython_handler = false;
 
     ress = (PGresult **) pg_malloc(old_cluster.dbarr.ndbs * sizeof(PGresult *));
     totaltups = 0;
 
     /* Fetch all library names, removing duplicates within each DB */
     for (dbnum = 0; dbnum < old_cluster.dbarr.ndbs; dbnum++)
     {
         DbInfo     *active_db = &old_cluster.dbarr.dbs[dbnum];
         PGconn     *conn = connectToServer(&old_cluster, active_db->db_name);
 
         /*
          * Fetch all libraries containing non-built-in C functions in this DB.
          */
         ress[dbnum] = executeQueryOrDie(conn,
                                         "SELECT DISTINCT probin "
                                         "FROM pg_catalog.pg_proc "
                                         "WHERE prolang = %u AND "
                                         "probin IS NOT NULL AND "
                                         "oid >= %u;",
                                         ClanguageId,
                                         FirstNormalObjectId);
         totaltups += PQntuples(ress[dbnum]);
 
         /*
          * Systems that install plpython before 8.1 have
          * plpython_call_handler() defined in the "public" schema, causing
          * pg_dump to dump it.  However that function still references
          * "plpython" (no "2"), so it throws an error on restore.  This code
          * checks for the problem function, reports affected databases to the
          * user and explains how to remove them. 8.1 git commit:
          * e0dedd0559f005d60c69c9772163e69c204bac69
          * http://archives.postgresql.org/pgsql-hackers/2012-03/msg01101.php
          * http://archives.postgresql.org/pgsql-bugs/2012-05/msg00206.php
          */
         if (GET_MAJOR_VERSION(old_cluster.major_version) < 901)
         {
             PGresult   *res;
 
             res = executeQueryOrDie(conn,
                                     "SELECT 1 "
                                     "FROM pg_catalog.pg_proc p "
                                     "    JOIN pg_catalog.pg_namespace n "
                                     "    ON pronamespace = n.oid "
                                     "WHERE proname = 'plpython_call_handler' AND "
                                     "nspname = 'public' AND "
                                     "prolang = %u AND "
                                     "probin = '$libdir/plpython' AND "
                                     "p.oid >= %u;",
                                     ClanguageId,
                                     FirstNormalObjectId);
             if (PQntuples(res) > 0)
             {
                 if (!found_public_plpython_handler)
                 {
                     pg_log(PG_WARNING,
                            "\nThe old cluster has a \"plpython_call_handler\" function defined\n"
                            "in the \"public\" schema which is a duplicate of the one defined\n"
                            "in the \"pg_catalog\" schema.  You can confirm this by executing\n"
                            "in psql:\n"
                            "\n"
                            "    \\df *.plpython_call_handler\n"
                            "\n"
                            "The \"public\" schema version of this function was created by a\n"
                            "pre-8.1 install of plpython, and must be removed for pg_upgrade\n"
                            "to complete because it references a now-obsolete \"plpython\"\n"
                            "shared object file.  You can remove the \"public\" schema version\n"
                            "of this function by running the following command:\n"
                            "\n"
                            "    DROP FUNCTION public.plpython_call_handler()\n"
                            "\n"
                            "in each affected database:\n"
                            "\n");
                 }
                 pg_log(PG_WARNING, "    %s\n", active_db->db_name);
                 found_public_plpython_handler = true;
             }
             PQclear(res);
         }
 
         PQfinish(conn);
     }
 
     if (found_public_plpython_handler)
         pg_fatal("Remove the problem functions from the old cluster to continue.\n");
 
     os_info.libraries = (LibraryInfo *) pg_malloc(totaltups * sizeof(LibraryInfo));
     totaltups = 0;
 
     for (dbnum = 0; dbnum < old_cluster.dbarr.ndbs; dbnum++)
     {
         PGresult   *res = ress[dbnum];
         int         ntups;
         int         rowno;
 
         ntups = PQntuples(res);
         for (rowno = 0; rowno < ntups; rowno++)
         {
             char       *lib = PQgetvalue(res, rowno, 0);
 
             os_info.libraries[totaltups].name = pg_strdup(lib);
             os_info.libraries[totaltups].dbnum = dbnum;
 
             totaltups++;
         }
         PQclear(res);
     }
 
     pg_free(ress);
 
     os_info.num_libraries = totaltups;
 }

◆ get_major_server_version()

uint32 get_major_server_version ( ClusterInfo * cluster )

Definition at line 157 of file server.c.

References ClusterInfo::major_version_str, MAXPGPATH, pg_fatal, ClusterInfo::pgdata, and snprintf.

Referenced by check_data_dir().

 {
     FILE       *version_fd;
     char        ver_filename[MAXPGPATH];
     int         v1 = 0,
                 v2 = 0;
 
     snprintf(ver_filename, sizeof(ver_filename), "%s/PG_VERSION",
              cluster->pgdata);
     if ((version_fd = fopen(ver_filename, "r")) == NULL)
         pg_fatal("could not open version file: %s\n", ver_filename);
 
     if (fscanf(version_fd, "%63s", cluster->major_version_str) == 0 ||
         sscanf(cluster->major_version_str, "%d.%d", &v1, &v2) < 1)
         pg_fatal("could not parse PG_VERSION file from %s\n", cluster->pgdata);
 
     fclose(version_fd);
 
     if (v1 < 10)
     {
         /* old style, e.g. 9.6.1 */
         return v1 * 10000 + v2 * 100;
     }
     else
     {
         /* new style, e.g. 10.1 */
         return v1 * 10000;
     }
 }

◆ get_sock_dir()

void get_sock_dir	(	ClusterInfo *	cluster,
		bool	live_check
	)

Definition at line 468 of file option.c.

References DEF_PGUPORT, filename, GET_MAJOR_VERSION, LOCK_FILE_LINE_PORT, LOCK_FILE_LINE_SOCKET_DIR, ClusterInfo::major_version, Max, MAXPGPATH, old_cluster, pg_fatal, pg_log(), pg_strdup(), pg_strip_crlf(), PG_WARNING, ClusterInfo::pgdata, ClusterInfo::port, snprintf, ClusterInfo::sockdir, UserOpts::socketdir, and strerror.

Referenced by main().

 {
 #ifdef HAVE_UNIX_SOCKETS
 
     /*
      * sockdir and port were added to postmaster.pid in PG 9.1. Pre-9.1 cannot
      * process pg_ctl -w for sockets in non-default locations.
      */
     if (GET_MAJOR_VERSION(cluster->major_version) >= 901)
     {
         if (!live_check)
             cluster->sockdir = user_opts.socketdir;
         else
         {
             /*
              * If we are doing a live check, we will use the old cluster's
              * Unix domain socket directory so we can connect to the live
              * server.
              */
             unsigned short orig_port = cluster->port;
             char        filename[MAXPGPATH],
                         line[MAXPGPATH];
             FILE       *fp;
             int         lineno;
 
             snprintf(filename, sizeof(filename), "%s/postmaster.pid",
                      cluster->pgdata);
             if ((fp = fopen(filename, "r")) == NULL)
                 pg_fatal("could not open file \"%s\": %s\n",
                          filename, strerror(errno));
 
             for (lineno = 1;
                  lineno <= Max(LOCK_FILE_LINE_PORT, LOCK_FILE_LINE_SOCKET_DIR);
                  lineno++)
             {
                 if (fgets(line, sizeof(line), fp) == NULL)
                     pg_fatal("could not read line %d from file \"%s\": %s\n",
                              lineno, filename, strerror(errno));
 
                 /* potentially overwrite user-supplied value */
                 if (lineno == LOCK_FILE_LINE_PORT)
                     sscanf(line, "%hu", &old_cluster.port);
                 if (lineno == LOCK_FILE_LINE_SOCKET_DIR)
                 {
                     /* strip trailing newline and carriage return */
                     cluster->sockdir = pg_strdup(line);
                     (void) pg_strip_crlf(cluster->sockdir);
                 }
             }
             fclose(fp);
 
             /* warn of port number correction */
             if (orig_port != DEF_PGUPORT && old_cluster.port != orig_port)
                 pg_log(PG_WARNING, "user-supplied old port number %hu corrected to %hu\n",
                        orig_port, cluster->port);
         }
     }
     else
 
         /*
          * Can't get sockdir and pg_ctl -w can't use a non-default, use
          * default
          */
         cluster->sockdir = NULL;
 #else                           /* !HAVE_UNIX_SOCKETS */
     cluster->sockdir = NULL;
 #endif
 }

◆ get_user_info()

int get_user_info ( char ** user_name_p )

Definition at line 211 of file util.c.

References get_user_name(), pg_fatal(), and pg_strdup().

Referenced by parseCommandLine().

 {
     int         user_id;
     const char *user_name;
     char       *errstr;
 
 #ifndef WIN32
     user_id = geteuid();
 #else
     user_id = 1;
 #endif
 
     user_name = get_user_name(&errstr);
     if (!user_name)
         pg_fatal("%s\n", errstr);
 
     /* make a copy */
     *user_name_p = pg_strdup(user_name);
 
     return user_id;
 }

◆ init_tablespaces()

void init_tablespaces ( void )

Definition at line 19 of file tablespace.c.

References get_tablespace_paths(), new_cluster, OSInfo::num_old_tablespaces, old_cluster, os_info, pg_fatal, set_tablespace_directory_suffix(), and ClusterInfo::tablespace_suffix.

Referenced by check_and_dump_old_cluster().

 {
     get_tablespace_paths();
 
     set_tablespace_directory_suffix(&old_cluster);
     set_tablespace_directory_suffix(&new_cluster);
 
     if (os_info.num_old_tablespaces > 0 &&
         strcmp(old_cluster.tablespace_suffix, new_cluster.tablespace_suffix) == 0)
         pg_fatal("Cannot upgrade to/from the same system catalog version when\n"
                  "using tablespaces.\n");
 }

◆ issue_warnings_and_set_wal_level()

void issue_warnings_and_set_wal_level ( void )

Definition at line 203 of file check.c.

References GET_MAJOR_VERSION, ClusterInfo::major_version, new_9_0_populate_pg_largeobject_metadata(), new_cluster, old_9_6_invalidate_hash_indexes(), old_cluster, start_postmaster(), and stop_postmaster().

Referenced by main().

 {
     /*
      * We unconditionally start/stop the new server because pg_resetwal -o set
      * wal_level to 'minimum'.  If the user is upgrading standby servers using
      * the rsync instructions, they will need pg_upgrade to write its final
      * WAL record showing wal_level as 'replica'.
      */
     start_postmaster(&new_cluster, true);
 
     /* Create dummy large object permissions for old < PG 9.0? */
     if (GET_MAJOR_VERSION(old_cluster.major_version) <= 804)
         new_9_0_populate_pg_largeobject_metadata(&new_cluster, false);
 
     /* Reindex hash indexes for old < 10.0 */
     if (GET_MAJOR_VERSION(old_cluster.major_version) <= 906)
         old_9_6_invalidate_hash_indexes(&new_cluster, false);
 
     stop_postmaster(false);
 }

◆ linkFile()

void linkFile	(	const char *	src,
		const char *	dst,
		const char *	schemaName,
		const char *	relName
	)

Definition at line 151 of file file.c.

References pg_fatal, pg_link_file, and strerror.

Referenced by transfer_relfile().

 {
     if (pg_link_file(src, dst) < 0)
         pg_fatal("error while creating link for relation \"%s.%s\" (\"%s\" to \"%s\"): %s\n",
                  schemaName, relName, src, dst, strerror(errno));
 }

◆ new_9_0_populate_pg_largeobject_metadata()

void new_9_0_populate_pg_largeobject_metadata	(	ClusterInfo *	cluster,
		bool	check_mode
	)

Definition at line 22 of file version.c.

References appendPsqlMetaConnect(), check_ok(), conn, connectToServer(), PQExpBufferData::data, DbInfo::db_name, ClusterInfo::dbarr, DbInfoArr::dbs, executeQueryOrDie(), fopen_priv, fprintf, initPQExpBuffer(), MAXPGPATH, DbInfoArr::ndbs, pg_fatal, pg_log(), PG_WARNING, PQclear(), PQfinish(), PQfnumber(), PQgetvalue(), prep_status(), report_status(), snprintf, strerror, and termPQExpBuffer().

Referenced by check_and_dump_old_cluster(), and issue_warnings_and_set_wal_level().

 {
     int         dbnum;
     FILE       *script = NULL;
     bool        found = false;
     char        output_path[MAXPGPATH];
 
     prep_status("Checking for large objects");
 
     snprintf(output_path, sizeof(output_path), "pg_largeobject.sql");
 
     for (dbnum = 0; dbnum < cluster->dbarr.ndbs; dbnum++)
     {
         PGresult   *res;
         int         i_count;
         DbInfo     *active_db = &cluster->dbarr.dbs[dbnum];
         PGconn     *conn = connectToServer(cluster, active_db->db_name);
 
         /* find if there are any large objects */
         res = executeQueryOrDie(conn,
                                 "SELECT count(*) "
                                 "FROM   pg_catalog.pg_largeobject ");
 
         i_count = PQfnumber(res, "count");
         if (atoi(PQgetvalue(res, 0, i_count)) != 0)
         {
             found = true;
             if (!check_mode)
             {
                 PQExpBufferData connectbuf;
 
                 if (script == NULL && (script = fopen_priv(output_path, "w")) == NULL)
                     pg_fatal("could not open file \"%s\": %s\n", output_path,
                              strerror(errno));
 
                 initPQExpBuffer(&connectbuf);
                 appendPsqlMetaConnect(&connectbuf, active_db->db_name);
                 fputs(connectbuf.data, script);
                 termPQExpBuffer(&connectbuf);
 
                 fprintf(script,
                         "SELECT pg_catalog.lo_create(t.loid)\n"
                         "FROM (SELECT DISTINCT loid FROM pg_catalog.pg_largeobject) AS t;\n");
             }
         }
 
         PQclear(res);
         PQfinish(conn);
     }
 
     if (script)
         fclose(script);
 
     if (found)
     {
         report_status(PG_WARNING, "warning");
         if (check_mode)
             pg_log(PG_WARNING, "\n"
                    "Your installation contains large objects.  The new database has an\n"
                    "additional large object permission table.  After upgrading, you will be\n"
                    "given a command to populate the pg_largeobject_metadata table with\n"
                    "default permissions.\n\n");
         else
             pg_log(PG_WARNING, "\n"
                    "Your installation contains large objects.  The new database has an\n"
                    "additional large object permission table, so default permissions must be\n"
                    "defined for all large objects.  The file\n"
                    "    %s\n"
                    "when executed by psql by the database superuser will set the default\n"
                    "permissions.\n\n",
                    output_path);
     }
     else
         check_ok();
 }

◆ old_11_check_for_sql_identifier_data_type_usage()

void old_11_check_for_sql_identifier_data_type_usage ( ClusterInfo * cluster )

Definition at line 414 of file version.c.

References check_for_data_type_usage(), check_ok(), MAXPGPATH, pg_fatal, pg_log(), PG_REPORT, prep_status(), and snprintf.

Referenced by check_and_dump_old_cluster().

 {
     char        output_path[MAXPGPATH];
 
     prep_status("Checking for invalid \"sql_identifier\" user columns");
 
     snprintf(output_path, sizeof(output_path), "tables_using_sql_identifier.txt");
 
     if (check_for_data_type_usage(cluster, "information_schema.sql_identifier",
                                   output_path))
     {
         pg_log(PG_REPORT, "fatal\n");
         pg_fatal("Your installation contains the \"sql_identifier\" data type in user tables\n"
                  "and/or indexes.  The on-disk format for this data type has changed, so this\n"
                  "cluster cannot currently be upgraded.  You can remove the problem tables or\n"
                  "change the data type to \"name\" and restart the upgrade.\n"
                  "A list of the problem columns is in the file:\n"
                  "    %s\n\n", output_path);
     }
     else
         check_ok();
 }

◆ old_9_3_check_for_line_data_type_usage()

void old_9_3_check_for_line_data_type_usage ( ClusterInfo * cluster )

Definition at line 235 of file version.c.

References check_for_data_type_usage(), check_ok(), MAXPGPATH, pg_fatal, pg_log(), PG_REPORT, prep_status(), and snprintf.

Referenced by check_and_dump_old_cluster().

 {
     char        output_path[MAXPGPATH];
 
     prep_status("Checking for incompatible \"line\" data type");
 
     snprintf(output_path, sizeof(output_path), "tables_using_line.txt");
 
     if (check_for_data_type_usage(cluster, "pg_catalog.line", output_path))
     {
         pg_log(PG_REPORT, "fatal\n");
         pg_fatal("Your installation contains the \"line\" data type in user tables.  This\n"
                  "data type changed its internal and input/output format between your old\n"
                  "and new clusters so this cluster cannot currently be upgraded.  You can\n"
                  "remove the problem tables and restart the upgrade.  A list of the problem\n"
                  "columns is in the file:\n"
                  "    %s\n\n", output_path);
     }
     else
         check_ok();
 }

◆ old_9_6_check_for_unknown_data_type_usage()

void old_9_6_check_for_unknown_data_type_usage ( ClusterInfo * cluster )

Definition at line 272 of file version.c.

References check_for_data_type_usage(), check_ok(), MAXPGPATH, pg_fatal, pg_log(), PG_REPORT, prep_status(), and snprintf.

Referenced by check_and_dump_old_cluster().

 {
     char        output_path[MAXPGPATH];
 
     prep_status("Checking for invalid \"unknown\" user columns");
 
     snprintf(output_path, sizeof(output_path), "tables_using_unknown.txt");
 
     if (check_for_data_type_usage(cluster, "pg_catalog.unknown", output_path))
     {
         pg_log(PG_REPORT, "fatal\n");
         pg_fatal("Your installation contains the \"unknown\" data type in user tables.  This\n"
                  "data type is no longer allowed in tables, so this cluster cannot currently\n"
                  "be upgraded.  You can remove the problem tables and restart the upgrade.\n"
                  "A list of the problem columns is in the file:\n"
                  "    %s\n\n", output_path);
     }
     else
         check_ok();
 }

◆ old_9_6_invalidate_hash_indexes()

void old_9_6_invalidate_hash_indexes	(	ClusterInfo *	cluster,
		bool	check_mode
	)

Definition at line 299 of file version.c.

References appendPsqlMetaConnect(), check_ok(), conn, connectToServer(), PQExpBufferData::data, DbInfo::db_name, ClusterInfo::dbarr, DbInfoArr::dbs, executeQueryOrDie(), fopen_priv, fprintf, initPQExpBuffer(), DbInfoArr::ndbs, pg_fatal, pg_log(), PG_WARNING, PQclear(), PQfinish(), PQfnumber(), PQgetvalue(), PQntuples(), prep_status(), quote_identifier(), report_status(), strerror, and termPQExpBuffer().

Referenced by check_and_dump_old_cluster(), and issue_warnings_and_set_wal_level().

 {
     int         dbnum;
     FILE       *script = NULL;
     bool        found = false;
     char       *output_path = "reindex_hash.sql";
 
     prep_status("Checking for hash indexes");
 
     for (dbnum = 0; dbnum < cluster->dbarr.ndbs; dbnum++)
     {
         PGresult   *res;
         bool        db_used = false;
         int         ntups;
         int         rowno;
         int         i_nspname,
                     i_relname;
         DbInfo     *active_db = &cluster->dbarr.dbs[dbnum];
         PGconn     *conn = connectToServer(cluster, active_db->db_name);
 
         /* find hash indexes */
         res = executeQueryOrDie(conn,
                                 "SELECT n.nspname, c.relname "
                                 "FROM   pg_catalog.pg_class c, "
                                 "       pg_catalog.pg_index i, "
                                 "       pg_catalog.pg_am a, "
                                 "       pg_catalog.pg_namespace n "
                                 "WHERE  i.indexrelid = c.oid AND "
                                 "       c.relam = a.oid AND "
                                 "       c.relnamespace = n.oid AND "
                                 "       a.amname = 'hash'"
             );
 
         ntups = PQntuples(res);
         i_nspname = PQfnumber(res, "nspname");
         i_relname = PQfnumber(res, "relname");
         for (rowno = 0; rowno < ntups; rowno++)
         {
             found = true;
             if (!check_mode)
             {
                 if (script == NULL && (script = fopen_priv(output_path, "w")) == NULL)
                     pg_fatal("could not open file \"%s\": %s\n", output_path,
                              strerror(errno));
                 if (!db_used)
                 {
                     PQExpBufferData connectbuf;
 
                     initPQExpBuffer(&connectbuf);
                     appendPsqlMetaConnect(&connectbuf, active_db->db_name);
                     fputs(connectbuf.data, script);
                     termPQExpBuffer(&connectbuf);
                     db_used = true;
                 }
                 fprintf(script, "REINDEX INDEX %s.%s;\n",
                         quote_identifier(PQgetvalue(res, rowno, i_nspname)),
                         quote_identifier(PQgetvalue(res, rowno, i_relname)));
             }
         }
 
         PQclear(res);
 
         if (!check_mode && db_used)
         {
             /* mark hash indexes as invalid */
             PQclear(executeQueryOrDie(conn,
                                       "UPDATE pg_catalog.pg_index i "
                                       "SET  indisvalid = false "
                                       "FROM pg_catalog.pg_class c, "
                                       "     pg_catalog.pg_am a, "
                                       "     pg_catalog.pg_namespace n "
                                       "WHERE    i.indexrelid = c.oid AND "
                                       "     c.relam = a.oid AND "
                                       "     c.relnamespace = n.oid AND "
                                       "     a.amname = 'hash'"));
         }
 
         PQfinish(conn);
     }
 
     if (script)
         fclose(script);
 
     if (found)
     {
         report_status(PG_WARNING, "warning");
         if (check_mode)
             pg_log(PG_WARNING, "\n"
                    "Your installation contains hash indexes.  These indexes have different\n"
                    "internal formats between your old and new clusters, so they must be\n"
                    "reindexed with the REINDEX command.  After upgrading, you will be given\n"
                    "REINDEX instructions.\n\n");
         else
             pg_log(PG_WARNING, "\n"
                    "Your installation contains hash indexes.  These indexes have different\n"
                    "internal formats between your old and new clusters, so they must be\n"
                    "reindexed with the REINDEX command.  The file\n"
                    "    %s\n"
                    "when executed by psql by the database superuser will recreate all invalid\n"
                    "indexes; until then, none of these indexes will be used.\n\n",
                    output_path);
     }
     else
         check_ok();
 }

◆ output_check_banner()

void output_check_banner ( bool live_check )

Definition at line 61 of file check.c.

References UserOpts::check, pg_log(), PG_REPORT, and user_opts.

Referenced by main().

 {
     if (user_opts.check && live_check)
     {
         pg_log(PG_REPORT,
                "Performing Consistency Checks on Old Live Server\n"
                "------------------------------------------------\n");
     }
     else
     {
         pg_log(PG_REPORT,
                "Performing Consistency Checks\n"
                "-----------------------------\n");
     }
 }

◆ output_completion_banner()

void output_completion_banner	(	char *	analyze_script_file_name,
		char *	deletion_script_file_name
	)

Definition at line 226 of file check.c.

References GET_MAJOR_VERSION, ClusterInfo::major_version, old_cluster, pg_log(), and PG_REPORT.

Referenced by main().

 {
     /* Did we copy the free space files? */
     if (GET_MAJOR_VERSION(old_cluster.major_version) >= 804)
         pg_log(PG_REPORT,
                "Optimizer statistics are not transferred by pg_upgrade so,\n"
                "once you start the new server, consider running:\n"
                "    %s\n\n", analyze_script_file_name);
     else
         pg_log(PG_REPORT,
                "Optimizer statistics and free space information are not transferred\n"
                "by pg_upgrade so, once you start the new server, consider running:\n"
                "    %s\n\n", analyze_script_file_name);
 
 
     if (deletion_script_file_name)
         pg_log(PG_REPORT,
                "Running this script will delete the old cluster's data files:\n"
                "    %s\n",
                deletion_script_file_name);
     else
         pg_log(PG_REPORT,
                "Could not create a script to delete the old cluster's data files\n"
                "because user-defined tablespaces or the new cluster's data directory\n"
                "exist in the old cluster directory.  The old cluster's contents must\n"
                "be deleted manually.\n");
 }

◆ parallel_exec_prog()

void parallel_exec_prog	(	const char *	log_file,
		const char *	opt_log_file,
		const char *	fmt,
			...
	)

◆ parallel_transfer_all_new_dbs()

void void parallel_transfer_all_new_dbs	(	DbInfoArr *	old_db_arr,
		DbInfoArr *	new_db_arr,
		char *	old_pgdata,
		char *	new_pgdata,
		char *	old_tablespace
	)

Definition at line 175 of file parallel.c.

References generate_unaccent_rules::args, i, UserOpts::jobs, parallel_jobs, pg_fatal, pg_free(), pg_malloc(), pg_malloc0(), pg_strdup(), reap_child(), strerror, transfer_all_new_dbs(), and user_opts.

Referenced by transfer_all_new_tablespaces().

 {
 #ifndef WIN32
     pid_t       child;
 #else
     HANDLE      child;
     transfer_thread_arg *new_arg;
 #endif
 
     if (user_opts.jobs <= 1)
         transfer_all_new_dbs(old_db_arr, new_db_arr, old_pgdata, new_pgdata, NULL);
     else
     {
         /* parallel */
 #ifdef WIN32
         if (thread_handles == NULL)
             thread_handles = pg_malloc(user_opts.jobs * sizeof(HANDLE));
 
         if (transfer_thread_args == NULL)
         {
             int         i;
 
             transfer_thread_args = pg_malloc(user_opts.jobs * sizeof(transfer_thread_arg *));
 
             /*
              * For safety and performance, we keep the args allocated during
              * the entire life of the process, and we don't free the args in a
              * thread different from the one that allocated it.
              */
             for (i = 0; i < user_opts.jobs; i++)
                 transfer_thread_args[i] = pg_malloc0(sizeof(transfer_thread_arg));
         }
 
         cur_thread_args = (void **) transfer_thread_args;
 #endif
         /* harvest any dead children */
         while (reap_child(false) == true)
             ;
 
         /* must we wait for a dead child? */
         if (parallel_jobs >= user_opts.jobs)
             reap_child(true);
 
         /* set this before we start the job */
         parallel_jobs++;
 
         /* Ensure stdio state is quiesced before forking */
         fflush(NULL);
 
 #ifndef WIN32
         child = fork();
         if (child == 0)
         {
             transfer_all_new_dbs(old_db_arr, new_db_arr, old_pgdata, new_pgdata,
                                  old_tablespace);
             /* if we take another exit path, it will be non-zero */
             /* use _exit to skip atexit() functions */
             _exit(0);
         }
         else if (child < 0)
             /* fork failed */
             pg_fatal("could not create worker process: %s\n", strerror(errno));
 #else
         /* empty array element are always at the end */
         new_arg = transfer_thread_args[parallel_jobs - 1];
 
         /* Can only pass one pointer into the function, so use a struct */
         new_arg->old_db_arr = old_db_arr;
         new_arg->new_db_arr = new_db_arr;
         if (new_arg->old_pgdata)
             pg_free(new_arg->old_pgdata);
         new_arg->old_pgdata = pg_strdup(old_pgdata);
         if (new_arg->new_pgdata)
             pg_free(new_arg->new_pgdata);
         new_arg->new_pgdata = pg_strdup(new_pgdata);
         if (new_arg->old_tablespace)
             pg_free(new_arg->old_tablespace);
         new_arg->old_tablespace = old_tablespace ? pg_strdup(old_tablespace) : NULL;
 
         child = (HANDLE) _beginthreadex(NULL, 0, (void *) win32_transfer_all_new_dbs,
                                         new_arg, 0, NULL);
         if (child == 0)
             pg_fatal("could not create worker thread: %s\n", strerror(errno));
 
         thread_handles[parallel_jobs - 1] = child;
 #endif
     }
 }

◆ parseCommandLine()

void parseCommandLine	(	int	argc,
		char *	argv[]
	)

Definition at line 39 of file option.c.

References _, ClusterInfo::bindir, canonicalize_path(), UserOpts::check, check_required_directory(), DEF_PGUPORT, filename, FIX_DEFAULT_READ_ONLY, fopen_priv, fprintf, free, get_progname(), get_user_info(), getopt_long(), LogOpts::internal, INTERNAL_LOG_FILE, UserOpts::jobs, log_opts, MAXPGPATH, new_cluster, no_argument, old_cluster, optarg, optind, os_info, output_files, path_is_prefix_of_path(), pfree(), pg_fatal, pg_free(), pg_log(), pg_putenv(), PG_REPORT, pg_strdup(), ClusterInfo::pgdata, ClusterInfo::pgopts, ClusterInfo::port, OSInfo::progname, psprintf(), required_argument, LogOpts::retain, UserOpts::socketdir, strlcpy(), UserOpts::transfer_mode, TRANSFER_MODE_CLONE, TRANSFER_MODE_COPY, TRANSFER_MODE_LINK, usage(), OSInfo::user, OSInfo::user_specified, and LogOpts::verbose.

Referenced by main().

 {
     static struct option long_options[] = {
         {"old-datadir", required_argument, NULL, 'd'},
         {"new-datadir", required_argument, NULL, 'D'},
         {"old-bindir", required_argument, NULL, 'b'},
         {"new-bindir", required_argument, NULL, 'B'},
         {"old-options", required_argument, NULL, 'o'},
         {"new-options", required_argument, NULL, 'O'},
         {"old-port", required_argument, NULL, 'p'},
         {"new-port", required_argument, NULL, 'P'},
 
         {"username", required_argument, NULL, 'U'},
         {"check", no_argument, NULL, 'c'},
         {"link", no_argument, NULL, 'k'},
         {"retain", no_argument, NULL, 'r'},
         {"jobs", required_argument, NULL, 'j'},
         {"socketdir", required_argument, NULL, 's'},
         {"verbose", no_argument, NULL, 'v'},
         {"clone", no_argument, NULL, 1},
 
         {NULL, 0, NULL, 0}
     };
     int         option;         /* Command line option */
     int         optindex = 0;   /* used by getopt_long */
     int         os_user_effective_id;
     FILE       *fp;
     char      **filename;
     time_t      run_time = time(NULL);
 
     user_opts.transfer_mode = TRANSFER_MODE_COPY;
 
     os_info.progname = get_progname(argv[0]);
 
     /* Process libpq env. variables; load values here for usage() output */
     old_cluster.port = getenv("PGPORTOLD") ? atoi(getenv("PGPORTOLD")) : DEF_PGUPORT;
     new_cluster.port = getenv("PGPORTNEW") ? atoi(getenv("PGPORTNEW")) : DEF_PGUPORT;
 
     os_user_effective_id = get_user_info(&os_info.user);
     /* we override just the database user name;  we got the OS id above */
     if (getenv("PGUSER"))
     {
         pg_free(os_info.user);
         /* must save value, getenv()'s pointer is not stable */
         os_info.user = pg_strdup(getenv("PGUSER"));
     }
 
     if (argc > 1)
     {
         if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
         {
             usage();
             exit(0);
         }
         if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
         {
             puts("pg_upgrade (PostgreSQL) " PG_VERSION);
             exit(0);
         }
     }
 
     /* Allow help and version to be run as root, so do the test here. */
     if (os_user_effective_id == 0)
         pg_fatal("%s: cannot be run as root\n", os_info.progname);
 
     while ((option = getopt_long(argc, argv, "d:D:b:B:cj:ko:O:p:P:rs:U:v",
                                  long_options, &optindex)) != -1)
     {
         switch (option)
         {
             case 'b':
                 old_cluster.bindir = pg_strdup(optarg);
                 break;
 
             case 'B':
                 new_cluster.bindir = pg_strdup(optarg);
                 break;
 
             case 'c':
                 user_opts.check = true;
                 break;
 
             case 'd':
                 old_cluster.pgdata = pg_strdup(optarg);
                 break;
 
             case 'D':
                 new_cluster.pgdata = pg_strdup(optarg);
                 break;
 
             case 'j':
                 user_opts.jobs = atoi(optarg);
                 break;
 
             case 'k':
                 user_opts.transfer_mode = TRANSFER_MODE_LINK;
                 break;
 
             case 'o':
                 /* append option? */
                 if (!old_cluster.pgopts)
                     old_cluster.pgopts = pg_strdup(optarg);
                 else
                 {
                     char       *old_pgopts = old_cluster.pgopts;
 
                     old_cluster.pgopts = psprintf("%s %s", old_pgopts, optarg);
                     free(old_pgopts);
                 }
                 break;
 
             case 'O':
                 /* append option? */
                 if (!new_cluster.pgopts)
                     new_cluster.pgopts = pg_strdup(optarg);
                 else
                 {
                     char       *new_pgopts = new_cluster.pgopts;
 
                     new_cluster.pgopts = psprintf("%s %s", new_pgopts, optarg);
                     free(new_pgopts);
                 }
                 break;
 
                 /*
                  * Someday, the port number option could be removed and passed
                  * using -o/-O, but that requires postmaster -C to be
                  * supported on all old/new versions (added in PG 9.2).
                  */
             case 'p':
                 if ((old_cluster.port = atoi(optarg)) <= 0)
                     pg_fatal("invalid old port number\n");
                 break;
 
             case 'P':
                 if ((new_cluster.port = atoi(optarg)) <= 0)
                     pg_fatal("invalid new port number\n");
                 break;
 
             case 'r':
                 log_opts.retain = true;
                 break;
 
             case 's':
                 user_opts.socketdir = pg_strdup(optarg);
                 break;
 
             case 'U':
                 pg_free(os_info.user);
                 os_info.user = pg_strdup(optarg);
                 os_info.user_specified = true;
 
                 /*
                  * Push the user name into the environment so pre-9.1
                  * pg_ctl/libpq uses it.
                  */
                 pg_putenv("PGUSER", os_info.user);
                 break;
 
             case 'v':
                 log_opts.verbose = true;
                 break;
 
             case 1:
                 user_opts.transfer_mode = TRANSFER_MODE_CLONE;
                 break;
 
             default:
                 fprintf(stderr, _("Try \"%s --help\" for more information.\n"),
                         os_info.progname);
                 exit(1);
         }
     }
 
     if (optind < argc)
         pg_fatal("too many command-line arguments (first is \"%s\")\n", argv[optind]);
 
     if ((log_opts.internal = fopen_priv(INTERNAL_LOG_FILE, "a")) == NULL)
         pg_fatal("could not open log file \"%s\": %m\n", INTERNAL_LOG_FILE);
 
     if (log_opts.verbose)
         pg_log(PG_REPORT, "Running in verbose mode\n");
 
     /* label start of upgrade in logfiles */
     for (filename = output_files; *filename != NULL; filename++)
     {
         if ((fp = fopen_priv(*filename, "a")) == NULL)
             pg_fatal("could not write to log file \"%s\": %m\n", *filename);
 
         /* Start with newline because we might be appending to a file. */
         fprintf(fp, "\n"
                 "-----------------------------------------------------------------\n"
                 "  pg_upgrade run on %s"
                 "-----------------------------------------------------------------\n\n",
                 ctime(&run_time));
         fclose(fp);
     }
 
     /* Turn off read-only mode;  add prefix to PGOPTIONS? */
     if (getenv("PGOPTIONS"))
     {
         char       *pgoptions = psprintf("%s %s", FIX_DEFAULT_READ_ONLY,
                                          getenv("PGOPTIONS"));
 
         pg_putenv("PGOPTIONS", pgoptions);
         pfree(pgoptions);
     }
     else
         pg_putenv("PGOPTIONS", FIX_DEFAULT_READ_ONLY);
 
     /* Get values from env if not already set */
     check_required_directory(&old_cluster.bindir, "PGBINOLD", false,
                              "-b", _("old cluster binaries reside"), false);
     check_required_directory(&new_cluster.bindir, "PGBINNEW", false,
                              "-B", _("new cluster binaries reside"), true);
     check_required_directory(&old_cluster.pgdata, "PGDATAOLD", false,
                              "-d", _("old cluster data resides"), false);
     check_required_directory(&new_cluster.pgdata, "PGDATANEW", false,
                              "-D", _("new cluster data resides"), false);
     check_required_directory(&user_opts.socketdir, "PGSOCKETDIR", true,
                              "-s", _("sockets will be created"), false);
 
 #ifdef WIN32
 
     /*
      * On Windows, initdb --sync-only will fail with a "Permission denied"
      * error on file pg_upgrade_utility.log if pg_upgrade is run inside the
      * new cluster directory, so we do a check here.
      */
     {
         char        cwd[MAXPGPATH],
                     new_cluster_pgdata[MAXPGPATH];
 
         strlcpy(new_cluster_pgdata, new_cluster.pgdata, MAXPGPATH);
         canonicalize_path(new_cluster_pgdata);
 
         if (!getcwd(cwd, MAXPGPATH))
             pg_fatal("could not determine current directory\n");
         canonicalize_path(cwd);
         if (path_is_prefix_of_path(new_cluster_pgdata, cwd))
             pg_fatal("cannot run pg_upgrade from inside the new cluster data directory on Windows\n");
     }
 #endif
 }

◆ pg_attribute_noreturn()

void void void pg_attribute_noreturn ( )

◆ pg_fatal()

void void void pg_fatal	(	const char *	fmt,
			...
	)

◆ pg_log()

void void pg_log	(	eLogType	type,
		const char *	fmt,
			...
	)

Referenced by check_for_isn_and_int8_passing_mismatch(), check_for_jsonb_9_4_usage(), check_for_reg_data_type_usage(), check_for_tables_with_oids(), check_loadable_libraries(), connectToServer(), create_new_objects(), create_script_for_old_cluster_deletion(), disable_old_cluster(), exec_prog(), executeQueryOrDie(), gen_db_file_maps(), generate_old_dump(), get_control_data(), get_db_and_rel_infos(), get_loadable_libraries(), get_sock_dir(), main(), new_9_0_populate_pg_largeobject_metadata(), old_11_check_for_sql_identifier_data_type_usage(), old_9_3_check_for_line_data_type_usage(), old_9_6_check_for_unknown_data_type_usage(), old_9_6_invalidate_hash_indexes(), output_check_banner(), output_completion_banner(), parseCommandLine(), print_db_infos(), print_maps(), print_rel_infos(), report_clusters_compatible(), report_unmatched_relation(), start_postmaster(), transfer_all_new_tablespaces(), and transfer_relfile().

◆ pg_putenv()

void pg_putenv	(	const char *	var,
		const char *	val
	)

Definition at line 253 of file util.c.

References psprintf(), putenv, and unsetenv.

Referenced by get_control_data(), and parseCommandLine().

 {
     if (val)
     {
 #ifndef WIN32
         char       *envstr;
 
         envstr = psprintf("%s=%s", var, val);
         putenv(envstr);
 
         /*
          * Do not free envstr because it becomes part of the environment on
          * some operating systems.  See port/unsetenv.c::unsetenv.
          */
 #else
         SetEnvironmentVariableA(var, val);
 #endif
     }
     else
     {
 #ifndef WIN32
         unsetenv(var);
 #else
         SetEnvironmentVariableA(var, "");
 #endif
     }
 }

◆ pid_lock_file_exists()

bool pid_lock_file_exists ( const char * datadir )

Definition at line 219 of file exec.c.

References close, fd(), MAXPGPATH, pg_fatal, snprintf, and strerror.

Referenced by setup().

 {
     char        path[MAXPGPATH];
     int         fd;
 
     snprintf(path, sizeof(path), "%s/postmaster.pid", datadir);
 
     if ((fd = open(path, O_RDONLY, 0)) < 0)
     {
         /* ENOTDIR means we will throw a more useful error later */
         if (errno != ENOENT && errno != ENOTDIR)
             pg_fatal("could not open file \"%s\" for reading: %s\n",
                      path, strerror(errno));
 
         return false;
     }
 
     close(fd);
     return true;
 }

◆ prep_status()

void prep_status	(	const char *	fmt,
			...
	)

Referenced by adjust_data_dir(), check_cluster_versions(), check_for_isn_and_int8_passing_mismatch(), check_for_jsonb_9_4_usage(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_for_reg_data_type_usage(), check_for_tables_with_oids(), check_is_install_user(), check_loadable_libraries(), check_proper_datallowconn(), copy_subdir_files(), copy_xact_xlog_xid(), create_new_objects(), create_script_for_cluster_analyze(), create_script_for_old_cluster_deletion(), disable_old_cluster(), generate_old_dump(), main(), new_9_0_populate_pg_largeobject_metadata(), old_11_check_for_sql_identifier_data_type_usage(), old_9_3_check_for_line_data_type_usage(), old_9_6_check_for_unknown_data_type_usage(), old_9_6_invalidate_hash_indexes(), prepare_new_cluster(), prepare_new_globals(), remove_new_subdir(), and set_frozenxids().

◆ print_maps()

void print_maps	(	FileNameMap *	maps,
		int	n,
		const char *	db_name
	)

Definition at line 283 of file info.c.

References log_opts, pg_log(), PG_VERBOSE, relname, and LogOpts::verbose.

Referenced by transfer_all_new_dbs().

 {
     if (log_opts.verbose)
     {
         int         mapnum;
 
         pg_log(PG_VERBOSE, "mappings for database \"%s\":\n", db_name);
 
         for (mapnum = 0; mapnum < n_maps; mapnum++)
             pg_log(PG_VERBOSE, "%s.%s: %u to %u\n",
                    maps[mapnum].nspname, maps[mapnum].relname,
                    maps[mapnum].old_relfilenode,
                    maps[mapnum].new_relfilenode);
 
         pg_log(PG_VERBOSE, "\n\n");
     }
 }

◆ quote_identifier()

char* quote_identifier ( const char * s )

Definition at line 10696 of file ruleutils.c.

 {
     /*
      * Can avoid quoting if ident starts with a lowercase letter or underscore
      * and contains only lowercase letters, digits, and underscores, *and* is
      * not any SQL keyword.  Otherwise, supply quotes.
      */
     int         nquotes = 0;
     bool        safe;
     const char *ptr;
     char       *result;
     char       *optr;
 
     /*
      * would like to use <ctype.h> macros here, but they might yield unwanted
      * locale-specific results...
      */
     safe = ((ident[0] >= 'a' && ident[0] <= 'z') || ident[0] == '_');
 
     for (ptr = ident; *ptr; ptr++)
     {
         char        ch = *ptr;
 
         if ((ch >= 'a' && ch <= 'z') ||
             (ch >= '0' && ch <= '9') ||
             (ch == '_'))
         {
             /* okay */
         }
         else
         {
             safe = false;
             if (ch == '"')
                 nquotes++;
         }
     }
 
     if (quote_all_identifiers)
         safe = false;
 
     if (safe)
     {
         /*
          * Check for keyword.  We quote keywords except for unreserved ones.
          * (In some cases we could avoid quoting a col_name or type_func_name
          * keyword, but it seems much harder than it's worth to tell that.)
          *
          * Note: ScanKeywordLookup() does case-insensitive comparison, but
          * that's fine, since we already know we have all-lower-case.
          */
         int         kwnum = ScanKeywordLookup(ident, &ScanKeywords);
 
         if (kwnum >= 0 && ScanKeywordCategories[kwnum] != UNRESERVED_KEYWORD)
             safe = false;
     }
 
     if (safe)
         return ident;           /* no change needed */
 
     result = (char *) palloc(strlen(ident) + nquotes + 2 + 1);
 
     optr = result;
     *optr++ = '"';
     for (ptr = ident; *ptr; ptr++)
     {
         char        ch = *ptr;
 
         if (ch == '"')
             *optr++ = '"';
         *optr++ = ch;
     }
     *optr++ = '"';
     *optr = '\0';
 
     return result;
 }

◆ reap_child()

bool reap_child ( bool wait_for_child )

Definition at line 284 of file parallel.c.

References UserOpts::jobs, parallel_jobs, pg_fatal, strerror, and user_opts.

Referenced by create_new_objects(), generate_old_dump(), parallel_exec_prog(), parallel_transfer_all_new_dbs(), and transfer_all_new_tablespaces().

 {
 #ifndef WIN32
     int         work_status;
     pid_t       child;
 #else
     int         thread_num;
     DWORD       res;
 #endif
 
     if (user_opts.jobs <= 1 || parallel_jobs == 0)
         return false;
 
 #ifndef WIN32
     child = waitpid(-1, &work_status, wait_for_child ? 0 : WNOHANG);
     if (child == (pid_t) -1)
         pg_fatal("waitpid() failed: %s\n", strerror(errno));
     if (child == 0)
         return false;           /* no children, or no dead children */
     if (work_status != 0)
         pg_fatal("child process exited abnormally: status %d\n", work_status);
 #else
     /* wait for one to finish */
     thread_num = WaitForMultipleObjects(parallel_jobs, thread_handles,
                                         false, wait_for_child ? INFINITE : 0);
 
     if (thread_num == WAIT_TIMEOUT || thread_num == WAIT_FAILED)
         return false;
 
     /* compute thread index in active_threads */
     thread_num -= WAIT_OBJECT_0;
 
     /* get the result */
     GetExitCodeThread(thread_handles[thread_num], &res);
     if (res != 0)
         pg_fatal("child worker exited abnormally: %s\n", strerror(errno));
 
     /* dispose of handle to stop leaks */
     CloseHandle(thread_handles[thread_num]);
 
     /* Move last slot into dead child's position */
     if (thread_num != parallel_jobs - 1)
     {
         void       *tmp_args;
 
         thread_handles[thread_num] = thread_handles[parallel_jobs - 1];
 
         /*
          * Move last active thread arg struct into the now-dead slot, and the
          * now-dead slot to the end for reuse by the next thread. Though the
          * thread struct is in use by another thread, we can safely swap the
          * struct pointers within the array.
          */
         tmp_args = cur_thread_args[thread_num];
         cur_thread_args[thread_num] = cur_thread_args[parallel_jobs - 1];
         cur_thread_args[parallel_jobs - 1] = tmp_args;
     }
 #endif
 
     /* do this after job has been removed */
     parallel_jobs--;
 
     return true;
 }

◆ report_clusters_compatible()

void report_clusters_compatible ( void )

Definition at line 186 of file check.c.

References UserOpts::check, pg_log(), PG_REPORT, stop_postmaster(), and user_opts.

Referenced by main().

 {
     if (user_opts.check)
     {
         pg_log(PG_REPORT, "\n*Clusters are compatible*\n");
         /* stops new cluster */
         stop_postmaster(false);
         exit(0);
     }
 
     pg_log(PG_REPORT, "\n"
            "If pg_upgrade fails after this point, you must re-initdb the\n"
            "new cluster before continuing.\n");
 }

◆ report_status()

void report_status	(	eLogType	type,
		const char *	fmt,
			...
	)

Referenced by check_bin_dir(), check_single_dir(), exec_prog(), get_tablespace_paths(), new_9_0_populate_pg_largeobject_metadata(), and old_9_6_invalidate_hash_indexes().

◆ rewriteVisibilityMap()

void rewriteVisibilityMap	(	const char *	fromfile,
		const char *	tofile,
		const char *	schemaName,
		const char *	relName
	)

Definition at line 177 of file file.c.

References BITS_PER_BYTE, BITS_PER_HEAPBLOCK, byte, close, ClusterInfo::controldata, PGAlignedBlock::data, ControlData::data_checksum_version, i, new_cluster, PG_BINARY, pg_checksum_page(), pg_fatal, pg_file_create_mode, read, SizeOfPageHeaderData, stat, strerror, VISIBILITYMAP_ALL_VISIBLE, and write.

Referenced by transfer_relfile().

 {
     int         src_fd;
     int         dst_fd;
     PGAlignedBlock buffer;
     PGAlignedBlock new_vmbuf;
     ssize_t     totalBytesRead = 0;
     ssize_t     src_filesize;
     int         rewriteVmBytesPerPage;
     BlockNumber new_blkno = 0;
     struct stat statbuf;
 
     /* Compute number of old-format bytes per new page */
     rewriteVmBytesPerPage = (BLCKSZ - SizeOfPageHeaderData) / 2;
 
     if ((src_fd = open(fromfile, O_RDONLY | PG_BINARY, 0)) < 0)
         pg_fatal("error while copying relation \"%s.%s\": could not open file \"%s\": %s\n",
                  schemaName, relName, fromfile, strerror(errno));
 
     if (fstat(src_fd, &statbuf) != 0)
         pg_fatal("error while copying relation \"%s.%s\": could not stat file \"%s\": %s\n",
                  schemaName, relName, fromfile, strerror(errno));
 
     if ((dst_fd = open(tofile, O_RDWR | O_CREAT | O_EXCL | PG_BINARY,
                        pg_file_create_mode)) < 0)
         pg_fatal("error while copying relation \"%s.%s\": could not create file \"%s\": %s\n",
                  schemaName, relName, tofile, strerror(errno));
 
     /* Save old file size */
     src_filesize = statbuf.st_size;
 
     /*
      * Turn each visibility map page into 2 pages one by one. Each new page
      * has the same page header as the old one.  If the last section of the
      * last page is empty, we skip it, mostly to avoid turning one-page
      * visibility maps for small relations into two pages needlessly.
      */
     while (totalBytesRead < src_filesize)
     {
         ssize_t     bytesRead;
         char       *old_cur;
         char       *old_break;
         char       *old_blkend;
         PageHeaderData pageheader;
         bool        old_lastblk;
 
         if ((bytesRead = read(src_fd, buffer.data, BLCKSZ)) != BLCKSZ)
         {
             if (bytesRead < 0)
                 pg_fatal("error while copying relation \"%s.%s\": could not read file \"%s\": %s\n",
                          schemaName, relName, fromfile, strerror(errno));
             else
                 pg_fatal("error while copying relation \"%s.%s\": partial page found in file \"%s\"\n",
                          schemaName, relName, fromfile);
         }
 
         totalBytesRead += BLCKSZ;
         old_lastblk = (totalBytesRead == src_filesize);
 
         /* Save the page header data */
         memcpy(&pageheader, buffer.data, SizeOfPageHeaderData);
 
         /*
          * These old_* variables point to old visibility map page. old_cur
          * points to current position on old page. old_blkend points to end of
          * old block.  old_break is the end+1 position on the old page for the
          * data that will be transferred to the current new page.
          */
         old_cur = buffer.data + SizeOfPageHeaderData;
         old_blkend = buffer.data + bytesRead;
         old_break = old_cur + rewriteVmBytesPerPage;
 
         while (old_break <= old_blkend)
         {
             char       *new_cur;
             bool        empty = true;
             bool        old_lastpart;
 
             /* First, copy old page header to new page */
             memcpy(new_vmbuf.data, &pageheader, SizeOfPageHeaderData);
 
             /* Rewriting the last part of the last old page? */
             old_lastpart = old_lastblk && (old_break == old_blkend);
 
             new_cur = new_vmbuf.data + SizeOfPageHeaderData;
 
             /* Process old page bytes one by one, and turn it into new page. */
             while (old_cur < old_break)
             {
                 uint8       byte = *(uint8 *) old_cur;
                 uint16      new_vmbits = 0;
                 int         i;
 
                 /* Generate new format bits while keeping old information */
                 for (i = 0; i < BITS_PER_BYTE; i++)
                 {
                     if (byte & (1 << i))
                     {
                         empty = false;
                         new_vmbits |=
                             VISIBILITYMAP_ALL_VISIBLE << (BITS_PER_HEAPBLOCK * i);
                     }
                 }
 
                 /* Copy new visibility map bytes to new-format page */
                 new_cur[0] = (char) (new_vmbits & 0xFF);
                 new_cur[1] = (char) (new_vmbits >> 8);
 
                 old_cur++;
                 new_cur += BITS_PER_HEAPBLOCK;
             }
 
             /* If the last part of the last page is empty, skip writing it */
             if (old_lastpart && empty)
                 break;
 
             /* Set new checksum for visibility map page, if enabled */
             if (new_cluster.controldata.data_checksum_version != 0)
                 ((PageHeader) new_vmbuf.data)->pd_checksum =
                     pg_checksum_page(new_vmbuf.data, new_blkno);
 
             errno = 0;
             if (write(dst_fd, new_vmbuf.data, BLCKSZ) != BLCKSZ)
             {
                 /* if write didn't set errno, assume problem is no disk space */
                 if (errno == 0)
                     errno = ENOSPC;
                 pg_fatal("error while copying relation \"%s.%s\": could not write file \"%s\": %s\n",
                          schemaName, relName, tofile, strerror(errno));
             }
 
             /* Advance for next new page */
             old_break += rewriteVmBytesPerPage;
             new_blkno++;
         }
     }
 
     /* Clean up */
     close(dst_fd);
     close(src_fd);
 }

◆ start_postmaster()

bool start_postmaster	(	ClusterInfo *	cluster,
		bool	report_and_exit_on_error
	)

Definition at line 196 of file server.c.

References BINARY_UPGRADE_SERVER_FLAG_CAT_VER, ClusterInfo::bindir, ControlData::cat_ver, cluster(), conn, CONNECTION_OK, ClusterInfo::controldata, exec_prog(), get_db_conn(), GET_MAJOR_VERSION, ClusterInfo::major_version, MAXPGPATH, new_cluster, old_cluster, os_info, pg_fatal, pg_log(), PG_REPORT, ClusterInfo::pgconfig, ClusterInfo::pgopts, ClusterInfo::port, PQerrorMessage(), PQfinish(), PQstatus(), OSInfo::running_cluster, SERVER_LOG_FILE, SERVER_START_LOG_FILE, snprintf, ClusterInfo::sockdir, and stop_postmaster_atexit().

 {
     char        cmd[MAXPGPATH * 4 + 1000];
     PGconn     *conn;
     bool        pg_ctl_return = false;
     char        socket_string[MAXPGPATH + 200];
 
     static bool exit_hook_registered = false;
 
     if (!exit_hook_registered)
     {
         atexit(stop_postmaster_atexit);
         exit_hook_registered = true;
     }
 
     socket_string[0] = '\0';
 
 #ifdef HAVE_UNIX_SOCKETS
     /* prevent TCP/IP connections, restrict socket access */
     strcat(socket_string,
            " -c listen_addresses='' -c unix_socket_permissions=0700");
 
     /* Have a sockdir?  Tell the postmaster. */
     if (cluster->sockdir)
         snprintf(socket_string + strlen(socket_string),
                  sizeof(socket_string) - strlen(socket_string),
                  " -c %s='%s'",
                  (GET_MAJOR_VERSION(cluster->major_version) < 903) ?
                  "unix_socket_directory" : "unix_socket_directories",
                  cluster->sockdir);
 #endif
 
     /*
      * Since PG 9.1, we have used -b to disable autovacuum.  For earlier
      * releases, setting autovacuum=off disables cleanup vacuum and analyze,
      * but freeze vacuums can still happen, so we set
      * autovacuum_freeze_max_age to its maximum.
      * (autovacuum_multixact_freeze_max_age was introduced after 9.1, so there
      * is no need to set that.)  We assume all datfrozenxid and relfrozenxid
      * values are less than a gap of 2000000000 from the current xid counter,
      * so autovacuum will not touch them.
      *
      * Turn off durability requirements to improve object creation speed, and
      * we only modify the new cluster, so only use it there.  If there is a
      * crash, the new cluster has to be recreated anyway.  fsync=off is a big
      * win on ext4.
      */
     snprintf(cmd, sizeof(cmd),
              "\"%s/pg_ctl\" -w -l \"%s\" -D \"%s\" -o \"-p %d%s%s %s%s\" start",
              cluster->bindir, SERVER_LOG_FILE, cluster->pgconfig, cluster->port,
              (cluster->controldata.cat_ver >=
               BINARY_UPGRADE_SERVER_FLAG_CAT_VER) ? " -b" :
              " -c autovacuum=off -c autovacuum_freeze_max_age=2000000000",
              (cluster == &new_cluster) ?
              " -c synchronous_commit=off -c fsync=off -c full_page_writes=off" : "",
              cluster->pgopts ? cluster->pgopts : "", socket_string);
 
     /*
      * Don't throw an error right away, let connecting throw the error because
      * it might supply a reason for the failure.
      */
     pg_ctl_return = exec_prog(SERVER_START_LOG_FILE,
     /* pass both file names if they differ */
                               (strcmp(SERVER_LOG_FILE,
                                       SERVER_START_LOG_FILE) != 0) ?
                               SERVER_LOG_FILE : NULL,
                               report_and_exit_on_error, false,
                               "%s", cmd);
 
     /* Did it fail and we are just testing if the server could be started? */
     if (!pg_ctl_return && !report_and_exit_on_error)
         return false;
 
     /*
      * We set this here to make sure atexit() shuts down the server, but only
      * if we started the server successfully.  We do it before checking for
      * connectivity in case the server started but there is a connectivity
      * failure.  If pg_ctl did not return success, we will exit below.
      *
      * Pre-9.1 servers do not have PQping(), so we could be leaving the server
      * running if authentication was misconfigured, so someday we might went
      * to be more aggressive about doing server shutdowns even if pg_ctl
      * fails, but now (2013-08-14) it seems prudent to be cautious.  We don't
      * want to shutdown a server that might have been accidentally started
      * during the upgrade.
      */
     if (pg_ctl_return)
         os_info.running_cluster = cluster;
 
     /*
      * pg_ctl -w might have failed because the server couldn't be started, or
      * there might have been a connection problem in _checking_ if the server
      * has started.  Therefore, even if pg_ctl failed, we continue and test
      * for connectivity in case we get a connection reason for the failure.
      */
     if ((conn = get_db_conn(cluster, "template1")) == NULL ||
         PQstatus(conn) != CONNECTION_OK)
     {
         pg_log(PG_REPORT, "\nconnection to database failed: %s",
                PQerrorMessage(conn));
         if (conn)
             PQfinish(conn);
         if (cluster == &old_cluster)
             pg_fatal("could not connect to source postmaster started with the command:\n"
                      "%s\n",
                      cmd);
         else
             pg_fatal("could not connect to target postmaster started with the command:\n"
                      "%s\n",
                      cmd);
     }
     PQfinish(conn);
 
     /*
      * If pg_ctl failed, and the connection didn't fail, and
      * report_and_exit_on_error is enabled, fail now.  This could happen if
      * the server was already running.
      */
     if (!pg_ctl_return)
     {
         if (cluster == &old_cluster)
             pg_fatal("pg_ctl failed to start the source server, or connection failed\n");
         else
             pg_fatal("pg_ctl failed to start the target server, or connection failed\n");
     }
 
     return true;
 }

◆ stop_postmaster()

void stop_postmaster ( bool in_atexit )

Definition at line 327 of file server.c.

References ClusterInfo::bindir, cluster(), exec_prog(), new_cluster, old_cluster, os_info, ClusterInfo::pgconfig, ClusterInfo::pgopts, OSInfo::running_cluster, and SERVER_STOP_LOG_FILE.

Referenced by check_and_dump_old_cluster(), issue_warnings_and_set_wal_level(), main(), report_clusters_compatible(), setup(), and stop_postmaster_atexit().

 {
     ClusterInfo *cluster;
 
     if (os_info.running_cluster == &old_cluster)
         cluster = &old_cluster;
     else if (os_info.running_cluster == &new_cluster)
         cluster = &new_cluster;
     else
         return;                 /* no cluster running */
 
     exec_prog(SERVER_STOP_LOG_FILE, NULL, !in_atexit, !in_atexit,
               "\"%s/pg_ctl\" -w -D \"%s\" -o \"%s\" %s stop",
               cluster->bindir, cluster->pgconfig,
               cluster->pgopts ? cluster->pgopts : "",
               in_atexit ? "-m fast" : "-m smart");
 
     os_info.running_cluster = NULL;
 }

◆ str2uint()

unsigned int str2uint ( const char * str )

Definition at line 240 of file util.c.

Referenced by get_control_data().

 {
     return strtoul(str, NULL, 10);
 }

◆ transfer_all_new_dbs()

void transfer_all_new_dbs	(	DbInfoArr *	old_db_arr,
		DbInfoArr *	new_db_arr,
		char *	old_pgdata,
		char *	new_pgdata,
		char *	old_tablespace
	)

Definition at line 86 of file relfilenode.c.

References DbInfo::db_name, DbInfoArr::dbs, gen_db_file_maps(), DbInfoArr::ndbs, pg_fatal, pg_free(), print_maps(), and transfer_single_new_db().

Referenced by parallel_transfer_all_new_dbs().

 {
     int         old_dbnum,
                 new_dbnum;
 
     /* Scan the old cluster databases and transfer their files */
     for (old_dbnum = new_dbnum = 0;
          old_dbnum < old_db_arr->ndbs;
          old_dbnum++, new_dbnum++)
     {
         DbInfo     *old_db = &old_db_arr->dbs[old_dbnum],
                    *new_db = NULL;
         FileNameMap *mappings;
         int         n_maps;
 
         /*
          * Advance past any databases that exist in the new cluster but not in
          * the old, e.g. "postgres".  (The user might have removed the
          * 'postgres' database from the old cluster.)
          */
         for (; new_dbnum < new_db_arr->ndbs; new_dbnum++)
         {
             new_db = &new_db_arr->dbs[new_dbnum];
             if (strcmp(old_db->db_name, new_db->db_name) == 0)
                 break;
         }
 
         if (new_dbnum >= new_db_arr->ndbs)
             pg_fatal("old database \"%s\" not found in the new cluster\n",
                      old_db->db_name);
 
         mappings = gen_db_file_maps(old_db, new_db, &n_maps, old_pgdata,
                                     new_pgdata);
         if (n_maps)
         {
             print_maps(mappings, n_maps, new_db->db_name);
 
             transfer_single_new_db(mappings, n_maps, old_tablespace);
         }
         /* We allocate something even for n_maps == 0 */
         pg_free(mappings);
     }
 }

◆ transfer_all_new_tablespaces()

void transfer_all_new_tablespaces	(	DbInfoArr *	old_db_arr,
		DbInfoArr *	new_db_arr,
		char *	old_pgdata,
		char *	new_pgdata
	)

Definition at line 29 of file relfilenode.c.

References check_ok(), end_progress_output(), UserOpts::jobs, OSInfo::num_old_tablespaces, OSInfo::old_tablespaces, os_info, parallel_transfer_all_new_dbs(), pg_log(), PG_REPORT, reap_child(), UserOpts::transfer_mode, TRANSFER_MODE_CLONE, TRANSFER_MODE_COPY, TRANSFER_MODE_LINK, and user_opts.

Referenced by main().

 {
     switch (user_opts.transfer_mode)
     {
         case TRANSFER_MODE_CLONE:
             pg_log(PG_REPORT, "Cloning user relation files\n");
             break;
         case TRANSFER_MODE_COPY:
             pg_log(PG_REPORT, "Copying user relation files\n");
             break;
         case TRANSFER_MODE_LINK:
             pg_log(PG_REPORT, "Linking user relation files\n");
             break;
     }
 
     /*
      * Transferring files by tablespace is tricky because a single database
      * can use multiple tablespaces.  For non-parallel mode, we just pass a
      * NULL tablespace path, which matches all tablespaces.  In parallel mode,
      * we pass the default tablespace and all user-created tablespaces and let
      * those operations happen in parallel.
      */
     if (user_opts.jobs <= 1)
         parallel_transfer_all_new_dbs(old_db_arr, new_db_arr, old_pgdata,
                                       new_pgdata, NULL);
     else
     {
         int         tblnum;
 
         /* transfer default tablespace */
         parallel_transfer_all_new_dbs(old_db_arr, new_db_arr, old_pgdata,
                                       new_pgdata, old_pgdata);
 
         for (tblnum = 0; tblnum < os_info.num_old_tablespaces; tblnum++)
             parallel_transfer_all_new_dbs(old_db_arr,
                                           new_db_arr,
                                           old_pgdata,
                                           new_pgdata,
                                           os_info.old_tablespaces[tblnum]);
         /* reap all children */
         while (reap_child(true) == true)
             ;
     }
 
     end_progress_output();
     check_ok();
 }

◆ verify_directories()

bool void verify_directories ( void )

Definition at line 250 of file exec.c.

References check_bin_dir(), check_data_dir(), close, fd(), GLOBALS_DUMP_FILE, new_cluster, old_cluster, pg_fatal, S_IRUSR, and S_IWUSR.

Referenced by setup().

 {
 #ifndef WIN32
     if (access(".", R_OK | W_OK | X_OK) != 0)
 #else
     if (win32_check_directory_write_permissions() != 0)
 #endif
         pg_fatal("You must have read and write access in the current directory.\n");
 
     check_bin_dir(&old_cluster);
     check_data_dir(&old_cluster);
     check_bin_dir(&new_cluster);
     check_data_dir(&new_cluster);
 }

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ BINARY_UPGRADE_SERVER_FLAG_CAT_VER

◆ DB_DUMP_FILE_MASK

◆ DB_DUMP_LOG_FILE_MASK

◆ DEF_PGUPORT

◆ ECHO_BLANK

◆ ECHO_QUOTE

◆ EXEC_PSQL_ARGS

◆ fopen_priv

◆ GET_MAJOR_VERSION

◆ GLOBALS_DUMP_FILE

◆ INTERNAL_LOG_FILE

◆ JSONB_FORMAT_CHANGE_CAT_VER

◆ LARGE_OBJECT_SIZE_PG_CONTROL_VER

◆ MAX_STRING

◆ MESSAGE_WIDTH

◆ MULTIXACT_FORMATCHANGE_CAT_VER

◆ PATH_QUOTE

◆ PATH_SEPARATOR

◆ pg_link_file

◆ pg_mv_file

◆ QUERY_ALLOC

◆ RM_CMD

◆ RMDIR_CMD

◆ SCRIPT_EXT

◆ SCRIPT_PREFIX

◆ SERVER_LOG_FILE

◆ SERVER_START_LOG_FILE

◆ SERVER_STOP_LOG_FILE

◆ UTILITY_LOG_FILE

◆ VISIBILITY_MAP_CRASHSAFE_CAT_VER

◆ VISIBILITY_MAP_FROZEN_BIT_CAT_VER

Typedef Documentation

◆ pgpid_t

Enumeration Type Documentation

◆ eLogType

◆ transferMode

Function Documentation

◆ adjust_data_dir()

◆ check_and_dump_old_cluster()

◆ check_cluster_compatibility()

◆ check_cluster_versions()

◆ check_control_data()

◆ check_file_clone()

◆ check_hard_link()

◆ check_loadable_libraries()

◆ check_new_cluster()

◆ check_ok()

◆ check_pghost_envvar()

◆ cloneFile()

◆ cluster_conn_opts()

◆ connectToServer()

◆ copyFile()

◆ create_script_for_cluster_analyze()

◆ create_script_for_old_cluster_deletion()

◆ disable_old_cluster()

◆ end_progress_output()

◆ exec_prog()

◆ executeQueryOrDie()

◆ gen_db_file_maps()

◆ generate_old_dump()

◆ get_control_data()

◆ get_db_and_rel_infos()

◆ get_loadable_libraries()

◆ get_major_server_version()

◆ get_sock_dir()

◆ get_user_info()

◆ init_tablespaces()

◆ issue_warnings_and_set_wal_level()

◆ linkFile()

◆ new_9_0_populate_pg_largeobject_metadata()

◆ old_11_check_for_sql_identifier_data_type_usage()

◆ old_9_3_check_for_line_data_type_usage()

◆ old_9_6_check_for_unknown_data_type_usage()