pg_ctl.c File Reference

#include "postgres_fe.h"
#include <fcntl.h>
#include <signal.h>
#include <time.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>
#include "catalog/pg_control.h"
#include "common/controldata_utils.h"
#include "common/file_perm.h"
#include "common/logging.h"
#include "common/string.h"
#include "getopt_long.h"
#include "utils/pidfile.h"

Include dependency graph for pg_ctl.c:

Go to the source code of this file.

Macros
#define	DEFAULT_WAIT   60
#define	USEC_PER_SEC   1000000
#define	WAITS_PER_SEC   10 /* should divide USEC_PER_SEC evenly */

Typedefs
typedef long	pgpid_t

Enumerations
enum	ShutdownMode { SMART_MODE, FAST_MODE, IMMEDIATE_MODE }
enum	WaitPMResult { POSTMASTER_READY, POSTMASTER_STILL_STARTING, POSTMASTER_FAILED }
enum	CtlCommand {   NO_COMMAND = 0, INIT_COMMAND, START_COMMAND, STOP_COMMAND,   RESTART_COMMAND, RELOAD_COMMAND, STATUS_COMMAND, PROMOTE_COMMAND,   LOGROTATE_COMMAND, KILL_COMMAND, REGISTER_COMMAND, UNREGISTER_COMMAND,   RUN_AS_SERVICE_COMMAND }

Functions
static void	write_stderr (const char *fmt,...) pg_attribute_printf(1
static void static void	do_advice (void)
static void	do_help (void)
static void	set_mode (char *modeopt)
static void	set_sig (char *signame)
static void	do_init (void)
static void	do_start (void)
static void	do_stop (void)
static void	do_restart (void)
static void	do_reload (void)
static void	do_status (void)
static void	do_promote (void)
static void	do_logrotate (void)
static void	do_kill (pgpid_t pid)
static void	print_msg (const char *msg)
static void	adjust_data_dir (void)
static pgpid_t	get_pgpid (bool is_status_request)
static char **	readfile (const char *path, int *numlines)
static void	free_readfile (char **optlines)
static pgpid_t	start_postmaster (void)
static void	read_post_opts (void)
static WaitPMResult	wait_for_postmaster (pgpid_t pm_pid, bool do_checkpoint)
static bool	postmaster_is_alive (pid_t pid)
static DBState	get_control_dbstate (void)
static void	trap_sigint_during_startup (int sig)
static char *	find_other_exec_or_die (const char *argv0, const char *target, const char *versionstr)
int	main (int argc, char **argv)

Variables
static bool	do_wait = true
static int	wait_seconds = DEFAULT_WAIT
static bool	wait_seconds_arg = false
static bool	silent_mode = false
static ShutdownMode	shutdown_mode = FAST_MODE
static int	sig = SIGINT
static CtlCommand	ctl_command = NO_COMMAND
static char *	pg_data = NULL
static char *	pg_config = NULL
static char *	pgdata_opt = NULL
static char *	post_opts = NULL
static const char *	progname
static char *	log_file = NULL
static char *	exec_path = NULL
static char *	event_source = NULL
static char *	register_servicename = "PostgreSQL"
static char *	register_username = NULL
static char *	register_password = NULL
static char *	argv0 = NULL
static bool	allow_core_files = false
static time_t	start_time
static char	postopts_file [MAXPGPATH]
static char	version_file [MAXPGPATH]
static char	pid_file [MAXPGPATH]
static char	backup_file [MAXPGPATH]
static char	promote_file [MAXPGPATH]
static char	logrotate_file [MAXPGPATH]
static volatile pgpid_t	postmasterPID = -1

Macro Definition Documentation

DEFAULT_WAIT

#define DEFAULT_WAIT   60

Definition at line 73 of file pg_ctl.c.

Referenced by do_kill().

USEC_PER_SEC

#define USEC_PER_SEC   1000000

Definition at line 75 of file pg_ctl.c.

Referenced by do_promote(), do_restart(), do_stop(), and wait_for_postmaster().

WAITS_PER_SEC

#define WAITS_PER_SEC   10 /* should divide USEC_PER_SEC evenly */

Definition at line 77 of file pg_ctl.c.

Referenced by do_promote(), do_restart(), do_stop(), and wait_for_postmaster().

Typedef Documentation

pgpid_t

typedef long pgpid_t

Definition at line 39 of file pg_ctl.c.

Enumeration Type Documentation

CtlCommand

enum CtlCommand

Enumerator
NO_COMMAND
INIT_COMMAND
START_COMMAND
STOP_COMMAND
RESTART_COMMAND
RELOAD_COMMAND
STATUS_COMMAND
PROMOTE_COMMAND
LOGROTATE_COMMAND
KILL_COMMAND
REGISTER_COMMAND
UNREGISTER_COMMAND
RUN_AS_SERVICE_COMMAND

Definition at line 56 of file pg_ctl.c.

{
    NO_COMMAND = 0,
    INIT_COMMAND,
    START_COMMAND,
    STOP_COMMAND,
    RESTART_COMMAND,
    RELOAD_COMMAND,
    STATUS_COMMAND,
    PROMOTE_COMMAND,
    LOGROTATE_COMMAND,
    KILL_COMMAND,
    REGISTER_COMMAND,
    UNREGISTER_COMMAND,
    RUN_AS_SERVICE_COMMAND
} CtlCommand;

ShutdownMode

enum ShutdownMode

Enumerator
SMART_MODE
FAST_MODE
IMMEDIATE_MODE

Definition at line 42 of file pg_ctl.c.

{
    SMART_MODE,
    FAST_MODE,
    IMMEDIATE_MODE
} ShutdownMode;

WaitPMResult

enum WaitPMResult

Enumerator
POSTMASTER_READY
POSTMASTER_STILL_STARTING
POSTMASTER_FAILED

Definition at line 49 of file pg_ctl.c.

{
    POSTMASTER_READY,
    POSTMASTER_STILL_STARTING,
    POSTMASTER_FAILED
} WaitPMResult;

Function Documentation

adjust_data_dir()

static void adjust_data_dir ( void  )

static

Definition at line 2168 of file pg_ctl.c.

References _, argv0, canonicalize_path(), exec_path, fd(), filename, find_other_exec_or_die(), free, MAXPGPATH, my_exec_path, PG_BACKEND_VERSIONSTR, pg_config, pg_data, pg_strdup(), pg_strip_crlf(), pgdata_opt, post_opts, progname, snprintf, and write_stderr().

Referenced by main().

{
    char        cmd[MAXPGPATH],
                filename[MAXPGPATH],
               *my_exec_path;
    FILE       *fd;

    /* do nothing if we're working without knowledge of data dir */
    if (pg_config == NULL)
        return;

    /* If there is no postgresql.conf, it can't be a config-only dir */
    snprintf(filename, sizeof(filename), "%s/postgresql.conf", pg_config);
    if ((fd = fopen(filename, "r")) == NULL)
        return;
    fclose(fd);

    /* If PG_VERSION exists, it can't be a config-only dir */
    snprintf(filename, sizeof(filename), "%s/PG_VERSION", pg_config);
    if ((fd = fopen(filename, "r")) != NULL)
    {
        fclose(fd);
        return;
    }

    /* Must be a configuration directory, so find the data directory */

    /* we use a private my_exec_path to avoid interfering with later uses */
    if (exec_path == NULL)
        my_exec_path = find_other_exec_or_die(argv0, "postgres", PG_BACKEND_VERSIONSTR);
    else
        my_exec_path = pg_strdup(exec_path);

    /* it's important for -C to be the first option, see main.c */
    snprintf(cmd, MAXPGPATH, "\"%s\" -C data_directory %s%s",
             my_exec_path,
             pgdata_opt ? pgdata_opt : "",
             post_opts ? post_opts : "");

    fd = popen(cmd, "r");
    if (fd == NULL || fgets(filename, sizeof(filename), fd) == NULL)
    {
        write_stderr(_("%s: could not determine the data directory using command \"%s\"\n"), progname, cmd);
        exit(1);
    }
    pclose(fd);
    free(my_exec_path);

    /* strip trailing newline and carriage return */
    (void) pg_strip_crlf(filename);

    free(pg_data);
    pg_data = pg_strdup(filename);
    canonicalize_path(pg_data);
}

do_advice()

static void do_advice ( void  )

static

Definition at line 2009 of file pg_ctl.c.

References _, progname, and write_stderr().

Referenced by main(), set_mode(), and set_sig().

{
    write_stderr(_("Try \"%s --help\" for more information.\n"), progname);
}

do_help()

static void do_help ( void  )

static

Definition at line 2017 of file pg_ctl.c.

References _, printf, and progname.

Referenced by main().

{
    printf(_("%s is a utility to initialize, start, stop, or control a PostgreSQL server.\n\n"), progname);
    printf(_("Usage:\n"));
    printf(_("  %s init[db]   [-D DATADIR] [-s] [-o OPTIONS]\n"), progname);
    printf(_("  %s start      [-D DATADIR] [-l FILENAME] [-W] [-t SECS] [-s]\n"
             "                    [-o OPTIONS] [-p PATH] [-c]\n"), progname);
    printf(_("  %s stop       [-D DATADIR] [-m SHUTDOWN-MODE] [-W] [-t SECS] [-s]\n"), progname);
    printf(_("  %s restart    [-D DATADIR] [-m SHUTDOWN-MODE] [-W] [-t SECS] [-s]\n"
             "                    [-o OPTIONS] [-c]\n"), progname);
    printf(_("  %s reload     [-D DATADIR] [-s]\n"), progname);
    printf(_("  %s status     [-D DATADIR]\n"), progname);
    printf(_("  %s promote    [-D DATADIR] [-W] [-t SECS] [-s]\n"), progname);
    printf(_("  %s logrotate  [-D DATADIR] [-s]\n"), progname);
    printf(_("  %s kill       SIGNALNAME PID\n"), progname);
#ifdef WIN32
    printf(_("  %s register   [-D DATADIR] [-N SERVICENAME] [-U USERNAME] [-P PASSWORD]\n"
             "                    [-S START-TYPE] [-e SOURCE] [-W] [-t SECS] [-s] [-o OPTIONS]\n"), progname);
    printf(_("  %s unregister [-N SERVICENAME]\n"), progname);
#endif

    printf(_("\nCommon options:\n"));
    printf(_("  -D, --pgdata=DATADIR   location of the database storage area\n"));
#ifdef WIN32
    printf(_("  -e SOURCE              event source for logging when running as a service\n"));
#endif
    printf(_("  -s, --silent           only print errors, no informational messages\n"));
    printf(_("  -t, --timeout=SECS     seconds to wait when using -w option\n"));
    printf(_("  -V, --version          output version information, then exit\n"));
    printf(_("  -w, --wait             wait until operation completes (default)\n"));
    printf(_("  -W, --no-wait          do not wait until operation completes\n"));
    printf(_("  -?, --help             show this help, then exit\n"));
    printf(_("If the -D option is omitted, the environment variable PGDATA is used.\n"));

    printf(_("\nOptions for start or restart:\n"));
#if defined(HAVE_GETRLIMIT) && defined(RLIMIT_CORE)
    printf(_("  -c, --core-files       allow postgres to produce core files\n"));
#else
    printf(_("  -c, --core-files       not applicable on this platform\n"));
#endif
    printf(_("  -l, --log=FILENAME     write (or append) server log to FILENAME\n"));
    printf(_("  -o, --options=OPTIONS  command line options to pass to postgres\n"
             "                         (PostgreSQL server executable) or initdb\n"));
    printf(_("  -p PATH-TO-POSTGRES    normally not necessary\n"));
    printf(_("\nOptions for stop or restart:\n"));
    printf(_("  -m, --mode=MODE        MODE can be \"smart\", \"fast\", or \"immediate\"\n"));

    printf(_("\nShutdown modes are:\n"));
    printf(_("  smart       quit after all clients have disconnected\n"));
    printf(_("  fast        quit directly, with proper shutdown (default)\n"));
    printf(_("  immediate   quit without complete shutdown; will lead to recovery on restart\n"));

    printf(_("\nAllowed signal names for kill:\n"));
    printf("  ABRT HUP INT KILL QUIT TERM USR1 USR2\n");

#ifdef WIN32
    printf(_("\nOptions for register and unregister:\n"));
    printf(_("  -N SERVICENAME  service name with which to register PostgreSQL server\n"));
    printf(_("  -P PASSWORD     password of account to register PostgreSQL server\n"));
    printf(_("  -U USERNAME     user name of account to register PostgreSQL server\n"));
    printf(_("  -S START-TYPE   service start type to register PostgreSQL server\n"));

    printf(_("\nStart types are:\n"));
    printf(_("  auto       start service automatically during system startup (default)\n"));
    printf(_("  demand     start service on demand\n"));
#endif

    printf(_("\nReport bugs to <pgsql-bugs@lists.postgresql.org>.\n"));
}

do_init()

static void do_init ( void  )

static

Definition at line 816 of file pg_ctl.c.

References _, argv0, DEVNULL, exec_path, find_other_exec_or_die(), MAXPGPATH, pgdata_opt, post_opts, progname, silent_mode, snprintf, and write_stderr().

Referenced by main().

{
    char        cmd[MAXPGPATH];

    if (exec_path == NULL)
        exec_path = find_other_exec_or_die(argv0, "initdb", "initdb (PostgreSQL) " PG_VERSION "\n");

    if (pgdata_opt == NULL)
        pgdata_opt = "";

    if (post_opts == NULL)
        post_opts = "";

    if (!silent_mode)
        snprintf(cmd, MAXPGPATH, "\"%s\" %s%s",
                 exec_path, pgdata_opt, post_opts);
    else
        snprintf(cmd, MAXPGPATH, "\"%s\" %s%s > \"%s\"",
                 exec_path, pgdata_opt, post_opts, DEVNULL);

    if (system(cmd) != 0)
    {
        write_stderr(_("%s: database system initialization failed\n"), progname);
        exit(1);
    }
}

do_kill()

static void do_kill ( pgpid_t  pid )

static

Definition at line 1392 of file pg_ctl.c.

References _, AddUserToTokenDacl(), appendPQExpBuffer(), appendPQExpBufferStr(), argv0, createPQExpBuffer(), PQExpBufferData::data, DEFAULT_WAIT, do_wait, event_source, find_my_exec(), find_other_exec(), free, i, kill, make_absolute_path(), make_native_path(), MAXPGPATH, MCXT_ALLOC_NO_OOM, PG_BACKEND_VERSIONSTR, pg_config, pg_malloc_extended(), pg_strcasecmp(), post_opts, POSTMASTER_READY, postmasterPID, progname, read_post_opts(), register_password, register_servicename, register_username, sig, SIGHUP, silent_mode, snprintf, sprintf, status(), strerror, wait_for_postmaster(), wait_seconds, wait_seconds_arg, and write_stderr().

Referenced by main().

{
    if (kill((pid_t) pid, sig) != 0)
    {
        write_stderr(_("%s: could not send signal %d (PID: %ld): %s\n"),
                     progname, sig, pid, strerror(errno));
        exit(1);
    }
}

do_logrotate()

static void do_logrotate ( void  )

static

Definition at line 1254 of file pg_ctl.c.

References _, get_pgpid(), kill, logrotate_file, MAXPGPATH, pg_data, pid_file, print_msg(), progname, sig, SIGUSR1, snprintf, strerror, and write_stderr().

Referenced by main().

{
    FILE       *logrotatefile;
    pgpid_t     pid;

    pid = get_pgpid(false);

    if (pid == 0)               /* no pid file */
    {
        write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
        write_stderr(_("Is server running?\n"));
        exit(1);
    }
    else if (pid < 0)           /* standalone backend, not postmaster */
    {
        pid = -pid;
        write_stderr(_("%s: cannot rotate log file; "
                       "single-user server is running (PID: %ld)\n"),
                     progname, pid);
        exit(1);
    }

    snprintf(logrotate_file, MAXPGPATH, "%s/logrotate", pg_data);

    if ((logrotatefile = fopen(logrotate_file, "w")) == NULL)
    {
        write_stderr(_("%s: could not create log rotation signal file \"%s\": %s\n"),
                     progname, logrotate_file, strerror(errno));
        exit(1);
    }
    if (fclose(logrotatefile))
    {
        write_stderr(_("%s: could not write log rotation signal file \"%s\": %s\n"),
                     progname, logrotate_file, strerror(errno));
        exit(1);
    }

    sig = SIGUSR1;
    if (kill((pid_t) pid, sig) != 0)
    {
        write_stderr(_("%s: could not send log rotation signal (PID: %ld): %s\n"),
                     progname, pid, strerror(errno));
        if (unlink(logrotate_file) != 0)
            write_stderr(_("%s: could not remove log rotation signal file \"%s\": %s\n"),
                         progname, logrotate_file, strerror(errno));
        exit(1);
    }

    print_msg(_("server signaled to rotate log file\n"));
}

do_promote()

static void do_promote ( void  )

static

Definition at line 1155 of file pg_ctl.c.

References _, DB_IN_ARCHIVE_RECOVERY, DB_IN_PRODUCTION, DB_STARTUP, do_wait, get_control_dbstate(), get_pgpid(), kill, MAXPGPATH, pg_data, pg_usleep(), pid_file, print_msg(), progname, promote_file, sig, SIGUSR1, snprintf, strerror, USEC_PER_SEC, wait_seconds, WAITS_PER_SEC, and write_stderr().

Referenced by main().

{
    FILE       *prmfile;
    pgpid_t     pid;

    pid = get_pgpid(false);

    if (pid == 0)               /* no pid file */
    {
        write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
        write_stderr(_("Is server running?\n"));
        exit(1);
    }
    else if (pid < 0)           /* standalone backend, not postmaster */
    {
        pid = -pid;
        write_stderr(_("%s: cannot promote server; "
                       "single-user server is running (PID: %ld)\n"),
                     progname, pid);
        exit(1);
    }

    if (get_control_dbstate() != DB_IN_ARCHIVE_RECOVERY)
    {
        write_stderr(_("%s: cannot promote server; "
                       "server is not in standby mode\n"),
                     progname);
        exit(1);
    }

    /*
     * For 9.3 onwards, "fast" promotion is performed. Promotion with a full
     * checkpoint is still possible by writing a file called
     * "fallback_promote" instead of "promote"
     */
    snprintf(promote_file, MAXPGPATH, "%s/promote", pg_data);

    if ((prmfile = fopen(promote_file, "w")) == NULL)
    {
        write_stderr(_("%s: could not create promote signal file \"%s\": %s\n"),
                     progname, promote_file, strerror(errno));
        exit(1);
    }
    if (fclose(prmfile))
    {
        write_stderr(_("%s: could not write promote signal file \"%s\": %s\n"),
                     progname, promote_file, strerror(errno));
        exit(1);
    }

    sig = SIGUSR1;
    if (kill((pid_t) pid, sig) != 0)
    {
        write_stderr(_("%s: could not send promote signal (PID: %ld): %s\n"),
                     progname, pid, strerror(errno));
        if (unlink(promote_file) != 0)
            write_stderr(_("%s: could not remove promote signal file \"%s\": %s\n"),
                         progname, promote_file, strerror(errno));
        exit(1);
    }

    if (do_wait)
    {
        DBState     state = DB_STARTUP;
        int         cnt;

        print_msg(_("waiting for server to promote..."));
        for (cnt = 0; cnt < wait_seconds * WAITS_PER_SEC; cnt++)
        {
            state = get_control_dbstate();
            if (state == DB_IN_PRODUCTION)
                break;

            if (cnt % WAITS_PER_SEC == 0)
                print_msg(".");
            pg_usleep(USEC_PER_SEC / WAITS_PER_SEC);
        }
        if (state == DB_IN_PRODUCTION)
        {
            print_msg(_(" done\n"));
            print_msg(_("server promoted\n"));
        }
        else
        {
            print_msg(_(" stopped waiting\n"));
            write_stderr(_("%s: server did not promote in time\n"),
                         progname);
            exit(1);
        }
    }
    else
        print_msg(_("server promoting\n"));
}

do_reload()

static void do_reload ( void  )

static

Definition at line 1118 of file pg_ctl.c.

References _, get_pgpid(), kill, pid_file, print_msg(), progname, sig, strerror, and write_stderr().

Referenced by main().

{
    pgpid_t     pid;

    pid = get_pgpid(false);
    if (pid == 0)               /* no pid file */
    {
        write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
        write_stderr(_("Is server running?\n"));
        exit(1);
    }
    else if (pid < 0)           /* standalone backend, not postmaster */
    {
        pid = -pid;
        write_stderr(_("%s: cannot reload server; "
                       "single-user server is running (PID: %ld)\n"),
                     progname, pid);
        write_stderr(_("Please terminate the single-user server and try again.\n"));
        exit(1);
    }

    if (kill((pid_t) pid, sig) != 0)
    {
        write_stderr(_("%s: could not send reload signal (PID: %ld): %s\n"),
                     progname, pid, strerror(errno));
        exit(1);
    }

    print_msg(_("server signaled\n"));
}

do_restart()

static void do_restart ( void  )

static

Definition at line 1024 of file pg_ctl.c.

References _, backup_file, DB_IN_ARCHIVE_RECOVERY, do_start(), get_control_dbstate(), get_pgpid(), kill, pg_usleep(), pid_file, postmaster_is_alive(), print_msg(), progname, shutdown_mode, sig, SMART_MODE, stat, strerror, USEC_PER_SEC, wait_seconds, WAITS_PER_SEC, and write_stderr().

Referenced by main().

{
    int         cnt;
    pgpid_t     pid;
    struct stat statbuf;

    pid = get_pgpid(false);

    if (pid == 0)               /* no pid file */
    {
        write_stderr(_("%s: PID file \"%s\" does not exist\n"),
                     progname, pid_file);
        write_stderr(_("Is server running?\n"));
        write_stderr(_("trying to start server anyway\n"));
        do_start();
        return;
    }
    else if (pid < 0)           /* standalone backend, not postmaster */
    {
        pid = -pid;
        if (postmaster_is_alive((pid_t) pid))
        {
            write_stderr(_("%s: cannot restart server; "
                           "single-user server is running (PID: %ld)\n"),
                         progname, pid);
            write_stderr(_("Please terminate the single-user server and try again.\n"));
            exit(1);
        }
    }

    if (postmaster_is_alive((pid_t) pid))
    {
        if (kill((pid_t) pid, sig) != 0)
        {
            write_stderr(_("%s: could not send stop signal (PID: %ld): %s\n"), progname, pid,
                         strerror(errno));
            exit(1);
        }

        /*
         * If backup_label exists, an online backup is running. Warn the user
         * that smart shutdown will wait for it to finish. However, if the
         * server is in archive recovery, we're recovering from an online
         * backup instead of performing one.
         */
        if (shutdown_mode == SMART_MODE &&
            stat(backup_file, &statbuf) == 0 &&
            get_control_dbstate() != DB_IN_ARCHIVE_RECOVERY)
        {
            print_msg(_("WARNING: online backup mode is active\n"
                        "Shutdown will not complete until pg_stop_backup() is called.\n\n"));
        }

        print_msg(_("waiting for server to shut down..."));

        /* always wait for restart */

        for (cnt = 0; cnt < wait_seconds * WAITS_PER_SEC; cnt++)
        {
            if ((pid = get_pgpid(false)) != 0)
            {
                if (cnt % WAITS_PER_SEC == 0)
                    print_msg(".");
                pg_usleep(USEC_PER_SEC / WAITS_PER_SEC);
            }
            else
                break;
        }

        if (pid != 0)           /* pid file still exists */
        {
            print_msg(_(" failed\n"));

            write_stderr(_("%s: server does not shut down\n"), progname);
            if (shutdown_mode == SMART_MODE)
                write_stderr(_("HINT: The \"-m fast\" option immediately disconnects sessions rather than\n"
                               "waiting for session-initiated disconnection.\n"));
            exit(1);
        }

        print_msg(_(" done\n"));
        print_msg(_("server stopped\n"));
    }
    else
    {
        write_stderr(_("%s: old server process (PID: %ld) seems to be gone\n"),
                     progname, pid);
        write_stderr(_("starting server anyway\n"));
    }

    do_start();
}

do_start()

static void do_start ( void  )

static

Definition at line 844 of file pg_ctl.c.

References _, allow_core_files, argv0, ctl_command, do_wait, exec_path, find_other_exec_or_die(), get_pgpid(), PG_BACKEND_VERSIONSTR, pgdata_opt, POSTMASTER_FAILED, POSTMASTER_READY, POSTMASTER_STILL_STARTING, postmasterPID, pqsignal(), print_msg(), progname, putenv, read_post_opts(), RESTART_COMMAND, snprintf, start_postmaster(), trap_sigint_during_startup(), wait_for_postmaster(), and write_stderr().

Referenced by do_restart(), and main().

{
    pgpid_t     old_pid = 0;
    pgpid_t     pm_pid;

    if (ctl_command != RESTART_COMMAND)
    {
        old_pid = get_pgpid(false);
        if (old_pid != 0)
            write_stderr(_("%s: another server might be running; "
                           "trying to start server anyway\n"),
                         progname);
    }

    read_post_opts();

    /* No -D or -D already added during server start */
    if (ctl_command == RESTART_COMMAND || pgdata_opt == NULL)
        pgdata_opt = "";

    if (exec_path == NULL)
        exec_path = find_other_exec_or_die(argv0, "postgres", PG_BACKEND_VERSIONSTR);

#if defined(HAVE_GETRLIMIT) && defined(RLIMIT_CORE)
    if (allow_core_files)
        unlimit_core_size();
#endif

    /*
     * If possible, tell the postmaster our parent shell's PID (see the
     * comments in CreateLockFile() for motivation).  Windows hasn't got
     * getppid() unfortunately.
     */
#ifndef WIN32
    {
        static char env_var[32];

        snprintf(env_var, sizeof(env_var), "PG_GRANDPARENT_PID=%d",
                 (int) getppid());
        putenv(env_var);
    }
#endif

    pm_pid = start_postmaster();

    if (do_wait)
    {
        /*
         * If the user interrupts the startup (e.g. with CTRL-C), we'd like to
         * abort the server launch.  Install a signal handler that will
         * forward SIGINT to the postmaster process, while we wait.
         *
         * (We don't bother to reset the signal handler after the launch, as
         * we're about to exit, anyway.)
         */
        postmasterPID = pm_pid;
        pqsignal(SIGINT, trap_sigint_during_startup);

        print_msg(_("waiting for server to start..."));

        switch (wait_for_postmaster(pm_pid, false))
        {
            case POSTMASTER_READY:
                print_msg(_(" done\n"));
                print_msg(_("server started\n"));
                break;
            case POSTMASTER_STILL_STARTING:
                print_msg(_(" stopped waiting\n"));
                write_stderr(_("%s: server did not start in time\n"),
                             progname);
                exit(1);
                break;
            case POSTMASTER_FAILED:
                print_msg(_(" stopped waiting\n"));
                write_stderr(_("%s: could not start server\n"
                               "Examine the log output.\n"),
                             progname);
                exit(1);
                break;
        }
    }
    else
        print_msg(_("server starting\n"));

#ifdef WIN32
    /* Now we don't need the handle to the shell process anymore */
    CloseHandle(postmasterProcess);
    postmasterProcess = INVALID_HANDLE_VALUE;
#endif
}

do_status()

static void do_status ( void  )

static

Definition at line 1335 of file pg_ctl.c.

References _, free_readfile(), get_pgpid(), postmaster_is_alive(), postopts_file, printf, progname, and readfile().

Referenced by main().

{
    pgpid_t     pid;

    pid = get_pgpid(true);
    /* Is there a pid file? */
    if (pid != 0)
    {
        /* standalone backend? */
        if (pid < 0)
        {
            pid = -pid;
            if (postmaster_is_alive((pid_t) pid))
            {
                printf(_("%s: single-user server is running (PID: %ld)\n"),
                       progname, pid);
                return;
            }
        }
        else
            /* must be a postmaster */
        {
            if (postmaster_is_alive((pid_t) pid))
            {
                char      **optlines;
                char      **curr_line;
                int         numlines;

                printf(_("%s: server is running (PID: %ld)\n"),
                       progname, pid);

                optlines = readfile(postopts_file, &numlines);
                if (optlines != NULL)
                {
                    for (curr_line = optlines; *curr_line != NULL; curr_line++)
                        puts(*curr_line);

                    /* Free the results of readfile */
                    free_readfile(optlines);
                }
                return;
            }
        }
    }
    printf(_("%s: no server running\n"), progname);

    /*
     * The Linux Standard Base Core Specification 3.1 says this should return
     * '3, program is not running'
     * https://refspecs.linuxbase.org/LSB_3.1.0/LSB-Core-generic/LSB-Core-generic/iniscrptact.html
     */
    exit(3);
}

do_stop()

static void do_stop ( void  )

static

Definition at line 937 of file pg_ctl.c.

References _, backup_file, DB_IN_ARCHIVE_RECOVERY, do_wait, get_control_dbstate(), get_pgpid(), kill, pg_usleep(), pid_file, print_msg(), progname, shutdown_mode, sig, SMART_MODE, stat, strerror, USEC_PER_SEC, wait_seconds, WAITS_PER_SEC, and write_stderr().

Referenced by main().

{
    int         cnt;
    pgpid_t     pid;
    struct stat statbuf;

    pid = get_pgpid(false);

    if (pid == 0)               /* no pid file */
    {
        write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
        write_stderr(_("Is server running?\n"));
        exit(1);
    }
    else if (pid < 0)           /* standalone backend, not postmaster */
    {
        pid = -pid;
        write_stderr(_("%s: cannot stop server; "
                       "single-user server is running (PID: %ld)\n"),
                     progname, pid);
        exit(1);
    }

    if (kill((pid_t) pid, sig) != 0)
    {
        write_stderr(_("%s: could not send stop signal (PID: %ld): %s\n"), progname, pid,
                     strerror(errno));
        exit(1);
    }

    if (!do_wait)
    {
        print_msg(_("server shutting down\n"));
        return;
    }
    else
    {
        /*
         * If backup_label exists, an online backup is running. Warn the user
         * that smart shutdown will wait for it to finish. However, if the
         * server is in archive recovery, we're recovering from an online
         * backup instead of performing one.
         */
        if (shutdown_mode == SMART_MODE &&
            stat(backup_file, &statbuf) == 0 &&
            get_control_dbstate() != DB_IN_ARCHIVE_RECOVERY)
        {
            print_msg(_("WARNING: online backup mode is active\n"
                        "Shutdown will not complete until pg_stop_backup() is called.\n\n"));
        }

        print_msg(_("waiting for server to shut down..."));

        for (cnt = 0; cnt < wait_seconds * WAITS_PER_SEC; cnt++)
        {
            if ((pid = get_pgpid(false)) != 0)
            {
                if (cnt % WAITS_PER_SEC == 0)
                    print_msg(".");
                pg_usleep(USEC_PER_SEC / WAITS_PER_SEC);
            }
            else
                break;
        }

        if (pid != 0)           /* pid file still exists */
        {
            print_msg(_(" failed\n"));

            write_stderr(_("%s: server does not shut down\n"), progname);
            if (shutdown_mode == SMART_MODE)
                write_stderr(_("HINT: The \"-m fast\" option immediately disconnects sessions rather than\n"
                               "waiting for session-initiated disconnection.\n"));
            exit(1);
        }
        print_msg(_(" done\n"));

        print_msg(_("server stopped\n"));
    }
}

find_other_exec_or_die()

static char* find_other_exec_or_die ( const char *  argv0, const char *  target, const char *  versionstr  )

static

Definition at line 784 of file pg_ctl.c.

References _, find_my_exec(), find_other_exec(), MAXPGPATH, pg_malloc(), progname, strlcpy(), and write_stderr().

Referenced by adjust_data_dir(), do_init(), and do_start().

{
    int         ret;
    char       *found_path;

    found_path = pg_malloc(MAXPGPATH);

    if ((ret = find_other_exec(argv0, target, versionstr, found_path)) < 0)
    {
        char        full_path[MAXPGPATH];

        if (find_my_exec(argv0, full_path) < 0)
            strlcpy(full_path, progname, sizeof(full_path));

        if (ret == -1)
            write_stderr(_("The program \"%s\" is needed by %s "
                           "but was not found in the\n"
                           "same directory as \"%s\".\n"
                           "Check your installation.\n"),
                         target, progname, full_path);
        else
            write_stderr(_("The program \"%s\" was found by \"%s\"\n"
                           "but was not the same version as %s.\n"
                           "Check your installation.\n"),
                         target, full_path, progname);
        exit(1);
    }

    return found_path;
}

free_readfile()

static void free_readfile ( char **  optlines )

static

Definition at line 413 of file pg_ctl.c.

References free, and i.

Referenced by do_status(), read_post_opts(), and wait_for_postmaster().

{
    char       *curr_line = NULL;
    int         i = 0;

    if (!optlines)
        return;

    while ((curr_line = optlines[i++]))
        free(curr_line);

    free(optlines);
}

get_control_dbstate()

static DBState get_control_dbstate ( void  )

static

Definition at line 2226 of file pg_ctl.c.

References _, get_controlfile(), pfree(), pg_data, progname, ControlFileData::state, and write_stderr().

Referenced by do_promote(), do_restart(), and do_stop().

{
    DBState     ret;
    bool        crc_ok;
    ControlFileData *control_file_data = get_controlfile(pg_data, &crc_ok);

    if (!crc_ok)
    {
        write_stderr(_("%s: control file appears to be corrupt\n"), progname);
        exit(1);
    }

    ret = control_file_data->state;
    pfree(control_file_data);
    return ret;
}

get_pgpid()

static pgpid_t get_pgpid ( bool  is_status_request )

static

Definition at line 249 of file pg_ctl.c.

References _, pg_data, pid_file, progname, stat, strerror, version_file, and write_stderr().

Referenced by do_logrotate(), do_promote(), do_reload(), do_restart(), do_start(), do_status(), and do_stop().

{
    FILE       *pidf;
    long        pid;
    struct stat statbuf;

    if (stat(pg_data, &statbuf) != 0)
    {
        if (errno == ENOENT)
            write_stderr(_("%s: directory \"%s\" does not exist\n"), progname,
                         pg_data);
        else
            write_stderr(_("%s: could not access directory \"%s\": %s\n"), progname,
                         pg_data, strerror(errno));

        /*
         * The Linux Standard Base Core Specification 3.1 says this should
         * return '4, program or service status is unknown'
         * https://refspecs.linuxbase.org/LSB_3.1.0/LSB-Core-generic/LSB-Core-generic/iniscrptact.html
         */
        exit(is_status_request ? 4 : 1);
    }

    if (stat(version_file, &statbuf) != 0 && errno == ENOENT)
    {
        write_stderr(_("%s: directory \"%s\" is not a database cluster directory\n"),
                     progname, pg_data);
        exit(is_status_request ? 4 : 1);
    }

    pidf = fopen(pid_file, "r");
    if (pidf == NULL)
    {
        /* No pid file, not an error on startup */
        if (errno == ENOENT)
            return 0;
        else
        {
            write_stderr(_("%s: could not open PID file \"%s\": %s\n"),
                         progname, pid_file, strerror(errno));
            exit(1);
        }
    }
    if (fscanf(pidf, "%ld", &pid) != 1)
    {
        /* Is the file empty? */
        if (ftell(pidf) == 0 && feof(pidf))
            write_stderr(_("%s: the PID file \"%s\" is empty\n"),
                         progname, pid_file);
        else
            write_stderr(_("%s: invalid data in PID file \"%s\"\n"),
                         progname, pid_file);
        exit(1);
    }
    fclose(pidf);
    return (pgpid_t) pid;
}

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 2245 of file pg_ctl.c.

References _, adjust_data_dir(), allow_core_files, argv0, backup_file, canonicalize_path(), ctl_command, do_advice(), do_help(), do_init(), do_kill(), do_logrotate(), do_promote(), do_reload(), do_restart(), do_start(), do_status(), do_stop(), do_wait, event_source, exec_path, free, get_progname(), GetDataDirectoryCreatePerm(), getopt_long(), INIT_COMMAND, KILL_COMMAND, log_file, LOGROTATE_COMMAND, MAXPGPATH, no_argument, NO_COMMAND, optarg, optind, pg_config, pg_data, pg_logging_init(), pg_mode_mask, PG_MODE_MASK_OWNER, pg_strdup(), PG_TEXTDOMAIN, pgdata_opt, pid_file, post_opts, postopts_file, progname, PROMOTE_COMMAND, psprintf(), putenv, REGISTER_COMMAND, register_password, register_servicename, register_username, RELOAD_COMMAND, required_argument, RESTART_COMMAND, RUN_AS_SERVICE_COMMAND, set_mode(), set_pglocale_pgservice(), set_sig(), sig, SIGHUP, silent_mode, snprintf, START_COMMAND, start_time, STATUS_COMMAND, STOP_COMMAND, UNREGISTER_COMMAND, version_file, wait_seconds, wait_seconds_arg, and write_stderr().

{
    static struct option long_options[] = {
        {"help", no_argument, NULL, '?'},
        {"version", no_argument, NULL, 'V'},
        {"log", required_argument, NULL, 'l'},
        {"mode", required_argument, NULL, 'm'},
        {"pgdata", required_argument, NULL, 'D'},
        {"options", required_argument, NULL, 'o'},
        {"silent", no_argument, NULL, 's'},
        {"timeout", required_argument, NULL, 't'},
        {"core-files", no_argument, NULL, 'c'},
        {"wait", no_argument, NULL, 'w'},
        {"no-wait", no_argument, NULL, 'W'},
        {NULL, 0, NULL, 0}
    };

    char       *env_wait;
    int         option_index;
    int         c;
    pgpid_t     killproc = 0;

    pg_logging_init(argv[0]);
    progname = get_progname(argv[0]);
    set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_ctl"));
    start_time = time(NULL);

    /*
     * save argv[0] so do_start() can look for the postmaster if necessary. we
     * don't look for postmaster here because in many cases we won't need it.
     */
    argv0 = argv[0];

    /* Set restrictive mode mask until PGDATA permissions are checked */
    umask(PG_MODE_MASK_OWNER);

    /* support --help and --version even if invoked as root */
    if (argc > 1)
    {
        if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
        {
            do_help();
            exit(0);
        }
        else if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
        {
            puts("pg_ctl (PostgreSQL) " PG_VERSION);
            exit(0);
        }
    }

    /*
     * Disallow running as root, to forestall any possible security holes.
     */
#ifndef WIN32
    if (geteuid() == 0)
    {
        write_stderr(_("%s: cannot be run as root\n"
                       "Please log in (using, e.g., \"su\") as the "
                       "(unprivileged) user that will\n"
                       "own the server process.\n"),
                     progname);
        exit(1);
    }
#endif

    env_wait = getenv("PGCTLTIMEOUT");
    if (env_wait != NULL)
        wait_seconds = atoi(env_wait);

    /*
     * 'Action' can be before or after args so loop over both. Some
     * getopt_long() implementations will reorder argv[] to place all flags
     * first (GNU?), but we don't rely on it. Our /port version doesn't do
     * that.
     */
    optind = 1;

    /* process command-line options */
    while (optind < argc)
    {
        while ((c = getopt_long(argc, argv, "cD:e:l:m:N:o:p:P:sS:t:U:wW",
                                long_options, &option_index)) != -1)
        {
            switch (c)
            {
                case 'D':
                    {
                        char       *pgdata_D;
                        char       *env_var;

                        pgdata_D = pg_strdup(optarg);
                        canonicalize_path(pgdata_D);
                        env_var = psprintf("PGDATA=%s", pgdata_D);
                        putenv(env_var);

                        /*
                         * We could pass PGDATA just in an environment
                         * variable but we do -D too for clearer postmaster
                         * 'ps' display
                         */
                        pgdata_opt = psprintf("-D \"%s\" ", pgdata_D);
                        break;
                    }
                case 'e':
                    event_source = pg_strdup(optarg);
                    break;
                case 'l':
                    log_file = pg_strdup(optarg);
                    break;
                case 'm':
                    set_mode(optarg);
                    break;
                case 'N':
                    register_servicename = pg_strdup(optarg);
                    break;
                case 'o':
                    /* append option? */
                    if (!post_opts)
                        post_opts = pg_strdup(optarg);
                    else
                    {
                        char       *old_post_opts = post_opts;

                        post_opts = psprintf("%s %s", old_post_opts, optarg);
                        free(old_post_opts);
                    }
                    break;
                case 'p':
                    exec_path = pg_strdup(optarg);
                    break;
                case 'P':
                    register_password = pg_strdup(optarg);
                    break;
                case 's':
                    silent_mode = true;
                    break;
                case 'S':
#ifdef WIN32
                    set_starttype(optarg);
#else
                    write_stderr(_("%s: -S option not supported on this platform\n"),
                                 progname);
                    exit(1);
#endif
                    break;
                case 't':
                    wait_seconds = atoi(optarg);
                    wait_seconds_arg = true;
                    break;
                case 'U':
                    if (strchr(optarg, '\\'))
                        register_username = pg_strdup(optarg);
                    else
                        /* Prepend .\ for local accounts */
                        register_username = psprintf(".\\%s", optarg);
                    break;
                case 'w':
                    do_wait = true;
                    break;
                case 'W':
                    do_wait = false;
                    break;
                case 'c':
                    allow_core_files = true;
                    break;
                default:
                    /* getopt_long already issued a suitable error message */
                    do_advice();
                    exit(1);
            }
        }

        /* Process an action */
        if (optind < argc)
        {
            if (ctl_command != NO_COMMAND)
            {
                write_stderr(_("%s: too many command-line arguments (first is \"%s\")\n"), progname, argv[optind]);
                do_advice();
                exit(1);
            }

            if (strcmp(argv[optind], "init") == 0
                || strcmp(argv[optind], "initdb") == 0)
                ctl_command = INIT_COMMAND;
            else if (strcmp(argv[optind], "start") == 0)
                ctl_command = START_COMMAND;
            else if (strcmp(argv[optind], "stop") == 0)
                ctl_command = STOP_COMMAND;
            else if (strcmp(argv[optind], "restart") == 0)
                ctl_command = RESTART_COMMAND;
            else if (strcmp(argv[optind], "reload") == 0)
                ctl_command = RELOAD_COMMAND;
            else if (strcmp(argv[optind], "status") == 0)
                ctl_command = STATUS_COMMAND;
            else if (strcmp(argv[optind], "promote") == 0)
                ctl_command = PROMOTE_COMMAND;
            else if (strcmp(argv[optind], "logrotate") == 0)
                ctl_command = LOGROTATE_COMMAND;
            else if (strcmp(argv[optind], "kill") == 0)
            {
                if (argc - optind < 3)
                {
                    write_stderr(_("%s: missing arguments for kill mode\n"), progname);
                    do_advice();
                    exit(1);
                }
                ctl_command = KILL_COMMAND;
                set_sig(argv[++optind]);
                killproc = atol(argv[++optind]);
            }
#ifdef WIN32
            else if (strcmp(argv[optind], "register") == 0)
                ctl_command = REGISTER_COMMAND;
            else if (strcmp(argv[optind], "unregister") == 0)
                ctl_command = UNREGISTER_COMMAND;
            else if (strcmp(argv[optind], "runservice") == 0)
                ctl_command = RUN_AS_SERVICE_COMMAND;
#endif
            else
            {
                write_stderr(_("%s: unrecognized operation mode \"%s\"\n"), progname, argv[optind]);
                do_advice();
                exit(1);
            }
            optind++;
        }
    }

    if (ctl_command == NO_COMMAND)
    {
        write_stderr(_("%s: no operation specified\n"), progname);
        do_advice();
        exit(1);
    }

    /* Note we put any -D switch into the env var above */
    pg_config = getenv("PGDATA");
    if (pg_config)
    {
        pg_config = pg_strdup(pg_config);
        canonicalize_path(pg_config);
        pg_data = pg_strdup(pg_config);
    }

    /* -D might point at config-only directory; if so find the real PGDATA */
    adjust_data_dir();

    /* Complain if -D needed and not provided */
    if (pg_config == NULL &&
        ctl_command != KILL_COMMAND && ctl_command != UNREGISTER_COMMAND)
    {
        write_stderr(_("%s: no database directory specified and environment variable PGDATA unset\n"),
                     progname);
        do_advice();
        exit(1);
    }

    if (ctl_command == RELOAD_COMMAND)
    {
        sig = SIGHUP;
        do_wait = false;
    }

    if (pg_data)
    {
        snprintf(postopts_file, MAXPGPATH, "%s/postmaster.opts", pg_data);
        snprintf(version_file, MAXPGPATH, "%s/PG_VERSION", pg_data);
        snprintf(pid_file, MAXPGPATH, "%s/postmaster.pid", pg_data);
        snprintf(backup_file, MAXPGPATH, "%s/backup_label", pg_data);

        /*
         * Set mask based on PGDATA permissions,
         *
         * Don't error here if the data directory cannot be stat'd. This is
         * handled differently based on the command and we don't want to
         * interfere with that logic.
         */
        if (GetDataDirectoryCreatePerm(pg_data))
            umask(pg_mode_mask);
    }

    switch (ctl_command)
    {
        case INIT_COMMAND:
            do_init();
            break;
        case STATUS_COMMAND:
            do_status();
            break;
        case START_COMMAND:
            do_start();
            break;
        case STOP_COMMAND:
            do_stop();
            break;
        case RESTART_COMMAND:
            do_restart();
            break;
        case RELOAD_COMMAND:
            do_reload();
            break;
        case PROMOTE_COMMAND:
            do_promote();
            break;
        case LOGROTATE_COMMAND:
            do_logrotate();
            break;
        case KILL_COMMAND:
            do_kill(killproc);
            break;
#ifdef WIN32
        case REGISTER_COMMAND:
            pgwin32_doRegister();
            break;
        case UNREGISTER_COMMAND:
            pgwin32_doUnregister();
            break;
        case RUN_AS_SERVICE_COMMAND:
            pgwin32_doRunAsService();
            break;
#endif
        default:
            break;
    }

    exit(0);
}

postmaster_is_alive()

static bool postmaster_is_alive ( pid_t  pid )

static

Definition at line 1311 of file pg_ctl.c.

References kill.

Referenced by do_restart(), and do_status().

{
    /*
     * Test to see if the process is still there.  Note that we do not
     * consider an EPERM failure to mean that the process is still there;
     * EPERM must mean that the given PID belongs to some other userid, and
     * considering the permissions on $PGDATA, that means it's not the
     * postmaster we are after.
     *
     * Don't believe that our own PID or parent shell's PID is the postmaster,
     * either.  (Windows hasn't got getppid(), though.)
     */
    if (pid == getpid())
        return false;
#ifndef WIN32
    if (pid == getppid())
        return false;
#endif
    if (kill(pid, 0) == 0)
        return true;
    return false;
}

print_msg()

static void print_msg ( const char *  msg )

static

Definition at line 239 of file pg_ctl.c.

References silent_mode, and generate_unaccent_rules::stdout.

Referenced by do_logrotate(), do_promote(), do_reload(), do_restart(), do_start(), do_stop(), and wait_for_postmaster().

{
    if (!silent_mode)
    {
        fputs(msg, stdout);
        fflush(stdout);
    }
}

read_post_opts()

static void read_post_opts ( void  )

static

Definition at line 711 of file pg_ctl.c.

References _, ctl_command, exec_path, free_readfile(), pg_strdup(), post_opts, postopts_file, progname, readfile(), RESTART_COMMAND, and write_stderr().

Referenced by do_kill(), and do_start().

{
    if (post_opts == NULL)
    {
        post_opts = "";         /* default */
        if (ctl_command == RESTART_COMMAND)
        {
            char      **optlines;
            int         numlines;

            optlines = readfile(postopts_file, &numlines);
            if (optlines == NULL)
            {
                write_stderr(_("%s: could not read file \"%s\"\n"), progname, postopts_file);
                exit(1);
            }
            else if (numlines != 1)
            {
                write_stderr(_("%s: option file \"%s\" must have exactly one line\n"),
                             progname, postopts_file);
                exit(1);
            }
            else
            {
                char       *optline;
                char       *arg1;

                optline = optlines[0];

                /*
                 * Are we at the first option, as defined by space and
                 * double-quote?
                 */
                if ((arg1 = strstr(optline, " \"")) != NULL)
                {
                    *arg1 = '\0';   /* terminate so we get only program name */
                    post_opts = pg_strdup(arg1 + 1);    /* point past whitespace */
                }
                if (exec_path == NULL)
                    exec_path = pg_strdup(optline);
            }

            /* Free the results of readfile. */
            free_readfile(optlines);
        }
    }
}

readfile()

static char ** readfile ( const char *  path, int *  numlines  )

static

Definition at line 317 of file pg_ctl.c.

References close, fd(), free, i, PG_BINARY, pg_malloc(), read, and stat.

Referenced by do_status(), read_post_opts(), and wait_for_postmaster().

{
    int         fd;
    int         nlines;
    char      **result;
    char       *buffer;
    char       *linebegin;
    int         i;
    int         n;
    int         len;
    struct stat statbuf;

    *numlines = 0;              /* in case of failure or empty file */

    /*
     * Slurp the file into memory.
     *
     * The file can change concurrently, so we read the whole file into memory
     * with a single read() call. That's not guaranteed to get an atomic
     * snapshot, but in practice, for a small file, it's close enough for the
     * current use.
     */
    fd = open(path, O_RDONLY | PG_BINARY, 0);
    if (fd < 0)
        return NULL;
    if (fstat(fd, &statbuf) < 0)
    {
        close(fd);
        return NULL;
    }
    if (statbuf.st_size == 0)
    {
        /* empty file */
        close(fd);
        result = (char **) pg_malloc(sizeof(char *));
        *result = NULL;
        return result;
    }
    buffer = pg_malloc(statbuf.st_size + 1);

    len = read(fd, buffer, statbuf.st_size + 1);
    close(fd);
    if (len != statbuf.st_size)
    {
        /* oops, the file size changed between fstat and read */
        free(buffer);
        return NULL;
    }

    /*
     * Count newlines. We expect there to be a newline after each full line,
     * including one at the end of file. If there isn't a newline at the end,
     * any characters after the last newline will be ignored.
     */
    nlines = 0;
    for (i = 0; i < len; i++)
    {
        if (buffer[i] == '\n')
            nlines++;
    }

    /* set up the result buffer */
    result = (char **) pg_malloc((nlines + 1) * sizeof(char *));
    *numlines = nlines;

    /* now split the buffer into lines */
    linebegin = buffer;
    n = 0;
    for (i = 0; i < len; i++)
    {
        if (buffer[i] == '\n')
        {
            int         slen = &buffer[i] - linebegin;
            char       *linebuf = pg_malloc(slen + 1);

            memcpy(linebuf, linebegin, slen);
            /* we already dropped the \n, but get rid of any \r too */
            if (slen > 0 && linebuf[slen - 1] == '\r')
                slen--;
            linebuf[slen] = '\0';
            result[n++] = linebuf;
            linebegin = &buffer[i + 1];
        }
    }
    result[n] = NULL;

    free(buffer);

    return result;
}

set_mode()

static void set_mode ( char *  modeopt )

static

Definition at line 2090 of file pg_ctl.c.

References _, do_advice(), FAST_MODE, IMMEDIATE_MODE, progname, shutdown_mode, sig, SIGQUIT, SMART_MODE, and write_stderr().

Referenced by main().

{
    if (strcmp(modeopt, "s") == 0 || strcmp(modeopt, "smart") == 0)
    {
        shutdown_mode = SMART_MODE;
        sig = SIGTERM;
    }
    else if (strcmp(modeopt, "f") == 0 || strcmp(modeopt, "fast") == 0)
    {
        shutdown_mode = FAST_MODE;
        sig = SIGINT;
    }
    else if (strcmp(modeopt, "i") == 0 || strcmp(modeopt, "immediate") == 0)
    {
        shutdown_mode = IMMEDIATE_MODE;
        sig = SIGQUIT;
    }
    else
    {
        write_stderr(_("%s: unrecognized shutdown mode \"%s\"\n"), progname, modeopt);
        do_advice();
        exit(1);
    }
}

set_sig()

static void set_sig ( char *  signame )

static

Definition at line 2118 of file pg_ctl.c.

References _, do_advice(), progname, sig, SIGABRT, SIGHUP, SIGKILL, SIGQUIT, SIGUSR1, SIGUSR2, and write_stderr().

Referenced by main().

{
    if (strcmp(signame, "HUP") == 0)
        sig = SIGHUP;
    else if (strcmp(signame, "INT") == 0)
        sig = SIGINT;
    else if (strcmp(signame, "QUIT") == 0)
        sig = SIGQUIT;
    else if (strcmp(signame, "ABRT") == 0)
        sig = SIGABRT;
    else if (strcmp(signame, "KILL") == 0)
        sig = SIGKILL;
    else if (strcmp(signame, "TERM") == 0)
        sig = SIGTERM;
    else if (strcmp(signame, "USR1") == 0)
        sig = SIGUSR1;
    else if (strcmp(signame, "USR2") == 0)
        sig = SIGUSR2;
    else
    {
        write_stderr(_("%s: unrecognized signal name \"%s\"\n"), progname, signame);
        do_advice();
        exit(1);
    }
}

start_postmaster()

static pgpid_t start_postmaster ( void  )

static

Definition at line 443 of file pg_ctl.c.

References _, DEVNULL, exec_path, fd(), log_file, MAXPGPATH, pgdata_opt, post_opts, progname, snprintf, generate_unaccent_rules::stdout, strerror, and write_stderr().

Referenced by check_and_dump_old_cluster(), do_start(), issue_warnings_and_set_wal_level(), main(), and setup().

{
    char        cmd[MAXPGPATH];

#ifndef WIN32
    pgpid_t     pm_pid;

    /* Flush stdio channels just before fork, to avoid double-output problems */
    fflush(stdout);
    fflush(stderr);

    pm_pid = fork();
    if (pm_pid < 0)
    {
        /* fork failed */
        write_stderr(_("%s: could not start server: %s\n"),
                     progname, strerror(errno));
        exit(1);
    }
    if (pm_pid > 0)
    {
        /* fork succeeded, in parent */
        return pm_pid;
    }

    /* fork succeeded, in child */

    /*
     * If possible, detach the postmaster process from the launching process
     * group and make it a group leader, so that it doesn't get signaled along
     * with the current group that launched it.
     */
#ifdef HAVE_SETSID
    if (setsid() < 0)
    {
        write_stderr(_("%s: could not start server due to setsid() failure: %s\n"),
                     progname, strerror(errno));
        exit(1);
    }
#endif

    /*
     * Since there might be quotes to handle here, it is easier simply to pass
     * everything to a shell to process them.  Use exec so that the postmaster
     * has the same PID as the current child process.
     */
    if (log_file != NULL)
        snprintf(cmd, MAXPGPATH, "exec \"%s\" %s%s < \"%s\" >> \"%s\" 2>&1",
                 exec_path, pgdata_opt, post_opts,
                 DEVNULL, log_file);
    else
        snprintf(cmd, MAXPGPATH, "exec \"%s\" %s%s < \"%s\" 2>&1",
                 exec_path, pgdata_opt, post_opts, DEVNULL);

    (void) execl("/bin/sh", "/bin/sh", "-c", cmd, (char *) NULL);

    /* exec failed */
    write_stderr(_("%s: could not start server: %s\n"),
                 progname, strerror(errno));
    exit(1);

    return 0;                   /* keep dumb compilers quiet */

#else                           /* WIN32 */

    /*
     * As with the Unix case, it's easiest to use the shell (CMD.EXE) to
     * handle redirection etc.  Unfortunately CMD.EXE lacks any equivalent of
     * "exec", so we don't get to find out the postmaster's PID immediately.
     */
    PROCESS_INFORMATION pi;
    const char *comspec;

    /* Find CMD.EXE location using COMSPEC, if it's set */
    comspec = getenv("COMSPEC");
    if (comspec == NULL)
        comspec = "CMD";

    if (log_file != NULL)
    {
        /*
         * First, touch the log file.  The main value of this is that if the
         * file is still locked by a previous postmaster run, we'll wait until
         * it comes free, instead of failing with ERROR_SHARING_VIOLATION.
         * (It'd be better to open the file in a sharing-friendly mode, but we
         * can't use CMD.EXE to do that, so work around it.  Note that the
         * previous postmaster will still have the file open for a short time
         * after removing postmaster.pid.)
         */
        FILE       *fd = fopen(log_file, "a");

        if (fd == NULL)
        {
            write_stderr(_("%s: could not create log file \"%s\": %s\n"),
                         progname, log_file, strerror(errno));
            exit(1);
        }
        fclose(fd);

        snprintf(cmd, MAXPGPATH, "\"%s\" /C \"\"%s\" %s%s < \"%s\" >> \"%s\" 2>&1\"",
                 comspec, exec_path, pgdata_opt, post_opts, DEVNULL, log_file);
    }
    else
        snprintf(cmd, MAXPGPATH, "\"%s\" /C \"\"%s\" %s%s < \"%s\" 2>&1\"",
                 comspec, exec_path, pgdata_opt, post_opts, DEVNULL);

    if (!CreateRestrictedProcess(cmd, &pi, false))
    {
        write_stderr(_("%s: could not start server: error code %lu\n"),
                     progname, (unsigned long) GetLastError());
        exit(1);
    }
    /* Don't close command process handle here; caller must do so */
    postmasterProcess = pi.hProcess;
    CloseHandle(pi.hThread);
    return pi.dwProcessId;      /* Shell's PID, not postmaster's! */
#endif                          /* WIN32 */
}

trap_sigint_during_startup()

static void trap_sigint_during_startup ( int  sig )

static

Definition at line 766 of file pg_ctl.c.

References _, kill, postmasterPID, pqsignal(), progname, SIG_DFL, strerror, and write_stderr().

Referenced by do_start().

{
    if (postmasterPID != -1)
    {
        if (kill(postmasterPID, SIGINT) != 0)
            write_stderr(_("%s: could not send stop signal (PID: %ld): %s\n"),
                         progname, (pgpid_t) postmasterPID, strerror(errno));
    }

    /*
     * Clear the signal handler, and send the signal again, to terminate the
     * process as normal.
     */
    pqsignal(SIGINT, SIG_DFL);
    raise(SIGINT);
}

wait_for_postmaster()

static WaitPMResult wait_for_postmaster ( pgpid_t  pm_pid, bool  do_checkpoint  )

static

Definition at line 579 of file pg_ctl.c.

References _, free_readfile(), i, LOCK_FILE_LINE_PID, LOCK_FILE_LINE_PM_STATUS, LOCK_FILE_LINE_START_TIME, pg_usleep(), pid_file, PM_STATUS_READY, PM_STATUS_STANDBY, POSTMASTER_FAILED, POSTMASTER_READY, POSTMASTER_STILL_STARTING, print_msg(), progname, readfile(), start_time, status(), USEC_PER_SEC, wait_seconds, WAITS_PER_SEC, and write_stderr().

Referenced by do_kill(), and do_start().

{
    int         i;

    for (i = 0; i < wait_seconds * WAITS_PER_SEC; i++)
    {
        char      **optlines;
        int         numlines;

        /*
         * Try to read the postmaster.pid file.  If it's not valid, or if the
         * status line isn't there yet, just keep waiting.
         */
        if ((optlines = readfile(pid_file, &numlines)) != NULL &&
            numlines >= LOCK_FILE_LINE_PM_STATUS)
        {
            /* File is complete enough for us, parse it */
            pgpid_t     pmpid;
            time_t      pmstart;

            /*
             * Make sanity checks.  If it's for the wrong PID, or the recorded
             * start time is before pg_ctl started, then either we are looking
             * at the wrong data directory, or this is a pre-existing pidfile
             * that hasn't (yet?) been overwritten by our child postmaster.
             * Allow 2 seconds slop for possible cross-process clock skew.
             */
            pmpid = atol(optlines[LOCK_FILE_LINE_PID - 1]);
            pmstart = atol(optlines[LOCK_FILE_LINE_START_TIME - 1]);
            if (pmstart >= start_time - 2 &&
#ifndef WIN32
                pmpid == pm_pid
#else
            /* Windows can only reject standalone-backend PIDs */
                pmpid > 0
#endif
                )
            {
                /*
                 * OK, seems to be a valid pidfile from our child.  Check the
                 * status line (this assumes a v10 or later server).
                 */
                char       *pmstatus = optlines[LOCK_FILE_LINE_PM_STATUS - 1];

                if (strcmp(pmstatus, PM_STATUS_READY) == 0 ||
                    strcmp(pmstatus, PM_STATUS_STANDBY) == 0)
                {
                    /* postmaster is done starting up */
                    free_readfile(optlines);
                    return POSTMASTER_READY;
                }
            }
        }

        /*
         * Free the results of readfile.
         *
         * This is safe to call even if optlines is NULL.
         */
        free_readfile(optlines);

        /*
         * Check whether the child postmaster process is still alive.  This
         * lets us exit early if the postmaster fails during startup.
         *
         * On Windows, we may be checking the postmaster's parent shell, but
         * that's fine for this purpose.
         */
#ifndef WIN32
        {
            int         exitstatus;

            if (waitpid((pid_t) pm_pid, &exitstatus, WNOHANG) == (pid_t) pm_pid)
                return POSTMASTER_FAILED;
        }
#else
        if (WaitForSingleObject(postmasterProcess, 0) == WAIT_OBJECT_0)
            return POSTMASTER_FAILED;
#endif

        /* Startup still in process; wait, printing a dot once per second */
        if (i % WAITS_PER_SEC == 0)
        {
#ifdef WIN32
            if (do_checkpoint)
            {
                /*
                 * Increment the wait hint by 6 secs (connection timeout +
                 * sleep).  We must do this to indicate to the SCM that our
                 * startup time is changing, otherwise it'll usually send a
                 * stop signal after 20 seconds, despite incrementing the
                 * checkpoint counter.
                 */
                status.dwWaitHint += 6000;
                status.dwCheckPoint++;
                SetServiceStatus(hStatus, (LPSERVICE_STATUS) &status);
            }
            else
#endif
                print_msg(".");
        }

        pg_usleep(USEC_PER_SEC / WAITS_PER_SEC);
    }

    /* out of patience; report that postmaster is still starting up */
    return POSTMASTER_STILL_STARTING;
}

write_stderr()

static void write_stderr ( const char *  fmt,   ...  )

static

Definition at line 205 of file pg_ctl.c.

References pgwin32_is_service(), vfprintf, and vsnprintf.

Referenced by adjust_data_dir(), do_advice(), do_init(), do_kill(), do_logrotate(), do_promote(), do_reload(), do_restart(), do_start(), do_stop(), find_other_exec_or_die(), get_control_dbstate(), get_pgpid(), main(), read_post_opts(), set_mode(), set_sig(), start_postmaster(), trap_sigint_during_startup(), and wait_for_postmaster().

{
    va_list     ap;

    va_start(ap, fmt);
#ifndef WIN32
    /* On Unix, we just fprintf to stderr */
    vfprintf(stderr, fmt, ap);
#else

    /*
     * On Win32, we print to stderr if running on a console, or write to
     * eventlog if running as a service
     */
    if (pgwin32_is_service())   /* Running as a service */
    {
        char        errbuf[2048];   /* Arbitrary size? */

        vsnprintf(errbuf, sizeof(errbuf), fmt, ap);

        write_eventlog(EVENTLOG_ERROR_TYPE, errbuf);
    }
    else
        /* Not running as service, write to stderr */
        vfprintf(stderr, fmt, ap);
#endif
    va_end(ap);
}

Variable Documentation

allow_core_files

bool allow_core_files = false

static

Definition at line 98 of file pg_ctl.c.

Referenced by do_start(), and main().

argv0

char* argv0 = NULL

static

Definition at line 97 of file pg_ctl.c.

Referenced by adjust_data_dir(), do_init(), do_kill(), do_start(), and main().

backup_file

char backup_file[MAXPGPATH]

static

Definition at line 104 of file pg_ctl.c.

Referenced by do_restart(), do_stop(), and main().

ctl_command

CtlCommand ctl_command = NO_COMMAND

static

Definition at line 85 of file pg_ctl.c.

Referenced by do_start(), main(), and read_post_opts().

do_wait

bool do_wait = true

static

Definition at line 79 of file pg_ctl.c.

Referenced by do_kill(), do_promote(), do_start(), do_stop(), main(), and WaitForWorkers().

event_source

char* event_source = NULL

static

Definition at line 93 of file pg_ctl.c.

Referenced by do_kill(), and main().

exec_path

char* exec_path = NULL

static

Definition at line 92 of file pg_ctl.c.

Referenced by adjust_data_dir(), do_init(), do_start(), ensureCleanShutdown(), main(), read_post_opts(), setup(), and start_postmaster().

log_file

char* log_file = NULL

static

Definition at line 91 of file pg_ctl.c.

Referenced by main(), and start_postmaster().

logrotate_file

char logrotate_file[MAXPGPATH]

static

Definition at line 106 of file pg_ctl.c.

Referenced by do_logrotate().

pg_config

char* pg_config = NULL

static

Definition at line 87 of file pg_ctl.c.

Referenced by adjust_data_dir(), do_kill(), and main().

pg_data

char* pg_data = NULL

static

Definition at line 86 of file pg_ctl.c.

Referenced by adjust_data_dir(), do_logrotate(), do_promote(), get_control_dbstate(), get_pgpid(), and main().

pgdata_opt

char* pgdata_opt = NULL

static

Definition at line 88 of file pg_ctl.c.

Referenced by adjust_data_dir(), do_init(), do_start(), main(), and start_postmaster().

pid_file

char pid_file[MAXPGPATH]

static

Definition at line 103 of file pg_ctl.c.

Referenced by do_logrotate(), do_promote(), do_reload(), do_restart(), do_stop(), get_pgpid(), main(), and wait_for_postmaster().

post_opts

char* post_opts = NULL

static

Definition at line 89 of file pg_ctl.c.

Referenced by adjust_data_dir(), do_init(), do_kill(), main(), read_post_opts(), and start_postmaster().

postmasterPID

volatile pgpid_t postmasterPID = -1

static

Definition at line 108 of file pg_ctl.c.

Referenced by do_kill(), do_start(), and trap_sigint_during_startup().

postopts_file

char postopts_file[MAXPGPATH]

static

Definition at line 101 of file pg_ctl.c.

Referenced by do_status(), main(), and read_post_opts().

progname

const char* progname

static

Definition at line 90 of file pg_ctl.c.

Referenced by adjust_data_dir(), do_advice(), do_help(), do_init(), do_kill(), do_logrotate(), do_promote(), do_reload(), do_restart(), do_start(), do_status(), do_stop(), find_other_exec_or_die(), get_control_dbstate(), get_pgpid(), main(), read_post_opts(), set_mode(), set_sig(), start_postmaster(), trap_sigint_during_startup(), and wait_for_postmaster().

promote_file

char promote_file[MAXPGPATH]

static

Definition at line 105 of file pg_ctl.c.

Referenced by do_promote(), and pg_promote().

register_password

char* register_password = NULL

static

Definition at line 96 of file pg_ctl.c.

Referenced by do_kill(), and main().

register_servicename

char* register_servicename = "PostgreSQL"

static

Definition at line 94 of file pg_ctl.c.

Referenced by do_kill(), and main().

register_username

char* register_username = NULL

static

Definition at line 95 of file pg_ctl.c.

Referenced by do_kill(), and main().

shutdown_mode

ShutdownMode shutdown_mode = FAST_MODE

static

Definition at line 83 of file pg_ctl.c.

Referenced by do_restart(), do_stop(), and set_mode().

sig

int sig = SIGINT

static

Definition at line 84 of file pg_ctl.c.

Referenced by _discoverArchiveFormat(), build_EvalXFunc(), create_LifetimeEnd(), do_kill(), do_logrotate(), do_promote(), do_reload(), do_restart(), do_stop(), main(), pgwin32_dispatch_queued_signals(), set_mode(), set_sig(), and StatementTimeoutHandler().

silent_mode

bool silent_mode = false

static

Definition at line 82 of file pg_ctl.c.

Referenced by do_init(), do_kill(), main(), and print_msg().

start_time

time_t start_time

static

Definition at line 99 of file pg_ctl.c.

Referenced by ConditionVariableTimedSleep(), feTimestampDifference(), feTimestampDifferenceExceeds(), initStats(), main(), test_timing(), TimestampDifference(), TimestampDifferenceExceeds(), wait_for_postmaster(), and WaitEventSetWait().

version_file

char version_file[MAXPGPATH]

static

Definition at line 102 of file pg_ctl.c.

Referenced by get_pgpid(), main(), and write_version_file().

wait_seconds

int wait_seconds = DEFAULT_WAIT

static

Definition at line 80 of file pg_ctl.c.

Referenced by do_kill(), do_promote(), do_restart(), do_stop(), main(), pg_promote(), regression_main(), and wait_for_postmaster().

wait_seconds_arg

bool wait_seconds_arg = false

static

Definition at line 81 of file pg_ctl.c.

Referenced by do_kill(), and main().