pg_upgrade.h File Reference

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

Include dependency graph for pg_upgrade.h:

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

Go to the source code of this file.

Data Structures
struct	RelInfo
struct	RelInfoArr
struct	LogicalSlotInfo
struct	LogicalSlotInfoArr
struct	FileNameMap
struct	DbInfo
struct	DbLocaleInfo
struct	DbInfoArr
struct	ControlData
struct	ClusterInfo
struct	LogOpts
struct	UserOpts
struct	LibraryInfo
struct	OSInfo
struct	UpgradeTaskReport

Macros
#define	DEF_PGUPORT   50432
#define	MAX_STRING   1024
#define	QUERY_ALLOC   8192
#define	MESSAGE_WIDTH   62
#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	BASE_OUTPUTDIR   "pg_upgrade_output.d"
#define	LOG_OUTPUTDIR   "log"
#define	DUMP_OUTPUTDIR   "dump"
#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	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	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	DEFAULT_CHAR_SIGNEDNESS_CAT_VER   202502212
#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 bool(*	DataTypesUsageVersionCheck) (ClusterInfo *cluster)
typedef void(*	UpgradeTaskProcessCB) (DbInfo *dbinfo, PGresult *res, void *arg)
typedef struct UpgradeTask	UpgradeTask

Enumerations
enum	transferMode {   TRANSFER_MODE_CLONE , TRANSFER_MODE_COPY , TRANSFER_MODE_COPY_FILE_RANGE , TRANSFER_MODE_LINK ,   TRANSFER_MODE_SWAP }
enum	eLogType {   PG_VERBOSE , PG_STATUS , PG_REPORT_NONL , PG_REPORT ,   PG_WARNING , PG_FATAL }

Functions
void	output_check_banner (void)
void	check_and_dump_old_cluster (void)
void	check_new_cluster (void)
void	report_clusters_compatible (void)
void	issue_warnings_and_set_wal_level (void)
void	output_completion_banner (char *deletion_script_file_name)
void	check_cluster_versions (void)
void	check_cluster_compatibility (void)
void	create_script_for_old_cluster_deletion (char **deletion_script_file_name)
void	get_control_data (ClusterInfo *cluster)
void	check_control_data (ControlData *oldctrl, ControlData *newctrl)
void	disable_old_cluster (transferMode transfer_mode)
void	generate_old_dump (void)
bool	exec_prog (const char *log_filename, 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	copyFileByRange (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_copy_file_range (void)
void	check_hard_link (transferMode transfer_mode)
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_rel_and_slot_infos (ClusterInfo *cluster)
int	count_old_cluster_logical_slots (void)
void	get_subscription_count (ClusterInfo *cluster)
void	parseCommandLine (int argc, char *argv[])
void	adjust_data_dir (ClusterInfo *cluster)
void	get_sock_dir (ClusterInfo *cluster)
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 pg_noreturn void	pg_fatal (const char *fmt,...) pg_attribute_printf(1
void void pg_noreturn void void	end_progress_output (void)
void	cleanup_output_dirs (void)
void	prep_status (const char *fmt,...) pg_attribute_printf(1
void void	prep_status_progress (const char *fmt,...) pg_attribute_printf(1
void void unsigned int	str2uint (const char *str)
bool	jsonb_9_4_check_applicable (ClusterInfo *cluster)
void	old_9_6_invalidate_hash_indexes (ClusterInfo *cluster, bool check_mode)
void	report_extension_updates (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)
UpgradeTask *	upgrade_task_create (void)
void	upgrade_task_add_step (UpgradeTask *task, const char *query, UpgradeTaskProcessCB process_cb, bool free_result, void *arg)
void	upgrade_task_run (const UpgradeTask *task, const ClusterInfo *cluster)
void	upgrade_task_free (UpgradeTask *task)

Variables
char *	output_files []
LogOpts	log_opts
UserOpts	user_opts
ClusterInfo	old_cluster
ClusterInfo	new_cluster
OSInfo	os_info

Macro Definition Documentation

BASE_OUTPUTDIR

#define BASE_OUTPUTDIR   "pg_upgrade_output.d"

Definition at line 39 of file pg_upgrade.h.

DB_DUMP_FILE_MASK

#define DB_DUMP_FILE_MASK   "pg_upgrade_dump_%u.custom"

Definition at line 31 of file pg_upgrade.h.

DB_DUMP_LOG_FILE_MASK

#define DB_DUMP_LOG_FILE_MASK   "pg_upgrade_dump_%u.log"

Definition at line 43 of file pg_upgrade.h.

DEF_PGUPORT

#define DEF_PGUPORT   50432

Definition at line 20 of file pg_upgrade.h.

DEFAULT_CHAR_SIGNEDNESS_CAT_VER

#define DEFAULT_CHAR_SIGNEDNESS_CAT_VER   202502212

Definition at line 132 of file pg_upgrade.h.

DUMP_OUTPUTDIR

#define DUMP_OUTPUTDIR   "dump"

Definition at line 41 of file pg_upgrade.h.

ECHO_BLANK

#define ECHO_BLANK   ""

Definition at line 89 of file pg_upgrade.h.

ECHO_QUOTE

#define ECHO_QUOTE   "'"

Definition at line 88 of file pg_upgrade.h.

EXEC_PSQL_ARGS

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

Definition at line 405 of file pg_upgrade.h.

fopen_priv

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

Definition at line 430 of file pg_upgrade.h.

GET_MAJOR_VERSION

#define GET_MAJOR_VERSION

(

v

)

((v) / 100)

Definition at line 27 of file pg_upgrade.h.

GLOBALS_DUMP_FILE

#define GLOBALS_DUMP_FILE   "pg_upgrade_dump_globals.sql"

Definition at line 30 of file pg_upgrade.h.

INTERNAL_LOG_FILE

#define INTERNAL_LOG_FILE   "pg_upgrade_internal.log"

Definition at line 46 of file pg_upgrade.h.

JSONB_FORMAT_CHANGE_CAT_VER

#define JSONB_FORMAT_CHANGE_CAT_VER   201409291

Definition at line 126 of file pg_upgrade.h.

LARGE_OBJECT_SIZE_PG_CONTROL_VER

#define LARGE_OBJECT_SIZE_PG_CONTROL_VER   942

Definition at line 121 of file pg_upgrade.h.

LOG_OUTPUTDIR

#define LOG_OUTPUTDIR   "log"

Definition at line 40 of file pg_upgrade.h.

MAX_STRING

#define MAX_STRING   1024

Definition at line 22 of file pg_upgrade.h.

MESSAGE_WIDTH

#define MESSAGE_WIDTH   62

Definition at line 25 of file pg_upgrade.h.

MULTIXACT_FORMATCHANGE_CAT_VER

#define MULTIXACT_FORMATCHANGE_CAT_VER   201301231

Definition at line 115 of file pg_upgrade.h.

PATH_QUOTE

#define PATH_QUOTE   '\''

Definition at line 83 of file pg_upgrade.h.

PATH_SEPARATOR

#define PATH_SEPARATOR   '/'

Definition at line 82 of file pg_upgrade.h.

pg_mv_file

#define pg_mv_file   rename

Definition at line 81 of file pg_upgrade.h.

QUERY_ALLOC

#define QUERY_ALLOC   8192

Definition at line 23 of file pg_upgrade.h.

RM_CMD

#define RM_CMD   "rm -f"

Definition at line 84 of file pg_upgrade.h.

RMDIR_CMD

#define RMDIR_CMD   "rm -rf"

Definition at line 85 of file pg_upgrade.h.

SCRIPT_EXT

#define SCRIPT_EXT   "sh"

Definition at line 87 of file pg_upgrade.h.

SCRIPT_PREFIX

#define SCRIPT_PREFIX   "./"

Definition at line 86 of file pg_upgrade.h.

SERVER_LOG_FILE

#define SERVER_LOG_FILE   "pg_upgrade_server.log"

Definition at line 44 of file pg_upgrade.h.

SERVER_START_LOG_FILE

#define SERVER_START_LOG_FILE   SERVER_LOG_FILE

Definition at line 67 of file pg_upgrade.h.

SERVER_STOP_LOG_FILE

#define SERVER_STOP_LOG_FILE   SERVER_LOG_FILE

Definition at line 68 of file pg_upgrade.h.

UTILITY_LOG_FILE

#define UTILITY_LOG_FILE   "pg_upgrade_utility.log"

Definition at line 45 of file pg_upgrade.h.

VISIBILITY_MAP_FROZEN_BIT_CAT_VER

#define VISIBILITY_MAP_FROZEN_BIT_CAT_VER   201603011

Definition at line 107 of file pg_upgrade.h.

Typedef Documentation

DataTypesUsageVersionCheck

typedef bool(* DataTypesUsageVersionCheck) (ClusterInfo *cluster)

Definition at line 366 of file pg_upgrade.h.

UpgradeTask

typedef struct UpgradeTask UpgradeTask

Definition at line 514 of file pg_upgrade.h.

UpgradeTaskProcessCB

typedef void(* UpgradeTaskProcessCB) (DbInfo *dbinfo, PGresult *res, void *arg)

Definition at line 511 of file pg_upgrade.h.

Enumeration Type Documentation

eLogType

enum eLogType

Enumerator
PG_VERBOSE
PG_STATUS
PG_REPORT_NONL
PG_REPORT
PG_WARNING
PG_FATAL

Definition at line 271 of file pg_upgrade.h.

{
    PG_VERBOSE,
    PG_STATUS,                  /* these messages do not get a newline added */
    PG_REPORT_NONL,             /* these too */
    PG_REPORT,
    PG_WARNING,
    PG_FATAL,
} eLogType;

transferMode

enum transferMode

Enumerator
TRANSFER_MODE_CLONE
TRANSFER_MODE_COPY
TRANSFER_MODE_COPY_FILE_RANGE
TRANSFER_MODE_LINK
TRANSFER_MODE_SWAP

Definition at line 259 of file pg_upgrade.h.

{
    TRANSFER_MODE_CLONE,
    TRANSFER_MODE_COPY,
    TRANSFER_MODE_COPY_FILE_RANGE,
    TRANSFER_MODE_LINK,
    TRANSFER_MODE_SWAP,
} transferMode;

Function Documentation

adjust_data_dir()

void adjust_data_dir

(

ClusterInfo *

cluster

)

Definition at line 430 of file option.c.

{
    char        filename[MAXPGPATH];
    char        cmd[MAXPGPATH],
                cmd_output[MAX_STRING];
    FILE       *fp,
               *output;
    int         rc;
 
    /* 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);
    fflush(NULL);
 
    if ((output = popen(cmd, "r")) == NULL ||
        fgets(cmd_output, sizeof(cmd_output), output) == NULL)
        pg_fatal("could not get data directory using %s: %m", cmd);
 
    rc = pclose(output);
    if (rc != 0)
        pg_fatal("could not get data directory using %s: %s",
                 cmd, wait_result_to_str(rc));
 
    /* strip trailing newline and carriage return */
    (void) pg_strip_crlf(cmd_output);
 
    cluster->pgdata = pg_strdup(cmd_output);
 
    check_ok();
}

References check_ok(), cluster(), filename, MAX_STRING, MAXPGPATH, old_cluster, output, pg_fatal, pg_strdup(), pg_strip_crlf(), prep_status(), snprintf, and wait_result_to_str().

check_and_dump_old_cluster()

void check_and_dump_old_cluster

(

void

)

Definition at line 588 of file check.c.

{
    /* -- OLD -- */
 
    if (!user_opts.live_check)
        start_postmaster(&old_cluster, true);
 
    /*
     * First check that all databases allow connections since we'll otherwise
     * fail in later stages.
     */
    check_for_connection_status(&old_cluster);
 
    /*
     * Extract a list of databases, tables, and logical replication slots from
     * the old cluster.
     */
    get_db_rel_and_slot_infos(&old_cluster);
 
    init_tablespaces();
 
    get_loadable_libraries();
 
 
    /*
     * Check for various failure cases
     */
    check_is_install_user(&old_cluster);
    check_for_prepared_transactions(&old_cluster);
    check_for_isn_and_int8_passing_mismatch(&old_cluster);
 
    if (GET_MAJOR_VERSION(old_cluster.major_version) >= 1700)
    {
        /*
         * Logical replication slots can be migrated since PG17. See comments
         * atop get_old_cluster_logical_slot_infos().
         */
        check_old_cluster_for_valid_slots();
 
        /*
         * Subscriptions and their dependencies can be migrated since PG17.
         * Before that the logical slots are not upgraded, so we will not be
         * able to upgrade the logical replication clusters completely.
         */
        get_subscription_count(&old_cluster);
        check_old_cluster_subscription_state();
    }
 
    check_for_data_types_usage(&old_cluster);
 
    /*
     * Unicode updates can affect some objects that use expressions with
     * functions dependent on Unicode.
     */
    check_for_unicode_update(&old_cluster);
 
    /*
     * PG 14 changed the function signature of encoding conversion functions.
     * Conversions from older versions cannot be upgraded automatically
     * because the user-defined functions used by the encoding conversions
     * need to be changed to match the new signature.
     */
    if (GET_MAJOR_VERSION(old_cluster.major_version) <= 1300)
        check_for_user_defined_encoding_conversions(&old_cluster);
 
    /*
     * Pre-PG 14 allowed user defined postfix operators, which are not
     * supported anymore.  Verify there are none, iff applicable.
     */
    if (GET_MAJOR_VERSION(old_cluster.major_version) <= 1300)
        check_for_user_defined_postfix_ops(&old_cluster);
 
    /*
     * PG 14 changed polymorphic functions from anyarray to
     * anycompatiblearray.
     */
    if (GET_MAJOR_VERSION(old_cluster.major_version) <= 1300)
        check_for_incompatible_polymorphics(&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);
 
    /*
     * Pre-PG 10 allowed tables with 'unknown' type columns and non WAL logged
     * hash indexes
     */
    if (GET_MAJOR_VERSION(old_cluster.major_version) <= 906)
    {
        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);
 
    /*
     * 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 (!user_opts.live_check)
        stop_postmaster(false);
}

References UserOpts::check, check_for_connection_status(), check_for_data_types_usage(), check_for_incompatible_polymorphics(), check_for_isn_and_int8_passing_mismatch(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_for_tables_with_oids(), check_for_unicode_update(), check_for_user_defined_encoding_conversions(), check_for_user_defined_postfix_ops(), check_is_install_user(), check_old_cluster_for_valid_slots(), check_old_cluster_subscription_state(), generate_old_dump(), get_db_rel_and_slot_infos(), get_loadable_libraries(), GET_MAJOR_VERSION, get_subscription_count(), init_tablespaces(), UserOpts::live_check, ClusterInfo::major_version, old_9_6_invalidate_hash_indexes(), old_cluster, start_postmaster(), stop_postmaster(), and user_opts.

Referenced by main().

check_cluster_compatibility()

void check_cluster_compatibility

(

void

)

Definition at line 896 of file check.c.

{
    /* get/check pg_control data of servers */
    get_control_data(&old_cluster);
    get_control_data(&new_cluster);
    check_control_data(&old_cluster.controldata, &new_cluster.controldata);
 
    if (user_opts.live_check && old_cluster.port == new_cluster.port)
        pg_fatal("When checking a live server, "
                 "the old and new port numbers must be different.");
}

References check_control_data(), ClusterInfo::controldata, get_control_data(), UserOpts::live_check, new_cluster, old_cluster, pg_fatal, ClusterInfo::port, and user_opts.

Referenced by main().

check_cluster_versions()

void check_cluster_versions

(

void

)

Definition at line 841 of file check.c.

{
    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) < 902)
        pg_fatal("This utility can only upgrade from PostgreSQL version %s and later.",
                 "9.2");
 
    /* 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.",
                 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.");
 
    /* 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.");
    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.");
 
    /*
     * Since from version 18, newly created database clusters always have
     * 'signed' default char-signedness, it makes less sense to use
     * --set-char-signedness option for upgrading from version 18 or later.
     * Users who want to change the default char signedness of the new
     * cluster, they can use pg_resetwal manually before the upgrade.
     */
    if (GET_MAJOR_VERSION(old_cluster.major_version) >= 1800 &&
        user_opts.char_signedness != -1)
        pg_fatal("%s option cannot be used to upgrade from PostgreSQL %s and later.",
                 "--set-char-signedness", "18");
 
    check_ok();
}

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

Referenced by main().

check_control_data()

void check_control_data	(	ControlData *	oldctrl,
		ControlData *	newctrl
	)

Definition at line 698 of file controldata.c.

{
    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");
 
    if (oldctrl->blocksz == 0 || oldctrl->blocksz != newctrl->blocksz)
        pg_fatal("old and new pg_controldata block sizes are invalid or do not match");
 
    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");
 
    if (oldctrl->walsz == 0 || oldctrl->walsz != newctrl->walsz)
        pg_fatal("old and new pg_controldata WAL block sizes are invalid or do not match");
 
    if (oldctrl->walseg == 0 || oldctrl->walseg != newctrl->walseg)
        pg_fatal("old and new pg_controldata WAL segment sizes are invalid or do not match");
 
    if (oldctrl->ident == 0 || oldctrl->ident != newctrl->ident)
        pg_fatal("old and new pg_controldata maximum identifier lengths are invalid or do not match");
 
    if (oldctrl->index == 0 || oldctrl->index != newctrl->index)
        pg_fatal("old and new pg_controldata maximum indexed columns are invalid or do not match");
 
    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");
 
    /* 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");
 
    if (oldctrl->date_is_int != newctrl->date_is_int)
        pg_fatal("old and new pg_controldata date/time storage types do not match");
 
    /*
     * 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");
    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");
    else if (oldctrl->data_checksum_version != newctrl->data_checksum_version)
        pg_fatal("old and new cluster pg_controldata checksum versions do not match");
}

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().

check_copy_file_range()

void check_copy_file_range

(

void

)

Definition at line 400 of file file.c.

{
    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.copy_file_range_test", new_cluster.pgdata);
    unlink(new_link_file);      /* might fail */
 
#if defined(HAVE_COPY_FILE_RANGE)
    {
        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\": %m",
                     existing_file);
 
        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\": %m",
                     new_link_file);
 
        if (copy_file_range(src_fd, NULL, dest_fd, NULL, SSIZE_MAX, 0) < 0)
            pg_fatal("could not copy file range between old and new data directories: %m");
 
        close(src_fd);
        close(dest_fd);
    }
#else
    pg_fatal("copy_file_range not supported on this platform");
#endif
 
    unlink(new_link_file);
}

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

Referenced by check_new_cluster().

check_file_clone()

void check_file_clone

(

void

)

Definition at line 360 of file file.c.

{
    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: %m");
#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\": %m",
                     existing_file);
 
        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\": %m",
                     new_link_file);
 
        if (ioctl(dest_fd, FICLONE, src_fd) < 0)
            pg_fatal("could not clone file between old and new data directories: %m");
 
        close(src_fd);
        close(dest_fd);
    }
#else
    pg_fatal("file cloning not supported on this platform");
#endif
 
    unlink(new_link_file);
}

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

Referenced by check_new_cluster().

check_hard_link()

void check_hard_link

(

transferMode

transfer_mode

)

Definition at line 437 of file file.c.

{
    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 (link(existing_file, new_link_file) < 0)
    {
        if (transfer_mode == TRANSFER_MODE_LINK)
            pg_fatal("could not create hard link between old and new data directories: %m\n"
                     "In link mode the old and new data directories must be on the same file system.");
        else if (transfer_mode == TRANSFER_MODE_SWAP)
            pg_fatal("could not create hard link between old and new data directories: %m\n"
                     "In swap mode the old and new data directories must be on the same file system.");
        else
            pg_fatal("unrecognized transfer mode");
    }
 
    unlink(new_link_file);
}

References link(), MAXPGPATH, new_cluster, old_cluster, pg_fatal, ClusterInfo::pgdata, snprintf, TRANSFER_MODE_LINK, and TRANSFER_MODE_SWAP.

Referenced by check_new_cluster().

check_loadable_libraries()

void check_loadable_libraries

(

void

)

Definition at line 165 of file function.c.

{
    PGconn     *conn = connectToServer(&new_cluster, "template1");
    int         libnum;
    int         was_load_failure = false;
    FILE       *script = NULL;
    char        output_path[MAXPGPATH];
 
    prep_status("Checking for presence of required libraries");
 
    snprintf(output_path, sizeof(output_path), "%s/%s",
             log_opts.basedir, "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(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)
        {
            strcpy(cmd, "LOAD '");
            PQescapeStringConn(conn, cmd + strlen(cmd), lib, llen, NULL);
            strcat(cmd, "'");
 
            res = PQexec(conn, cmd);
 
            if (PQresultStatus(res) != PGRES_COMMAND_OK)
            {
                was_load_failure = true;
 
                if (script == NULL && (script = fopen_priv(output_path, "w")) == NULL)
                    pg_fatal("could not open file \"%s\": %m", output_path);
                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 (script)
    {
        fclose(script);
        pg_log(PG_REPORT, "fatal");
        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", output_path);
    }
    else
        check_ok();
}

References _, LogOpts::basedir, check_ok(), conn, connectToServer(), DbInfo::db_name, ClusterInfo::dbarr, LibraryInfo::dbnum, DbInfoArr::dbs, fopen_priv, fprintf, OSInfo::libraries, library_name_compare(), log_opts, 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, and snprintf.

Referenced by check_new_cluster().

check_new_cluster()

void check_new_cluster

(

void

)

Definition at line 701 of file check.c.

{
    get_db_rel_and_slot_infos(&new_cluster);
 
    check_new_cluster_is_empty();
 
    check_loadable_libraries();
 
    switch (user_opts.transfer_mode)
    {
        case TRANSFER_MODE_CLONE:
            check_file_clone();
            break;
        case TRANSFER_MODE_COPY:
            break;
        case TRANSFER_MODE_COPY_FILE_RANGE:
            check_copy_file_range();
            break;
        case TRANSFER_MODE_LINK:
            check_hard_link(TRANSFER_MODE_LINK);
            break;
        case TRANSFER_MODE_SWAP:
 
            /*
             * We do the hard link check for --swap, too, since it's an easy
             * way to verify the clusters are in the same file system.  This
             * allows us to take some shortcuts in the file synchronization
             * step.  With some more effort, we could probably support the
             * separate-file-system use case, but this mode is unlikely to
             * offer much benefit if we have to copy the files across file
             * system boundaries.
             */
            check_hard_link(TRANSFER_MODE_SWAP);
 
            /*
             * There are a few known issues with using --swap to upgrade from
             * versions older than 10.  For example, the sequence tuple format
             * changed in v10, and the visibility map format changed in 9.6.
             * While such problems are not insurmountable (and we may have to
             * deal with similar problems in the future, anyway), it doesn't
             * seem worth the effort to support swap mode for upgrades from
             * long-unsupported versions.
             */
            if (GET_MAJOR_VERSION(old_cluster.major_version) < 1000)
                pg_fatal("Swap mode can only upgrade clusters from PostgreSQL version %s and later.",
                         "10");
 
            break;
    }
 
    check_is_install_user(&new_cluster);
 
    check_for_prepared_transactions(&new_cluster);
 
    check_for_new_tablespace_dir();
 
    check_new_cluster_logical_replication_slots();
 
    check_new_cluster_subscription_configuration();
}

References check_copy_file_range(), check_file_clone(), check_for_new_tablespace_dir(), check_for_prepared_transactions(), check_hard_link(), check_is_install_user(), check_loadable_libraries(), check_new_cluster_is_empty(), check_new_cluster_logical_replication_slots(), check_new_cluster_subscription_configuration(), get_db_rel_and_slot_infos(), GET_MAJOR_VERSION, ClusterInfo::major_version, new_cluster, old_cluster, pg_fatal, UserOpts::transfer_mode, TRANSFER_MODE_CLONE, TRANSFER_MODE_COPY, TRANSFER_MODE_COPY_FILE_RANGE, TRANSFER_MODE_LINK, TRANSFER_MODE_SWAP, and user_opts.

Referenced by main().

check_ok()

void check_ok

(

void

)

Definition at line 284 of file util.c.

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

References PG_REPORT, and report_status().

check_pghost_envvar()

void check_pghost_envvar

(

void

)

Definition at line 376 of file server.c.

{
    PQconninfoOption *option;
    PQconninfoOption *start;
 
    /* Get valid libpq env vars from the PQconndefaults function */
 
    start = PQconndefaults();
 
    if (!start)
        pg_fatal("out of memory");
 
    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 && !is_unixsock_path(value)))
                pg_fatal("libpq environment variable %s has a non-local server value: %s",
                         option->envvar, value);
        }
    }
 
    /* Free the memory that libpq allocated on our behalf */
    PQconninfoFree(start);
}

References is_unixsock_path(), pg_fatal, PQconndefaults(), PQconninfoFree(), start, and value.

Referenced by setup().

cleanup_output_dirs()

void cleanup_output_dirs

(

void

)

Definition at line 63 of file util.c.

{
    fclose(log_opts.internal);
 
    /* Remove dump and log files? */
    if (log_opts.retain)
        return;
 
    /*
     * Try twice.  The second time might wait for files to finish being
     * unlinked, on Windows.
     */
    if (!rmtree(log_opts.basedir, true))
        rmtree(log_opts.basedir, true);
 
    /* Remove pg_upgrade_output.d only if empty */
    switch (pg_check_dir(log_opts.rootdir))
    {
        case 0:                 /* non-existent */
        case 3:                 /* exists and contains a mount point */
            Assert(false);
            break;
 
        case 1:                 /* exists and empty */
        case 2:                 /* exists and contains only dot files */
 
            /*
             * Try twice.  The second time might wait for files to finish
             * being unlinked, on Windows.
             */
            if (!rmtree(log_opts.rootdir, true))
                rmtree(log_opts.rootdir, true);
            break;
 
        case 4:                 /* exists */
 
            /*
             * Keep the root directory as this includes some past log
             * activity.
             */
            break;
 
        default:
            /* different failure, just report it */
            pg_log(PG_WARNING, "could not access directory \"%s\": %m",
                   log_opts.rootdir);
            break;
    }
}

References Assert(), LogOpts::basedir, LogOpts::internal, log_opts, pg_check_dir(), pg_log(), PG_WARNING, LogOpts::retain, rmtree(), and LogOpts::rootdir.

Referenced by main(), and report_clusters_compatible().

cloneFile()

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

Definition at line 39 of file file.c.

{
#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\"): %m",
                 schemaName, relName, src, dst);
#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\": %m",
                 schemaName, relName, src);
 
    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\": %m",
                 schemaName, relName, dst);
 
    if (ioctl(dest_fd, FICLONE, src_fd) < 0)
    {
        int         save_errno = errno;
 
        unlink(dst);
 
        pg_fatal("error while cloning relation \"%s.%s\" (\"%s\" to \"%s\"): %s",
                 schemaName, relName, src, dst, strerror(save_errno));
    }
 
    close(src_fd);
    close(dest_fd);
#endif
}

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

Referenced by transfer_relfile().

cluster_conn_opts()

PGresult char * cluster_conn_opts

(

ClusterInfo *

cluster

)

Definition at line 92 of file server.c.

{
    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;
}

References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendShellString(), buf, cluster(), createPQExpBuffer(), os_info, resetPQExpBuffer(), and OSInfo::user.

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

connectToServer()

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

Definition at line 28 of file server.c.

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

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

Referenced by check_for_connection_status(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_is_install_user(), check_loadable_libraries(), check_new_cluster_logical_replication_slots(), check_new_cluster_subscription_configuration(), check_old_cluster_subscription_state(), create_logical_replication_slots(), create_new_objects(), get_db_infos(), get_subscription_count(), get_tablespace_paths(), get_template0_info(), old_9_6_invalidate_hash_indexes(), set_frozenxids(), set_locale_and_encoding(), and unicode_version_changed().

copyFile()

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

Definition at line 82 of file file.c.

{
#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\": %m",
                 schemaName, relName, src);
 
    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\": %m",
                 schemaName, relName, dst);
 
    /* 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\": %m",
                     schemaName, relName, src);
 
        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\": %m",
                     schemaName, relName, dst);
        }
    }
 
    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\"): %m",
                 schemaName, relName, src, dst);
    }
 
#endif                          /* WIN32 */
}

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

Referenced by transfer_relfile().

copyFileByRange()

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

Definition at line 151 of file file.c.

{
#ifdef HAVE_COPY_FILE_RANGE
    int         src_fd;
    int         dest_fd;
    ssize_t     nbytes;
 
    if ((src_fd = open(src, O_RDONLY | PG_BINARY, 0)) < 0)
        pg_fatal("error while copying relation \"%s.%s\": could not open file \"%s\": %m",
                 schemaName, relName, src);
 
    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\": %m",
                 schemaName, relName, dst);
 
    do
    {
        nbytes = copy_file_range(src_fd, NULL, dest_fd, NULL, SSIZE_MAX, 0);
        if (nbytes < 0)
            pg_fatal("error while copying relation \"%s.%s\": could not copy file range from \"%s\" to \"%s\": %m",
                     schemaName, relName, src, dst);
    }
    while (nbytes > 0);
 
    close(src_fd);
    close(dest_fd);
#endif
}

References close, PG_BINARY, pg_fatal, and pg_file_create_mode.

Referenced by transfer_relfile().

count_old_cluster_logical_slots()

int count_old_cluster_logical_slots

(

void

)

Definition at line 744 of file info.c.

{
    int         slot_count = 0;
 
    for (int dbnum = 0; dbnum < old_cluster.dbarr.ndbs; dbnum++)
        slot_count += old_cluster.dbarr.dbs[dbnum].slot_arr.nslots;
 
    return slot_count;
}

References ClusterInfo::dbarr, DbInfoArr::dbs, DbInfoArr::ndbs, LogicalSlotInfoArr::nslots, old_cluster, and DbInfo::slot_arr.

Referenced by check_new_cluster_logical_replication_slots(), get_loadable_libraries(), and main().

create_script_for_old_cluster_deletion()

void create_script_for_old_cluster_deletion

(

char **

deletion_script_file_name

)

Definition at line 971 of file check.c.

{
    FILE       *script = NULL;
    int         tblnum;
    char        old_cluster_pgdata[MAXPGPATH],
                new_cluster_pgdata[MAXPGPATH];
    char       *old_tblspc_suffix;
 
    *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, i.e. %s", 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, i.e. %s", 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\": %m",
                 *deletion_script_file_name);
 
#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 */
    old_tblspc_suffix = pg_strdup(old_cluster.tablespace_suffix);
    fix_path_separator(old_tblspc_suffix);
    for (tblnum = 0; tblnum < os_info.num_old_tablespaces; tblnum++)
        fprintf(script, RMDIR_CMD " %c%s%s%c\n", PATH_QUOTE,
                fix_path_separator(os_info.old_tablespaces[tblnum]),
                old_tblspc_suffix, PATH_QUOTE);
    pfree(old_tblspc_suffix);
 
    fclose(script);
 
#ifndef WIN32
    if (chmod(*deletion_script_file_name, S_IRWXU) != 0)
        pg_fatal("could not add execute permission to file \"%s\": %m",
                 *deletion_script_file_name);
#endif
 
    check_ok();
}

References canonicalize_path(), check_ok(), fix_path_separator(), fopen_priv, fprintf, MAXPGPATH, new_cluster, OSInfo::num_old_tablespaces, old_cluster, OSInfo::old_tablespaces, os_info, path_is_prefix_of_path(), PATH_QUOTE, pfree(), pg_fatal, pg_free(), pg_log(), pg_strdup(), PG_WARNING, ClusterInfo::pgdata, prep_status(), psprintf(), RMDIR_CMD, S_IRWXU, SCRIPT_EXT, SCRIPT_PREFIX, strlcpy(), and ClusterInfo::tablespace_suffix.

Referenced by main().

disable_old_cluster()

void disable_old_cluster

(

transferMode

transfer_mode

)

Definition at line 755 of file controldata.c.

{
    char        old_path[MAXPGPATH],
                new_path[MAXPGPATH];
 
    /* rename pg_control so old server cannot be accidentally started */
    /* translator: %s is the file path of the control file */
    prep_status("Adding \".old\" suffix to old \"%s\"", XLOG_CONTROL_FILE);
 
    snprintf(old_path, sizeof(old_path), "%s/%s", old_cluster.pgdata, XLOG_CONTROL_FILE);
    snprintf(new_path, sizeof(new_path), "%s/%s.old", old_cluster.pgdata, XLOG_CONTROL_FILE);
    if (pg_mv_file(old_path, new_path) != 0)
        pg_fatal("could not rename file \"%s\" to \"%s\": %m",
                 old_path, new_path);
    check_ok();
 
    if (transfer_mode == TRANSFER_MODE_LINK)
        /* translator: %s/%s is the file path of the control file */
        pg_log(PG_REPORT, "\n"
               "If you want to start the old cluster, you will need to remove\n"
               "the \".old\" suffix from \"%s/%s.old\".\n"
               "Because \"link\" mode was used, the old cluster cannot be safely\n"
               "started once the new cluster has been started.",
               old_cluster.pgdata, XLOG_CONTROL_FILE);
    else if (transfer_mode == TRANSFER_MODE_SWAP)
        pg_log(PG_REPORT, "\n"
               "Because \"swap\" mode was used, the old cluster can no longer be\n"
               "safely started.");
    else
        pg_fatal("unrecognized transfer mode");
}

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

Referenced by main().

end_progress_output()

void void pg_noreturn void void end_progress_output

(

void

)

Definition at line 43 of file util.c.

{
    /*
     * For output to a tty, erase prior contents of progress line. When either
     * tty or verbose, indent so that report_status() output will align
     * nicely.
     */
    if (log_opts.isatty)
    {
        printf("\r");
        pg_log(PG_REPORT_NONL, "%-*s", MESSAGE_WIDTH, "");
    }
    else if (log_opts.verbose)
        pg_log(PG_REPORT_NONL, "%-*s", MESSAGE_WIDTH, "");
}

References LogOpts::isatty, log_opts, MESSAGE_WIDTH, pg_log(), PG_REPORT_NONL, printf, and LogOpts::verbose.

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

exec_prog()

bool exec_prog	(	const char *	log_filename,
		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_connection_status(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_is_install_user(), check_new_cluster_logical_replication_slots(), check_new_cluster_subscription_configuration(), check_old_cluster_subscription_state(), create_logical_replication_slots(), create_new_objects(), get_db_infos(), get_subscription_count(), get_tablespace_paths(), get_template0_info(), old_9_6_invalidate_hash_indexes(), set_frozenxids(), set_locale_and_encoding(), and unicode_version_changed().

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 45 of file info.c.

{
    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).
         */
        if (strcmp(old_rel->nspname, new_rel->nspname) != 0 ||
            strcmp(old_rel->relname, new_rel->relname) != 0)
        {
            pg_log(PG_WARNING, "Relation names for OID %u in database \"%s\" do not match: "
                   "old name \"%s.%s\", new name \"%s.%s\"",
                   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\"",
                 old_db->db_name);
 
    *nmaps = num_maps;
    return maps;
}

References create_rel_filename_map(), DbInfo::db_name, maps, RelInfoArr::nrels, RelInfo::nspname, 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().

generate_old_dump()

void generate_old_dump

(

void

)

Definition at line 16 of file dump.c.

{
    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 --no-sync -f \"%s/%s\"",
              new_cluster.bindir, cluster_conn_opts(&old_cluster),
              log_opts.verbose ? "--verbose" : "",
              log_opts.dumpdir,
              GLOBALS_DUMP_FILE);
    check_ok();
 
    prep_status_progress("Creating dump of database schemas");
 
    /* 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 --no-data %s %s --quote-all-identifiers "
                           "--binary-upgrade --format=custom %s --no-sync --file=\"%s/%s\" %s",
                           new_cluster.bindir, cluster_conn_opts(&old_cluster),
                           (user_opts.transfer_mode == TRANSFER_MODE_SWAP) ?
                           "" : "--sequence-data",
                           log_opts.verbose ? "--verbose" : "",
                           user_opts.do_statistics ? "" : "--no-statistics",
                           log_opts.dumpdir,
                           sql_file_name, escaped_connstr.data);
 
        termPQExpBuffer(&escaped_connstr);
    }
 
    /* reap all children */
    while (reap_child(true) == true)
        ;
 
    end_progress_output();
    check_ok();
}

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, UserOpts::do_statistics, LogOpts::dumpdir, 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(), prep_status_progress(), reap_child(), snprintf, termPQExpBuffer(), UserOpts::transfer_mode, TRANSFER_MODE_SWAP, user_opts, UTILITY_LOG_FILE, and LogOpts::verbose.

Referenced by check_and_dump_old_cluster().

get_control_data()

void get_control_data

(

ClusterInfo *

cluster

)

Definition at line 38 of file controldata.c.

{
    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_oldestxid = 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;
    bool        got_default_char_signedness = 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;
    int         rc;
    bool        live_check = (cluster == &old_cluster && user_opts.live_check);
 
    /*
     * 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"));
 
    unsetenv("LC_COLLATE");
    unsetenv("LC_CTYPE");
    unsetenv("LC_MONETARY");
    unsetenv("LC_NUMERIC");
    unsetenv("LC_TIME");
#ifndef WIN32
    unsetenv("LANG");
#else
    /* On Windows the default locale may not be English, so force it */
    setenv("LANG", "en", 1);
#endif
    unsetenv("LANGUAGE");
    unsetenv("LC_ALL");
    setenv("LC_MESSAGES", "C", 1);
 
    /*
     * 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(NULL);
 
        if ((output = popen(cmd, "r")) == NULL)
            pg_fatal("could not get control data using %s: %m", cmd);
 
        /* 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", __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 trailing newline and leading spaces */
                (void) pg_strip_crlf(p);
                while (*p == ' ')
                    p++;
                if (strcmp(p, "shut down in recovery") == 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.");
                    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.");
                }
                else if (strcmp(p, "shut down") != 0)
                {
                    if (cluster == &old_cluster)
                        pg_fatal("The source cluster was not shut down cleanly, state reported as: \"%s\"", p);
                    else
                        pg_fatal("The target cluster was not shut down cleanly, state reported as: \"%s\"", p);
                }
                got_cluster_state = true;
            }
        }
 
        rc = pclose(output);
        if (rc != 0)
            pg_fatal("could not get control data using %s: %s",
                     cmd, wait_result_to_str(rc));
 
        if (!got_cluster_state)
        {
            if (cluster == &old_cluster)
                pg_fatal("The source cluster lacks cluster state information:");
            else
                pg_fatal("The target cluster lacks cluster state information:");
        }
    }
 
    /* pg_resetxlog has been renamed to pg_resetwal in version 10 */
    if (GET_MAJOR_VERSION(cluster->bin_version) <= 906)
        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(NULL);
 
    if ((output = popen(cmd, "r")) == NULL)
        pg_fatal("could not get control data using %s: %m", cmd);
 
    /* 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))
    {
        /* In verbose mode, log each line */
        pg_strip_crlf(bufin);
        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", __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", __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", __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", __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", __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", __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", __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", __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", __LINE__);
 
            p++;                /* remove ':' char */
            cluster->controldata.chkpnt_nxtmulti = str2uint(p);
            got_multi = true;
        }
        else if ((p = strstr(bufin, "Latest checkpoint's oldestXID:")) != NULL)
        {
            p = strchr(p, ':');
 
            if (p == NULL || strlen(p) <= 1)
                pg_fatal("%d: controldata retrieval problem", __LINE__);
 
            p++;                /* remove ':' char */
            cluster->controldata.chkpnt_oldstxid = str2uint(p);
            got_oldestxid = 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", __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", __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", __LINE__);
            p = strpbrk(p, "01234567890ABCDEF");
            if (p == NULL || strlen(p) <= 1)
                pg_fatal("%d: controldata retrieval problem", __LINE__);
 
            /* Make sure it looks like a valid WAL file name */
            if (strspn(p, "0123456789ABCDEF") != 24)
                pg_fatal("%d: controldata retrieval problem", __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", __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", __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", __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", __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", __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", __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", __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", __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", __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", __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", __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", __LINE__);
 
            p++;                /* remove ':' char */
            cluster->controldata.data_checksum_version = str2uint(p);
            got_data_checksum_version = true;
        }
        else if ((p = strstr(bufin, "Default char data signedness:")) != NULL)
        {
            p = strchr(p, ':');
 
            if (p == NULL || strlen(p) <= 1)
                pg_fatal("%d: controldata retrieval problem", __LINE__);
 
            /* Skip the colon and any whitespace after it */
            p++;
            while (isspace((unsigned char) *p))
                p++;
 
            /* The value should be either 'signed' or 'unsigned' */
            if (strcmp(p, "signed") != 0 && strcmp(p, "unsigned") != 0)
                pg_fatal("%d: controldata retrieval problem", __LINE__);
 
            cluster->controldata.default_char_signedness = strcmp(p, "signed") == 0;
            got_default_char_signedness = true;
        }
    }
 
    rc = pclose(output);
    if (rc != 0)
        pg_fatal("could not get control data using %s: %s",
                 cmd, wait_result_to_str(rc));
 
    /*
     * Restore environment variables.  Note all but LANG and LC_MESSAGES were
     * unset above.
     */
    if (lc_collate)
        setenv("LC_COLLATE", lc_collate, 1);
    if (lc_ctype)
        setenv("LC_CTYPE", lc_ctype, 1);
    if (lc_monetary)
        setenv("LC_MONETARY", lc_monetary, 1);
    if (lc_numeric)
        setenv("LC_NUMERIC", lc_numeric, 1);
    if (lc_time)
        setenv("LC_TIME", lc_time, 1);
    if (lang)
        setenv("LANG", lang, 1);
    else
        unsetenv("LANG");
    if (language)
        setenv("LANGUAGE", language, 1);
    if (lc_all)
        setenv("LC_ALL", lc_all, 1);
    if (lc_messages)
        setenv("LC_MESSAGES", lc_messages, 1);
    else
        unsetenv("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;
        }
    }
 
    /*
     * Pre-v18 database clusters don't have the default char signedness
     * information. We use the char signedness of the platform where
     * pg_upgrade was built.
     */
    if (cluster->controldata.cat_ver < DEFAULT_CHAR_SIGNEDNESS_CAT_VER)
    {
        Assert(!got_default_char_signedness);
#if CHAR_MIN != 0
        cluster->controldata.default_char_signedness = true;
#else
        cluster->controldata.default_char_signedness = false;
#endif
    }
 
    /* verify that we got all the mandatory pg_control data */
    if (!got_xid || !got_oid ||
        !got_multi || !got_oldestxid ||
        (!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 ||
        (!got_default_char_signedness &&
         cluster->controldata.cat_ver >= DEFAULT_CHAR_SIGNEDNESS_CAT_VER))
    {
        if (cluster == &old_cluster)
            pg_log(PG_REPORT,
                   "The source cluster lacks some required control information:");
        else
            pg_log(PG_REPORT,
                   "The target cluster lacks some required control information:");
 
        if (!got_xid)
            pg_log(PG_REPORT, "  checkpoint next XID");
 
        if (!got_oid)
            pg_log(PG_REPORT, "  latest checkpoint next OID");
 
        if (!got_multi)
            pg_log(PG_REPORT, "  latest checkpoint next MultiXactId");
 
        if (!got_oldestmulti &&
            cluster->controldata.cat_ver >= MULTIXACT_FORMATCHANGE_CAT_VER)
            pg_log(PG_REPORT, "  latest checkpoint oldest MultiXactId");
 
        if (!got_oldestxid)
            pg_log(PG_REPORT, "  latest checkpoint oldestXID");
 
        if (!got_mxoff)
            pg_log(PG_REPORT, "  latest checkpoint next MultiXactOffset");
 
        if (!live_check && !got_nextxlogfile)
            pg_log(PG_REPORT, "  first WAL segment after reset");
 
        if (!got_float8_pass_by_value)
            pg_log(PG_REPORT, "  float8 argument passing method");
 
        if (!got_align)
            pg_log(PG_REPORT, "  maximum alignment");
 
        if (!got_blocksz)
            pg_log(PG_REPORT, "  block size");
 
        if (!got_largesz)
            pg_log(PG_REPORT, "  large relation segment size");
 
        if (!got_walsz)
            pg_log(PG_REPORT, "  WAL block size");
 
        if (!got_walseg)
            pg_log(PG_REPORT, "  WAL segment size");
 
        if (!got_ident)
            pg_log(PG_REPORT, "  maximum identifier length");
 
        if (!got_index)
            pg_log(PG_REPORT, "  maximum number of indexed columns");
 
        if (!got_toast)
            pg_log(PG_REPORT, "  maximum TOAST chunk size");
 
        if (!got_large_object &&
            cluster->controldata.ctrl_ver >= LARGE_OBJECT_SIZE_PG_CONTROL_VER)
            pg_log(PG_REPORT, "  large-object chunk size");
 
        if (!got_date_is_int)
            pg_log(PG_REPORT, "  dates/times are integers?");
 
        /* value added in Postgres 9.3 */
        if (!got_data_checksum_version)
            pg_log(PG_REPORT, "  data checksum version");
 
        /* value added in Postgres 18 */
        if (!got_default_char_signedness)
            pg_log(PG_REPORT, "  default char signedness");
 
        pg_fatal("Cannot continue without required control information, terminating");
    }
}

References Assert(), cluster(), DEFAULT_CHAR_SIGNEDNESS_CAT_VER, GET_MAJOR_VERSION, LARGE_OBJECT_SIZE_PG_CONTROL_VER, lc_collate, lc_ctype, lc_messages, lc_monetary, lc_numeric, lc_time, UserOpts::live_check, MAX_STRING, MAXPGPATH, MULTIXACT_FORMATCHANGE_CAT_VER, new_cluster, old_cluster, output, pg_fatal, pg_free(), pg_log(), PG_REPORT, pg_strdup(), pg_strip_crlf(), PG_VERBOSE, setenv, snprintf, str2uint(), strlcpy(), unsetenv, user_opts, and wait_result_to_str().

Referenced by check_cluster_compatibility().

get_db_rel_and_slot_infos()

void get_db_rel_and_slot_infos

(

ClusterInfo *

cluster

)

Definition at line 280 of file info.c.

{
    UpgradeTask *task = upgrade_task_create();
    char       *rel_infos_query = NULL;
    char       *logical_slot_infos_query = NULL;
 
    if (cluster->dbarr.dbs != NULL)
        free_db_and_rel_infos(&cluster->dbarr);
 
    get_template0_info(cluster);
    get_db_infos(cluster);
 
    rel_infos_query = get_rel_infos_query();
    upgrade_task_add_step(task,
                          rel_infos_query,
                          process_rel_infos,
                          true, NULL);
 
    /*
     * Logical slots are only carried over to the new cluster when the old
     * cluster is on PG17 or newer.  This is because before that the logical
     * slots are not saved at shutdown, so there is no guarantee that the
     * latest confirmed_flush_lsn is saved to disk which can lead to data
     * loss. It is still not guaranteed for manually created slots in PG17, so
     * subsequent checks done in check_old_cluster_for_valid_slots() would
     * raise a FATAL error if such slots are included.
     */
    if (cluster == &old_cluster &&
        GET_MAJOR_VERSION(cluster->major_version) > 1600)
    {
        logical_slot_infos_query = get_old_cluster_logical_slot_infos_query();
        upgrade_task_add_step(task,
                              logical_slot_infos_query,
                              process_old_cluster_logical_slot_infos,
                              true, NULL);
    }
 
    upgrade_task_run(task, cluster);
    upgrade_task_free(task);
 
    pg_free(rel_infos_query);
    if (logical_slot_infos_query)
        pg_free(logical_slot_infos_query);
 
    if (cluster == &old_cluster)
        pg_log(PG_VERBOSE, "\nsource databases:");
    else
        pg_log(PG_VERBOSE, "\ntarget databases:");
 
    if (log_opts.verbose)
        print_db_infos(&cluster->dbarr);
}

References cluster(), free_db_and_rel_infos(), get_db_infos(), GET_MAJOR_VERSION, get_old_cluster_logical_slot_infos_query(), get_rel_infos_query(), get_template0_info(), log_opts, old_cluster, pg_free(), pg_log(), PG_VERBOSE, print_db_infos(), process_old_cluster_logical_slot_infos(), process_rel_infos(), upgrade_task_add_step(), upgrade_task_create(), upgrade_task_free(), upgrade_task_run(), and LogOpts::verbose.

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

get_loadable_libraries()

void get_loadable_libraries

(

void

)

Definition at line 79 of file function.c.

{
    int         totaltups;
    int         dbnum;
    int         n_libinfos;
    UpgradeTask *task = upgrade_task_create();
    struct loadable_libraries_state state;
    char       *query;
 
    state.ress = (PGresult **) pg_malloc(old_cluster.dbarr.ndbs * sizeof(PGresult *));
    state.totaltups = 0;
 
    query = psprintf("SELECT DISTINCT probin "
                     "FROM pg_catalog.pg_proc "
                     "WHERE prolang = %u AND "
                     "probin IS NOT NULL AND "
                     "oid >= %u",
                     ClanguageId,
                     FirstNormalObjectId);
 
    upgrade_task_add_step(task, query, process_loadable_libraries,
                          false, &state);
 
    upgrade_task_run(task, &old_cluster);
    upgrade_task_free(task);
 
    /*
     * Allocate memory for required libraries and logical replication output
     * plugins.
     */
    n_libinfos = state.totaltups + count_old_cluster_logical_slots();
    os_info.libraries = (LibraryInfo *) pg_malloc(sizeof(LibraryInfo) * n_libinfos);
    totaltups = 0;
 
    for (dbnum = 0; dbnum < old_cluster.dbarr.ndbs; dbnum++)
    {
        PGresult   *res = state.ress[dbnum];
        int         ntups;
        int         rowno;
        LogicalSlotInfoArr *slot_arr = &old_cluster.dbarr.dbs[dbnum].slot_arr;
 
        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);
 
        /*
         * Store the names of output plugins as well. There is a possibility
         * that duplicated plugins are set, but the consumer function
         * check_loadable_libraries() will avoid checking the same library, so
         * we do not have to consider their uniqueness here.
         */
        for (int slotno = 0; slotno < slot_arr->nslots; slotno++)
        {
            if (slot_arr->slots[slotno].invalid)
                continue;
 
            os_info.libraries[totaltups].name = pg_strdup(slot_arr->slots[slotno].plugin);
            os_info.libraries[totaltups].dbnum = dbnum;
 
            totaltups++;
        }
    }
 
    pg_free(state.ress);
    pg_free(query);
 
    os_info.num_libraries = totaltups;
}

References count_old_cluster_logical_slots(), ClusterInfo::dbarr, LibraryInfo::dbnum, DbInfoArr::dbs, FirstNormalObjectId, LogicalSlotInfo::invalid, OSInfo::libraries, LibraryInfo::name, DbInfoArr::ndbs, LogicalSlotInfoArr::nslots, OSInfo::num_libraries, old_cluster, os_info, pg_free(), pg_malloc(), pg_strdup(), LogicalSlotInfo::plugin, PQclear(), PQgetvalue(), PQntuples(), process_loadable_libraries(), psprintf(), DbInfo::slot_arr, LogicalSlotInfoArr::slots, loadable_libraries_state::totaltups, upgrade_task_add_step(), upgrade_task_create(), upgrade_task_free(), and upgrade_task_run().

Referenced by check_and_dump_old_cluster().

get_major_server_version()

uint32 get_major_server_version

(

ClusterInfo *

cluster

)

Definition at line 159 of file server.c.

{
    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\": %m", 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 version file \"%s\"", ver_filename);
 
    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;
    }
}

References cluster(), MAXPGPATH, pg_fatal, and snprintf.

Referenced by check_data_dir().

get_sock_dir()

void get_sock_dir

(

ClusterInfo *

cluster

)

Definition at line 499 of file option.c.

{
#if !defined(WIN32)
    if (!user_opts.live_check || cluster == &new_cluster)
        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\": %m", filename);
 
        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\": %m",
                         lineno, filename);
 
            /* 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",
                   orig_port, cluster->port);
    }
#else                           /* WIN32 */
    cluster->sockdir = NULL;
#endif
}

References cluster(), DEF_PGUPORT, filename, UserOpts::live_check, LOCK_FILE_LINE_PORT, LOCK_FILE_LINE_SOCKET_DIR, Max, MAXPGPATH, new_cluster, old_cluster, pg_fatal, pg_log(), pg_strdup(), pg_strip_crlf(), PG_WARNING, ClusterInfo::port, snprintf, UserOpts::socketdir, and user_opts.

Referenced by main().

get_subscription_count()

void get_subscription_count

(

ClusterInfo *

cluster

)

Definition at line 760 of file info.c.

{
    PGconn     *conn;
    PGresult   *res;
 
    conn = connectToServer(cluster, "template1");
    res = executeQueryOrDie(conn, "SELECT count(*) "
                            "FROM pg_catalog.pg_subscription");
    cluster->nsubs = atoi(PQgetvalue(res, 0, 0));
 
    PQclear(res);
    PQfinish(conn);
}

References cluster(), conn, connectToServer(), executeQueryOrDie(), PQclear(), PQfinish(), and PQgetvalue().

Referenced by check_and_dump_old_cluster().

get_user_info()

int get_user_info

(

char **

user_name_p

)

Definition at line 323 of file util.c.

{
    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", errstr);
 
    /* make a copy */
    *user_name_p = pg_strdup(user_name);
 
    return user_id;
}

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

Referenced by parseCommandLine().

init_tablespaces()

void init_tablespaces

(

void

)

Definition at line 19 of file tablespace.c.

{
    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.");
}

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().

issue_warnings_and_set_wal_level()

void issue_warnings_and_set_wal_level

(

void

)

Definition at line 783 of file check.c.

{
    /*
     * 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);
 
    /* 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);
 
    report_extension_updates(&new_cluster);
 
    stop_postmaster(false);
}

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

Referenced by main().

jsonb_9_4_check_applicable()

bool jsonb_9_4_check_applicable

(

ClusterInfo *

cluster

)

Definition at line 21 of file version.c.

{
    /* JSONB changed its storage format during 9.4 beta */
    if (GET_MAJOR_VERSION(cluster->major_version) == 904 &&
        cluster->controldata.cat_ver < JSONB_FORMAT_CHANGE_CAT_VER)
        return true;
 
    return false;
}

References cluster(), GET_MAJOR_VERSION, and JSONB_FORMAT_CHANGE_CAT_VER.

linkFile()

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

Definition at line 190 of file file.c.

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

References link(), and pg_fatal.

Referenced by transfer_relfile().

old_9_6_invalidate_hash_indexes()

void old_9_6_invalidate_hash_indexes	(	ClusterInfo *	cluster,
		bool	check_mode
	)

Definition at line 37 of file version.c.

{
    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\": %m", output_path);
                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.");
        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.",
                   output_path);
    }
    else
        check_ok();
}

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

Referenced by check_and_dump_old_cluster(), and issue_warnings_and_set_wal_level().

output_check_banner()

void output_check_banner

(

void

)

Definition at line 570 of file check.c.

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

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

Referenced by main().

output_completion_banner()

void output_completion_banner

(

char *

deletion_script_file_name

)

Definition at line 804 of file check.c.

{
    PQExpBufferData user_specification;
 
    initPQExpBuffer(&user_specification);
    if (os_info.user_specified)
    {
        appendPQExpBufferStr(&user_specification, "-U ");
        appendShellString(&user_specification, os_info.user);
        appendPQExpBufferChar(&user_specification, ' ');
    }
 
    pg_log(PG_REPORT,
           "Some statistics are not transferred by pg_upgrade.\n"
           "Once you start the new server, consider running these two commands:\n"
           "    %s/vacuumdb %s--all --analyze-in-stages --missing-stats-only\n"
           "    %s/vacuumdb %s--all --analyze-only",
           new_cluster.bindir, user_specification.data,
           new_cluster.bindir, user_specification.data);
 
    if (deletion_script_file_name)
        pg_log(PG_REPORT,
               "Running this script will delete the old cluster's data files:\n"
               "    %s",
               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.");
 
    termPQExpBuffer(&user_specification);
}

References appendPQExpBufferChar(), appendPQExpBufferStr(), appendShellString(), ClusterInfo::bindir, PQExpBufferData::data, initPQExpBuffer(), new_cluster, os_info, pg_log(), PG_REPORT, termPQExpBuffer(), OSInfo::user, and OSInfo::user_specified.

Referenced by main().

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 172 of file parallel.c.

{
#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: %m");
#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;
        pg_free(new_arg->old_pgdata);
        new_arg->old_pgdata = pg_strdup(old_pgdata);
        pg_free(new_arg->new_pgdata);
        new_arg->new_pgdata = pg_strdup(new_pgdata);
        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: %m");
 
        thread_handles[parallel_jobs - 1] = child;
#endif
    }
}

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

Referenced by transfer_all_new_tablespaces().

parseCommandLine()

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

Definition at line 39 of file option.c.

{
    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'},
        {"no-sync", no_argument, NULL, 'N'},
        {"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},
        {"copy", no_argument, NULL, 2},
        {"copy-file-range", no_argument, NULL, 3},
        {"sync-method", required_argument, NULL, 4},
        {"no-statistics", no_argument, NULL, 5},
        {"set-char-signedness", required_argument, NULL, 6},
        {"swap", no_argument, NULL, 7},
 
        {NULL, 0, NULL, 0}
    };
    int         option;         /* Command line option */
    int         optindex = 0;   /* used by getopt_long */
    int         os_user_effective_id;
    DataDirSyncMethod unused;
 
    user_opts.do_sync = true;
    user_opts.transfer_mode = TRANSFER_MODE_COPY;
    user_opts.do_statistics = true;
    user_opts.char_signedness = -1;
 
    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", os_info.progname);
 
    while ((option = getopt_long(argc, argv, "b:B:cd:D:j:kNo: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 'N':
                user_opts.do_sync = false;
                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;
 
            case 'p':
                if ((old_cluster.port = atoi(optarg)) <= 0)
                    pg_fatal("invalid old port number");
                break;
 
            case 'P':
                if ((new_cluster.port = atoi(optarg)) <= 0)
                    pg_fatal("invalid new port number");
                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;
                break;
 
            case 'v':
                log_opts.verbose = true;
                break;
 
            case 1:
                user_opts.transfer_mode = TRANSFER_MODE_CLONE;
                break;
 
            case 2:
                user_opts.transfer_mode = TRANSFER_MODE_COPY;
                break;
 
            case 3:
                user_opts.transfer_mode = TRANSFER_MODE_COPY_FILE_RANGE;
                break;
            case 4:
                if (!parse_sync_method(optarg, &unused))
                    exit(1);
                user_opts.sync_method = pg_strdup(optarg);
                break;
 
            case 5:
                user_opts.do_statistics = false;
                break;
 
            case 6:
                if (pg_strcasecmp(optarg, "signed") == 0)
                    user_opts.char_signedness = 1;
                else if (pg_strcasecmp(optarg, "unsigned") == 0)
                    user_opts.char_signedness = 0;
                else
                    pg_fatal("invalid argument for option %s", "--set-char-signedness");
                break;
 
            case 7:
                user_opts.transfer_mode = TRANSFER_MODE_SWAP;
                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\")", argv[optind]);
 
    if (!user_opts.sync_method)
        user_opts.sync_method = pg_strdup("fsync");
 
    if (log_opts.verbose)
        pg_log(PG_REPORT, "Running in verbose mode");
 
    log_opts.isatty = isatty(fileno(stdout));
 
    /* Turn off read-only mode;  add prefix to PGOPTIONS? */
    if (getenv("PGOPTIONS"))
    {
        char       *pgoptions = psprintf("%s %s", FIX_DEFAULT_READ_ONLY,
                                         getenv("PGOPTIONS"));
 
        setenv("PGOPTIONS", pgoptions, 1);
        pfree(pgoptions);
    }
    else
        setenv("PGOPTIONS", FIX_DEFAULT_READ_ONLY, 1);
 
    /* 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");
        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");
    }
#endif
}

References _, ClusterInfo::bindir, canonicalize_path(), UserOpts::char_signedness, UserOpts::check, check_required_directory(), DEF_PGUPORT, UserOpts::do_statistics, UserOpts::do_sync, FIX_DEFAULT_READ_ONLY, fprintf, free, get_progname(), get_user_info(), getopt_long(), LogOpts::isatty, UserOpts::jobs, log_opts, MAXPGPATH, new_cluster, no_argument, old_cluster, optarg, optind, os_info, parse_sync_method(), path_is_prefix_of_path(), pfree(), pg_fatal, pg_free(), pg_log(), PG_REPORT, pg_strcasecmp(), pg_strdup(), ClusterInfo::pgdata, ClusterInfo::pgopts, ClusterInfo::port, OSInfo::progname, psprintf(), required_argument, LogOpts::retain, setenv, UserOpts::socketdir, generate_unaccent_rules::stdout, strlcpy(), UserOpts::sync_method, UserOpts::transfer_mode, TRANSFER_MODE_CLONE, TRANSFER_MODE_COPY, TRANSFER_MODE_COPY_FILE_RANGE, TRANSFER_MODE_LINK, TRANSFER_MODE_SWAP, usage(), OSInfo::user, user_opts, OSInfo::user_specified, and LogOpts::verbose.

Referenced by main().

pg_fatal()

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

pg_log()

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

Referenced by check_for_connection_status(), check_for_incompatible_polymorphics(), check_for_isn_and_int8_passing_mismatch(), check_for_pg_role_prefix(), check_for_tables_with_oids(), check_for_unicode_update(), check_for_user_defined_encoding_conversions(), check_for_user_defined_postfix_ops(), check_loadable_libraries(), check_old_cluster_for_valid_slots(), check_old_cluster_subscription_state(), connectToServer(), create_logical_replication_slots(), 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_rel_and_slot_infos(), get_sock_dir(), main(), old_9_6_invalidate_hash_indexes(), output_check_banner(), output_completion_banner(), parseCommandLine(), print_db_infos(), print_rel_infos(), print_slot_infos(), process_data_type_check(), report_clusters_compatible(), report_extension_updates(), report_unmatched_relation(), start_postmaster(), and transfer_relfile().

pid_lock_file_exists()

bool pid_lock_file_exists

(

const char *

datadir

)

Definition at line 233 of file exec.c.

{
    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: %m", path);
 
        return false;
    }
 
    close(fd);
    return true;
}

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

Referenced by setup().

prep_status()

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

Referenced by adjust_data_dir(), check_cluster_versions(), check_for_connection_status(), check_for_data_types_usage(), check_for_incompatible_polymorphics(), check_for_isn_and_int8_passing_mismatch(), check_for_new_tablespace_dir(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_for_tables_with_oids(), check_for_unicode_update(), check_for_user_defined_encoding_conversions(), check_for_user_defined_postfix_ops(), check_is_install_user(), check_loadable_libraries(), check_new_cluster_logical_replication_slots(), check_new_cluster_subscription_configuration(), check_old_cluster_for_valid_slots(), check_old_cluster_subscription_state(), copy_subdir_files(), copy_xact_xlog_xid(), create_script_for_old_cluster_deletion(), disable_old_cluster(), generate_old_dump(), main(), old_9_6_invalidate_hash_indexes(), prepare_new_cluster(), prepare_new_globals(), remove_new_subdir(), report_extension_updates(), set_frozenxids(), set_locale_and_encoding(), and set_new_cluster_char_signedness().

prep_status_progress()

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

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

quote_identifier()

char * quote_identifier

(

const char *

s

)

Definition at line 13019 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 278 of file parallel.c.

{
#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("%s() failed: %m", "waitpid");
    if (child == 0)
        return false;           /* no children, or no dead children */
    if (work_status != 0)
        pg_fatal("child process exited abnormally: status %d", 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: %m");
 
    /* 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;
}

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

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

report_clusters_compatible()

void report_clusters_compatible

(

void

)

Definition at line 764 of file check.c.

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

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

Referenced by main().

report_extension_updates()

void report_extension_updates

(

ClusterInfo *

cluster

)

Definition at line 179 of file version.c.

{
    UpgradeTaskReport report;
    UpgradeTask *task = upgrade_task_create();
    const char *query = "SELECT name "
        "FROM pg_available_extensions "
        "WHERE installed_version != default_version";
 
    prep_status("Checking for extension updates");
 
    report.file = NULL;
    strcpy(report.path, "update_extensions.sql");
 
    upgrade_task_add_step(task, query, process_extension_updates,
                          true, &report);
 
    upgrade_task_run(task, cluster);
    upgrade_task_free(task);
 
    if (report.file)
    {
        fclose(report.file);
        report_status(PG_REPORT, "notice");
        pg_log(PG_REPORT, "\n"
               "Your installation contains extensions that should be updated\n"
               "with the ALTER EXTENSION command.  The file\n"
               "    %s\n"
               "when executed by psql by the database superuser will update\n"
               "these extensions.",
               report.path);
    }
    else
        check_ok();
}

References check_ok(), cluster(), UpgradeTaskReport::file, UpgradeTaskReport::path, pg_log(), PG_REPORT, prep_status(), process_extension_updates(), report_status(), upgrade_task_add_step(), upgrade_task_create(), upgrade_task_free(), and upgrade_task_run().

Referenced by issue_warnings_and_set_wal_level().

report_status()

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

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

rewriteVisibilityMap()

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

Definition at line 216 of file file.c.

{
    int         src_fd;
    int         dst_fd;
    PGIOAlignedBlock buffer;
    PGIOAlignedBlock 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\": %m",
                 schemaName, relName, fromfile);
 
    if (fstat(src_fd, &statbuf) != 0)
        pg_fatal("error while copying relation \"%s.%s\": could not stat file \"%s\": %m",
                 schemaName, relName, fromfile);
 
    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\": %m",
                 schemaName, relName, tofile);
 
    /* 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\": %m",
                         schemaName, relName, fromfile);
            else
                pg_fatal("error while copying relation \"%s.%s\": partial page found in file \"%s\"",
                         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\": %m",
                         schemaName, relName, tofile);
            }
 
            /* Advance for next new page */
            old_break += rewriteVmBytesPerPage;
            new_blkno++;
        }
    }
 
    /* Clean up */
    close(dst_fd);
    close(src_fd);
}

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

Referenced by transfer_relfile().

start_postmaster()

bool start_postmaster	(	ClusterInfo *	cluster,
		bool	report_and_exit_on_error
	)

Definition at line 198 of file server.c.

{
    char        cmd[MAXPGPATH * 4 + 1000];
    PGconn     *conn;
    bool        pg_ctl_return = false;
    char        socket_string[MAXPGPATH + 200];
    PQExpBufferData pgoptions;
 
    static bool exit_hook_registered = false;
 
    if (!exit_hook_registered)
    {
        atexit(stop_postmaster_atexit);
        exit_hook_registered = true;
    }
 
    socket_string[0] = '\0';
 
#if !defined(WIN32)
    /* 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) <= 902) ?
                 "unix_socket_directory" : "unix_socket_directories",
                 cluster->sockdir);
#endif
 
    initPQExpBuffer(&pgoptions);
 
    /*
     * Construct a parameter string which is passed to the server process.
     *
     * 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.
     */
    if (cluster == &new_cluster)
        appendPQExpBufferStr(&pgoptions, " -c synchronous_commit=off -c fsync=off -c full_page_writes=off");
 
    /*
     * Use max_slot_wal_keep_size as -1 to prevent the WAL removal by the
     * checkpointer process.  If WALs required by logical replication slots
     * are removed, the slots are unusable.  This setting prevents the
     * invalidation of slots during the upgrade. We set this option when
     * cluster is PG17 or later because logical replication slots can only be
     * migrated since then. Besides, max_slot_wal_keep_size is added in PG13.
     */
    if (GET_MAJOR_VERSION(cluster->major_version) >= 1700)
        appendPQExpBufferStr(&pgoptions, " -c max_slot_wal_keep_size=-1");
 
    /*
     * Use idle_replication_slot_timeout=0 to prevent slot invalidation due to
     * idle_timeout by checkpointer process during upgrade.
     */
    if (GET_MAJOR_VERSION(cluster->major_version) >= 1800)
        appendPQExpBufferStr(&pgoptions, " -c idle_replication_slot_timeout=0");
 
    /*
     * Use -b to disable autovacuum and logical replication launcher
     * (effective in PG17 or later for the latter).
     */
    snprintf(cmd, sizeof(cmd),
             "\"%s/pg_ctl\" -w -l \"%s/%s\" -D \"%s\" -o \"-p %d -b%s %s%s\" start",
             cluster->bindir,
             log_opts.logdir,
             SERVER_LOG_FILE, cluster->pgconfig, cluster->port,
             pgoptions.data,
             cluster->pgopts ? cluster->pgopts : "", socket_string);
 
    termPQExpBuffer(&pgoptions);
 
    /*
     * 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, "\n%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",
                     cmd);
        else
            pg_fatal("could not connect to target postmaster started with the command:\n"
                     "%s",
                     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");
        else
            pg_fatal("pg_ctl failed to start the target server, or connection failed");
    }
 
    return true;
}

References appendPQExpBufferStr(), cluster(), conn, CONNECTION_OK, PQExpBufferData::data, exec_prog(), get_db_conn(), GET_MAJOR_VERSION, initPQExpBuffer(), log_opts, LogOpts::logdir, MAXPGPATH, new_cluster, old_cluster, os_info, pg_fatal, pg_log(), PG_REPORT, PQerrorMessage(), PQfinish(), PQstatus(), OSInfo::running_cluster, SERVER_LOG_FILE, SERVER_START_LOG_FILE, snprintf, stop_postmaster_atexit(), and termPQExpBuffer().

stop_postmaster()

void stop_postmaster

(

bool

in_atexit

)

Definition at line 349 of file server.c.

{
    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;
}

References cluster(), exec_prog(), new_cluster, old_cluster, os_info, 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().

str2uint()

void void unsigned int str2uint

(

const char *

str

)

Definition at line 352 of file util.c.

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

References str.

Referenced by get_control_data().

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 171 of file relfilenumber.c.

{
    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",
                     old_db->db_name);
 
        mappings = gen_db_file_maps(old_db, new_db, &n_maps, old_pgdata,
                                    new_pgdata);
        if (n_maps)
        {
            transfer_single_new_db(mappings, n_maps, old_tablespace);
        }
        /* We allocate something even for n_maps == 0 */
        pg_free(mappings);
    }
 
    /*
     * Make sure anything pending synchronization in swap mode is fully
     * persisted to disk.  This is a no-op for other transfer modes.
     */
    sync_queue_sync_all();
    sync_queue_destroy();
}

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

Referenced by parallel_transfer_all_new_dbs().

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 108 of file relfilenumber.c.

{
    switch (user_opts.transfer_mode)
    {
        case TRANSFER_MODE_CLONE:
            prep_status_progress("Cloning user relation files");
            break;
        case TRANSFER_MODE_COPY:
            prep_status_progress("Copying user relation files");
            break;
        case TRANSFER_MODE_COPY_FILE_RANGE:
            prep_status_progress("Copying user relation files with copy_file_range");
            break;
        case TRANSFER_MODE_LINK:
            prep_status_progress("Linking user relation files");
            break;
        case TRANSFER_MODE_SWAP:
            prep_status_progress("Swapping data directories");
            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();
}

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

Referenced by main().

upgrade_task_add_step()

void upgrade_task_add_step	(	UpgradeTask *	task,
		const char *	query,
		UpgradeTaskProcessCB	process_cb,
		bool	free_result,
		void *	arg
	)

Definition at line 151 of file task.c.

{
    UpgradeTaskStep *new_step;
 
    task->steps = pg_realloc(task->steps,
                             ++task->num_steps * sizeof(UpgradeTaskStep));
 
    new_step = &task->steps[task->num_steps - 1];
    new_step->process_cb = process_cb;
    new_step->free_result = free_result;
    new_step->arg = arg;
 
    appendPQExpBuffer(task->queries, "%s;", query);
}

References appendPQExpBuffer(), arg, UpgradeTaskStep::arg, UpgradeTaskStep::free_result, UpgradeTask::num_steps, pg_realloc(), UpgradeTaskStep::process_cb, UpgradeTask::queries, and UpgradeTask::steps.

Referenced by check_for_data_types_usage(), check_for_incompatible_polymorphics(), check_for_isn_and_int8_passing_mismatch(), check_for_tables_with_oids(), check_for_unicode_update(), check_for_user_defined_encoding_conversions(), check_for_user_defined_postfix_ops(), check_old_cluster_subscription_state(), get_db_rel_and_slot_infos(), get_loadable_libraries(), report_extension_updates(), and upgrade_task_create().

upgrade_task_create()

UpgradeTask * upgrade_task_create

(

void

)

Definition at line 117 of file task.c.

{
    UpgradeTask *task = pg_malloc0(sizeof(UpgradeTask));
 
    task->queries = createPQExpBuffer();
 
    /* All tasks must first set a secure search_path. */
    upgrade_task_add_step(task, ALWAYS_SECURE_SEARCH_PATH_SQL, NULL, true, NULL);
 
    return task;
}

References ALWAYS_SECURE_SEARCH_PATH_SQL, createPQExpBuffer(), pg_malloc0(), UpgradeTask::queries, and upgrade_task_add_step().

Referenced by check_for_data_types_usage(), check_for_incompatible_polymorphics(), check_for_isn_and_int8_passing_mismatch(), check_for_tables_with_oids(), check_for_unicode_update(), check_for_user_defined_encoding_conversions(), check_for_user_defined_postfix_ops(), check_old_cluster_subscription_state(), get_db_rel_and_slot_infos(), get_loadable_libraries(), and report_extension_updates().

upgrade_task_free()

void upgrade_task_free

(

UpgradeTask *

task

)

Definition at line 133 of file task.c.

{
    destroyPQExpBuffer(task->queries);
    pg_free(task->steps);
    pg_free(task);
}

References destroyPQExpBuffer(), pg_free(), UpgradeTask::queries, and UpgradeTask::steps.

Referenced by check_for_data_types_usage(), check_for_incompatible_polymorphics(), check_for_isn_and_int8_passing_mismatch(), check_for_tables_with_oids(), check_for_unicode_update(), check_for_user_defined_encoding_conversions(), check_for_user_defined_postfix_ops(), check_old_cluster_subscription_state(), get_db_rel_and_slot_infos(), get_loadable_libraries(), and report_extension_updates().

upgrade_task_run()

void upgrade_task_run	(	const UpgradeTask *	task,
		const ClusterInfo *	cluster
	)

Definition at line 420 of file task.c.

{
    int         jobs = Max(1, user_opts.jobs);
    UpgradeTaskSlot *slots = pg_malloc0(sizeof(UpgradeTaskSlot) * jobs);
 
    dbs_complete = 0;
    dbs_processing = 0;
 
    /*
     * Process every slot the first time round.
     */
    for (int i = 0; i < jobs; i++)
        slots[i].ready = true;
 
    while (dbs_complete < cluster->dbarr.ndbs)
    {
        for (int i = 0; i < jobs; i++)
            process_slot(cluster, &slots[i], task);
 
        wait_on_slots(slots, jobs);
    }
 
    pg_free(slots);
}

References cluster(), dbs_complete, dbs_processing, i, UserOpts::jobs, Max, pg_free(), pg_malloc0(), process_slot(), user_opts, and wait_on_slots().

Referenced by check_for_data_types_usage(), check_for_incompatible_polymorphics(), check_for_isn_and_int8_passing_mismatch(), check_for_tables_with_oids(), check_for_unicode_update(), check_for_user_defined_encoding_conversions(), check_for_user_defined_postfix_ops(), check_old_cluster_subscription_state(), get_db_rel_and_slot_infos(), get_loadable_libraries(), and report_extension_updates().

verify_directories()

bool void verify_directories

(

void

)

Definition at line 263 of file exec.c.

{
#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.");
 
    check_bin_dir(&old_cluster, false);
    check_data_dir(&old_cluster);
    check_bin_dir(&new_cluster, true);
    check_data_dir(&new_cluster);
}

References check_bin_dir(), check_data_dir(), new_cluster, old_cluster, and pg_fatal.

Referenced by setup().

Variable Documentation

log_opts

LogOpts log_opts

extern

Definition at line 17 of file util.c.

Referenced by check_for_connection_status(), check_for_incompatible_polymorphics(), check_for_isn_and_int8_passing_mismatch(), check_for_pg_role_prefix(), check_for_tables_with_oids(), check_for_unicode_update(), check_for_user_defined_encoding_conversions(), check_for_user_defined_postfix_ops(), check_loadable_libraries(), check_old_cluster_for_valid_slots(), check_old_cluster_subscription_state(), cleanup_output_dirs(), create_new_objects(), end_progress_output(), exec_prog(), generate_old_dump(), get_db_rel_and_slot_infos(), make_outputdirs(), parseCommandLine(), pg_log_v(), prep_status_progress(), prepare_new_cluster(), prepare_new_globals(), process_data_type_check(), and start_postmaster().

new_cluster

ClusterInfo new_cluster

Definition at line 374 of file pg_upgrade.h.

old_cluster

ClusterInfo old_cluster

extern

Definition at line 71 of file pg_upgrade.c.

Referenced by adjust_data_dir(), check_and_dump_old_cluster(), check_cluster_compatibility(), check_cluster_versions(), check_copy_file_range(), check_file_clone(), check_for_isn_and_int8_passing_mismatch(), check_for_prepared_transactions(), check_hard_link(), check_loadable_libraries(), check_new_cluster(), check_new_cluster_logical_replication_slots(), check_new_cluster_subscription_configuration(), check_old_cluster_for_valid_slots(), check_old_cluster_subscription_state(), copy_subdir_files(), copy_xact_xlog_xid(), count_old_cluster_logical_slots(), create_logical_replication_slots(), create_new_objects(), create_rel_filename_map(), create_script_for_old_cluster_deletion(), disable_old_cluster(), do_swap(), generate_old_dump(), get_control_data(), get_db_rel_and_slot_infos(), get_loadable_libraries(), get_sock_dir(), get_tablespace_paths(), init_tablespaces(), issue_warnings_and_set_wal_level(), main(), parseCommandLine(), prepare_for_swap(), process_loadable_libraries(), set_frozenxids(), set_locale_and_encoding(), set_new_cluster_char_signedness(), setup(), start_postmaster(), stop_postmaster(), transfer_single_new_db(), usage(), and verify_directories().

os_info

OSInfo os_info

extern

Definition at line 73 of file pg_upgrade.c.

Referenced by check_for_new_tablespace_dir(), check_is_install_user(), check_loadable_libraries(), cluster_conn_opts(), create_script_for_old_cluster_deletion(), do_swap(), get_db_conn(), get_loadable_libraries(), get_tablespace_paths(), init_tablespaces(), output_completion_banner(), parseCommandLine(), start_conn(), start_postmaster(), stop_postmaster(), transfer_all_new_tablespaces(), and usage().

output_files

char* output_files[]

extern

Definition at line 75 of file pg_upgrade.c.

Referenced by make_outputdirs().

user_opts

UserOpts user_opts

extern

Definition at line 30 of file option.c.

Referenced by check_and_dump_old_cluster(), check_cluster_compatibility(), check_cluster_versions(), check_new_cluster(), check_old_cluster_for_valid_slots(), create_new_objects(), generate_old_dump(), get_control_data(), get_old_cluster_logical_slot_infos_query(), get_rel_infos_query(), get_sock_dir(), main(), output_check_banner(), parallel_exec_prog(), parallel_transfer_all_new_dbs(), parseCommandLine(), reap_child(), report_clusters_compatible(), set_new_cluster_char_signedness(), setup(), swap_catalog_files(), transfer_all_new_tablespaces(), transfer_relfile(), transfer_single_new_db(), and upgrade_task_run().