exec.c File Reference

#include "postgres_fe.h"
#include <fcntl.h>
#include "common/string.h"
#include "fe_utils/version.h"
#include "pg_upgrade.h"

Include dependency graph for exec.c:

Go to the source code of this file.

Macros
#define	MAXCMDLEN   (2 * MAXPGPATH)

Functions
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)
bool	exec_prog (const char *log_filename, const char *opt_log_file, bool report_error, bool exit_on_error, const char *fmt,...)
bool	pid_lock_file_exists (const char *datadir)
void	verify_directories (void)
static void	check_single_dir (const char *pg_data, const char *subdir)

Macro Definition Documentation

MAXCMDLEN

#define MAXCMDLEN   (2 * MAXPGPATH)

Function Documentation

check_bin_dir()

static void check_bin_dir ( ClusterInfo *  cluster, bool  check_versions  )

static

Definition at line 384 of file exec.c.

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

References check_exec(), cluster(), get_bin_version(), GET_MAJOR_VERSION, new_cluster, PG_FATAL, report_status(), S_ISDIR, stat::st_mode, and stat.

Referenced by verify_directories().

check_data_dir()

static void check_data_dir ( ClusterInfo *  cluster )

static

Definition at line 342 of file exec.c.

{
    const char *pg_data = cluster->pgdata;
 
    /* get the cluster version */
    cluster->major_version = get_pg_version(cluster->pgdata,
                                            &cluster->major_version_str);
    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");
}

References check_single_dir(), cluster(), GET_MAJOR_VERSION, get_pg_version(), pg_data, and PG_TBLSPC_DIR.

Referenced by verify_directories().

check_exec()

static void check_exec ( const char *  dir, const char *  program, bool  check_version  )

static

Definition at line 430 of file exec.c.

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

References MAXPGPATH, pg_fatal, pg_free(), pg_strip_crlf(), pipe_read_line(), snprintf, and validate_exec().

Referenced by check_bin_dir().

check_single_dir()

static void check_single_dir ( const char *  pg_data, const char *  subdir  )

static

Definition at line 313 of file exec.c.

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

References MAXPGPATH, pg_data, PG_FATAL, report_status(), S_ISDIR, snprintf, stat::st_mode, and stat.

Referenced by check_data_dir().

exec_prog()

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

Definition at line 86 of file exec.c.

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

References fprintf, log_file, log_opts, LogOpts::logdir, MAXCMDLEN, MAXPGPATH, pg_fatal, PG_FATAL, pg_log(), PG_REPORT, pg_usleep(), PG_VERBOSE, report_status(), snprintf, generate_unaccent_rules::stdout, and vsnprintf.

Referenced by copy_subdir_files(), copy_xact_xlog_xid(), create_new_objects(), generate_old_dump(), main(), parallel_exec_prog(), prepare_new_cluster(), prepare_new_globals(), set_new_cluster_char_signedness(), start_postmaster(), and stop_postmaster().

get_bin_version()

static void get_bin_version ( ClusterInfo *  cluster )

static

Definition at line 34 of file exec.c.

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

References cluster(), MAX_STRING, MAXPGPATH, output, pg_fatal, snprintf, and wait_result_to_str().

Referenced by check_bin_dir().

pid_lock_file_exists()

bool pid_lock_file_exists

(

const char *

datadir

)

Definition at line 234 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().

verify_directories()

void verify_directories

(

void

)

Definition at line 264 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().