PostgreSQL Source Code  git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
pg_ctl.c File Reference
#include "postgres_fe.h"
#include <fcntl.h>
#include <signal.h>
#include <time.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>
#include "catalog/pg_control.h"
#include "common/controldata_utils.h"
#include "common/file_perm.h"
#include "common/logging.h"
#include "common/string.h"
#include "getopt_long.h"
#include "utils/pidfile.h"
Include dependency graph for pg_ctl.c:

Go to the source code of this file.

Macros

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

Enumerations

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

Functions

static void write_stderr (const char *fmt,...) pg_attribute_printf(1
 
static void static void do_advice (void)
 
static void do_help (void)
 
static void set_mode (char *modeopt)
 
static void set_sig (char *signame)
 
static void do_init (void)
 
static void do_start (void)
 
static void do_stop (void)
 
static void do_restart (void)
 
static void do_reload (void)
 
static void do_status (void)
 
static void do_promote (void)
 
static void do_logrotate (void)
 
static void do_kill (pid_t pid)
 
static void print_msg (const char *msg)
 
static void adjust_data_dir (void)
 
static pid_t get_pgpid (bool is_status_request)
 
static char ** readfile (const char *path, int *numlines)
 
static void free_readfile (char **optlines)
 
static pid_t start_postmaster (void)
 
static void read_post_opts (void)
 
static WaitPMResult wait_for_postmaster_start (pid_t pm_pid, bool do_checkpoint)
 
static bool wait_for_postmaster_stop (void)
 
static bool wait_for_postmaster_promote (void)
 
static bool postmaster_is_alive (pid_t pid)
 
static void unlimit_core_size (void)
 
static DBState get_control_dbstate (void)
 
static void trap_sigint_during_startup (SIGNAL_ARGS)
 
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 promote_file [MAXPGPATH]
 
static char logrotate_file [MAXPGPATH]
 
static volatile pid_t postmasterPID = -1
 

Macro Definition Documentation

◆ DEFAULT_WAIT

#define DEFAULT_WAIT   60

Definition at line 69 of file pg_ctl.c.

◆ USEC_PER_SEC

#define USEC_PER_SEC   1000000

Definition at line 71 of file pg_ctl.c.

◆ WAITS_PER_SEC

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

Definition at line 73 of file pg_ctl.c.

Enumeration Type Documentation

◆ CtlCommand

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

Definition at line 52 of file pg_ctl.c.

53 {
54  NO_COMMAND = 0,
67 } CtlCommand;
CtlCommand
Definition: pg_ctl.c:53
@ REGISTER_COMMAND
Definition: pg_ctl.c:64
@ RUN_AS_SERVICE_COMMAND
Definition: pg_ctl.c:66
@ LOGROTATE_COMMAND
Definition: pg_ctl.c:62
@ RESTART_COMMAND
Definition: pg_ctl.c:58
@ UNREGISTER_COMMAND
Definition: pg_ctl.c:65
@ START_COMMAND
Definition: pg_ctl.c:56
@ KILL_COMMAND
Definition: pg_ctl.c:63
@ INIT_COMMAND
Definition: pg_ctl.c:55
@ STOP_COMMAND
Definition: pg_ctl.c:57
@ STATUS_COMMAND
Definition: pg_ctl.c:60
@ NO_COMMAND
Definition: pg_ctl.c:54
@ PROMOTE_COMMAND
Definition: pg_ctl.c:61
@ RELOAD_COMMAND
Definition: pg_ctl.c:59

◆ ShutdownMode

Enumerator
SMART_MODE 
FAST_MODE 
IMMEDIATE_MODE 

Definition at line 37 of file pg_ctl.c.

38 {
39  SMART_MODE,
40  FAST_MODE,
42 } ShutdownMode;
ShutdownMode
Definition: pg_ctl.c:38
@ FAST_MODE
Definition: pg_ctl.c:40
@ IMMEDIATE_MODE
Definition: pg_ctl.c:41
@ SMART_MODE
Definition: pg_ctl.c:39

◆ WaitPMResult

Enumerator
POSTMASTER_READY 
POSTMASTER_STILL_STARTING 
POSTMASTER_READY 
POSTMASTER_STILL_STARTING 
POSTMASTER_SHUTDOWN_IN_RECOVERY 
POSTMASTER_FAILED 

Definition at line 44 of file pg_ctl.c.

45 {
50 } WaitPMResult;
WaitPMResult
Definition: pg_ctl.c:45
@ POSTMASTER_SHUTDOWN_IN_RECOVERY
Definition: pg_ctl.c:48
@ POSTMASTER_FAILED
Definition: pg_ctl.c:49
@ POSTMASTER_READY
Definition: pg_ctl.c:46
@ POSTMASTER_STILL_STARTING
Definition: pg_ctl.c:47

Function Documentation

◆ adjust_data_dir()

static void adjust_data_dir ( void  )
static

Definition at line 2125 of file pg_ctl.c.

2126 {
2127  char filename[MAXPGPATH];
2128  char *my_exec_path,
2129  *cmd;
2130  FILE *fd;
2131 
2132  /* do nothing if we're working without knowledge of data dir */
2133  if (pg_config == NULL)
2134  return;
2135 
2136  /* If there is no postgresql.conf, it can't be a config-only dir */
2137  snprintf(filename, sizeof(filename), "%s/postgresql.conf", pg_config);
2138  if ((fd = fopen(filename, "r")) == NULL)
2139  return;
2140  fclose(fd);
2141 
2142  /* If PG_VERSION exists, it can't be a config-only dir */
2143  snprintf(filename, sizeof(filename), "%s/PG_VERSION", pg_config);
2144  if ((fd = fopen(filename, "r")) != NULL)
2145  {
2146  fclose(fd);
2147  return;
2148  }
2149 
2150  /* Must be a configuration directory, so find the data directory */
2151 
2152  /* we use a private my_exec_path to avoid interfering with later uses */
2153  if (exec_path == NULL)
2155  else
2157 
2158  /* it's important for -C to be the first option, see main.c */
2159  cmd = psprintf("\"%s\" -C data_directory %s%s",
2160  my_exec_path,
2161  pgdata_opt ? pgdata_opt : "",
2162  post_opts ? post_opts : "");
2163  fflush(NULL);
2164 
2165  fd = popen(cmd, "r");
2166  if (fd == NULL || fgets(filename, sizeof(filename), fd) == NULL || pclose(fd) != 0)
2167  {
2168  write_stderr(_("%s: could not determine the data directory using command \"%s\"\n"), progname, cmd);
2169  exit(1);
2170  }
2171  free(my_exec_path);
2172 
2173  /* strip trailing newline and carriage return */
2174  (void) pg_strip_crlf(filename);
2175 
2176  free(pg_data);
2179 }
#define _(x)
Definition: elog.c:90
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
char my_exec_path[MAXPGPATH]
Definition: globals.c:80
#define free(a)
Definition: header.h:65
static void const char fflush(stdout)
exit(1)
#define MAXPGPATH
static char * post_opts
Definition: pg_ctl.c:85
static char * pgdata_opt
Definition: pg_ctl.c:84
static char * find_other_exec_or_die(const char *argv0, const char *target, const char *versionstr)
Definition: pg_ctl.c:875
static char * pg_config
Definition: pg_ctl.c:83
static char * pg_data
Definition: pg_ctl.c:82
static char * argv0
Definition: pg_ctl.c:93
static void write_stderr(const char *fmt,...) pg_attribute_printf(1
Definition: pg_ctl.c:202
static const char * progname
Definition: pg_ctl.c:86
static char * exec_path
Definition: pg_ctl.c:88
static char * filename
Definition: pg_dumpall.c:119
void canonicalize_path(char *path)
Definition: path.c:265
#define snprintf
Definition: port.h:238
#define PG_BACKEND_VERSIONSTR
Definition: port.h:143
static int fd(const char *x, int i)
Definition: preproc-init.c:105
char * psprintf(const char *fmt,...)
Definition: psprintf.c:43
int pg_strip_crlf(char *str)
Definition: string.c:154

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

Referenced by main().

◆ do_advice()

static void do_advice ( void  )
static

Definition at line 1965 of file pg_ctl.c.

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

References _, progname, and write_stderr().

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

◆ do_help()

static void do_help ( void  )
static

Definition at line 1973 of file pg_ctl.c.

1974 {
1975  printf(_("%s is a utility to initialize, start, stop, or control a PostgreSQL server.\n\n"), progname);
1976  printf(_("Usage:\n"));
1977  printf(_(" %s init[db] [-D DATADIR] [-s] [-o OPTIONS]\n"), progname);
1978  printf(_(" %s start [-D DATADIR] [-l FILENAME] [-W] [-t SECS] [-s]\n"
1979  " [-o OPTIONS] [-p PATH] [-c]\n"), progname);
1980  printf(_(" %s stop [-D DATADIR] [-m SHUTDOWN-MODE] [-W] [-t SECS] [-s]\n"), progname);
1981  printf(_(" %s restart [-D DATADIR] [-m SHUTDOWN-MODE] [-W] [-t SECS] [-s]\n"
1982  " [-o OPTIONS] [-c]\n"), progname);
1983  printf(_(" %s reload [-D DATADIR] [-s]\n"), progname);
1984  printf(_(" %s status [-D DATADIR]\n"), progname);
1985  printf(_(" %s promote [-D DATADIR] [-W] [-t SECS] [-s]\n"), progname);
1986  printf(_(" %s logrotate [-D DATADIR] [-s]\n"), progname);
1987  printf(_(" %s kill SIGNALNAME PID\n"), progname);
1988 #ifdef WIN32
1989  printf(_(" %s register [-D DATADIR] [-N SERVICENAME] [-U USERNAME] [-P PASSWORD]\n"
1990  " [-S START-TYPE] [-e SOURCE] [-W] [-t SECS] [-s] [-o OPTIONS]\n"), progname);
1991  printf(_(" %s unregister [-N SERVICENAME]\n"), progname);
1992 #endif
1993 
1994  printf(_("\nCommon options:\n"));
1995  printf(_(" -D, --pgdata=DATADIR location of the database storage area\n"));
1996 #ifdef WIN32
1997  printf(_(" -e SOURCE event source for logging when running as a service\n"));
1998 #endif
1999  printf(_(" -s, --silent only print errors, no informational messages\n"));
2000  printf(_(" -t, --timeout=SECS seconds to wait when using -w option\n"));
2001  printf(_(" -V, --version output version information, then exit\n"));
2002  printf(_(" -w, --wait wait until operation completes (default)\n"));
2003  printf(_(" -W, --no-wait do not wait until operation completes\n"));
2004  printf(_(" -?, --help show this help, then exit\n"));
2005  printf(_("If the -D option is omitted, the environment variable PGDATA is used.\n"));
2006 
2007  printf(_("\nOptions for start or restart:\n"));
2008 #if defined(HAVE_GETRLIMIT)
2009  printf(_(" -c, --core-files allow postgres to produce core files\n"));
2010 #else
2011  printf(_(" -c, --core-files not applicable on this platform\n"));
2012 #endif
2013  printf(_(" -l, --log=FILENAME write (or append) server log to FILENAME\n"));
2014  printf(_(" -o, --options=OPTIONS command line options to pass to postgres\n"
2015  " (PostgreSQL server executable) or initdb\n"));
2016  printf(_(" -p PATH-TO-POSTGRES normally not necessary\n"));
2017  printf(_("\nOptions for stop or restart:\n"));
2018  printf(_(" -m, --mode=MODE MODE can be \"smart\", \"fast\", or \"immediate\"\n"));
2019 
2020  printf(_("\nShutdown modes are:\n"));
2021  printf(_(" smart quit after all clients have disconnected\n"));
2022  printf(_(" fast quit directly, with proper shutdown (default)\n"));
2023  printf(_(" immediate quit without complete shutdown; will lead to recovery on restart\n"));
2024 
2025  printf(_("\nAllowed signal names for kill:\n"));
2026  printf(" ABRT HUP INT KILL QUIT TERM USR1 USR2\n");
2027 
2028 #ifdef WIN32
2029  printf(_("\nOptions for register and unregister:\n"));
2030  printf(_(" -N SERVICENAME service name with which to register PostgreSQL server\n"));
2031  printf(_(" -P PASSWORD password of account to register PostgreSQL server\n"));
2032  printf(_(" -U USERNAME user name of account to register PostgreSQL server\n"));
2033  printf(_(" -S START-TYPE service start type to register PostgreSQL server\n"));
2034 
2035  printf(_("\nStart types are:\n"));
2036  printf(_(" auto start service automatically during system startup (default)\n"));
2037  printf(_(" demand start service on demand\n"));
2038 #endif
2039 
2040  printf(_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
2041  printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
2042 }
#define printf(...)
Definition: port.h:244

References _, printf, and progname.

Referenced by main().

◆ do_init()

static void do_init ( void  )
static

Definition at line 902 of file pg_ctl.c.

903 {
904  char *cmd;
905 
906  if (exec_path == NULL)
907  exec_path = find_other_exec_or_die(argv0, "initdb", "initdb (PostgreSQL) " PG_VERSION "\n");
908 
909  if (pgdata_opt == NULL)
910  pgdata_opt = "";
911 
912  if (post_opts == NULL)
913  post_opts = "";
914 
915  if (!silent_mode)
916  cmd = psprintf("\"%s\" %s%s",
918  else
919  cmd = psprintf("\"%s\" %s%s > \"%s\"",
921 
922  fflush(NULL);
923  if (system(cmd) != 0)
924  {
925  write_stderr(_("%s: database system initialization failed\n"), progname);
926  exit(1);
927  }
928 }
static bool silent_mode
Definition: pg_ctl.c:78
#define DEVNULL
Definition: port.h:160

References _, argv0, DEVNULL, exec_path, exit(), fflush(), find_other_exec_or_die(), pgdata_opt, post_opts, progname, psprintf(), silent_mode, and write_stderr().

Referenced by main().

◆ do_kill()

static void do_kill ( pid_t  pid)
static

Definition at line 1405 of file pg_ctl.c.

1406 {
1407  if (kill(pid, sig) != 0)
1408  {
1409  write_stderr(_("%s: could not send signal %d (PID: %d): %m\n"),
1410  progname, sig, (int) pid);
1411  exit(1);
1412  }
1413 }
static int sig
Definition: pg_ctl.c:80
#define kill(pid, sig)
Definition: win32_port.h:503

References _, exit(), kill, progname, sig, and write_stderr().

Referenced by main().

◆ do_logrotate()

static void do_logrotate ( void  )
static

Definition at line 1267 of file pg_ctl.c.

1268 {
1269  FILE *logrotatefile;
1270  pid_t pid;
1271 
1272  pid = get_pgpid(false);
1273 
1274  if (pid == 0) /* no pid file */
1275  {
1276  write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
1277  write_stderr(_("Is server running?\n"));
1278  exit(1);
1279  }
1280  else if (pid < 0) /* standalone backend, not postmaster */
1281  {
1282  pid = -pid;
1283  write_stderr(_("%s: cannot rotate log file; "
1284  "single-user server is running (PID: %d)\n"),
1285  progname, (int) pid);
1286  exit(1);
1287  }
1288 
1289  snprintf(logrotate_file, MAXPGPATH, "%s/logrotate", pg_data);
1290 
1291  if ((logrotatefile = fopen(logrotate_file, "w")) == NULL)
1292  {
1293  write_stderr(_("%s: could not create log rotation signal file \"%s\": %m\n"),
1295  exit(1);
1296  }
1297  if (fclose(logrotatefile))
1298  {
1299  write_stderr(_("%s: could not write log rotation signal file \"%s\": %m\n"),
1301  exit(1);
1302  }
1303 
1304  sig = SIGUSR1;
1305  if (kill(pid, sig) != 0)
1306  {
1307  write_stderr(_("%s: could not send log rotation signal (PID: %d): %m\n"),
1308  progname, (int) pid);
1309  if (unlink(logrotate_file) != 0)
1310  write_stderr(_("%s: could not remove log rotation signal file \"%s\": %m\n"),
1312  exit(1);
1313  }
1314 
1315  print_msg(_("server signaled to rotate log file\n"));
1316 }
static pid_t get_pgpid(bool is_status_request)
Definition: pg_ctl.c:246
static char pid_file[MAXPGPATH]
Definition: pg_ctl.c:99
static void print_msg(const char *msg)
Definition: pg_ctl.c:236
static char logrotate_file[MAXPGPATH]
Definition: pg_ctl.c:101
#define SIGUSR1
Definition: win32_port.h:180

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

Referenced by main().

◆ do_promote()

static void do_promote ( void  )
static

Definition at line 1186 of file pg_ctl.c.

1187 {
1188  FILE *prmfile;
1189  pid_t pid;
1190 
1191  pid = get_pgpid(false);
1192 
1193  if (pid == 0) /* no pid file */
1194  {
1195  write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
1196  write_stderr(_("Is server running?\n"));
1197  exit(1);
1198  }
1199  else if (pid < 0) /* standalone backend, not postmaster */
1200  {
1201  pid = -pid;
1202  write_stderr(_("%s: cannot promote server; "
1203  "single-user server is running (PID: %d)\n"),
1204  progname, (int) pid);
1205  exit(1);
1206  }
1207 
1209  {
1210  write_stderr(_("%s: cannot promote server; "
1211  "server is not in standby mode\n"),
1212  progname);
1213  exit(1);
1214  }
1215 
1216  snprintf(promote_file, MAXPGPATH, "%s/promote", pg_data);
1217 
1218  if ((prmfile = fopen(promote_file, "w")) == NULL)
1219  {
1220  write_stderr(_("%s: could not create promote signal file \"%s\": %m\n"),
1222  exit(1);
1223  }
1224  if (fclose(prmfile))
1225  {
1226  write_stderr(_("%s: could not write promote signal file \"%s\": %m\n"),
1228  exit(1);
1229  }
1230 
1231  sig = SIGUSR1;
1232  if (kill(pid, sig) != 0)
1233  {
1234  write_stderr(_("%s: could not send promote signal (PID: %d): %m\n"),
1235  progname, (int) pid);
1236  if (unlink(promote_file) != 0)
1237  write_stderr(_("%s: could not remove promote signal file \"%s\": %m\n"),
1239  exit(1);
1240  }
1241 
1242  if (do_wait)
1243  {
1244  print_msg(_("waiting for server to promote..."));
1246  {
1247  print_msg(_(" done\n"));
1248  print_msg(_("server promoted\n"));
1249  }
1250  else
1251  {
1252  print_msg(_(" stopped waiting\n"));
1253  write_stderr(_("%s: server did not promote in time\n"),
1254  progname);
1255  exit(1);
1256  }
1257  }
1258  else
1259  print_msg(_("server promoting\n"));
1260 }
@ DB_IN_ARCHIVE_RECOVERY
Definition: pg_control.h:96
static bool wait_for_postmaster_promote(void)
Definition: pg_ctl.c:754
static char promote_file[MAXPGPATH]
Definition: pg_ctl.c:100
static DBState get_control_dbstate(void)
Definition: pg_ctl.c:2183
static bool do_wait
Definition: pg_ctl.c:75

References _, DB_IN_ARCHIVE_RECOVERY, do_wait, exit(), get_control_dbstate(), get_pgpid(), kill, MAXPGPATH, pg_data, pid_file, print_msg(), progname, promote_file, sig, SIGUSR1, snprintf, wait_for_postmaster_promote(), and write_stderr().

Referenced by main().

◆ do_reload()

static void do_reload ( void  )
static

Definition at line 1149 of file pg_ctl.c.

1150 {
1151  pid_t pid;
1152 
1153  pid = get_pgpid(false);
1154  if (pid == 0) /* no pid file */
1155  {
1156  write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
1157  write_stderr(_("Is server running?\n"));
1158  exit(1);
1159  }
1160  else if (pid < 0) /* standalone backend, not postmaster */
1161  {
1162  pid = -pid;
1163  write_stderr(_("%s: cannot reload server; "
1164  "single-user server is running (PID: %d)\n"),
1165  progname, (int) pid);
1166  write_stderr(_("Please terminate the single-user server and try again.\n"));
1167  exit(1);
1168  }
1169 
1170  if (kill(pid, sig) != 0)
1171  {
1172  write_stderr(_("%s: could not send reload signal (PID: %d): %m\n"),
1173  progname, (int) pid);
1174  exit(1);
1175  }
1176 
1177  print_msg(_("server signaled\n"));
1178 }

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

Referenced by main().

◆ do_restart()

static void do_restart ( void  )
static

Definition at line 1085 of file pg_ctl.c.

1086 {
1087  pid_t pid;
1088 
1089  pid = get_pgpid(false);
1090 
1091  if (pid == 0) /* no pid file */
1092  {
1093  write_stderr(_("%s: PID file \"%s\" does not exist\n"),
1094  progname, pid_file);
1095  write_stderr(_("Is server running?\n"));
1096  write_stderr(_("trying to start server anyway\n"));
1097  do_start();
1098  return;
1099  }
1100  else if (pid < 0) /* standalone backend, not postmaster */
1101  {
1102  pid = -pid;
1103  if (postmaster_is_alive(pid))
1104  {
1105  write_stderr(_("%s: cannot restart server; "
1106  "single-user server is running (PID: %d)\n"),
1107  progname, (int) pid);
1108  write_stderr(_("Please terminate the single-user server and try again.\n"));
1109  exit(1);
1110  }
1111  }
1112 
1113  if (postmaster_is_alive(pid))
1114  {
1115  if (kill(pid, sig) != 0)
1116  {
1117  write_stderr(_("%s: could not send stop signal (PID: %d): %m\n"), progname, (int) pid);
1118  exit(1);
1119  }
1120 
1121  print_msg(_("waiting for server to shut down..."));
1122 
1123  /* always wait for restart */
1124  if (!wait_for_postmaster_stop())
1125  {
1126  print_msg(_(" failed\n"));
1127 
1128  write_stderr(_("%s: server does not shut down\n"), progname);
1129  if (shutdown_mode == SMART_MODE)
1130  write_stderr(_("HINT: The \"-m fast\" option immediately disconnects sessions rather than\n"
1131  "waiting for session-initiated disconnection.\n"));
1132  exit(1);
1133  }
1134 
1135  print_msg(_(" done\n"));
1136  print_msg(_("server stopped\n"));
1137  }
1138  else
1139  {
1140  write_stderr(_("%s: old server process (PID: %d) seems to be gone\n"),
1141  progname, (int) pid);
1142  write_stderr(_("starting server anyway\n"));
1143  }
1144 
1145  do_start();
1146 }
static void do_start(void)
Definition: pg_ctl.c:931
static bool postmaster_is_alive(pid_t pid)
Definition: pg_ctl.c:1324
static bool wait_for_postmaster_stop(void)
Definition: pg_ctl.c:717
static ShutdownMode shutdown_mode
Definition: pg_ctl.c:79

References _, do_start(), exit(), get_pgpid(), kill, pid_file, postmaster_is_alive(), print_msg(), progname, shutdown_mode, sig, SMART_MODE, wait_for_postmaster_stop(), and write_stderr().

Referenced by main().

◆ do_start()

static void do_start ( void  )
static

Definition at line 931 of file pg_ctl.c.

932 {
933  pid_t old_pid = 0;
934  pid_t pm_pid;
935 
937  {
938  old_pid = get_pgpid(false);
939  if (old_pid != 0)
940  write_stderr(_("%s: another server might be running; "
941  "trying to start server anyway\n"),
942  progname);
943  }
944 
945  read_post_opts();
946 
947  /* No -D or -D already added during server start */
948  if (ctl_command == RESTART_COMMAND || pgdata_opt == NULL)
949  pgdata_opt = "";
950 
951  if (exec_path == NULL)
953 
954 #if defined(HAVE_GETRLIMIT)
955  if (allow_core_files)
957 #endif
958 
959  /*
960  * If possible, tell the postmaster our parent shell's PID (see the
961  * comments in CreateLockFile() for motivation). Windows hasn't got
962  * getppid() unfortunately.
963  */
964 #ifndef WIN32
965  {
966  char env_var[32];
967 
968  snprintf(env_var, sizeof(env_var), "%d", (int) getppid());
969  setenv("PG_GRANDPARENT_PID", env_var, 1);
970  }
971 #endif
972 
973  pm_pid = start_postmaster();
974 
975  if (do_wait)
976  {
977  /*
978  * If the user interrupts the startup (e.g. with CTRL-C), we'd like to
979  * abort the server launch. Install a signal handler that will
980  * forward SIGINT to the postmaster process, while we wait.
981  *
982  * (We don't bother to reset the signal handler after the launch, as
983  * we're about to exit, anyway.)
984  */
985  postmasterPID = pm_pid;
987 
988  print_msg(_("waiting for server to start..."));
989 
990  switch (wait_for_postmaster_start(pm_pid, false))
991  {
992  case POSTMASTER_READY:
993  print_msg(_(" done\n"));
994  print_msg(_("server started\n"));
995  break;
997  print_msg(_(" stopped waiting\n"));
998  write_stderr(_("%s: server did not start in time\n"),
999  progname);
1000  exit(1);
1001  break;
1003  print_msg(_(" done\n"));
1004  print_msg(_("server shut down because of recovery target settings\n"));
1005  break;
1006  case POSTMASTER_FAILED:
1007  print_msg(_(" stopped waiting\n"));
1008  write_stderr(_("%s: could not start server\n"
1009  "Examine the log output.\n"),
1010  progname);
1011  exit(1);
1012  break;
1013  }
1014  }
1015  else
1016  print_msg(_("server starting\n"));
1017 
1018 #ifdef WIN32
1019  /* Now we don't need the handle to the shell process anymore */
1020  CloseHandle(postmasterProcess);
1021  postmasterProcess = INVALID_HANDLE_VALUE;
1022 #endif
1023 }
static void read_post_opts(void)
Definition: pg_ctl.c:802
static WaitPMResult wait_for_postmaster_start(pid_t pm_pid, bool do_checkpoint)
Definition: pg_ctl.c:593
static void trap_sigint_during_startup(SIGNAL_ARGS)
Definition: pg_ctl.c:857
static volatile pid_t postmasterPID
Definition: pg_ctl.c:103
static bool allow_core_files
Definition: pg_ctl.c:94
static void unlimit_core_size(void)
Definition: pg_ctl.c:782
static CtlCommand ctl_command
Definition: pg_ctl.c:81
static pid_t start_postmaster(void)
Definition: pg_ctl.c:440
pqsigfunc pqsignal(int signo, pqsigfunc func)
#define setenv(x, y, z)
Definition: win32_port.h:555

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

Referenced by do_restart(), and main().

◆ do_status()

static void do_status ( void  )
static

Definition at line 1348 of file pg_ctl.c.

1349 {
1350  pid_t pid;
1351 
1352  pid = get_pgpid(true);
1353  /* Is there a pid file? */
1354  if (pid != 0)
1355  {
1356  /* standalone backend? */
1357  if (pid < 0)
1358  {
1359  pid = -pid;
1360  if (postmaster_is_alive(pid))
1361  {
1362  printf(_("%s: single-user server is running (PID: %d)\n"),
1363  progname, (int) pid);
1364  return;
1365  }
1366  }
1367  else
1368  /* must be a postmaster */
1369  {
1370  if (postmaster_is_alive(pid))
1371  {
1372  char **optlines;
1373  char **curr_line;
1374  int numlines;
1375 
1376  printf(_("%s: server is running (PID: %d)\n"),
1377  progname, (int) pid);
1378 
1379  optlines = readfile(postopts_file, &numlines);
1380  if (optlines != NULL)
1381  {
1382  for (curr_line = optlines; *curr_line != NULL; curr_line++)
1383  puts(*curr_line);
1384 
1385  /* Free the results of readfile */
1386  free_readfile(optlines);
1387  }
1388  return;
1389  }
1390  }
1391  }
1392  printf(_("%s: no server running\n"), progname);
1393 
1394  /*
1395  * The Linux Standard Base Core Specification 3.1 says this should return
1396  * '3, program is not running'
1397  * https://refspecs.linuxbase.org/LSB_3.1.0/LSB-Core-generic/LSB-Core-generic/iniscrptact.html
1398  */
1399  exit(3);
1400 }
static void free_readfile(char **optlines)
Definition: pg_ctl.c:410
static char ** readfile(const char *path, int *numlines)
Definition: pg_ctl.c:314
static char postopts_file[MAXPGPATH]
Definition: pg_ctl.c:97

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

Referenced by main().

◆ do_stop()

static void do_stop ( void  )
static

Definition at line 1027 of file pg_ctl.c.

1028 {
1029  pid_t pid;
1030 
1031  pid = get_pgpid(false);
1032 
1033  if (pid == 0) /* no pid file */
1034  {
1035  write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
1036  write_stderr(_("Is server running?\n"));
1037  exit(1);
1038  }
1039  else if (pid < 0) /* standalone backend, not postmaster */
1040  {
1041  pid = -pid;
1042  write_stderr(_("%s: cannot stop server; "
1043  "single-user server is running (PID: %d)\n"),
1044  progname, (int) pid);
1045  exit(1);
1046  }
1047 
1048  if (kill(pid, sig) != 0)
1049  {
1050  write_stderr(_("%s: could not send stop signal (PID: %d): %m\n"), progname, (int) pid);
1051  exit(1);
1052  }
1053 
1054  if (!do_wait)
1055  {
1056  print_msg(_("server shutting down\n"));
1057  return;
1058  }
1059  else
1060  {
1061  print_msg(_("waiting for server to shut down..."));
1062 
1063  if (!wait_for_postmaster_stop())
1064  {
1065  print_msg(_(" failed\n"));
1066 
1067  write_stderr(_("%s: server does not shut down\n"), progname);
1068  if (shutdown_mode == SMART_MODE)
1069  write_stderr(_("HINT: The \"-m fast\" option immediately disconnects sessions rather than\n"
1070  "waiting for session-initiated disconnection.\n"));
1071  exit(1);
1072  }
1073  print_msg(_(" done\n"));
1074 
1075  print_msg(_("server stopped\n"));
1076  }
1077 }

References _, do_wait, exit(), get_pgpid(), kill, pid_file, print_msg(), progname, shutdown_mode, sig, SMART_MODE, wait_for_postmaster_stop(), and write_stderr().

Referenced by main().

◆ find_other_exec_or_die()

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

Definition at line 875 of file pg_ctl.c.

876 {
877  int ret;
878  char *found_path;
879 
880  found_path = pg_malloc(MAXPGPATH);
881 
882  if ((ret = find_other_exec(argv0, target, versionstr, found_path)) < 0)
883  {
884  char full_path[MAXPGPATH];
885 
886  if (find_my_exec(argv0, full_path) < 0)
887  strlcpy(full_path, progname, sizeof(full_path));
888 
889  if (ret == -1)
890  write_stderr(_("program \"%s\" is needed by %s but was not found in the same directory as \"%s\"\n"),
891  target, progname, full_path);
892  else
893  write_stderr(_("program \"%s\" was found by \"%s\" but was not the same version as %s\n"),
894  target, full_path, progname);
895  exit(1);
896  }
897 
898  return found_path;
899 }
int find_my_exec(const char *argv0, char *retpath)
Definition: exec.c:160
int find_other_exec(const char *argv0, const char *target, const char *versionstr, char *retpath)
Definition: exec.c:310
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45

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

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

◆ free_readfile()

static void free_readfile ( char **  optlines)
static

Definition at line 410 of file pg_ctl.c.

411 {
412  char *curr_line = NULL;
413  int i = 0;
414 
415  if (!optlines)
416  return;
417 
418  while ((curr_line = optlines[i++]))
419  free(curr_line);
420 
421  free(optlines);
422 }
int i
Definition: isn.c:72

References free, and i.

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

◆ get_control_dbstate()

static DBState get_control_dbstate ( void  )
static

Definition at line 2183 of file pg_ctl.c.

2184 {
2185  DBState ret;
2186  bool crc_ok;
2187  ControlFileData *control_file_data = get_controlfile(pg_data, &crc_ok);
2188 
2189  if (!crc_ok)
2190  {
2191  write_stderr(_("%s: control file appears to be corrupt\n"), progname);
2192  exit(1);
2193  }
2194 
2195  ret = control_file_data->state;
2196  pfree(control_file_data);
2197  return ret;
2198 }
ControlFileData * get_controlfile(const char *DataDir, bool *crc_ok_p)
void pfree(void *pointer)
Definition: mcxt.c:1521
DBState
Definition: pg_control.h:90

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

Referenced by do_promote(), wait_for_postmaster_promote(), and wait_for_postmaster_start().

◆ get_pgpid()

static pid_t get_pgpid ( bool  is_status_request)
static

Definition at line 246 of file pg_ctl.c.

247 {
248  FILE *pidf;
249  int pid;
250  struct stat statbuf;
251 
252  if (stat(pg_data, &statbuf) != 0)
253  {
254  if (errno == ENOENT)
255  write_stderr(_("%s: directory \"%s\" does not exist\n"), progname,
256  pg_data);
257  else
258  write_stderr(_("%s: could not access directory \"%s\": %m\n"), progname,
259  pg_data);
260 
261  /*
262  * The Linux Standard Base Core Specification 3.1 says this should
263  * return '4, program or service status is unknown'
264  * https://refspecs.linuxbase.org/LSB_3.1.0/LSB-Core-generic/LSB-Core-generic/iniscrptact.html
265  */
266  exit(is_status_request ? 4 : 1);
267  }
268 
269  if (stat(version_file, &statbuf) != 0 && errno == ENOENT)
270  {
271  write_stderr(_("%s: directory \"%s\" is not a database cluster directory\n"),
272  progname, pg_data);
273  exit(is_status_request ? 4 : 1);
274  }
275 
276  pidf = fopen(pid_file, "r");
277  if (pidf == NULL)
278  {
279  /* No pid file, not an error on startup */
280  if (errno == ENOENT)
281  return 0;
282  else
283  {
284  write_stderr(_("%s: could not open PID file \"%s\": %m\n"),
285  progname, pid_file);
286  exit(1);
287  }
288  }
289  if (fscanf(pidf, "%d", &pid) != 1)
290  {
291  /* Is the file empty? */
292  if (ftell(pidf) == 0 && feof(pidf))
293  write_stderr(_("%s: the PID file \"%s\" is empty\n"),
294  progname, pid_file);
295  else
296  write_stderr(_("%s: invalid data in PID file \"%s\"\n"),
297  progname, pid_file);
298  exit(1);
299  }
300  fclose(pidf);
301  return (pid_t) pid;
302 }
static char version_file[MAXPGPATH]
Definition: pg_ctl.c:98
#define stat
Definition: win32_port.h:284

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

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

◆ main()

int main ( int  argc,
char **  argv 
)

Definition at line 2202 of file pg_ctl.c.

2203 {
2204  static struct option long_options[] = {
2205  {"help", no_argument, NULL, '?'},
2206  {"version", no_argument, NULL, 'V'},
2207  {"log", required_argument, NULL, 'l'},
2208  {"mode", required_argument, NULL, 'm'},
2209  {"pgdata", required_argument, NULL, 'D'},
2210  {"options", required_argument, NULL, 'o'},
2211  {"silent", no_argument, NULL, 's'},
2212  {"timeout", required_argument, NULL, 't'},
2213  {"core-files", no_argument, NULL, 'c'},
2214  {"wait", no_argument, NULL, 'w'},
2215  {"no-wait", no_argument, NULL, 'W'},
2216  {NULL, 0, NULL, 0}
2217  };
2218 
2219  char *env_wait;
2220  int option_index;
2221  int c;
2222  pid_t killproc = 0;
2223 
2224  pg_logging_init(argv[0]);
2225  progname = get_progname(argv[0]);
2226  set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_ctl"));
2227  start_time = time(NULL);
2228 
2229  /*
2230  * save argv[0] so do_start() can look for the postmaster if necessary. we
2231  * don't look for postmaster here because in many cases we won't need it.
2232  */
2233  argv0 = argv[0];
2234 
2235  /* Set restrictive mode mask until PGDATA permissions are checked */
2236  umask(PG_MODE_MASK_OWNER);
2237 
2238  /* support --help and --version even if invoked as root */
2239  if (argc > 1)
2240  {
2241  if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
2242  {
2243  do_help();
2244  exit(0);
2245  }
2246  else if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
2247  {
2248  puts("pg_ctl (PostgreSQL) " PG_VERSION);
2249  exit(0);
2250  }
2251  }
2252 
2253  /*
2254  * Disallow running as root, to forestall any possible security holes.
2255  */
2256 #ifndef WIN32
2257  if (geteuid() == 0)
2258  {
2259  write_stderr(_("%s: cannot be run as root\n"
2260  "Please log in (using, e.g., \"su\") as the "
2261  "(unprivileged) user that will\n"
2262  "own the server process.\n"),
2263  progname);
2264  exit(1);
2265  }
2266 #endif
2267 
2268  env_wait = getenv("PGCTLTIMEOUT");
2269  if (env_wait != NULL)
2270  wait_seconds = atoi(env_wait);
2271 
2272  /* process command-line options */
2273  while ((c = getopt_long(argc, argv, "cD:e:l:m:N:o:p:P:sS:t:U:wW",
2274  long_options, &option_index)) != -1)
2275  {
2276  switch (c)
2277  {
2278  case 'D':
2279  {
2280  char *pgdata_D;
2281 
2282  pgdata_D = pg_strdup(optarg);
2283  canonicalize_path(pgdata_D);
2284  setenv("PGDATA", pgdata_D, 1);
2285 
2286  /*
2287  * We could pass PGDATA just in an environment variable
2288  * but we do -D too for clearer postmaster 'ps' display
2289  */
2290  pgdata_opt = psprintf("-D \"%s\" ", pgdata_D);
2291  free(pgdata_D);
2292  break;
2293  }
2294  case 'e':
2296  break;
2297  case 'l':
2299  break;
2300  case 'm':
2301  set_mode(optarg);
2302  break;
2303  case 'N':
2305  break;
2306  case 'o':
2307  /* append option? */
2308  if (!post_opts)
2310  else
2311  {
2312  char *old_post_opts = post_opts;
2313 
2314  post_opts = psprintf("%s %s", old_post_opts, optarg);
2315  free(old_post_opts);
2316  }
2317  break;
2318  case 'p':
2320  break;
2321  case 'P':
2323  break;
2324  case 's':
2325  silent_mode = true;
2326  break;
2327  case 'S':
2328 #ifdef WIN32
2329  set_starttype(optarg);
2330 #else
2331  write_stderr(_("%s: -S option not supported on this platform\n"),
2332  progname);
2333  exit(1);
2334 #endif
2335  break;
2336  case 't':
2337  wait_seconds = atoi(optarg);
2338  wait_seconds_arg = true;
2339  break;
2340  case 'U':
2341  if (strchr(optarg, '\\'))
2343  else
2344  /* Prepend .\ for local accounts */
2345  register_username = psprintf(".\\%s", optarg);
2346  break;
2347  case 'w':
2348  do_wait = true;
2349  break;
2350  case 'W':
2351  do_wait = false;
2352  break;
2353  case 'c':
2354  allow_core_files = true;
2355  break;
2356  default:
2357  /* getopt_long already issued a suitable error message */
2358  do_advice();
2359  exit(1);
2360  }
2361  }
2362 
2363  /* Process an action */
2364  if (optind < argc)
2365  {
2366  if (strcmp(argv[optind], "init") == 0
2367  || strcmp(argv[optind], "initdb") == 0)
2369  else if (strcmp(argv[optind], "start") == 0)
2371  else if (strcmp(argv[optind], "stop") == 0)
2373  else if (strcmp(argv[optind], "restart") == 0)
2375  else if (strcmp(argv[optind], "reload") == 0)
2377  else if (strcmp(argv[optind], "status") == 0)
2379  else if (strcmp(argv[optind], "promote") == 0)
2381  else if (strcmp(argv[optind], "logrotate") == 0)
2383  else if (strcmp(argv[optind], "kill") == 0)
2384  {
2385  if (argc - optind < 3)
2386  {
2387  write_stderr(_("%s: missing arguments for kill mode\n"), progname);
2388  do_advice();
2389  exit(1);
2390  }
2392  set_sig(argv[++optind]);
2393  killproc = atol(argv[++optind]);
2394  }
2395 #ifdef WIN32
2396  else if (strcmp(argv[optind], "register") == 0)
2398  else if (strcmp(argv[optind], "unregister") == 0)
2400  else if (strcmp(argv[optind], "runservice") == 0)
2402 #endif
2403  else
2404  {
2405  write_stderr(_("%s: unrecognized operation mode \"%s\"\n"), progname, argv[optind]);
2406  do_advice();
2407  exit(1);
2408  }
2409  optind++;
2410  }
2411 
2412  if (optind < argc)
2413  {
2414  write_stderr(_("%s: too many command-line arguments (first is \"%s\")\n"), progname, argv[optind]);
2415  do_advice();
2416  exit(1);
2417  }
2418 
2419  if (ctl_command == NO_COMMAND)
2420  {
2421  write_stderr(_("%s: no operation specified\n"), progname);
2422  do_advice();
2423  exit(1);
2424  }
2425 
2426  /* Note we put any -D switch into the env var above */
2427  pg_config = getenv("PGDATA");
2428  if (pg_config)
2429  {
2433  }
2434 
2435  /* -D might point at config-only directory; if so find the real PGDATA */
2436  adjust_data_dir();
2437 
2438  /* Complain if -D needed and not provided */
2439  if (pg_config == NULL &&
2441  {
2442  write_stderr(_("%s: no database directory specified and environment variable PGDATA unset\n"),
2443  progname);
2444  do_advice();
2445  exit(1);
2446  }
2447 
2448  if (ctl_command == RELOAD_COMMAND)
2449  {
2450  sig = SIGHUP;
2451  do_wait = false;
2452  }
2453 
2454  if (pg_data)
2455  {
2456  snprintf(postopts_file, MAXPGPATH, "%s/postmaster.opts", pg_data);
2457  snprintf(version_file, MAXPGPATH, "%s/PG_VERSION", pg_data);
2458  snprintf(pid_file, MAXPGPATH, "%s/postmaster.pid", pg_data);
2459 
2460  /*
2461  * Set mask based on PGDATA permissions,
2462  *
2463  * Don't error here if the data directory cannot be stat'd. This is
2464  * handled differently based on the command and we don't want to
2465  * interfere with that logic.
2466  */
2468  umask(pg_mode_mask);
2469  }
2470 
2471  switch (ctl_command)
2472  {
2473  case INIT_COMMAND:
2474  do_init();
2475  break;
2476  case STATUS_COMMAND:
2477  do_status();
2478  break;
2479  case START_COMMAND:
2480  do_start();
2481  break;
2482  case STOP_COMMAND:
2483  do_stop();
2484  break;
2485  case RESTART_COMMAND:
2486  do_restart();
2487  break;
2488  case RELOAD_COMMAND:
2489  do_reload();
2490  break;
2491  case PROMOTE_COMMAND:
2492  do_promote();
2493  break;
2494  case LOGROTATE_COMMAND:
2495  do_logrotate();
2496  break;
2497  case KILL_COMMAND:
2498  do_kill(killproc);
2499  break;
2500 #ifdef WIN32
2501  case REGISTER_COMMAND:
2502  pgwin32_doRegister();
2503  break;
2504  case UNREGISTER_COMMAND:
2505  pgwin32_doUnregister();
2506  break;
2508  pgwin32_doRunAsService();
2509  break;
2510 #endif
2511  default:
2512  break;
2513  }
2514 
2515  exit(0);
2516 }
#define PG_TEXTDOMAIN(domain)
Definition: c.h:1219
void set_pglocale_pgservice(const char *argv0, const char *app)
Definition: exec.c:429
int pg_mode_mask
Definition: file_perm.c:25
bool GetDataDirectoryCreatePerm(const char *dataDir)
#define PG_MODE_MASK_OWNER
Definition: file_perm.h:24
int getopt_long(int argc, char *const argv[], const char *optstring, const struct option *longopts, int *longindex)
Definition: getopt_long.c:60
#define no_argument
Definition: getopt_long.h:24
#define required_argument
Definition: getopt_long.h:25
void pg_logging_init(const char *argv0)
Definition: logging.c:83
static void static void do_advice(void)
Definition: pg_ctl.c:1965
static void do_reload(void)
Definition: pg_ctl.c:1149
static void do_help(void)
Definition: pg_ctl.c:1973
static char * register_username
Definition: pg_ctl.c:91
static char * event_source
Definition: pg_ctl.c:89
static void adjust_data_dir(void)
Definition: pg_ctl.c:2125
static char * register_servicename
Definition: pg_ctl.c:90
static void set_mode(char *modeopt)
Definition: pg_ctl.c:2047
static void do_logrotate(void)
Definition: pg_ctl.c:1267
static void do_stop(void)
Definition: pg_ctl.c:1027
static char * register_password
Definition: pg_ctl.c:92
static void do_init(void)
Definition: pg_ctl.c:902
static int wait_seconds
Definition: pg_ctl.c:76
static void do_restart(void)
Definition: pg_ctl.c:1085
static bool wait_seconds_arg
Definition: pg_ctl.c:77
static char * log_file
Definition: pg_ctl.c:87
static void do_promote(void)
Definition: pg_ctl.c:1186
static time_t start_time
Definition: pg_ctl.c:95
static void set_sig(char *signame)
Definition: pg_ctl.c:2075
static void do_status(void)
Definition: pg_ctl.c:1348
static void do_kill(pid_t pid)
Definition: pg_ctl.c:1405
PGDLLIMPORT int optind
Definition: getopt.c:51
PGDLLIMPORT char * optarg
Definition: getopt.c:53
const char * get_progname(const char *argv0)
Definition: path.c:575
char * c
#define SIGHUP
Definition: win32_port.h:168

References _, adjust_data_dir(), allow_core_files, argv0, canonicalize_path(), ctl_command, do_advice(), do_help(), do_init(), do_kill(), do_logrotate(), do_promote(), do_reload(), do_restart(), do_start(), do_status(), do_stop(), do_wait, event_source, exec_path, exit(), free, get_progname(), GetDataDirectoryCreatePerm(), getopt_long(), INIT_COMMAND, KILL_COMMAND, log_file, LOGROTATE_COMMAND, MAXPGPATH, no_argument, NO_COMMAND, optarg, optind, pg_config, pg_data, pg_logging_init(), pg_mode_mask, PG_MODE_MASK_OWNER, pg_strdup(), PG_TEXTDOMAIN, pgdata_opt, pid_file, post_opts, postopts_file, progname, PROMOTE_COMMAND, psprintf(), REGISTER_COMMAND, register_password, register_servicename, register_username, RELOAD_COMMAND, required_argument, RESTART_COMMAND, RUN_AS_SERVICE_COMMAND, set_mode(), set_pglocale_pgservice(), set_sig(), setenv, 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().

◆ postmaster_is_alive()

static bool postmaster_is_alive ( pid_t  pid)
static

Definition at line 1324 of file pg_ctl.c.

1325 {
1326  /*
1327  * Test to see if the process is still there. Note that we do not
1328  * consider an EPERM failure to mean that the process is still there;
1329  * EPERM must mean that the given PID belongs to some other userid, and
1330  * considering the permissions on $PGDATA, that means it's not the
1331  * postmaster we are after.
1332  *
1333  * Don't believe that our own PID or parent shell's PID is the postmaster,
1334  * either. (Windows hasn't got getppid(), though.)
1335  */
1336  if (pid == getpid())
1337  return false;
1338 #ifndef WIN32
1339  if (pid == getppid())
1340  return false;
1341 #endif
1342  if (kill(pid, 0) == 0)
1343  return true;
1344  return false;
1345 }

References kill.

Referenced by do_restart(), and do_status().

◆ print_msg()

static void print_msg ( const char *  msg)
static

◆ read_post_opts()

static void read_post_opts ( void  )
static

Definition at line 802 of file pg_ctl.c.

803 {
804  if (post_opts == NULL)
805  {
806  post_opts = ""; /* default */
808  {
809  char **optlines;
810  int numlines;
811 
812  optlines = readfile(postopts_file, &numlines);
813  if (optlines == NULL)
814  {
815  write_stderr(_("%s: could not read file \"%s\"\n"), progname, postopts_file);
816  exit(1);
817  }
818  else if (numlines != 1)
819  {
820  write_stderr(_("%s: option file \"%s\" must have exactly one line\n"),
822  exit(1);
823  }
824  else
825  {
826  char *optline;
827  char *arg1;
828 
829  optline = optlines[0];
830 
831  /*
832  * Are we at the first option, as defined by space and
833  * double-quote?
834  */
835  if ((arg1 = strstr(optline, " \"")) != NULL)
836  {
837  *arg1 = '\0'; /* terminate so we get only program name */
838  post_opts = pg_strdup(arg1 + 1); /* point past whitespace */
839  }
840  if (exec_path == NULL)
841  exec_path = pg_strdup(optline);
842  }
843 
844  /* Free the results of readfile. */
845  free_readfile(optlines);
846  }
847  }
848 }

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

Referenced by do_start().

◆ readfile()

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

Definition at line 314 of file pg_ctl.c.

315 {
316  int fd;
317  int nlines;
318  char **result;
319  char *buffer;
320  char *linebegin;
321  int i;
322  int n;
323  int len;
324  struct stat statbuf;
325 
326  *numlines = 0; /* in case of failure or empty file */
327 
328  /*
329  * Slurp the file into memory.
330  *
331  * The file can change concurrently, so we read the whole file into memory
332  * with a single read() call. That's not guaranteed to get an atomic
333  * snapshot, but in practice, for a small file, it's close enough for the
334  * current use.
335  */
336  fd = open(path, O_RDONLY | PG_BINARY, 0);
337  if (fd < 0)
338  return NULL;
339  if (fstat(fd, &statbuf) < 0)
340  {
341  close(fd);
342  return NULL;
343  }
344  if (statbuf.st_size == 0)
345  {
346  /* empty file */
347  close(fd);
348  result = (char **) pg_malloc(sizeof(char *));
349  *result = NULL;
350  return result;
351  }
352  buffer = pg_malloc(statbuf.st_size + 1);
353 
354  len = read(fd, buffer, statbuf.st_size + 1);
355  close(fd);
356  if (len != statbuf.st_size)
357  {
358  /* oops, the file size changed between fstat and read */
359  free(buffer);
360  return NULL;
361  }
362 
363  /*
364  * Count newlines. We expect there to be a newline after each full line,
365  * including one at the end of file. If there isn't a newline at the end,
366  * any characters after the last newline will be ignored.
367  */
368  nlines = 0;
369  for (i = 0; i < len; i++)
370  {
371  if (buffer[i] == '\n')
372  nlines++;
373  }
374 
375  /* set up the result buffer */
376  result = (char **) pg_malloc((nlines + 1) * sizeof(char *));
377  *numlines = nlines;
378 
379  /* now split the buffer into lines */
380  linebegin = buffer;
381  n = 0;
382  for (i = 0; i < len; i++)
383  {
384  if (buffer[i] == '\n')
385  {
386  int slen = &buffer[i] - linebegin;
387  char *linebuf = pg_malloc(slen + 1);
388 
389  memcpy(linebuf, linebegin, slen);
390  /* we already dropped the \n, but get rid of any \r too */
391  if (slen > 0 && linebuf[slen - 1] == '\r')
392  slen--;
393  linebuf[slen] = '\0';
394  result[n++] = linebuf;
395  linebegin = &buffer[i + 1];
396  }
397  }
398  result[n] = NULL;
399 
400  free(buffer);
401 
402  return result;
403 }
#define PG_BINARY
Definition: c.h:1278
#define close(a)
Definition: win32.h:12
#define read(a, b, c)
Definition: win32.h:13
const void size_t len
#define fstat
Definition: win32_port.h:283

References close, fd(), free, fstat, i, len, PG_BINARY, pg_malloc(), read, and stat::st_size.

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

◆ set_mode()

static void set_mode ( char *  modeopt)
static

Definition at line 2047 of file pg_ctl.c.

2048 {
2049  if (strcmp(modeopt, "s") == 0 || strcmp(modeopt, "smart") == 0)
2050  {
2052  sig = SIGTERM;
2053  }
2054  else if (strcmp(modeopt, "f") == 0 || strcmp(modeopt, "fast") == 0)
2055  {
2057  sig = SIGINT;
2058  }
2059  else if (strcmp(modeopt, "i") == 0 || strcmp(modeopt, "immediate") == 0)
2060  {
2062  sig = SIGQUIT;
2063  }
2064  else
2065  {
2066  write_stderr(_("%s: unrecognized shutdown mode \"%s\"\n"), progname, modeopt);
2067  do_advice();
2068  exit(1);
2069  }
2070 }
#define SIGQUIT
Definition: win32_port.h:169

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

Referenced by main().

◆ set_sig()

static void set_sig ( char *  signame)
static

Definition at line 2075 of file pg_ctl.c.

2076 {
2077  if (strcmp(signame, "HUP") == 0)
2078  sig = SIGHUP;
2079  else if (strcmp(signame, "INT") == 0)
2080  sig = SIGINT;
2081  else if (strcmp(signame, "QUIT") == 0)
2082  sig = SIGQUIT;
2083  else if (strcmp(signame, "ABRT") == 0)
2084  sig = SIGABRT;
2085  else if (strcmp(signame, "KILL") == 0)
2086  sig = SIGKILL;
2087  else if (strcmp(signame, "TERM") == 0)
2088  sig = SIGTERM;
2089  else if (strcmp(signame, "USR1") == 0)
2090  sig = SIGUSR1;
2091  else if (strcmp(signame, "USR2") == 0)
2092  sig = SIGUSR2;
2093  else
2094  {
2095  write_stderr(_("%s: unrecognized signal name \"%s\"\n"), progname, signame);
2096  do_advice();
2097  exit(1);
2098  }
2099 }
#define SIGABRT
Definition: win32_port.h:171
#define SIGUSR2
Definition: win32_port.h:181
#define SIGKILL
Definition: win32_port.h:172

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

Referenced by main().

◆ start_postmaster()

static pid_t start_postmaster ( void  )
static

Definition at line 440 of file pg_ctl.c.

441 {
442  char *cmd;
443 
444 #ifndef WIN32
445  pid_t pm_pid;
446 
447  /* Flush stdio channels just before fork, to avoid double-output problems */
448  fflush(NULL);
449 
450 #ifdef EXEC_BACKEND
451  pg_disable_aslr();
452 #endif
453 
454  pm_pid = fork();
455  if (pm_pid < 0)
456  {
457  /* fork failed */
458  write_stderr(_("%s: could not start server: %m\n"),
459  progname);
460  exit(1);
461  }
462  if (pm_pid > 0)
463  {
464  /* fork succeeded, in parent */
465  return pm_pid;
466  }
467 
468  /* fork succeeded, in child */
469 
470  /*
471  * If possible, detach the postmaster process from the launching process
472  * group and make it a group leader, so that it doesn't get signaled along
473  * with the current group that launched it.
474  */
475 #ifdef HAVE_SETSID
476  if (setsid() < 0)
477  {
478  write_stderr(_("%s: could not start server due to setsid() failure: %m\n"),
479  progname);
480  exit(1);
481  }
482 #endif
483 
484  /*
485  * Since there might be quotes to handle here, it is easier simply to pass
486  * everything to a shell to process them. Use exec so that the postmaster
487  * has the same PID as the current child process.
488  */
489  if (log_file != NULL)
490  cmd = psprintf("exec \"%s\" %s%s < \"%s\" >> \"%s\" 2>&1",
492  DEVNULL, log_file);
493  else
494  cmd = psprintf("exec \"%s\" %s%s < \"%s\" 2>&1",
496 
497  (void) execl("/bin/sh", "/bin/sh", "-c", cmd, (char *) NULL);
498 
499  /* exec failed */
500  write_stderr(_("%s: could not start server: %m\n"),
501  progname);
502  exit(1);
503 
504  return 0; /* keep dumb compilers quiet */
505 
506 #else /* WIN32 */
507 
508  /*
509  * As with the Unix case, it's easiest to use the shell (CMD.EXE) to
510  * handle redirection etc. Unfortunately CMD.EXE lacks any equivalent of
511  * "exec", so we don't get to find out the postmaster's PID immediately.
512  */
513  PROCESS_INFORMATION pi;
514  const char *comspec;
515 
516  /* Find CMD.EXE location using COMSPEC, if it's set */
517  comspec = getenv("COMSPEC");
518  if (comspec == NULL)
519  comspec = "CMD";
520 
521  if (log_file != NULL)
522  {
523  /*
524  * First, open the log file if it exists. The idea is that if the
525  * file is still locked by a previous postmaster run, we'll wait until
526  * it comes free, instead of failing with ERROR_SHARING_VIOLATION.
527  * (It'd be better to open the file in a sharing-friendly mode, but we
528  * can't use CMD.EXE to do that, so work around it. Note that the
529  * previous postmaster will still have the file open for a short time
530  * after removing postmaster.pid.)
531  *
532  * If the log file doesn't exist, we *must not* create it here. If we
533  * were launched with higher privileges than the restricted process
534  * will have, the log file might end up with permissions settings that
535  * prevent the postmaster from writing on it.
536  */
537  int fd = open(log_file, O_RDWR, 0);
538 
539  if (fd == -1)
540  {
541  /*
542  * ENOENT is expectable since we didn't use O_CREAT. Otherwise
543  * complain. We could just fall through and let CMD.EXE report
544  * the problem, but its error reporting is pretty miserable.
545  */
546  if (errno != ENOENT)
547  {
548  write_stderr(_("%s: could not open log file \"%s\": %m\n"),
549  progname, log_file);
550  exit(1);
551  }
552  }
553  else
554  close(fd);
555 
556  cmd = psprintf("\"%s\" /C \"\"%s\" %s%s < \"%s\" >> \"%s\" 2>&1\"",
558  }
559  else
560  cmd = psprintf("\"%s\" /C \"\"%s\" %s%s < \"%s\" 2>&1\"",
561  comspec, exec_path, pgdata_opt, post_opts, DEVNULL);
562 
563  if (!CreateRestrictedProcess(cmd, &pi, false))
564  {
565  write_stderr(_("%s: could not start server: error code %lu\n"),
566  progname, (unsigned long) GetLastError());
567  exit(1);
568  }
569  /* Don't close command process handle here; caller must do so */
570  postmasterProcess = pi.hProcess;
571  CloseHandle(pi.hThread);
572  return pi.dwProcessId; /* Shell's PID, not postmaster's! */
573 #endif /* WIN32 */
574 }

References _, close, DEVNULL, exec_path, exit(), fd(), fflush(), log_file, pgdata_opt, post_opts, progname, psprintf(), and write_stderr().

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

◆ trap_sigint_during_startup()

static void trap_sigint_during_startup ( SIGNAL_ARGS  )
static

Definition at line 857 of file pg_ctl.c.

858 {
859  if (postmasterPID != -1)
860  {
861  if (kill(postmasterPID, SIGINT) != 0)
862  write_stderr(_("%s: could not send stop signal (PID: %d): %m\n"),
863  progname, (int) postmasterPID);
864  }
865 
866  /*
867  * Clear the signal handler, and send the signal again, to terminate the
868  * process as normal.
869  */
870  pqsignal(postgres_signal_arg, SIG_DFL);
871  raise(postgres_signal_arg);
872 }
#define SIG_DFL
Definition: win32_port.h:163

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

Referenced by do_start().

◆ unlimit_core_size()

static void unlimit_core_size ( void  )
static

Definition at line 782 of file pg_ctl.c.

783 {
784  struct rlimit lim;
785 
786  getrlimit(RLIMIT_CORE, &lim);
787  if (lim.rlim_max == 0)
788  {
789  write_stderr(_("%s: cannot set core file size limit; disallowed by hard limit\n"),
790  progname);
791  return;
792  }
793  else if (lim.rlim_max == RLIM_INFINITY || lim.rlim_cur < lim.rlim_max)
794  {
795  lim.rlim_cur = lim.rlim_max;
796  setrlimit(RLIMIT_CORE, &lim);
797  }
798 }

References _, progname, and write_stderr().

Referenced by do_start().

◆ wait_for_postmaster_promote()

static bool wait_for_postmaster_promote ( void  )
static

Definition at line 754 of file pg_ctl.c.

755 {
756  int cnt;
757 
758  for (cnt = 0; cnt < wait_seconds * WAITS_PER_SEC; cnt++)
759  {
760  pid_t pid;
761  DBState state;
762 
763  if ((pid = get_pgpid(false)) == 0)
764  return false; /* pid file is gone */
765  if (kill(pid, 0) != 0)
766  return false; /* postmaster died */
767 
769  if (state == DB_IN_PRODUCTION)
770  return true; /* successful promotion */
771 
772  if (cnt % WAITS_PER_SEC == 0)
773  print_msg(".");
775  }
776  return false; /* timeout reached */
777 }
@ DB_IN_PRODUCTION
Definition: pg_control.h:97
#define WAITS_PER_SEC
Definition: pg_ctl.c:73
#define USEC_PER_SEC
Definition: pg_ctl.c:71
void pg_usleep(long microsec)
Definition: signal.c:53
Definition: regguts.h:323

References DB_IN_PRODUCTION, get_control_dbstate(), get_pgpid(), kill, pg_usleep(), print_msg(), USEC_PER_SEC, wait_seconds, and WAITS_PER_SEC.

Referenced by do_promote().

◆ wait_for_postmaster_start()

static WaitPMResult wait_for_postmaster_start ( pid_t  pm_pid,
bool  do_checkpoint 
)
static

Definition at line 593 of file pg_ctl.c.

594 {
595  int i;
596 
597  for (i = 0; i < wait_seconds * WAITS_PER_SEC; i++)
598  {
599  char **optlines;
600  int numlines;
601 
602  /*
603  * Try to read the postmaster.pid file. If it's not valid, or if the
604  * status line isn't there yet, just keep waiting.
605  */
606  if ((optlines = readfile(pid_file, &numlines)) != NULL &&
607  numlines >= LOCK_FILE_LINE_PM_STATUS)
608  {
609  /* File is complete enough for us, parse it */
610  pid_t pmpid;
611  time_t pmstart;
612 
613  /*
614  * Make sanity checks. If it's for the wrong PID, or the recorded
615  * start time is before pg_ctl started, then either we are looking
616  * at the wrong data directory, or this is a pre-existing pidfile
617  * that hasn't (yet?) been overwritten by our child postmaster.
618  * Allow 2 seconds slop for possible cross-process clock skew.
619  */
620  pmpid = atol(optlines[LOCK_FILE_LINE_PID - 1]);
621  pmstart = atoll(optlines[LOCK_FILE_LINE_START_TIME - 1]);
622  if (pmstart >= start_time - 2 &&
623 #ifndef WIN32
624  pmpid == pm_pid
625 #else
626  /* Windows can only reject standalone-backend PIDs */
627  pmpid > 0
628 #endif
629  )
630  {
631  /*
632  * OK, seems to be a valid pidfile from our child. Check the
633  * status line (this assumes a v10 or later server).
634  */
635  char *pmstatus = optlines[LOCK_FILE_LINE_PM_STATUS - 1];
636 
637  if (strcmp(pmstatus, PM_STATUS_READY) == 0 ||
638  strcmp(pmstatus, PM_STATUS_STANDBY) == 0)
639  {
640  /* postmaster is done starting up */
641  free_readfile(optlines);
642  return POSTMASTER_READY;
643  }
644  }
645  }
646 
647  /*
648  * Free the results of readfile.
649  *
650  * This is safe to call even if optlines is NULL.
651  */
652  free_readfile(optlines);
653 
654  /*
655  * Check whether the child postmaster process is still alive. This
656  * lets us exit early if the postmaster fails during startup.
657  *
658  * On Windows, we may be checking the postmaster's parent shell, but
659  * that's fine for this purpose.
660  */
661  {
662  bool pm_died;
663 #ifndef WIN32
664  int exitstatus;
665 
666  pm_died = (waitpid(pm_pid, &exitstatus, WNOHANG) == pm_pid);
667 #else
668  pm_died = (WaitForSingleObject(postmasterProcess, 0) == WAIT_OBJECT_0);
669 #endif
670  if (pm_died)
671  {
672  /* See if postmaster terminated intentionally */
675  else
676  return POSTMASTER_FAILED;
677  }
678  }
679 
680  /* Startup still in process; wait, printing a dot once per second */
681  if (i % WAITS_PER_SEC == 0)
682  {
683 #ifdef WIN32
684  if (do_checkpoint)
685  {
686  /*
687  * Increment the wait hint by 6 secs (connection timeout +
688  * sleep). We must do this to indicate to the SCM that our
689  * startup time is changing, otherwise it'll usually send a
690  * stop signal after 20 seconds, despite incrementing the
691  * checkpoint counter.
692  */
693  status.dwWaitHint += 6000;
694  status.dwCheckPoint++;
695  SetServiceStatus(hStatus, (LPSERVICE_STATUS) &status);
696  }
697  else
698 #endif
699  print_msg(".");
700  }
701 
703  }
704 
705  /* out of patience; report that postmaster is still starting up */
707 }
@ DB_SHUTDOWNED_IN_RECOVERY
Definition: pg_control.h:93
#define PM_STATUS_READY
Definition: pidfile.h:53
#define PM_STATUS_STANDBY
Definition: pidfile.h:54
#define LOCK_FILE_LINE_START_TIME
Definition: pidfile.h:39
#define LOCK_FILE_LINE_PM_STATUS
Definition: pidfile.h:44
#define LOCK_FILE_LINE_PID
Definition: pidfile.h:37

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

Referenced by do_start().

◆ wait_for_postmaster_stop()

static bool wait_for_postmaster_stop ( void  )
static

Definition at line 717 of file pg_ctl.c.

718 {
719  int cnt;
720 
721  for (cnt = 0; cnt < wait_seconds * WAITS_PER_SEC; cnt++)
722  {
723  pid_t pid;
724 
725  if ((pid = get_pgpid(false)) == 0)
726  return true; /* pid file is gone */
727 
728  if (kill(pid, 0) != 0)
729  {
730  /*
731  * Postmaster seems to have died. Check the pid file once more to
732  * avoid a race condition, but give up waiting.
733  */
734  if (get_pgpid(false) == 0)
735  return true; /* pid file is gone */
736  return false; /* postmaster died untimely */
737  }
738 
739  if (cnt % WAITS_PER_SEC == 0)
740  print_msg(".");
742  }
743  return false; /* timeout reached */
744 }

References get_pgpid(), kill, pg_usleep(), print_msg(), USEC_PER_SEC, wait_seconds, and WAITS_PER_SEC.

Referenced by do_restart(), and do_stop().

◆ write_stderr()

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

Definition at line 202 of file pg_ctl.c.

203 {
204  va_list ap;
205 
206  va_start(ap, fmt);
207 #ifndef WIN32
208  /* On Unix, we just fprintf to stderr */
209  vfprintf(stderr, fmt, ap);
210 #else
211 
212  /*
213  * On Win32, we print to stderr if running on a console, or write to
214  * eventlog if running as a service
215  */
216  if (pgwin32_is_service()) /* Running as a service */
217  {
218  char errbuf[2048]; /* Arbitrary size? */
219 
220  vsnprintf(errbuf, sizeof(errbuf), fmt, ap);
221 
222  write_eventlog(EVENTLOG_ERROR_TYPE, errbuf);
223  }
224  else
225  /* Not running as service, write to stderr */
226  vfprintf(stderr, fmt, ap);
227 #endif
228  va_end(ap);
229 }
static void const char * fmt
va_end(args)
vfprintf(stderr, fmt, args)
va_start(args, fmt)
#define vsnprintf
Definition: port.h:237
int pgwin32_is_service(void)

References fmt, pgwin32_is_service(), va_end(), va_start(), vfprintf(), and vsnprintf.

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

Variable Documentation

◆ allow_core_files

bool allow_core_files = false
static

Definition at line 94 of file pg_ctl.c.

Referenced by do_start(), and main().

◆ argv0

◆ ctl_command

CtlCommand ctl_command = NO_COMMAND
static

Definition at line 81 of file pg_ctl.c.

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

◆ do_wait

bool do_wait = true
static

◆ event_source

char* event_source = NULL
static

Definition at line 89 of file pg_ctl.c.

Referenced by main().

◆ exec_path

char* exec_path = NULL
static

◆ log_file

char* log_file = NULL
static

Definition at line 87 of file pg_ctl.c.

Referenced by exec_prog(), main(), parallel_exec_prog(), and start_postmaster().

◆ logrotate_file

char logrotate_file[MAXPGPATH]
static

Definition at line 101 of file pg_ctl.c.

Referenced by do_logrotate().

◆ pg_config

char* pg_config = NULL
static

Definition at line 83 of file pg_ctl.c.

Referenced by adjust_data_dir(), and main().

◆ pg_data

char* pg_data = NULL
static

Definition at line 82 of file pg_ctl.c.

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

◆ pgdata_opt

char* pgdata_opt = NULL
static

Definition at line 84 of file pg_ctl.c.

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

◆ pid_file

char pid_file[MAXPGPATH]
static

◆ post_opts

char* post_opts = NULL
static

Definition at line 85 of file pg_ctl.c.

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

◆ postmasterPID

volatile pid_t postmasterPID = -1
static

Definition at line 103 of file pg_ctl.c.

Referenced by do_start(), and trap_sigint_during_startup().

◆ postopts_file

char postopts_file[MAXPGPATH]
static

Definition at line 97 of file pg_ctl.c.

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

◆ progname

◆ promote_file

char promote_file[MAXPGPATH]
static

Definition at line 100 of file pg_ctl.c.

Referenced by do_promote(), and pg_promote().

◆ register_password

char* register_password = NULL
static

Definition at line 92 of file pg_ctl.c.

Referenced by main().

◆ register_servicename

char* register_servicename = "PostgreSQL"
static

Definition at line 90 of file pg_ctl.c.

Referenced by main().

◆ register_username

char* register_username = NULL
static

Definition at line 91 of file pg_ctl.c.

Referenced by main().

◆ shutdown_mode

ShutdownMode shutdown_mode = FAST_MODE
static

Definition at line 79 of file pg_ctl.c.

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

◆ sig

◆ silent_mode

bool silent_mode = false
static

Definition at line 78 of file pg_ctl.c.

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

◆ start_time

◆ version_file

char version_file[MAXPGPATH]
static

Definition at line 98 of file pg_ctl.c.

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

◆ wait_seconds

◆ wait_seconds_arg

bool wait_seconds_arg = false
static

Definition at line 77 of file pg_ctl.c.

Referenced by main().