exec.c

Go to the documentation of this file.

/*
 *  exec.c
 *
 *  execution functions
 *
 *  Copyright (c) 2010-2024, PostgreSQL Global Development Group
 *  src/bin/pg_upgrade/exec.c
 */
 
#include "postgres_fe.h"
 
#include <fcntl.h>
 
#include "common/string.h"
#include "pg_upgrade.h"
 
static void check_data_dir(ClusterInfo *cluster);
static void check_bin_dir(ClusterInfo *cluster, bool check_versions);
static void get_bin_version(ClusterInfo *cluster);
static void check_exec(const char *dir, const char *program, bool check_version);
 
#ifdef WIN32
static int  win32_check_directory_write_permissions(void);
#endif
 
 
/*
 * get_bin_version
 *
 *  Fetch major version of binaries for cluster.
 */
static void
get_bin_version(ClusterInfo *cluster)
{
    char        cmd[MAXPGPATH],
                cmd_output[MAX_STRING];
    FILE       *output;
    int         rc;
    int         v1 = 0,
                v2 = 0;
 
    snprintf(cmd, sizeof(cmd), "\"%s/pg_ctl\" --version", cluster->bindir);
    fflush(NULL);
 
    if ((output = popen(cmd, "r")) == NULL ||
        fgets(cmd_output, sizeof(cmd_output), output) == NULL)
        pg_fatal("could not get pg_ctl version data using %s: %m", cmd);
 
    rc = pclose(output);
    if (rc != 0)
        pg_fatal("could not get pg_ctl version data using %s: %s",
                 cmd, wait_result_to_str(rc));
 
    if (sscanf(cmd_output, "%*s %*s %d.%d", &v1, &v2) < 1)
        pg_fatal("could not get pg_ctl version output from %s", cmd);
 
    if (v1 < 10)
    {
        /* old style, e.g. 9.6.1 */
        cluster->bin_version = v1 * 10000 + v2 * 100;
    }
    else
    {
        /* new style, e.g. 10.1 */
        cluster->bin_version = v1 * 10000;
    }
}
 
 
/*
 * exec_prog()
 *      Execute an external program with stdout/stderr redirected, and report
 *      errors
 *
 * Formats a command from the given argument list, logs it to the log file,
 * and attempts to execute that command.  If the command executes
 * successfully, exec_prog() returns true.
 *
 * If the command fails, an error message is optionally written to the specified
 * log_file, and the program optionally exits.
 *
 * The code requires it be called first from the primary thread on Windows.
 */
bool
exec_prog(const char *log_filename, const char *opt_log_file,
          bool report_error, bool exit_on_error, const char *fmt,...)
{
    int         result = 0;
    int         written;
    char        log_file[MAXPGPATH];
 
#define MAXCMDLEN (2 * MAXPGPATH)
    char        cmd[MAXCMDLEN];
    FILE       *log;
    va_list     ap;
 
#ifdef WIN32
    static DWORD mainThreadId = 0;
 
    /* We assume we are called from the primary thread first */
    if (mainThreadId == 0)
        mainThreadId = GetCurrentThreadId();
#endif
 
    snprintf(log_file, MAXPGPATH, "%s/%s", log_opts.logdir, log_filename);
 
    written = 0;
    va_start(ap, fmt);
    written += vsnprintf(cmd + written, MAXCMDLEN - written, fmt, ap);
    va_end(ap);
    if (written >= MAXCMDLEN)
        pg_fatal("command too long");
    written += snprintf(cmd + written, MAXCMDLEN - written,
                        " >> \"%s\" 2>&1", log_file);
    if (written >= MAXCMDLEN)
        pg_fatal("command too long");
 
    pg_log(PG_VERBOSE, "%s", cmd);
 
#ifdef WIN32
 
    /*
     * For some reason, Windows issues a file-in-use error if we write data to
     * the log file from a non-primary thread just before we create a
     * subprocess that also writes to the same log file.  One fix is to sleep
     * for 100ms.  A cleaner fix is to write to the log file _after_ the
     * subprocess has completed, so we do this only when writing from a
     * non-primary thread.  fflush(), running system() twice, and pre-creating
     * the file do not see to help.
     */
    if (mainThreadId != GetCurrentThreadId())
    {
        fflush(NULL);
        result = system(cmd);
    }
#endif
 
    log = fopen(log_file, "a");
 
#ifdef WIN32
    {
        /*
         * "pg_ctl -w stop" might have reported that the server has stopped
         * because the postmaster.pid file has been removed, but "pg_ctl -w
         * start" might still be in the process of closing and might still be
         * holding its stdout and -l log file descriptors open.  Therefore,
         * try to open the log file a few more times.
         */
        int         iter;
 
        for (iter = 0; iter < 4 && log == NULL; iter++)
        {
            pg_usleep(1000000); /* 1 sec */
            log = fopen(log_file, "a");
        }
    }
#endif
 
    if (log == NULL)
        pg_fatal("could not open log file \"%s\": %m", log_file);
 
#ifdef WIN32
    /* Are we printing "command:" before its output? */
    if (mainThreadId == GetCurrentThreadId())
        fprintf(log, "\n\n");
#endif
    fprintf(log, "command: %s\n", cmd);
#ifdef WIN32
    /* Are we printing "command:" after its output? */
    if (mainThreadId != GetCurrentThreadId())
        fprintf(log, "\n\n");
#endif
 
    /*
     * In Windows, we must close the log file at this point so the file is not
     * open while the command is running, or we get a share violation.
     */
    fclose(log);
 
#ifdef WIN32
    /* see comment above */
    if (mainThreadId == GetCurrentThreadId())
#endif
    {
        fflush(NULL);
        result = system(cmd);
    }
 
    if (result != 0 && report_error)
    {
        /* we might be in on a progress status line, so go to the next line */
        report_status(PG_REPORT, "\n*failure*");
        fflush(stdout);
 
        pg_log(PG_VERBOSE, "There were problems executing \"%s\"", cmd);
        if (opt_log_file)
            pg_log(exit_on_error ? PG_FATAL : PG_REPORT,
                   "Consult the last few lines of \"%s\" or \"%s\" for\n"
                   "the probable cause of the failure.",
                   log_file, opt_log_file);
        else
            pg_log(exit_on_error ? PG_FATAL : PG_REPORT,
                   "Consult the last few lines of \"%s\" for\n"
                   "the probable cause of the failure.",
                   log_file);
    }
 
#ifndef WIN32
 
    /*
     * We can't do this on Windows because it will keep the "pg_ctl start"
     * output filename open until the server stops, so we do the \n\n above on
     * that platform.  We use a unique filename for "pg_ctl start" that is
     * never reused while the server is running, so it works fine.  We could
     * log these commands to a third file, but that just adds complexity.
     */
    if ((log = fopen(log_file, "a")) == NULL)
        pg_fatal("could not write to log file \"%s\": %m", log_file);
    fprintf(log, "\n\n");
    fclose(log);
#endif
 
    return result == 0;
}
 
 
/*
 * pid_lock_file_exists()
 *
 * Checks whether the postmaster.pid file exists.
 */
bool
pid_lock_file_exists(const char *datadir)
{
    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;
}
 
 
/*
 * verify_directories()
 *
 * does all the hectic work of verifying directories and executables
 * of old and new server.
 *
 * NOTE: May update the values of all parameters
 */
void
verify_directories(void)
{
#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);
}
 
 
#ifdef WIN32
/*
 * win32_check_directory_write_permissions()
 *
 *  access() on WIN32 can't check directory permissions, so we have to
 *  optionally create, then delete a file to check.
 *      http://msdn.microsoft.com/en-us/library/1w06ktdy%28v=vs.80%29.aspx
 */
static int
win32_check_directory_write_permissions(void)
{
    int         fd;
 
    /*
     * We open a file we would normally create anyway.  We do this even in
     * 'check' mode, which isn't ideal, but this is the best we can do.
     */
    if ((fd = open(GLOBALS_DUMP_FILE, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR)) < 0)
        return -1;
    close(fd);
 
    return unlink(GLOBALS_DUMP_FILE);
}
#endif
 
 
/*
 * check_single_dir()
 *
 *  Check for the presence of a single directory in PGDATA, and fail if
 * is it missing or not accessible.
 */
static void
check_single_dir(const char *pg_data, const char *subdir)
{
    struct stat statBuf;
    char        subDirName[MAXPGPATH];
 
    snprintf(subDirName, sizeof(subDirName), "%s%s%s", pg_data,
    /* Win32 can't stat() a directory with a trailing slash. */
             *subdir ? "/" : "",
             subdir);
 
    if (stat(subDirName, &statBuf) != 0)
        report_status(PG_FATAL, "check for \"%s\" failed: %m",
                      subDirName);
    else if (!S_ISDIR(statBuf.st_mode))
        report_status(PG_FATAL, "\"%s\" is not a directory",
                      subDirName);
}
 
 
/*
 * check_data_dir()
 *
 *  This function validates the given cluster directory - we search for a
 *  small set of subdirectories that we expect to find in a valid $PGDATA
 *  directory.  If any of the subdirectories are missing (or secured against
 *  us) we display an error message and exit()
 *
 */
static void
check_data_dir(ClusterInfo *cluster)
{
    const char *pg_data = cluster->pgdata;
 
    /* get the cluster version */
    cluster->major_version = get_major_server_version(cluster);
 
    check_single_dir(pg_data, "");
    check_single_dir(pg_data, "base");
    check_single_dir(pg_data, "global");
    check_single_dir(pg_data, "pg_multixact");
    check_single_dir(pg_data, "pg_subtrans");
    check_single_dir(pg_data, PG_TBLSPC_DIR);
    check_single_dir(pg_data, "pg_twophase");
 
    /* pg_xlog has been renamed to pg_wal in v10 */
    if (GET_MAJOR_VERSION(cluster->major_version) <= 906)
        check_single_dir(pg_data, "pg_xlog");
    else
        check_single_dir(pg_data, "pg_wal");
 
    /* pg_clog has been renamed to pg_xact in v10 */
    if (GET_MAJOR_VERSION(cluster->major_version) <= 906)
        check_single_dir(pg_data, "pg_clog");
    else
        check_single_dir(pg_data, "pg_xact");
}
 
 
/*
 * check_bin_dir()
 *
 *  This function searches for the executables that we expect to find
 *  in the binaries directory.  If we find that a required executable
 *  is missing (or secured against us), we display an error message and
 *  exit().
 *
 *  If check_versions is true, then the versions of the binaries are checked
 *  against the version of this pg_upgrade.  This is for checking the target
 *  bindir.
 */
static void
check_bin_dir(ClusterInfo *cluster, bool check_versions)
{
    struct stat statBuf;
 
    /* check bindir */
    if (stat(cluster->bindir, &statBuf) != 0)
        report_status(PG_FATAL, "check for \"%s\" failed: %m",
                      cluster->bindir);
    else if (!S_ISDIR(statBuf.st_mode))
        report_status(PG_FATAL, "\"%s\" is not a directory",
                      cluster->bindir);
 
    check_exec(cluster->bindir, "postgres", check_versions);
    check_exec(cluster->bindir, "pg_controldata", check_versions);
    check_exec(cluster->bindir, "pg_ctl", check_versions);
 
    /*
     * Fetch the binary version after checking for the existence of pg_ctl.
     * This way we report a useful error if the pg_ctl binary used for version
     * fetching is missing/broken.
     */
    get_bin_version(cluster);
 
    /* pg_resetxlog has been renamed to pg_resetwal in version 10 */
    if (GET_MAJOR_VERSION(cluster->bin_version) <= 906)
        check_exec(cluster->bindir, "pg_resetxlog", check_versions);
    else
        check_exec(cluster->bindir, "pg_resetwal", check_versions);
 
    if (cluster == &new_cluster)
    {
        /*
         * These binaries are only needed for the target version. pg_dump and
         * pg_dumpall are used to dump the old cluster, but must be of the
         * target version.
         */
        check_exec(cluster->bindir, "initdb", check_versions);
        check_exec(cluster->bindir, "pg_dump", check_versions);
        check_exec(cluster->bindir, "pg_dumpall", check_versions);
        check_exec(cluster->bindir, "pg_restore", check_versions);
        check_exec(cluster->bindir, "psql", check_versions);
        check_exec(cluster->bindir, "vacuumdb", check_versions);
    }
}
 
static void
check_exec(const char *dir, const char *program, bool check_version)
{
    char        path[MAXPGPATH];
    char       *line;
    char        cmd[MAXPGPATH];
    char        versionstr[128];
 
    snprintf(path, sizeof(path), "%s/%s", dir, program);
 
    if (validate_exec(path) != 0)
        pg_fatal("check for \"%s\" failed: %m", path);
 
    snprintf(cmd, sizeof(cmd), "\"%s\" -V", path);
 
    if ((line = pipe_read_line(cmd)) == NULL)
        pg_fatal("check for \"%s\" failed: cannot execute",
                 path);
 
    if (check_version)
    {
        pg_strip_crlf(line);
 
        snprintf(versionstr, sizeof(versionstr), "%s (PostgreSQL) " PG_VERSION, program);
 
        if (strcmp(line, versionstr) != 0)
            pg_fatal("check for \"%s\" failed: incorrect version: found \"%s\", expected \"%s\"",
                     path, line, versionstr);
    }
 
    pg_free(line);
}