#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 "utils/pidfile.h"

Include dependency graph for pg_ctl.c:

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, 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, 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 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 77 of file pg_ctl.c.

#define USEC_PER_SEC 1000000

Definition at line 79 of file pg_ctl.c.

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

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

Definition at line 81 of file pg_ctl.c.

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

Typedef Documentation

typedef long pgpid_t

Definition at line 44 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 61 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 47 of file pg_ctl.c.

 {
     SMART_MODE,
     FAST_MODE,
     IMMEDIATE_MODE
 } ShutdownMode;

enum WaitPMResult

Enumerator
POSTMASTER_READY
POSTMASTER_STILL_STARTING
POSTMASTER_FAILED

Definition at line 54 of file pg_ctl.c.

 {
     POSTMASTER_READY,
     POSTMASTER_STILL_STARTING,
     POSTMASTER_FAILED
 } WaitPMResult;

Function Documentation

static void adjust_data_dir ( void )

static

Definition at line 2007 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 1846 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 1854 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 758 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 1267 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 1086 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(), 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"));
 }

static void do_reload ( void )

static

Definition at line 1049 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 955 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(), 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(_("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 * 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();
 }

static void do_start ( void )

static

Definition at line 786 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, POSTMASTER_FAILED, POSTMASTER_READY, POSTMASTER_STILL_STARTING, print_msg(), progname, putenv, read_post_opts(), RESTART_COMMAND, snprintf(), start_postmaster(), 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)
     {
         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
 }

static void do_status ( void )

static

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

static void do_stop ( void )

static

Definition at line 868 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(), 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"));
     }
 }

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

static

Definition at line 726 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 418 of file pg_ctl.c.

References free, i, and NULL.

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

static DBState get_control_dbstate ( void )

static

Definition at line 2066 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 254 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 2085 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 1186 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 244 of file pg_ctl.c.

References silent_mode.

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

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

static void read_post_opts ( void )

static

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

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

static

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

static void set_mode ( char * modeopt )

static

Definition at line 1926 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 1954 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 450 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 WaitPMResult wait_for_postmaster	(	pgpid_t	pm_pid,
		bool	do_checkpoint
	)

static

Definition at line 545 of file pg_ctl.c.

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

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

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

static

Definition at line 210 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(), and start_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);
 }