#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 "getopt_long.h"
#include "libpq-fe.h"
#include "miscadmin.h"
#include "pqexpbuffer.h"

Include dependency graph for pg_ctl.c:

Macros
#define	DEFAULT_WAIT 60

Typedefs
typedef long	pgpid_t

Enumerations
enum	ShutdownMode { SMART_MODE, FAST_MODE, IMMEDIATE_MODE }

enum	CtlCommand { NO_COMMAND = 0, INIT_COMMAND, START_COMMAND, STOP_COMMAND, RESTART_COMMAND, RELOAD_COMMAND, STATUS_COMMAND, PROMOTE_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_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)

static void	free_readfile (char **optlines)

static pgpid_t	start_postmaster (void)

static void	read_post_opts (void)

static PGPing	test_postmaster_connection (pgpid_t pm_pid, bool do_checkpoint)

static bool	postmaster_is_alive (pid_t pid)

static DBState	get_control_dbstate (void)

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]

Macro Definition Documentation

#define DEFAULT_WAIT 60

Definition at line 69 of file pg_ctl.c.

Typedef Documentation

typedef long pgpid_t

Definition at line 42 of file pg_ctl.c.

Enumeration Type Documentation

enum CtlCommand

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

Definition at line 53 of file pg_ctl.c.

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

enum ShutdownMode

Enumerator
SMART_MODE
FAST_MODE
IMMEDIATE_MODE

Definition at line 45 of file pg_ctl.c.

 {
     SMART_MODE,
     FAST_MODE,
     IMMEDIATE_MODE
 } ShutdownMode;

Function Documentation

static void adjust_data_dir ( void )

static

Definition at line 2081 of file pg_ctl.c.

References _, argv0, canonicalize_path(), exec_path, fd(), filename, find_other_exec_or_die(), free, MAXPGPATH, my_exec_path, NULL, PG_BACKEND_VERSIONSTR, pg_config, pg_data, pg_strdup(), 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);
 
     /* Remove trailing newline */
     if (strchr(filename, '\n') != NULL)
         *strchr(filename, '\n') = '\0';
 
     free(pg_data);
     pg_data = pg_strdup(filename);
     canonicalize_path(pg_data);
 }

static void do_advice ( void )

static

Definition at line 1920 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);
 }

static void do_help ( void )

static

Definition at line 1928 of file pg_ctl.c.

References _, 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 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 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@postgresql.org>.\n"));
 }

static void do_init ( void )

static

Definition at line 835 of file pg_ctl.c.

References _, argv0, DEVNULL, exec_path, find_other_exec_or_die(), MAXPGPATH, NULL, 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);
     }
 }

static void do_kill ( pgpid_t pid )

static

Definition at line 1341 of file pg_ctl.c.

References _, progname, sig, strerror(), 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);
     }
 }

static void do_promote ( void )

static

Definition at line 1164 of file pg_ctl.c.

References _, DB_IN_ARCHIVE_RECOVERY, DB_IN_PRODUCTION, DB_STARTUP, do_wait, get_control_dbstate(), get_pgpid(), MAXPGPATH, NULL, pg_data, pg_usleep(), pid_file, print_msg(), progname, promote_file, sig, SIGUSR1, snprintf(), strerror(), unlink(), wait_seconds, 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;
 
         print_msg(_("waiting for server to promote..."));
         while (wait_seconds > 0)
         {
             state = get_control_dbstate();
             if (state == DB_IN_PRODUCTION)
                 break;
 
             print_msg(".");
             pg_usleep(1000000); /* 1 sec */
             wait_seconds--;
         }
         if (state == DB_IN_PRODUCTION)
         {
             print_msg(_(" done\n"));
             print_msg(_("server promoted\n"));
         }
         else
         {
             print_msg(_(" stopped waiting\n"));
             print_msg(_("server is still promoting\n"));
         }
     }
     else
         print_msg(_("server promoting\n"));
 }

static void do_reload ( void )

static

Definition at line 1127 of file pg_ctl.c.

References _, get_pgpid(), 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"));
 }

static void do_restart ( void )

static

Definition at line 1034 of file pg_ctl.c.

References _, backup_file, DB_IN_ARCHIVE_RECOVERY, do_start(), get_control_dbstate(), get_pgpid(), pg_usleep(), pid_file, postmaster_is_alive(), print_msg(), progname, shutdown_mode, sig, SMART_MODE, strerror(), wait_seconds, 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(_("starting 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; cnt++)
         {
             if ((pid = get_pgpid(false)) != 0)
             {
                 print_msg(".");
                 pg_usleep(1000000); /* 1 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();
 }

static void do_start ( void )

static

Definition at line 863 of file pg_ctl.c.

References _, allow_core_files, argv0, ctl_command, do_wait, exec_path, find_other_exec_or_die(), get_pgpid(), NULL, PG_BACKEND_VERSIONSTR, pgdata_opt, PQPING_NO_ATTEMPT, PQPING_NO_RESPONSE, PQPING_OK, PQPING_REJECT, print_msg(), progname, putenv, read_post_opts(), RESTART_COMMAND, snprintf(), start_postmaster(), test_postmaster_connection(), 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)
     {
         print_msg(_("waiting for server to start..."));
 
         switch (test_postmaster_connection(pm_pid, false))
         {
             case PQPING_OK:
                 print_msg(_(" done\n"));
                 print_msg(_("server started\n"));
                 break;
             case PQPING_REJECT:
                 print_msg(_(" stopped waiting\n"));
                 print_msg(_("server is still starting up\n"));
                 break;
             case PQPING_NO_RESPONSE:
                 print_msg(_(" stopped waiting\n"));
                 write_stderr(_("%s: could not start server\n"
                                "Examine the log output.\n"),
                              progname);
                 exit(1);
                 break;
             case PQPING_NO_ATTEMPT:
                 print_msg(_(" failed\n"));
                 write_stderr(_("%s: could not wait for server because of misconfiguration\n"),
                              progname);
                 exit(1);
         }
     }
     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
 }

static void do_status ( void )

static

Definition at line 1285 of file pg_ctl.c.

References _, free_readfile(), get_pgpid(), NULL, postmaster_is_alive(), postopts_file, 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;
 
                 printf(_("%s: server is running (PID: %ld)\n"),
                        progname, pid);
 
                 optlines = readfile(postopts_file);
                 if (optlines != NULL)
                 {
                     for (curr_line = optlines; *curr_line != NULL; curr_line++)
                         fputs(*curr_line, stdout);
 
                     /* 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);
 }

static void do_stop ( void )

static

Definition at line 948 of file pg_ctl.c.

References _, backup_file, DB_IN_ARCHIVE_RECOVERY, do_wait, get_control_dbstate(), get_pgpid(), pg_usleep(), pid_file, print_msg(), progname, shutdown_mode, sig, SMART_MODE, strerror(), wait_seconds, 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; cnt++)
         {
             if ((pid = get_pgpid(false)) != 0)
             {
                 print_msg(".");
                 pg_usleep(1000000); /* 1 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"));
     }
 }

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

static

Definition at line 803 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;
 }

static void free_readfile ( char ** optlines )

static

Definition at line 395 of file pg_ctl.c.

References free, i, and NULL.

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

 {
     char       *curr_line = NULL;
     int         i = 0;
 
     if (!optlines)
         return;
 
     while ((curr_line = optlines[i++]))
         free(curr_line);
 
     free(optlines);
 
     return;
 }

static DBState get_control_dbstate ( void )

static

Definition at line 2140 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, progname, &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;
 }

static pgpid_t get_pgpid ( bool is_status_request )

static

Definition at line 242 of file pg_ctl.c.

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

Referenced by 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;
 }

int main	(	int	argc,
		char **	argv
	)

Definition at line 2159 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_promote(), do_reload(), do_restart(), do_start(), do_status(), do_stop(), do_wait, event_source, exec_path, free, get_progname(), getopt_long(), INIT_COMMAND, KILL_COMMAND, log_file, MAXPGPATH, no_argument, NO_COMMAND, NULL, optarg, optind, pg_config, pg_data, 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, S_IRWXG, S_IRWXO, 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;
 
 #ifdef WIN32
     setvbuf(stderr, NULL, _IONBF, 0);
 #endif
 
     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];
 
     umask(S_IRWXG | S_IRWXO);
 
     /* 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], "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);
     }
 
     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 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);
 }

static bool postmaster_is_alive ( pid_t pid )

static

Definition at line 1261 of file pg_ctl.c.

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

static void print_msg ( const char * msg )

static

Definition at line 232 of file pg_ctl.c.

References silent_mode.

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

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

static void read_post_opts ( void )

static

Definition at line 751 of file pg_ctl.c.

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

Referenced by do_start().

 {
     if (post_opts == NULL)
     {
         post_opts = "";         /* default */
         if (ctl_command == RESTART_COMMAND)
         {
             char      **optlines;
 
             optlines = readfile(postopts_file);
             if (optlines == NULL)
             {
                 write_stderr(_("%s: could not read file \"%s\"\n"), progname, postopts_file);
                 exit(1);
             }
             else if (optlines[0] == NULL || optlines[1] != NULL)
             {
                 write_stderr(_("%s: option file \"%s\" must have exactly one line\n"),
                              progname, postopts_file);
                 exit(1);
             }
             else
             {
                 int         len;
                 char       *optline;
                 char       *arg1;
 
                 optline = optlines[0];
                 /* trim off line endings */
                 len = strcspn(optline, "\r\n");
                 optline[len] = '\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);
         }
     }
 }

static char ** readfile ( const char * path )

static

Definition at line 305 of file pg_ctl.c.

References buffer, close, fd(), free, i, NULL, PG_BINARY, pg_malloc(), read, and result.

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

 {
     int         fd;
     int         nlines;
     char      **result;
     char       *buffer;
     char       *linebegin;
     int         i;
     int         n;
     int         len;
     struct stat statbuf;
 
     /*
      * 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 *));
 
     /* 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 + 1;
             char       *linebuf = pg_malloc(slen + 1);
 
             memcpy(linebuf, linebegin, slen);
             linebuf[slen] = '\0';
             result[n++] = linebuf;
             linebegin = &buffer[i + 1];
         }
     }
     result[n] = NULL;
 
     free(buffer);
 
     return result;
 }

static void set_mode ( char * modeopt )

static

Definition at line 2000 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);
     }
 }

static void set_sig ( char * signame )

static

Definition at line 2028 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;
 #if 0
     /* probably should NOT provide SIGKILL */
     else if (strcmp(signame, "KILL") == 0)
         sig = SIGKILL;
 #endif
     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);
     }
 }

static pgpid_t start_postmaster ( void )

static

Definition at line 427 of file pg_ctl.c.

References _, DEVNULL, exec_path, log_file, MAXPGPATH, NULL, pgdata_opt, post_opts, progname, snprintf(), 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 */
 
     /*
      * 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;
 
     if (log_file != NULL)
         snprintf(cmd, MAXPGPATH, "CMD /C \"\"%s\" %s%s < \"%s\" >> \"%s\" 2>&1\"",
                  exec_path, pgdata_opt, post_opts, DEVNULL, log_file);
     else
         snprintf(cmd, MAXPGPATH, "CMD /C \"\"%s\" %s%s < \"%s\" 2>&1\"",
                  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 */
 }

static PGPing test_postmaster_connection	(	pgpid_t	pm_pid,
		bool	do_checkpoint
	)

static

Definition at line 522 of file pg_ctl.c.

References _, connstr, free_readfile(), i, LOCK_FILE_LINE_LISTEN_ADDR, LOCK_FILE_LINE_PID, LOCK_FILE_LINE_PORT, LOCK_FILE_LINE_SOCKET_DIR, LOCK_FILE_LINE_START_TIME, MAXPGPATH, NULL, pg_usleep(), pid_file, PQping(), PQPING_NO_ATTEMPT, PQPING_NO_RESPONSE, PQPING_OK, PQPING_REJECT, print_msg(), progname, readfile(), snprintf(), sockdir, start_time, status(), strlcpy(), wait_seconds, and write_stderr().

Referenced by do_start().

 {
     PGPing      ret = PQPING_NO_RESPONSE;
     char        connstr[MAXPGPATH * 2 + 256];
     int         i;
 
     /* if requested wait time is zero, return "still starting up" code */
     if (wait_seconds <= 0)
         return PQPING_REJECT;
 
     connstr[0] = '\0';
 
     for (i = 0; i < wait_seconds; i++)
     {
         /* Do we need a connection string? */
         if (connstr[0] == '\0')
         {
             /*----------
              * The number of lines in postmaster.pid tells us several things:
              *
              * # of lines
              *      0   lock file created but status not written
              *      2   pre-9.1 server, shared memory not created
              *      3   pre-9.1 server, shared memory created
              *      5   9.1+ server, ports not opened
              *      6   9.1+ server, shared memory not created
              *      7   9.1+ server, shared memory created
              *
              * This code does not support pre-9.1 servers.  On Unix machines
              * we could consider extracting the port number from the shmem
              * key, but that (a) is not robust, and (b) doesn't help with
              * finding out the socket directory.  And it wouldn't work anyway
              * on Windows.
              *
              * If we see less than 6 lines in postmaster.pid, just keep
              * waiting.
              *----------
              */
             char      **optlines;
 
             /* Try to read the postmaster.pid file */
             if ((optlines = readfile(pid_file)) != NULL &&
                 optlines[0] != NULL &&
                 optlines[1] != NULL &&
                 optlines[2] != NULL)
             {
                 if (optlines[3] == NULL)
                 {
                     /* File is exactly three lines, must be pre-9.1 */
                     write_stderr(_("\n%s: -w option is not supported when starting a pre-9.1 server\n"),
                                  progname);
                     return PQPING_NO_ATTEMPT;
                 }
                 else if (optlines[4] != NULL &&
                          optlines[5] != NULL)
                 {
                     /* 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.
                          */
                         int         portnum;
                         char       *sockdir;
                         char       *hostaddr;
                         char        host_str[MAXPGPATH];
 
                         /*
                          * Extract port number and host string to use. Prefer
                          * using Unix socket if available.
                          */
                         portnum = atoi(optlines[LOCK_FILE_LINE_PORT - 1]);
                         sockdir = optlines[LOCK_FILE_LINE_SOCKET_DIR - 1];
                         hostaddr = optlines[LOCK_FILE_LINE_LISTEN_ADDR - 1];
 
                         /*
                          * While unix_socket_directories can accept relative
                          * directories, libpq's host parameter must have a
                          * leading slash to indicate a socket directory.  So,
                          * ignore sockdir if it's relative, and try to use TCP
                          * instead.
                          */
                         if (sockdir[0] == '/')
                             strlcpy(host_str, sockdir, sizeof(host_str));
                         else
                             strlcpy(host_str, hostaddr, sizeof(host_str));
 
                         /* remove trailing newline */
                         if (strchr(host_str, '\n') != NULL)
                             *strchr(host_str, '\n') = '\0';
 
                         /* Fail if couldn't get either sockdir or host addr */
                         if (host_str[0] == '\0')
                         {
                             write_stderr(_("\n%s: -w option cannot use a relative socket directory specification\n"),
                                          progname);
                             return PQPING_NO_ATTEMPT;
                         }
 
                         /*
                          * Map listen-only addresses to counterparts usable
                          * for establishing a connection.  connect() to "::"
                          * or "0.0.0.0" is not portable to OpenBSD 5.0 or to
                          * Windows Server 2008, and connect() to "::" is
                          * additionally not portable to NetBSD 6.0.  (Cygwin
                          * does handle both addresses, though.)
                          */
                         if (strcmp(host_str, "*") == 0)
                             strcpy(host_str, "localhost");
                         else if (strcmp(host_str, "0.0.0.0") == 0)
                             strcpy(host_str, "127.0.0.1");
                         else if (strcmp(host_str, "::") == 0)
                             strcpy(host_str, "::1");
 
                         /*
                          * We need to set connect_timeout otherwise on Windows
                          * the Service Control Manager (SCM) will probably
                          * timeout first.
                          */
                         snprintf(connstr, sizeof(connstr),
                                  "dbname=postgres port=%d host='%s' connect_timeout=5",
                                  portnum, host_str);
                     }
                 }
             }
 
             /*
              * Free the results of readfile.
              *
              * This is safe to call even if optlines is NULL.
              */
             free_readfile(optlines);
         }
 
         /* If we have a connection string, ping the server */
         if (connstr[0] != '\0')
         {
             ret = PQping(connstr);
             if (ret == PQPING_OK || ret == PQPING_NO_ATTEMPT)
                 break;
         }
 
         /*
          * 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 PQPING_NO_RESPONSE;
         }
 #else
         if (WaitForSingleObject(postmasterProcess, 0) == WAIT_OBJECT_0)
             return PQPING_NO_RESPONSE;
 #endif
 
         /* No response, or startup still in process; wait */
 #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(1000000);     /* 1 sec */
     }
 
     /* return result of last call to PQping */
     return ret;
 }

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

static

Definition at line 198 of file pg_ctl.c.

References pgwin32_is_service(), and vsnprintf().

Referenced by adjust_data_dir(), do_advice(), do_init(), do_kill(), 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(), and test_postmaster_connection().

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