Age Owner Branch data TLA Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * pg_ctl --- start/stops/restarts the PostgreSQL server
4 : : *
5 : : * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
6 : : *
7 : : * src/bin/pg_ctl/pg_ctl.c
8 : : *
9 : : *-------------------------------------------------------------------------
10 : : */
11 : :
12 : : #include "postgres_fe.h"
13 : :
14 : : #include <fcntl.h>
15 : : #include <signal.h>
16 : : #include <time.h>
17 : : #include <sys/resource.h>
18 : : #include <sys/stat.h>
19 : : #include <sys/time.h>
20 : : #include <sys/wait.h>
21 : : #include <unistd.h>
22 : :
23 : :
24 : : #include "catalog/pg_control.h"
25 : : #include "common/controldata_utils.h"
26 : : #include "common/file_perm.h"
27 : : #include "common/logging.h"
28 : : #include "common/string.h"
29 : : #include "getopt_long.h"
30 : : #include "utils/pidfile.h"
31 : :
32 : : #ifdef WIN32 /* on Unix, we don't need libpq */
33 : : #include "pqexpbuffer.h"
34 : : #endif
35 : :
36 : :
37 : : typedef enum
38 : : {
39 : : SMART_MODE,
40 : : FAST_MODE,
41 : : IMMEDIATE_MODE,
42 : : } ShutdownMode;
43 : :
44 : : typedef enum
45 : : {
46 : : POSTMASTER_READY,
47 : : POSTMASTER_STILL_STARTING,
48 : : POSTMASTER_FAILED,
49 : : } WaitPMResult;
50 : :
51 : : typedef enum
52 : : {
53 : : NO_COMMAND = 0,
54 : : INIT_COMMAND,
55 : : START_COMMAND,
56 : : STOP_COMMAND,
57 : : RESTART_COMMAND,
58 : : RELOAD_COMMAND,
59 : : STATUS_COMMAND,
60 : : PROMOTE_COMMAND,
61 : : LOGROTATE_COMMAND,
62 : : KILL_COMMAND,
63 : : REGISTER_COMMAND,
64 : : UNREGISTER_COMMAND,
65 : : RUN_AS_SERVICE_COMMAND,
66 : : } CtlCommand;
67 : :
68 : : #define DEFAULT_WAIT 60
69 : :
70 : : #define USEC_PER_SEC 1000000
71 : :
72 : : #define WAITS_PER_SEC 10 /* should divide USEC_PER_SEC evenly */
73 : :
74 : : static bool do_wait = true;
75 : : static int wait_seconds = DEFAULT_WAIT;
76 : : static bool wait_seconds_arg = false;
77 : : static bool silent_mode = false;
78 : : static ShutdownMode shutdown_mode = FAST_MODE;
79 : : static int sig = SIGINT; /* default */
80 : : static CtlCommand ctl_command = NO_COMMAND;
81 : : static char *pg_data = NULL;
82 : : static char *pg_config = NULL;
83 : : static char *pgdata_opt = NULL;
84 : : static char *post_opts = NULL;
85 : : static const char *progname;
86 : : static char *log_file = NULL;
87 : : static char *exec_path = NULL;
88 : : static char *event_source = NULL;
89 : : static char *register_servicename = "PostgreSQL"; /* FIXME: + version ID? */
90 : : static char *register_username = NULL;
91 : : static char *register_password = NULL;
92 : : static char *argv0 = NULL;
93 : : static bool allow_core_files = false;
94 : : static time_t start_time;
95 : :
96 : : static char postopts_file[MAXPGPATH];
97 : : static char version_file[MAXPGPATH];
98 : : static char pid_file[MAXPGPATH];
99 : : static char promote_file[MAXPGPATH];
100 : : static char logrotate_file[MAXPGPATH];
101 : :
102 : : static volatile pid_t postmasterPID = -1;
103 : :
104 : : #ifdef WIN32
105 : : static DWORD pgctl_start_type = SERVICE_AUTO_START;
106 : : static SERVICE_STATUS status;
107 : : static SERVICE_STATUS_HANDLE hStatus = (SERVICE_STATUS_HANDLE) 0;
108 : : static HANDLE shutdownHandles[2];
109 : :
110 : : #define shutdownEvent shutdownHandles[0]
111 : : #define postmasterProcess shutdownHandles[1]
112 : : #endif
113 : :
114 : :
115 : : static void write_stderr(const char *fmt,...) pg_attribute_printf(1, 2);
116 : : static void do_advice(void);
117 : : static void do_help(void);
118 : : static void set_mode(char *modeopt);
119 : : static void set_sig(char *signame);
120 : : static void do_init(void);
121 : : static void do_start(void);
122 : : static void do_stop(void);
123 : : static void do_restart(void);
124 : : static void do_reload(void);
125 : : static void do_status(void);
126 : : static void do_promote(void);
127 : : static void do_logrotate(void);
128 : : static void do_kill(pid_t pid);
129 : : static void print_msg(const char *msg);
130 : : static void adjust_data_dir(void);
131 : :
132 : : #ifdef WIN32
133 : : #include <versionhelpers.h>
134 : : static bool pgwin32_IsInstalled(SC_HANDLE);
135 : : static char *pgwin32_CommandLine(bool);
136 : : static void pgwin32_doRegister(void);
137 : : static void pgwin32_doUnregister(void);
138 : : static void pgwin32_SetServiceStatus(DWORD);
139 : : static void WINAPI pgwin32_ServiceHandler(DWORD);
140 : : static void WINAPI pgwin32_ServiceMain(DWORD, LPTSTR *);
141 : : static void pgwin32_doRunAsService(void);
142 : : static int CreateRestrictedProcess(char *cmd, PROCESS_INFORMATION *processInfo, bool as_service);
143 : : static PTOKEN_PRIVILEGES GetPrivilegesToDelete(HANDLE hToken);
144 : : #endif
145 : :
146 : : static pid_t get_pgpid(bool is_status_request);
147 : : static char **readfile(const char *path, int *numlines);
148 : : static void free_readfile(char **optlines);
149 : : static pid_t start_postmaster(void);
150 : : static void read_post_opts(void);
151 : :
152 : : static WaitPMResult wait_for_postmaster_start(pid_t pm_pid, bool do_checkpoint);
153 : : static bool wait_for_postmaster_stop(void);
154 : : static bool wait_for_postmaster_promote(void);
155 : : static bool postmaster_is_alive(pid_t pid);
156 : :
157 : : #if defined(HAVE_GETRLIMIT)
158 : : static void unlimit_core_size(void);
159 : : #endif
160 : :
161 : : static DBState get_control_dbstate(void);
162 : :
163 : :
164 : : #ifdef WIN32
165 : : static void
166 : : write_eventlog(int level, const char *line)
167 : : {
168 : : static HANDLE evtHandle = INVALID_HANDLE_VALUE;
169 : :
170 : : if (silent_mode && level == EVENTLOG_INFORMATION_TYPE)
171 : : return;
172 : :
173 : : if (evtHandle == INVALID_HANDLE_VALUE)
174 : : {
175 : : evtHandle = RegisterEventSource(NULL,
176 : : event_source ? event_source : DEFAULT_EVENT_SOURCE);
177 : : if (evtHandle == NULL)
178 : : {
179 : : evtHandle = INVALID_HANDLE_VALUE;
180 : : return;
181 : : }
182 : : }
183 : :
184 : : ReportEvent(evtHandle,
185 : : level,
186 : : 0,
187 : : 0, /* All events are Id 0 */
188 : : NULL,
189 : : 1,
190 : : 0,
191 : : &line,
192 : : NULL);
193 : : }
194 : : #endif
195 : :
196 : : /*
197 : : * Write errors to stderr (or by equal means when stderr is
198 : : * not available).
199 : : */
200 : : static void
7234 tgl@sss.pgh.pa.us 201 :CBC 28 : write_stderr(const char *fmt,...)
202 : : {
203 : : va_list ap;
204 : :
205 : 28 : va_start(ap, fmt);
206 : : #ifndef WIN32
207 : : /* On Unix, we just fprintf to stderr */
208 : 28 : vfprintf(stderr, fmt, ap);
209 : : #else
210 : :
211 : : /*
212 : : * On Win32, we print to stderr if running on a console, or write to
213 : : * eventlog if running as a service
214 : : */
215 : : if (pgwin32_is_service()) /* Running as a service */
216 : : {
217 : : char errbuf[2048]; /* Arbitrary size? */
218 : :
219 : : vsnprintf(errbuf, sizeof(errbuf), fmt, ap);
220 : :
221 : : write_eventlog(EVENTLOG_ERROR_TYPE, errbuf);
222 : : }
223 : : else
224 : : /* Not running as service, write to stderr */
225 : : vfprintf(stderr, fmt, ap);
226 : : #endif
227 : 28 : va_end(ap);
228 : 28 : }
229 : :
230 : : /*
231 : : * Given an already-localized string, print it to stdout unless the
232 : : * user has specified that no messages should be printed.
233 : : */
234 : : static void
7121 neilc@samurai.com 235 : 5776 : print_msg(const char *msg)
236 : : {
237 [ + + ]: 5776 : if (!silent_mode)
238 : : {
239 : 5352 : fputs(msg, stdout);
240 : 5352 : fflush(stdout);
241 : : }
242 : 5776 : }
243 : :
244 : : static pid_t
3690 bruce@momjian.us 245 : 3715 : get_pgpid(bool is_status_request)
246 : : {
247 : : FILE *pidf;
248 : : int pid;
249 : : struct stat statbuf;
250 : :
251 [ + + ]: 3715 : if (stat(pg_data, &statbuf) != 0)
252 : : {
253 [ + - ]: 3 : if (errno == ENOENT)
3623 peter_e@gmx.net 254 : 3 : write_stderr(_("%s: directory \"%s\" does not exist\n"), progname,
255 : : pg_data);
256 : : else
33 michael@paquier.xyz 257 :UNC 0 : write_stderr(_("%s: could not access directory \"%s\": %m\n"), progname,
258 : : pg_data);
259 : :
260 : : /*
261 : : * The Linux Standard Base Core Specification 3.1 says this should
262 : : * return '4, program or service status is unknown'
263 : : * https://refspecs.linuxbase.org/LSB_3.1.0/LSB-Core-generic/LSB-Core-generic/iniscrptact.html
264 : : */
3690 bruce@momjian.us 265 [ + + ]:CBC 3 : exit(is_status_request ? 4 : 1);
266 : : }
267 : :
268 [ - + - - ]: 3712 : if (stat(version_file, &statbuf) != 0 && errno == ENOENT)
269 : : {
3623 peter_e@gmx.net 270 :UBC 0 : write_stderr(_("%s: directory \"%s\" is not a database cluster directory\n"),
271 : : progname, pg_data);
3690 bruce@momjian.us 272 [ # # ]: 0 : exit(is_status_request ? 4 : 1);
273 : : }
274 : :
7262 bruce@momjian.us 275 :CBC 3712 : pidf = fopen(pid_file, "r");
276 [ + + ]: 3712 : if (pidf == NULL)
277 : : {
278 : : /* No pid file, not an error on startup */
279 [ + - ]: 1284 : if (errno == ENOENT)
280 : 1284 : return 0;
281 : : else
282 : : {
33 michael@paquier.xyz 283 :UNC 0 : write_stderr(_("%s: could not open PID file \"%s\": %m\n"),
284 : : progname, pid_file);
7262 bruce@momjian.us 285 :UBC 0 : exit(1);
286 : : }
287 : : }
540 peter@eisentraut.org 288 [ - + ]:CBC 2428 : if (fscanf(pidf, "%d", &pid) != 1)
289 : : {
290 : : /* Is the file empty? */
4246 bruce@momjian.us 291 [ # # # # ]:UBC 0 : if (ftell(pidf) == 0 && feof(pidf))
292 : 0 : write_stderr(_("%s: the PID file \"%s\" is empty\n"),
293 : : progname, pid_file);
294 : : else
295 : 0 : write_stderr(_("%s: invalid data in PID file \"%s\"\n"),
296 : : progname, pid_file);
6934 tgl@sss.pgh.pa.us 297 : 0 : exit(1);
298 : : }
7262 bruce@momjian.us 299 :CBC 2428 : fclose(pidf);
540 peter@eisentraut.org 300 : 2428 : return (pid_t) pid;
301 : : }
302 : :
303 : :
304 : : /*
305 : : * get the lines from a text file - return NULL if file can't be opened
306 : : *
307 : : * Trailing newlines are deleted from the lines (this is a change from pre-v10)
308 : : *
309 : : * *numlines is set to the number of line pointers returned; there is
310 : : * also an additional NULL pointer after the last real line.
311 : : */
312 : : static char **
2482 tgl@sss.pgh.pa.us 313 : 1844 : readfile(const char *path, int *numlines)
314 : : {
315 : : int fd;
316 : : int nlines;
317 : : char **result;
318 : : char *buffer;
319 : : char *linebegin;
320 : : int i;
321 : : int n;
322 : : int len;
323 : : struct stat statbuf;
324 : :
325 : 1844 : *numlines = 0; /* in case of failure or empty file */
326 : :
327 : : /*
328 : : * Slurp the file into memory.
329 : : *
330 : : * The file can change concurrently, so we read the whole file into memory
331 : : * with a single read() call. That's not guaranteed to get an atomic
332 : : * snapshot, but in practice, for a small file, it's close enough for the
333 : : * current use.
334 : : */
4201 heikki.linnakangas@i 335 : 1844 : fd = open(path, O_RDONLY | PG_BINARY, 0);
336 [ + + ]: 1844 : if (fd < 0)
337 : 660 : return NULL;
338 [ - + ]: 1184 : if (fstat(fd, &statbuf) < 0)
339 : : {
4196 heikki.linnakangas@i 340 :UBC 0 : close(fd);
7262 bruce@momjian.us 341 : 0 : return NULL;
342 : : }
4201 heikki.linnakangas@i 343 [ - + ]:CBC 1184 : if (statbuf.st_size == 0)
344 : : {
345 : : /* empty file */
4196 heikki.linnakangas@i 346 :UBC 0 : close(fd);
4201 347 : 0 : result = (char **) pg_malloc(sizeof(char *));
348 : 0 : *result = NULL;
349 : 0 : return result;
350 : : }
4201 heikki.linnakangas@i 351 :CBC 1184 : buffer = pg_malloc(statbuf.st_size + 1);
352 : :
353 : 1184 : len = read(fd, buffer, statbuf.st_size + 1);
354 : 1184 : close(fd);
355 [ - + ]: 1184 : if (len != statbuf.st_size)
356 : : {
357 : : /* oops, the file size changed between fstat and read */
4201 heikki.linnakangas@i 358 :UBC 0 : free(buffer);
359 : 0 : return NULL;
360 : : }
361 : :
362 : : /*
363 : : * Count newlines. We expect there to be a newline after each full line,
364 : : * including one at the end of file. If there isn't a newline at the end,
365 : : * any characters after the last newline will be ignored.
366 : : */
4201 heikki.linnakangas@i 367 :CBC 1184 : nlines = 0;
4196 368 [ + + ]: 241542 : for (i = 0; i < len; i++)
369 : : {
4201 370 [ + + ]: 240358 : if (buffer[i] == '\n')
7262 bruce@momjian.us 371 : 8780 : nlines++;
372 : : }
373 : :
374 : : /* set up the result buffer */
6853 375 : 1184 : result = (char **) pg_malloc((nlines + 1) * sizeof(char *));
2482 tgl@sss.pgh.pa.us 376 : 1184 : *numlines = nlines;
377 : :
378 : : /* now split the buffer into lines */
4201 heikki.linnakangas@i 379 : 1184 : linebegin = buffer;
380 : 1184 : n = 0;
381 [ + + ]: 241542 : for (i = 0; i < len; i++)
382 : : {
4196 383 [ + + ]: 240358 : if (buffer[i] == '\n')
384 : : {
2482 tgl@sss.pgh.pa.us 385 : 8780 : int slen = &buffer[i] - linebegin;
3973 bruce@momjian.us 386 : 8780 : char *linebuf = pg_malloc(slen + 1);
387 : :
4201 heikki.linnakangas@i 388 : 8780 : memcpy(linebuf, linebegin, slen);
389 : : /* we already dropped the \n, but get rid of any \r too */
2482 tgl@sss.pgh.pa.us 390 [ + + - + ]: 8780 : if (slen > 0 && linebuf[slen - 1] == '\r')
2482 tgl@sss.pgh.pa.us 391 :UBC 0 : slen--;
4201 heikki.linnakangas@i 392 :CBC 8780 : linebuf[slen] = '\0';
393 : 8780 : result[n++] = linebuf;
394 : 8780 : linebegin = &buffer[i + 1];
395 : : }
396 : : }
397 : 1184 : result[n] = NULL;
398 : :
6446 meskes@postgresql.or 399 : 1184 : free(buffer);
400 : :
7262 bruce@momjian.us 401 : 1184 : return result;
402 : : }
403 : :
404 : :
405 : : /*
406 : : * Free memory allocated for optlines through readfile()
407 : : */
408 : : static void
3697 sfrost@snowman.net 409 : 1844 : free_readfile(char **optlines)
410 : : {
3631 bruce@momjian.us 411 : 1844 : char *curr_line = NULL;
412 : 1844 : int i = 0;
413 : :
3697 sfrost@snowman.net 414 [ + + ]: 1844 : if (!optlines)
415 : 660 : return;
416 : :
3693 417 [ + + ]: 9964 : while ((curr_line = optlines[i++]))
418 : 8780 : free(curr_line);
419 : :
3697 420 : 1184 : free(optlines);
421 : : }
422 : :
423 : : /*
424 : : * start/test/stop routines
425 : : */
426 : :
427 : : /*
428 : : * Start the postmaster and return its PID.
429 : : *
430 : : * Currently, on Windows what we return is the PID of the shell process
431 : : * that launched the postmaster (and, we trust, is waiting for it to exit).
432 : : * So the PID is usable for "is the postmaster still running" checks,
433 : : * but cannot be compared directly to postmaster.pid.
434 : : *
435 : : * On Windows, we also save aside a handle to the shell process in
436 : : * "postmasterProcess", which the caller should close when done with it.
437 : : */
438 : : static pid_t
7262 bruce@momjian.us 439 : 653 : start_postmaster(void)
440 : : {
441 : : char *cmd;
442 : :
443 : : #ifndef WIN32
444 : : pid_t pm_pid;
445 : :
446 : : /* Flush stdio channels just before fork, to avoid double-output problems */
594 tgl@sss.pgh.pa.us 447 : 653 : fflush(NULL);
448 : :
449 : : #ifdef EXEC_BACKEND
450 : : pg_disable_aslr();
451 : : #endif
452 : :
3107 453 : 653 : pm_pid = fork();
454 [ - + ]: 1306 : if (pm_pid < 0)
455 : : {
456 : : /* fork failed */
33 michael@paquier.xyz 457 :UNC 0 : write_stderr(_("%s: could not start server: %m\n"),
458 : : progname);
3107 tgl@sss.pgh.pa.us 459 :UBC 0 : exit(1);
460 : : }
3107 tgl@sss.pgh.pa.us 461 [ + + ]:CBC 1306 : if (pm_pid > 0)
462 : : {
463 : : /* fork succeeded, in parent */
464 : 653 : return pm_pid;
465 : : }
466 : :
467 : : /* fork succeeded, in child */
468 : :
469 : : /*
470 : : * If possible, detach the postmaster process from the launching process
471 : : * group and make it a group leader, so that it doesn't get signaled along
472 : : * with the current group that launched it.
473 : : */
474 : : #ifdef HAVE_SETSID
1917 heikki.linnakangas@i 475 [ - + ]: 653 : if (setsid() < 0)
476 : : {
33 michael@paquier.xyz 477 :UNC 0 : write_stderr(_("%s: could not start server due to setsid() failure: %m\n"),
478 : : progname);
1917 heikki.linnakangas@i 479 :UBC 0 : exit(1);
480 : : }
481 : : #endif
482 : :
483 : : /*
484 : : * Since there might be quotes to handle here, it is easier simply to pass
485 : : * everything to a shell to process them. Use exec so that the postmaster
486 : : * has the same PID as the current child process.
487 : : */
7262 bruce@momjian.us 488 [ + + ]:CBC 653 : if (log_file != NULL)
954 tgl@sss.pgh.pa.us 489 : 640 : cmd = psprintf("exec \"%s\" %s%s < \"%s\" >> \"%s\" 2>&1",
490 : : exec_path, pgdata_opt, post_opts,
491 : : DEVNULL, log_file);
492 : : else
493 : 13 : cmd = psprintf("exec \"%s\" %s%s < \"%s\" 2>&1",
494 : : exec_path, pgdata_opt, post_opts, DEVNULL);
495 : :
3107 496 : 653 : (void) execl("/bin/sh", "/bin/sh", "-c", cmd, (char *) NULL);
497 : :
498 : : /* exec failed */
33 michael@paquier.xyz 499 :GNC 653 : write_stderr(_("%s: could not start server: %m\n"),
500 : : progname);
3107 tgl@sss.pgh.pa.us 501 :UBC 0 : exit(1);
502 : :
503 : : return 0; /* keep dumb compilers quiet */
504 : :
505 : : #else /* WIN32 */
506 : :
507 : : /*
508 : : * As with the Unix case, it's easiest to use the shell (CMD.EXE) to
509 : : * handle redirection etc. Unfortunately CMD.EXE lacks any equivalent of
510 : : * "exec", so we don't get to find out the postmaster's PID immediately.
511 : : */
512 : : PROCESS_INFORMATION pi;
513 : : const char *comspec;
514 : :
515 : : /* Find CMD.EXE location using COMSPEC, if it's set */
516 : : comspec = getenv("COMSPEC");
517 : : if (comspec == NULL)
518 : : comspec = "CMD";
519 : :
520 : : if (log_file != NULL)
521 : : {
522 : : /*
523 : : * First, open the log file if it exists. The idea is that if the
524 : : * file is still locked by a previous postmaster run, we'll wait until
525 : : * it comes free, instead of failing with ERROR_SHARING_VIOLATION.
526 : : * (It'd be better to open the file in a sharing-friendly mode, but we
527 : : * can't use CMD.EXE to do that, so work around it. Note that the
528 : : * previous postmaster will still have the file open for a short time
529 : : * after removing postmaster.pid.)
530 : : *
531 : : * If the log file doesn't exist, we *must not* create it here. If we
532 : : * were launched with higher privileges than the restricted process
533 : : * will have, the log file might end up with permissions settings that
534 : : * prevent the postmaster from writing on it.
535 : : */
536 : : int fd = open(log_file, O_RDWR, 0);
537 : :
538 : : if (fd == -1)
539 : : {
540 : : /*
541 : : * ENOENT is expectable since we didn't use O_CREAT. Otherwise
542 : : * complain. We could just fall through and let CMD.EXE report
543 : : * the problem, but its error reporting is pretty miserable.
544 : : */
545 : : if (errno != ENOENT)
546 : : {
547 : : write_stderr(_("%s: could not open log file \"%s\": %m\n"),
548 : : progname, log_file);
549 : : exit(1);
550 : : }
551 : : }
552 : : else
553 : : close(fd);
554 : :
555 : : cmd = psprintf("\"%s\" /D /C \"\"%s\" %s%s < \"%s\" >> \"%s\" 2>&1\"",
556 : : comspec, exec_path, pgdata_opt, post_opts, DEVNULL, log_file);
557 : : }
558 : : else
559 : : cmd = psprintf("\"%s\" /D /C \"\"%s\" %s%s < \"%s\" 2>&1\"",
560 : : comspec, exec_path, pgdata_opt, post_opts, DEVNULL);
561 : :
562 : : if (!CreateRestrictedProcess(cmd, &pi, false))
563 : : {
564 : : write_stderr(_("%s: could not start server: error code %lu\n"),
565 : : progname, (unsigned long) GetLastError());
566 : : exit(1);
567 : : }
568 : : /* Don't close command process handle here; caller must do so */
569 : : postmasterProcess = pi.hProcess;
570 : : CloseHandle(pi.hThread);
571 : : return pi.dwProcessId; /* Shell's PID, not postmaster's! */
572 : : #endif /* WIN32 */
573 : : }
574 : :
575 : :
576 : :
577 : : /*
578 : : * Wait for the postmaster to become ready.
579 : : *
580 : : * On Unix, pm_pid is the PID of the just-launched postmaster. On Windows,
581 : : * it may be the PID of an ancestor shell process, so we can't check the
582 : : * contents of postmaster.pid quite as carefully.
583 : : *
584 : : * On Windows, the static variable postmasterProcess is an implicit argument
585 : : * to this routine; it contains a handle to the postmaster process or an
586 : : * ancestor shell process thereof.
587 : : *
588 : : * Note that the checkpoint parameter enables a Windows service control
589 : : * manager checkpoint, it's got nothing to do with database checkpoints!!
590 : : */
591 : : static WaitPMResult
540 peter@eisentraut.org 592 :CBC 653 : wait_for_postmaster_start(pid_t pm_pid, bool do_checkpoint)
593 : : {
594 : : int i;
595 : :
2484 tgl@sss.pgh.pa.us 596 [ + - ]: 1746 : for (i = 0; i < wait_seconds * WAITS_PER_SEC; i++)
597 : : {
598 : : char **optlines;
599 : : int numlines;
600 : :
601 : : /*
602 : : * Try to read the postmaster.pid file. If it's not valid, or if the
603 : : * status line isn't there yet, just keep waiting.
604 : : */
2482 605 [ + + ]: 1746 : if ((optlines = readfile(pid_file, &numlines)) != NULL &&
606 [ + + ]: 1086 : numlines >= LOCK_FILE_LINE_PM_STATUS)
607 : : {
608 : : /* File is complete enough for us, parse it */
609 : : pid_t pmpid;
610 : : time_t pmstart;
611 : :
612 : : /*
613 : : * Make sanity checks. If it's for the wrong PID, or the recorded
614 : : * start time is before pg_ctl started, then either we are looking
615 : : * at the wrong data directory, or this is a pre-existing pidfile
616 : : * that hasn't (yet?) been overwritten by our child postmaster.
617 : : * Allow 2 seconds slop for possible cross-process clock skew.
618 : : */
619 : 1082 : pmpid = atol(optlines[LOCK_FILE_LINE_PID - 1]);
620 : 1082 : pmstart = atol(optlines[LOCK_FILE_LINE_START_TIME - 1]);
621 [ + - + + ]: 1082 : if (pmstart >= start_time - 2 &&
622 : : #ifndef WIN32
623 : : pmpid == pm_pid
624 : : #else
625 : : /* Windows can only reject standalone-backend PIDs */
626 : : pmpid > 0
627 : : #endif
628 : : )
629 : : {
630 : : /*
631 : : * OK, seems to be a valid pidfile from our child. Check the
632 : : * status line (this assumes a v10 or later server).
633 : : */
634 : 1078 : char *pmstatus = optlines[LOCK_FILE_LINE_PM_STATUS - 1];
635 : :
636 [ + + ]: 1078 : if (strcmp(pmstatus, PM_STATUS_READY) == 0 ||
637 [ + + ]: 434 : strcmp(pmstatus, PM_STATUS_STANDBY) == 0)
638 : : {
639 : : /* postmaster is done starting up */
640 : 646 : free_readfile(optlines);
641 : 653 : return POSTMASTER_READY;
642 : : }
643 : : }
644 : : }
645 : :
646 : : /*
647 : : * Free the results of readfile.
648 : : *
649 : : * This is safe to call even if optlines is NULL.
650 : : */
651 : 1100 : free_readfile(optlines);
652 : :
653 : : /*
654 : : * Check whether the child postmaster process is still alive. This
655 : : * lets us exit early if the postmaster fails during startup.
656 : : *
657 : : * On Windows, we may be checking the postmaster's parent shell, but
658 : : * that's fine for this purpose.
659 : : */
660 : : #ifndef WIN32
661 : : {
662 : : int exitstatus;
663 : :
540 peter@eisentraut.org 664 [ + + ]: 1100 : if (waitpid(pm_pid, &exitstatus, WNOHANG) == pm_pid)
2482 tgl@sss.pgh.pa.us 665 : 7 : return POSTMASTER_FAILED;
666 : : }
667 : : #else
668 : : if (WaitForSingleObject(postmasterProcess, 0) == WAIT_OBJECT_0)
669 : : return POSTMASTER_FAILED;
670 : : #endif
671 : :
672 : : /* Startup still in process; wait, printing a dot once per second */
2484 673 [ + + ]: 1093 : if (i % WAITS_PER_SEC == 0)
674 : : {
675 : : #ifdef WIN32
676 : : if (do_checkpoint)
677 : : {
678 : : /*
679 : : * Increment the wait hint by 6 secs (connection timeout +
680 : : * sleep). We must do this to indicate to the SCM that our
681 : : * startup time is changing, otherwise it'll usually send a
682 : : * stop signal after 20 seconds, despite incrementing the
683 : : * checkpoint counter.
684 : : */
685 : : status.dwWaitHint += 6000;
686 : : status.dwCheckPoint++;
687 : : SetServiceStatus(hStatus, (LPSERVICE_STATUS) &status);
688 : : }
689 : : else
690 : : #endif
1204 bruce@momjian.us 691 : 656 : print_msg(".");
692 : : }
693 : :
2484 tgl@sss.pgh.pa.us 694 : 1093 : pg_usleep(USEC_PER_SEC / WAITS_PER_SEC);
695 : : }
696 : :
697 : : /* out of patience; report that postmaster is still starting up */
2482 tgl@sss.pgh.pa.us 698 :UBC 0 : return POSTMASTER_STILL_STARTING;
699 : : }
700 : :
701 : :
702 : : /*
703 : : * Wait for the postmaster to stop.
704 : : *
705 : : * Returns true if the postmaster stopped cleanly (i.e., removed its pidfile).
706 : : * Returns false if the postmaster dies uncleanly, or if we time out.
707 : : */
708 : : static bool
794 tgl@sss.pgh.pa.us 709 :CBC 725 : wait_for_postmaster_stop(void)
710 : : {
711 : : int cnt;
712 : :
713 [ + - ]: 2170 : for (cnt = 0; cnt < wait_seconds * WAITS_PER_SEC; cnt++)
714 : : {
715 : : pid_t pid;
716 : :
717 [ + + ]: 2170 : if ((pid = get_pgpid(false)) == 0)
718 : 725 : return true; /* pid file is gone */
719 : :
540 peter@eisentraut.org 720 [ - + ]: 1445 : if (kill(pid, 0) != 0)
721 : : {
722 : : /*
723 : : * Postmaster seems to have died. Check the pid file once more to
724 : : * avoid a race condition, but give up waiting.
725 : : */
794 tgl@sss.pgh.pa.us 726 [ # # ]:UBC 0 : if (get_pgpid(false) == 0)
727 : 0 : return true; /* pid file is gone */
728 : 0 : return false; /* postmaster died untimely */
729 : : }
730 : :
794 tgl@sss.pgh.pa.us 731 [ + + ]:CBC 1445 : if (cnt % WAITS_PER_SEC == 0)
732 : 733 : print_msg(".");
733 : 1445 : pg_usleep(USEC_PER_SEC / WAITS_PER_SEC);
734 : : }
794 tgl@sss.pgh.pa.us 735 :UBC 0 : return false; /* timeout reached */
736 : : }
737 : :
738 : :
739 : : /*
740 : : * Wait for the postmaster to promote.
741 : : *
742 : : * Returns true on success, else false.
743 : : * To avoid waiting uselessly, we check for postmaster death here too.
744 : : */
745 : : static bool
794 tgl@sss.pgh.pa.us 746 :CBC 37 : wait_for_postmaster_promote(void)
747 : : {
748 : : int cnt;
749 : :
750 [ + - ]: 104 : for (cnt = 0; cnt < wait_seconds * WAITS_PER_SEC; cnt++)
751 : : {
752 : : pid_t pid;
753 : : DBState state;
754 : :
755 [ - + ]: 104 : if ((pid = get_pgpid(false)) == 0)
794 tgl@sss.pgh.pa.us 756 :UBC 0 : return false; /* pid file is gone */
540 peter@eisentraut.org 757 [ - + ]:CBC 104 : if (kill(pid, 0) != 0)
794 tgl@sss.pgh.pa.us 758 :UBC 0 : return false; /* postmaster died */
759 : :
794 tgl@sss.pgh.pa.us 760 :CBC 104 : state = get_control_dbstate();
761 [ + + ]: 104 : if (state == DB_IN_PRODUCTION)
762 : 37 : return true; /* successful promotion */
763 : :
764 [ + + ]: 67 : if (cnt % WAITS_PER_SEC == 0)
765 : 37 : print_msg(".");
766 : 67 : pg_usleep(USEC_PER_SEC / WAITS_PER_SEC);
767 : : }
794 tgl@sss.pgh.pa.us 768 :UBC 0 : return false; /* timeout reached */
769 : : }
770 : :
771 : :
772 : : #if defined(HAVE_GETRLIMIT)
773 : : static void
6309 andrew@dunslane.net 774 : 0 : unlimit_core_size(void)
775 : : {
776 : : struct rlimit lim;
777 : :
5995 bruce@momjian.us 778 : 0 : getrlimit(RLIMIT_CORE, &lim);
6309 andrew@dunslane.net 779 [ # # ]: 0 : if (lim.rlim_max == 0)
780 : : {
5995 bruce@momjian.us 781 : 0 : write_stderr(_("%s: cannot set core file size limit; disallowed by hard limit\n"),
782 : : progname);
783 : 0 : return;
784 : : }
6309 andrew@dunslane.net 785 [ # # # # ]: 0 : else if (lim.rlim_max == RLIM_INFINITY || lim.rlim_cur < lim.rlim_max)
786 : : {
787 : 0 : lim.rlim_cur = lim.rlim_max;
5995 bruce@momjian.us 788 : 0 : setrlimit(RLIMIT_CORE, &lim);
789 : : }
790 : : }
791 : : #endif
792 : :
793 : : static void
6131 magnus@hagander.net 794 :CBC 653 : read_post_opts(void)
795 : : {
7262 bruce@momjian.us 796 [ + + ]: 653 : if (post_opts == NULL)
797 : : {
5421 798 : 106 : post_opts = ""; /* default */
5771 799 [ + + ]: 106 : if (ctl_command == RESTART_COMMAND)
800 : : {
801 : : char **optlines;
802 : : int numlines;
803 : :
2482 tgl@sss.pgh.pa.us 804 : 97 : optlines = readfile(postopts_file, &numlines);
5771 bruce@momjian.us 805 [ - + ]: 97 : if (optlines == NULL)
806 : : {
7124 peter_e@gmx.net 807 :UBC 0 : write_stderr(_("%s: could not read file \"%s\"\n"), progname, postopts_file);
7262 bruce@momjian.us 808 : 0 : exit(1);
809 : : }
2482 tgl@sss.pgh.pa.us 810 [ - + ]:CBC 97 : else if (numlines != 1)
811 : : {
5771 bruce@momjian.us 812 :UBC 0 : write_stderr(_("%s: option file \"%s\" must have exactly one line\n"),
813 : : progname, postopts_file);
814 : 0 : exit(1);
815 : : }
816 : : else
817 : : {
818 : : char *optline;
819 : : char *arg1;
820 : :
5771 bruce@momjian.us 821 :CBC 97 : optline = optlines[0];
822 : :
823 : : /*
824 : : * Are we at the first option, as defined by space and
825 : : * double-quote?
826 : : */
827 [ + - ]: 97 : if ((arg1 = strstr(optline, " \"")) != NULL)
828 : : {
2489 tgl@sss.pgh.pa.us 829 : 97 : *arg1 = '\0'; /* terminate so we get only program name */
3631 bruce@momjian.us 830 : 97 : post_opts = pg_strdup(arg1 + 1); /* point past whitespace */
831 : : }
5239 peter_e@gmx.net 832 [ + - ]: 97 : if (exec_path == NULL)
3693 sfrost@snowman.net 833 : 97 : exec_path = pg_strdup(optline);
834 : : }
835 : :
836 : : /* Free the results of readfile. */
3697 837 : 97 : free_readfile(optlines);
838 : : }
839 : : }
6131 magnus@hagander.net 840 : 653 : }
841 : :
842 : : /*
843 : : * SIGINT signal handler used while waiting for postmaster to start up.
844 : : * Forwards the SIGINT to the postmaster process, asking it to shut down,
845 : : * before terminating pg_ctl itself. This way, if the user hits CTRL-C while
846 : : * waiting for the server to start up, the server launch is aborted.
847 : : */
848 : : static void
578 tgl@sss.pgh.pa.us 849 :UBC 0 : trap_sigint_during_startup(SIGNAL_ARGS)
850 : : {
1917 heikki.linnakangas@i 851 [ # # ]: 0 : if (postmasterPID != -1)
852 : : {
853 [ # # ]: 0 : if (kill(postmasterPID, SIGINT) != 0)
33 michael@paquier.xyz 854 :UNC 0 : write_stderr(_("%s: could not send stop signal (PID: %d): %m\n"),
855 : : progname, (int) postmasterPID);
856 : : }
857 : :
858 : : /*
859 : : * Clear the signal handler, and send the signal again, to terminate the
860 : : * process as normal.
861 : : */
578 tgl@sss.pgh.pa.us 862 :UBC 0 : pqsignal(postgres_signal_arg, SIG_DFL);
863 : 0 : raise(postgres_signal_arg);
1917 heikki.linnakangas@i 864 : 0 : }
865 : :
866 : : static char *
5239 peter_e@gmx.net 867 :CBC 557 : find_other_exec_or_die(const char *argv0, const char *target, const char *versionstr)
868 : : {
869 : : int ret;
870 : : char *found_path;
871 : :
872 : 557 : found_path = pg_malloc(MAXPGPATH);
873 : :
874 [ - + ]: 557 : if ((ret = find_other_exec(argv0, target, versionstr, found_path)) < 0)
875 : : {
876 : : char full_path[MAXPGPATH];
877 : :
5239 peter_e@gmx.net 878 [ # # ]:UBC 0 : if (find_my_exec(argv0, full_path) < 0)
879 : 0 : strlcpy(full_path, progname, sizeof(full_path));
880 : :
881 [ # # ]: 0 : if (ret == -1)
737 tgl@sss.pgh.pa.us 882 : 0 : write_stderr(_("program \"%s\" is needed by %s but was not found in the same directory as \"%s\"\n"),
883 : : target, progname, full_path);
884 : : else
885 : 0 : write_stderr(_("program \"%s\" was found by \"%s\" but was not the same version as %s\n"),
886 : : target, full_path, progname);
5239 peter_e@gmx.net 887 : 0 : exit(1);
888 : : }
889 : :
5239 peter_e@gmx.net 890 :CBC 557 : return found_path;
891 : : }
892 : :
893 : : static void
894 : 1 : do_init(void)
895 : : {
896 : : char *cmd;
897 : :
898 [ + - ]: 1 : if (exec_path == NULL)
899 : 1 : exec_path = find_other_exec_or_die(argv0, "initdb", "initdb (PostgreSQL) " PG_VERSION "\n");
900 : :
5234 itagaki.takahiro@gma 901 [ - + ]: 1 : if (pgdata_opt == NULL)
5234 itagaki.takahiro@gma 902 :UBC 0 : pgdata_opt = "";
903 : :
5239 peter_e@gmx.net 904 [ - + ]:CBC 1 : if (post_opts == NULL)
5239 peter_e@gmx.net 905 :UBC 0 : post_opts = "";
906 : :
5239 peter_e@gmx.net 907 [ + - ]:CBC 1 : if (!silent_mode)
954 tgl@sss.pgh.pa.us 908 : 1 : cmd = psprintf("\"%s\" %s%s",
909 : : exec_path, pgdata_opt, post_opts);
910 : : else
954 tgl@sss.pgh.pa.us 911 :UBC 0 : cmd = psprintf("\"%s\" %s%s > \"%s\"",
912 : : exec_path, pgdata_opt, post_opts, DEVNULL);
913 : :
594 tgl@sss.pgh.pa.us 914 :CBC 1 : fflush(NULL);
5239 peter_e@gmx.net 915 [ - + ]: 1 : if (system(cmd) != 0)
916 : : {
5239 peter_e@gmx.net 917 :UBC 0 : write_stderr(_("%s: database system initialization failed\n"), progname);
918 : 0 : exit(1);
919 : : }
5239 peter_e@gmx.net 920 :CBC 1 : }
921 : :
922 : : static void
6131 magnus@hagander.net 923 : 654 : do_start(void)
924 : : {
540 peter@eisentraut.org 925 : 654 : pid_t old_pid = 0;
926 : : pid_t pm_pid;
927 : :
6131 magnus@hagander.net 928 [ + + ]: 654 : if (ctl_command != RESTART_COMMAND)
929 : : {
1645 tgl@sss.pgh.pa.us 930 : 557 : old_pid = get_pgpid(false);
931 [ + + ]: 556 : if (old_pid != 0)
4003 peter_e@gmx.net 932 : 3 : write_stderr(_("%s: another server might be running; "
933 : : "trying to start server anyway\n"),
934 : : progname);
935 : : }
936 : :
6131 magnus@hagander.net 937 : 653 : read_post_opts();
938 : :
939 : : /* No -D or -D already added during server start */
7169 bruce@momjian.us 940 [ + + - + ]: 653 : if (ctl_command == RESTART_COMMAND || pgdata_opt == NULL)
7168 941 : 97 : pgdata_opt = "";
942 : :
5239 peter_e@gmx.net 943 [ + + ]: 653 : if (exec_path == NULL)
944 : 556 : exec_path = find_other_exec_or_die(argv0, "postgres", PG_BACKEND_VERSIONSTR);
945 : :
946 : : #if defined(HAVE_GETRLIMIT)
6309 andrew@dunslane.net 947 [ - + ]: 653 : if (allow_core_files)
6309 andrew@dunslane.net 948 :UBC 0 : unlimit_core_size();
949 : : #endif
950 : :
951 : : /*
952 : : * If possible, tell the postmaster our parent shell's PID (see the
953 : : * comments in CreateLockFile() for motivation). Windows hasn't got
954 : : * getppid() unfortunately.
955 : : */
956 : : #ifndef WIN32
957 : : {
958 : : char env_var[32];
959 : :
1201 tgl@sss.pgh.pa.us 960 :CBC 653 : snprintf(env_var, sizeof(env_var), "%d", (int) getppid());
961 : 653 : setenv("PG_GRANDPARENT_PID", env_var, 1);
962 : : }
963 : : #endif
964 : :
3107 965 : 653 : pm_pid = start_postmaster();
966 : :
7262 bruce@momjian.us 967 [ + - ]: 653 : if (do_wait)
968 : : {
969 : : /*
970 : : * If the user interrupts the startup (e.g. with CTRL-C), we'd like to
971 : : * abort the server launch. Install a signal handler that will
972 : : * forward SIGINT to the postmaster process, while we wait.
973 : : *
974 : : * (We don't bother to reset the signal handler after the launch, as
975 : : * we're about to exit, anyway.)
976 : : */
1917 heikki.linnakangas@i 977 : 653 : postmasterPID = pm_pid;
978 : 653 : pqsignal(SIGINT, trap_sigint_during_startup);
979 : :
6510 peter_e@gmx.net 980 : 653 : print_msg(_("waiting for server to start..."));
981 : :
794 tgl@sss.pgh.pa.us 982 [ + - + - ]: 653 : switch (wait_for_postmaster_start(pm_pid, false))
983 : : {
2482 984 : 646 : case POSTMASTER_READY:
4887 985 : 646 : print_msg(_(" done\n"));
986 : 646 : print_msg(_("server started\n"));
987 : 646 : break;
2482 tgl@sss.pgh.pa.us 988 :UBC 0 : case POSTMASTER_STILL_STARTING:
4887 989 : 0 : print_msg(_(" stopped waiting\n"));
2540 peter_e@gmx.net 990 : 0 : write_stderr(_("%s: server did not start in time\n"),
991 : : progname);
992 : 0 : exit(1);
993 : : break;
2482 tgl@sss.pgh.pa.us 994 :CBC 7 : case POSTMASTER_FAILED:
4887 995 : 7 : print_msg(_(" stopped waiting\n"));
996 : 7 : write_stderr(_("%s: could not start server\n"
997 : : "Examine the log output.\n"),
998 : : progname);
999 : 7 : exit(1);
1000 : : break;
1001 : : }
1002 : : }
1003 : : else
6510 peter_e@gmx.net 1004 :UBC 0 : print_msg(_("server starting\n"));
1005 : :
1006 : : #ifdef WIN32
1007 : : /* Now we don't need the handle to the shell process anymore */
1008 : : CloseHandle(postmasterProcess);
1009 : : postmasterProcess = INVALID_HANDLE_VALUE;
1010 : : #endif
7262 bruce@momjian.us 1011 :CBC 646 : }
1012 : :
1013 : :
1014 : : static void
1015 : 632 : do_stop(void)
1016 : : {
1017 : : pid_t pid;
1018 : :
3690 1019 : 632 : pid = get_pgpid(false);
1020 : :
7262 1021 [ + + ]: 632 : if (pid == 0) /* no pid file */
1022 : : {
7124 peter_e@gmx.net 1023 : 1 : write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
6510 1024 : 1 : write_stderr(_("Is server running?\n"));
7262 bruce@momjian.us 1025 : 1 : exit(1);
1026 : : }
1027 [ - + ]: 631 : else if (pid < 0) /* standalone backend, not postmaster */
1028 : : {
7262 bruce@momjian.us 1029 :UBC 0 : pid = -pid;
6510 peter_e@gmx.net 1030 : 0 : write_stderr(_("%s: cannot stop server; "
1031 : : "single-user server is running (PID: %d)\n"),
1032 : : progname, (int) pid);
7262 bruce@momjian.us 1033 : 0 : exit(1);
1034 : : }
1035 : :
540 peter@eisentraut.org 1036 [ - + ]:CBC 631 : if (kill(pid, sig) != 0)
1037 : : {
33 michael@paquier.xyz 1038 :UNC 0 : write_stderr(_("%s: could not send stop signal (PID: %d): %m\n"), progname, (int) pid);
7262 bruce@momjian.us 1039 :UBC 0 : exit(1);
1040 : : }
1041 : :
7262 bruce@momjian.us 1042 [ - + ]:CBC 631 : if (!do_wait)
1043 : : {
6510 peter_e@gmx.net 1044 :UBC 0 : print_msg(_("server shutting down\n"));
7262 bruce@momjian.us 1045 : 0 : return;
1046 : : }
1047 : : else
1048 : : {
2986 tgl@sss.pgh.pa.us 1049 :CBC 631 : print_msg(_("waiting for server to shut down..."));
1050 : :
794 1051 [ - + ]: 631 : if (!wait_for_postmaster_stop())
1052 : : {
7121 neilc@samurai.com 1053 :UBC 0 : print_msg(_(" failed\n"));
1054 : :
2986 tgl@sss.pgh.pa.us 1055 : 0 : write_stderr(_("%s: server does not shut down\n"), progname);
4784 bruce@momjian.us 1056 [ # # ]: 0 : if (shutdown_mode == SMART_MODE)
4783 1057 : 0 : write_stderr(_("HINT: The \"-m fast\" option immediately disconnects sessions rather than\n"
1058 : : "waiting for session-initiated disconnection.\n"));
7262 1059 : 0 : exit(1);
1060 : : }
7121 neilc@samurai.com 1061 :CBC 631 : print_msg(_(" done\n"));
1062 : :
5168 peter_e@gmx.net 1063 : 631 : print_msg(_("server stopped\n"));
1064 : : }
1065 : : }
1066 : :
1067 : :
1068 : : /*
1069 : : * restart/reload routines
1070 : : */
1071 : :
1072 : : static void
7262 bruce@momjian.us 1073 : 97 : do_restart(void)
1074 : : {
1075 : : pid_t pid;
1076 : :
3690 1077 : 97 : pid = get_pgpid(false);
1078 : :
7262 1079 [ + + ]: 97 : if (pid == 0) /* no pid file */
1080 : : {
6920 tgl@sss.pgh.pa.us 1081 : 3 : write_stderr(_("%s: PID file \"%s\" does not exist\n"),
1082 : : progname, pid_file);
6510 peter_e@gmx.net 1083 : 3 : write_stderr(_("Is server running?\n"));
2355 1084 : 3 : write_stderr(_("trying to start server anyway\n"));
7262 bruce@momjian.us 1085 : 3 : do_start();
1086 : 3 : return;
1087 : : }
1088 [ - + ]: 94 : else if (pid < 0) /* standalone backend, not postmaster */
1089 : : {
7262 bruce@momjian.us 1090 :UBC 0 : pid = -pid;
540 peter@eisentraut.org 1091 [ # # ]: 0 : if (postmaster_is_alive(pid))
1092 : : {
6510 peter_e@gmx.net 1093 : 0 : write_stderr(_("%s: cannot restart server; "
1094 : : "single-user server is running (PID: %d)\n"),
1095 : : progname, (int) pid);
1096 : 0 : write_stderr(_("Please terminate the single-user server and try again.\n"));
6920 tgl@sss.pgh.pa.us 1097 : 0 : exit(1);
1098 : : }
1099 : : }
1100 : :
540 peter@eisentraut.org 1101 [ + - ]:CBC 94 : if (postmaster_is_alive(pid))
1102 : : {
1103 [ - + ]: 94 : if (kill(pid, sig) != 0)
1104 : : {
33 michael@paquier.xyz 1105 :UNC 0 : write_stderr(_("%s: could not send stop signal (PID: %d): %m\n"), progname, (int) pid);
6920 tgl@sss.pgh.pa.us 1106 :UBC 0 : exit(1);
1107 : : }
1108 : :
6510 peter_e@gmx.net 1109 :CBC 94 : print_msg(_("waiting for server to shut down..."));
1110 : :
1111 : : /* always wait for restart */
794 tgl@sss.pgh.pa.us 1112 [ - + ]: 94 : if (!wait_for_postmaster_stop())
1113 : : {
6920 tgl@sss.pgh.pa.us 1114 :UBC 0 : print_msg(_(" failed\n"));
1115 : :
6510 peter_e@gmx.net 1116 : 0 : write_stderr(_("%s: server does not shut down\n"), progname);
4784 bruce@momjian.us 1117 [ # # ]: 0 : if (shutdown_mode == SMART_MODE)
4783 1118 : 0 : write_stderr(_("HINT: The \"-m fast\" option immediately disconnects sessions rather than\n"
1119 : : "waiting for session-initiated disconnection.\n"));
6920 tgl@sss.pgh.pa.us 1120 : 0 : exit(1);
1121 : : }
1122 : :
6920 tgl@sss.pgh.pa.us 1123 :CBC 94 : print_msg(_(" done\n"));
5168 peter_e@gmx.net 1124 : 94 : print_msg(_("server stopped\n"));
1125 : : }
1126 : : else
1127 : : {
540 peter@eisentraut.org 1128 :UBC 0 : write_stderr(_("%s: old server process (PID: %d) seems to be gone\n"),
1129 : : progname, (int) pid);
6510 peter_e@gmx.net 1130 : 0 : write_stderr(_("starting server anyway\n"));
1131 : : }
1132 : :
7262 bruce@momjian.us 1133 :CBC 94 : do_start();
1134 : : }
1135 : :
1136 : : static void
4694 peter_e@gmx.net 1137 : 110 : do_reload(void)
1138 : : {
1139 : : pid_t pid;
1140 : :
3690 bruce@momjian.us 1141 : 110 : pid = get_pgpid(false);
4694 peter_e@gmx.net 1142 [ - + ]: 110 : if (pid == 0) /* no pid file */
1143 : : {
4694 peter_e@gmx.net 1144 :UBC 0 : write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
1145 : 0 : write_stderr(_("Is server running?\n"));
1146 : 0 : exit(1);
1147 : : }
4694 peter_e@gmx.net 1148 [ - + ]:CBC 110 : else if (pid < 0) /* standalone backend, not postmaster */
1149 : : {
4694 peter_e@gmx.net 1150 :UBC 0 : pid = -pid;
1151 : 0 : write_stderr(_("%s: cannot reload server; "
1152 : : "single-user server is running (PID: %d)\n"),
1153 : : progname, (int) pid);
1154 : 0 : write_stderr(_("Please terminate the single-user server and try again.\n"));
1155 : 0 : exit(1);
1156 : : }
1157 : :
540 peter@eisentraut.org 1158 [ - + ]:CBC 110 : if (kill(pid, sig) != 0)
1159 : : {
33 michael@paquier.xyz 1160 :UNC 0 : write_stderr(_("%s: could not send reload signal (PID: %d): %m\n"),
1161 : : progname, (int) pid);
4694 peter_e@gmx.net 1162 :UBC 0 : exit(1);
1163 : : }
1164 : :
4694 peter_e@gmx.net 1165 :CBC 110 : print_msg(_("server signaled\n"));
1166 : 110 : }
1167 : :
1168 : :
1169 : : /*
1170 : : * promote
1171 : : */
1172 : :
1173 : : static void
4807 rhaas@postgresql.org 1174 : 41 : do_promote(void)
1175 : : {
1176 : : FILE *prmfile;
1177 : : pid_t pid;
1178 : :
3690 bruce@momjian.us 1179 : 41 : pid = get_pgpid(false);
1180 : :
4807 rhaas@postgresql.org 1181 [ + + ]: 40 : if (pid == 0) /* no pid file */
1182 : : {
1183 : 1 : write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
1184 : 1 : write_stderr(_("Is server running?\n"));
1185 : 1 : exit(1);
1186 : : }
1187 [ - + ]: 39 : else if (pid < 0) /* standalone backend, not postmaster */
1188 : : {
4807 rhaas@postgresql.org 1189 :UBC 0 : pid = -pid;
1190 : 0 : write_stderr(_("%s: cannot promote server; "
1191 : : "single-user server is running (PID: %d)\n"),
1192 : : progname, (int) pid);
1193 : 0 : exit(1);
1194 : : }
1195 : :
2819 peter_e@gmx.net 1196 [ + + ]:CBC 39 : if (get_control_dbstate() != DB_IN_ARCHIVE_RECOVERY)
1197 : : {
4807 rhaas@postgresql.org 1198 : 1 : write_stderr(_("%s: cannot promote server; "
1199 : : "server is not in standby mode\n"),
1200 : : progname);
1201 : 1 : exit(1);
1202 : : }
1203 : :
3891 heikki.linnakangas@i 1204 : 38 : snprintf(promote_file, MAXPGPATH, "%s/promote", pg_data);
1205 : :
4807 rhaas@postgresql.org 1206 [ - + ]: 38 : if ((prmfile = fopen(promote_file, "w")) == NULL)
1207 : : {
33 michael@paquier.xyz 1208 :UNC 0 : write_stderr(_("%s: could not create promote signal file \"%s\": %m\n"),
1209 : : progname, promote_file);
4807 rhaas@postgresql.org 1210 :UBC 0 : exit(1);
1211 : : }
4807 rhaas@postgresql.org 1212 [ - + ]:CBC 38 : if (fclose(prmfile))
1213 : : {
33 michael@paquier.xyz 1214 :UNC 0 : write_stderr(_("%s: could not write promote signal file \"%s\": %m\n"),
1215 : : progname, promote_file);
4807 rhaas@postgresql.org 1216 :UBC 0 : exit(1);
1217 : : }
1218 : :
4807 rhaas@postgresql.org 1219 :CBC 38 : sig = SIGUSR1;
540 peter@eisentraut.org 1220 [ - + ]: 38 : if (kill(pid, sig) != 0)
1221 : : {
33 michael@paquier.xyz 1222 :UNC 0 : write_stderr(_("%s: could not send promote signal (PID: %d): %m\n"),
1223 : : progname, (int) pid);
4807 rhaas@postgresql.org 1224 [ # # ]:UBC 0 : if (unlink(promote_file) != 0)
33 michael@paquier.xyz 1225 :UNC 0 : write_stderr(_("%s: could not remove promote signal file \"%s\": %m\n"),
1226 : : progname, promote_file);
4807 rhaas@postgresql.org 1227 :UBC 0 : exit(1);
1228 : : }
1229 : :
2809 peter_e@gmx.net 1230 [ + + ]:CBC 38 : if (do_wait)
1231 : : {
1232 : 37 : print_msg(_("waiting for server to promote..."));
794 tgl@sss.pgh.pa.us 1233 [ + - ]: 37 : if (wait_for_postmaster_promote())
1234 : : {
2809 peter_e@gmx.net 1235 : 37 : print_msg(_(" done\n"));
1236 : 37 : print_msg(_("server promoted\n"));
1237 : : }
1238 : : else
1239 : : {
2809 peter_e@gmx.net 1240 :UBC 0 : print_msg(_(" stopped waiting\n"));
2540 1241 : 0 : write_stderr(_("%s: server did not promote in time\n"),
1242 : : progname);
1243 : 0 : exit(1);
1244 : : }
1245 : : }
1246 : : else
2809 peter_e@gmx.net 1247 :CBC 1 : print_msg(_("server promoting\n"));
4807 rhaas@postgresql.org 1248 : 38 : }
1249 : :
1250 : : /*
1251 : : * log rotate
1252 : : */
1253 : :
1254 : : static void
2052 akorotkov@postgresql 1255 : 1 : do_logrotate(void)
1256 : : {
1257 : : FILE *logrotatefile;
1258 : : pid_t pid;
1259 : :
1260 : 1 : pid = get_pgpid(false);
1261 : :
1262 [ - + ]: 1 : if (pid == 0) /* no pid file */
1263 : : {
2052 akorotkov@postgresql 1264 :UBC 0 : write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
1265 : 0 : write_stderr(_("Is server running?\n"));
1266 : 0 : exit(1);
1267 : : }
2052 akorotkov@postgresql 1268 [ - + ]:CBC 1 : else if (pid < 0) /* standalone backend, not postmaster */
1269 : : {
2052 akorotkov@postgresql 1270 :UBC 0 : pid = -pid;
1271 : 0 : write_stderr(_("%s: cannot rotate log file; "
1272 : : "single-user server is running (PID: %d)\n"),
1273 : : progname, (int) pid);
1274 : 0 : exit(1);
1275 : : }
1276 : :
2052 akorotkov@postgresql 1277 :CBC 1 : snprintf(logrotate_file, MAXPGPATH, "%s/logrotate", pg_data);
1278 : :
1279 [ - + ]: 1 : if ((logrotatefile = fopen(logrotate_file, "w")) == NULL)
1280 : : {
33 michael@paquier.xyz 1281 :UNC 0 : write_stderr(_("%s: could not create log rotation signal file \"%s\": %m\n"),
1282 : : progname, logrotate_file);
2052 akorotkov@postgresql 1283 :UBC 0 : exit(1);
1284 : : }
2052 akorotkov@postgresql 1285 [ - + ]:CBC 1 : if (fclose(logrotatefile))
1286 : : {
33 michael@paquier.xyz 1287 :UNC 0 : write_stderr(_("%s: could not write log rotation signal file \"%s\": %m\n"),
1288 : : progname, logrotate_file);
2052 akorotkov@postgresql 1289 :UBC 0 : exit(1);
1290 : : }
1291 : :
2052 akorotkov@postgresql 1292 :CBC 1 : sig = SIGUSR1;
540 peter@eisentraut.org 1293 [ - + ]: 1 : if (kill(pid, sig) != 0)
1294 : : {
33 michael@paquier.xyz 1295 :UNC 0 : write_stderr(_("%s: could not send log rotation signal (PID: %d): %m\n"),
1296 : : progname, (int) pid);
2052 akorotkov@postgresql 1297 [ # # ]:UBC 0 : if (unlink(logrotate_file) != 0)
33 michael@paquier.xyz 1298 :UNC 0 : write_stderr(_("%s: could not remove log rotation signal file \"%s\": %m\n"),
1299 : : progname, logrotate_file);
2052 akorotkov@postgresql 1300 :UBC 0 : exit(1);
1301 : : }
1302 : :
2052 akorotkov@postgresql 1303 :CBC 1 : print_msg(_("server signaled to rotate log file\n"));
1304 : 1 : }
1305 : :
1306 : :
1307 : : /*
1308 : : * utility routines
1309 : : */
1310 : :
1311 : : static bool
6934 tgl@sss.pgh.pa.us 1312 : 95 : postmaster_is_alive(pid_t pid)
1313 : : {
1314 : : /*
1315 : : * Test to see if the process is still there. Note that we do not
1316 : : * consider an EPERM failure to mean that the process is still there;
1317 : : * EPERM must mean that the given PID belongs to some other userid, and
1318 : : * considering the permissions on $PGDATA, that means it's not the
1319 : : * postmaster we are after.
1320 : : *
1321 : : * Don't believe that our own PID or parent shell's PID is the postmaster,
1322 : : * either. (Windows hasn't got getppid(), though.)
1323 : : */
1324 [ - + ]: 95 : if (pid == getpid())
6934 tgl@sss.pgh.pa.us 1325 :UBC 0 : return false;
1326 : : #ifndef WIN32
6934 tgl@sss.pgh.pa.us 1327 [ - + ]:CBC 95 : if (pid == getppid())
6934 tgl@sss.pgh.pa.us 1328 :UBC 0 : return false;
1329 : : #endif
6934 tgl@sss.pgh.pa.us 1330 [ + - ]:CBC 95 : if (kill(pid, 0) == 0)
1331 : 95 : return true;
6934 tgl@sss.pgh.pa.us 1332 :UBC 0 : return false;
1333 : : }
1334 : :
1335 : : static void
7262 bruce@momjian.us 1336 :CBC 3 : do_status(void)
1337 : : {
1338 : : pid_t pid;
1339 : :
3690 1340 : 3 : pid = get_pgpid(true);
1341 : : /* Is there a pid file? */
4567 1342 [ + + ]: 2 : if (pid != 0)
1343 : : {
1344 : : /* standalone backend? */
1345 [ - + ]: 1 : if (pid < 0)
1346 : : {
6934 tgl@sss.pgh.pa.us 1347 :UBC 0 : pid = -pid;
540 peter@eisentraut.org 1348 [ # # ]: 0 : if (postmaster_is_alive(pid))
1349 : : {
1350 : 0 : printf(_("%s: single-user server is running (PID: %d)\n"),
1351 : : progname, (int) pid);
6934 tgl@sss.pgh.pa.us 1352 : 0 : return;
1353 : : }
1354 : : }
1355 : : else
1356 : : /* must be a postmaster */
1357 : : {
540 peter@eisentraut.org 1358 [ + - ]:CBC 1 : if (postmaster_is_alive(pid))
1359 : : {
1360 : : char **optlines;
1361 : : char **curr_line;
1362 : : int numlines;
1363 : :
1364 : 1 : printf(_("%s: server is running (PID: %d)\n"),
1365 : : progname, (int) pid);
1366 : :
2482 tgl@sss.pgh.pa.us 1367 : 1 : optlines = readfile(postopts_file, &numlines);
6934 1368 [ + - ]: 1 : if (optlines != NULL)
1369 : : {
3693 sfrost@snowman.net 1370 [ + + ]: 2 : for (curr_line = optlines; *curr_line != NULL; curr_line++)
2482 tgl@sss.pgh.pa.us 1371 : 1 : puts(*curr_line);
1372 : :
1373 : : /* Free the results of readfile */
3697 sfrost@snowman.net 1374 : 1 : free_readfile(optlines);
1375 : : }
6934 tgl@sss.pgh.pa.us 1376 : 1 : return;
1377 : : }
1378 : : }
1379 : : }
6510 peter_e@gmx.net 1380 : 1 : printf(_("%s: no server running\n"), progname);
1381 : :
1382 : : /*
1383 : : * The Linux Standard Base Core Specification 3.1 says this should return
1384 : : * '3, program is not running'
1385 : : * https://refspecs.linuxbase.org/LSB_3.1.0/LSB-Core-generic/LSB-Core-generic/iniscrptact.html
1386 : : */
4567 bruce@momjian.us 1387 : 1 : exit(3);
1388 : : }
1389 : :
1390 : :
1391 : :
1392 : : static void
540 peter@eisentraut.org 1393 : 6 : do_kill(pid_t pid)
1394 : : {
1395 [ - + ]: 6 : if (kill(pid, sig) != 0)
1396 : : {
33 michael@paquier.xyz 1397 :UNC 0 : write_stderr(_("%s: could not send signal %d (PID: %d): %m\n"),
1398 : : progname, sig, (int) pid);
7262 bruce@momjian.us 1399 :UBC 0 : exit(1);
1400 : : }
7262 bruce@momjian.us 1401 :CBC 6 : }
1402 : :
1403 : : #ifdef WIN32
1404 : :
1405 : : static bool
1406 : : pgwin32_IsInstalled(SC_HANDLE hSCM)
1407 : : {
1408 : : SC_HANDLE hService = OpenService(hSCM, register_servicename, SERVICE_QUERY_CONFIG);
1409 : : bool bResult = (hService != NULL);
1410 : :
1411 : : if (bResult)
1412 : : CloseServiceHandle(hService);
1413 : : return bResult;
1414 : : }
1415 : :
1416 : : static char *
1417 : : pgwin32_CommandLine(bool registration)
1418 : : {
1419 : : PQExpBuffer cmdLine = createPQExpBuffer();
1420 : : char cmdPath[MAXPGPATH];
1421 : : int ret;
1422 : :
1423 : : if (registration)
1424 : : {
1425 : : ret = find_my_exec(argv0, cmdPath);
1426 : : if (ret != 0)
1427 : : {
1428 : : write_stderr(_("%s: could not find own program executable\n"), progname);
1429 : : exit(1);
1430 : : }
1431 : : }
1432 : : else
1433 : : {
1434 : : ret = find_other_exec(argv0, "postgres", PG_BACKEND_VERSIONSTR,
1435 : : cmdPath);
1436 : : if (ret != 0)
1437 : : {
1438 : : write_stderr(_("%s: could not find postgres program executable\n"), progname);
1439 : : exit(1);
1440 : : }
1441 : : }
1442 : :
1443 : : /* if path does not end in .exe, append it */
1444 : : if (strlen(cmdPath) < 4 ||
1445 : : pg_strcasecmp(cmdPath + strlen(cmdPath) - 4, ".exe") != 0)
1446 : : snprintf(cmdPath + strlen(cmdPath), sizeof(cmdPath) - strlen(cmdPath),
1447 : : ".exe");
1448 : :
1449 : : /* use backslashes in path to avoid problems with some third-party tools */
1450 : : make_native_path(cmdPath);
1451 : :
1452 : : /* be sure to double-quote the executable's name in the command */
1453 : : appendPQExpBuffer(cmdLine, "\"%s\"", cmdPath);
1454 : :
1455 : : /* append assorted switches to the command line, as needed */
1456 : :
1457 : : if (registration)
1458 : : appendPQExpBuffer(cmdLine, " runservice -N \"%s\"",
1459 : : register_servicename);
1460 : :
1461 : : if (pg_config)
1462 : : {
1463 : : /* We need the -D path to be absolute */
1464 : : char *dataDir;
1465 : :
1466 : : if ((dataDir = make_absolute_path(pg_config)) == NULL)
1467 : : {
1468 : : /* make_absolute_path already reported the error */
1469 : : exit(1);
1470 : : }
1471 : : make_native_path(dataDir);
1472 : : appendPQExpBuffer(cmdLine, " -D \"%s\"", dataDir);
1473 : : free(dataDir);
1474 : : }
1475 : :
1476 : : if (registration && event_source != NULL)
1477 : : appendPQExpBuffer(cmdLine, " -e \"%s\"", event_source);
1478 : :
1479 : : if (registration && do_wait)
1480 : : appendPQExpBufferStr(cmdLine, " -w");
1481 : :
1482 : : /* Don't propagate a value from an environment variable. */
1483 : : if (registration && wait_seconds_arg && wait_seconds != DEFAULT_WAIT)
1484 : : appendPQExpBuffer(cmdLine, " -t %d", wait_seconds);
1485 : :
1486 : : if (registration && silent_mode)
1487 : : appendPQExpBufferStr(cmdLine, " -s");
1488 : :
1489 : : if (post_opts)
1490 : : {
1491 : : if (registration)
1492 : : appendPQExpBuffer(cmdLine, " -o \"%s\"", post_opts);
1493 : : else
1494 : : appendPQExpBuffer(cmdLine, " %s", post_opts);
1495 : : }
1496 : :
1497 : : return cmdLine->data;
1498 : : }
1499 : :
1500 : : static void
1501 : : pgwin32_doRegister(void)
1502 : : {
1503 : : SC_HANDLE hService;
1504 : : SC_HANDLE hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
1505 : :
1506 : : if (hSCM == NULL)
1507 : : {
1508 : : write_stderr(_("%s: could not open service manager\n"), progname);
1509 : : exit(1);
1510 : : }
1511 : : if (pgwin32_IsInstalled(hSCM))
1512 : : {
1513 : : CloseServiceHandle(hSCM);
1514 : : write_stderr(_("%s: service \"%s\" already registered\n"), progname, register_servicename);
1515 : : exit(1);
1516 : : }
1517 : :
1518 : : if ((hService = CreateService(hSCM, register_servicename, register_servicename,
1519 : : SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
1520 : : pgctl_start_type, SERVICE_ERROR_NORMAL,
1521 : : pgwin32_CommandLine(true),
1522 : : NULL, NULL, "RPCSS\0", register_username, register_password)) == NULL)
1523 : : {
1524 : : CloseServiceHandle(hSCM);
1525 : : write_stderr(_("%s: could not register service \"%s\": error code %lu\n"),
1526 : : progname, register_servicename,
1527 : : (unsigned long) GetLastError());
1528 : : exit(1);
1529 : : }
1530 : : CloseServiceHandle(hService);
1531 : : CloseServiceHandle(hSCM);
1532 : : }
1533 : :
1534 : : static void
1535 : : pgwin32_doUnregister(void)
1536 : : {
1537 : : SC_HANDLE hService;
1538 : : SC_HANDLE hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
1539 : :
1540 : : if (hSCM == NULL)
1541 : : {
1542 : : write_stderr(_("%s: could not open service manager\n"), progname);
1543 : : exit(1);
1544 : : }
1545 : : if (!pgwin32_IsInstalled(hSCM))
1546 : : {
1547 : : CloseServiceHandle(hSCM);
1548 : : write_stderr(_("%s: service \"%s\" not registered\n"), progname, register_servicename);
1549 : : exit(1);
1550 : : }
1551 : :
1552 : : if ((hService = OpenService(hSCM, register_servicename, DELETE)) == NULL)
1553 : : {
1554 : : CloseServiceHandle(hSCM);
1555 : : write_stderr(_("%s: could not open service \"%s\": error code %lu\n"),
1556 : : progname, register_servicename,
1557 : : (unsigned long) GetLastError());
1558 : : exit(1);
1559 : : }
1560 : : if (!DeleteService(hService))
1561 : : {
1562 : : CloseServiceHandle(hService);
1563 : : CloseServiceHandle(hSCM);
1564 : : write_stderr(_("%s: could not unregister service \"%s\": error code %lu\n"),
1565 : : progname, register_servicename,
1566 : : (unsigned long) GetLastError());
1567 : : exit(1);
1568 : : }
1569 : : CloseServiceHandle(hService);
1570 : : CloseServiceHandle(hSCM);
1571 : : }
1572 : :
1573 : : static void
1574 : : pgwin32_SetServiceStatus(DWORD currentState)
1575 : : {
1576 : : status.dwCurrentState = currentState;
1577 : : SetServiceStatus(hStatus, (LPSERVICE_STATUS) &status);
1578 : : }
1579 : :
1580 : : static void WINAPI
1581 : : pgwin32_ServiceHandler(DWORD request)
1582 : : {
1583 : : switch (request)
1584 : : {
1585 : : case SERVICE_CONTROL_STOP:
1586 : : case SERVICE_CONTROL_SHUTDOWN:
1587 : :
1588 : : /*
1589 : : * We only need a short wait hint here as it just needs to wait
1590 : : * for the next checkpoint. They occur every 5 seconds during
1591 : : * shutdown
1592 : : */
1593 : : status.dwWaitHint = 10000;
1594 : : pgwin32_SetServiceStatus(SERVICE_STOP_PENDING);
1595 : : SetEvent(shutdownEvent);
1596 : : return;
1597 : :
1598 : : case SERVICE_CONTROL_PAUSE:
1599 : : /* Win32 config reloading */
1600 : : status.dwWaitHint = 5000;
1601 : : kill(postmasterPID, SIGHUP);
1602 : : return;
1603 : :
1604 : : /* FIXME: These could be used to replace other signals etc */
1605 : : case SERVICE_CONTROL_CONTINUE:
1606 : : case SERVICE_CONTROL_INTERROGATE:
1607 : : default:
1608 : : break;
1609 : : }
1610 : : }
1611 : :
1612 : : static void WINAPI
1613 : : pgwin32_ServiceMain(DWORD argc, LPTSTR *argv)
1614 : : {
1615 : : PROCESS_INFORMATION pi;
1616 : : DWORD ret;
1617 : :
1618 : : /* Initialize variables */
1619 : : status.dwWin32ExitCode = S_OK;
1620 : : status.dwCheckPoint = 0;
1621 : : status.dwWaitHint = 60000;
1622 : : status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
1623 : : status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN | SERVICE_ACCEPT_PAUSE_CONTINUE;
1624 : : status.dwServiceSpecificExitCode = 0;
1625 : : status.dwCurrentState = SERVICE_START_PENDING;
1626 : :
1627 : : memset(&pi, 0, sizeof(pi));
1628 : :
1629 : : read_post_opts();
1630 : :
1631 : : /* Register the control request handler */
1632 : : if ((hStatus = RegisterServiceCtrlHandler(register_servicename, pgwin32_ServiceHandler)) == (SERVICE_STATUS_HANDLE) 0)
1633 : : return;
1634 : :
1635 : : if ((shutdownEvent = CreateEvent(NULL, true, false, NULL)) == NULL)
1636 : : return;
1637 : :
1638 : : /* Start the postmaster */
1639 : : pgwin32_SetServiceStatus(SERVICE_START_PENDING);
1640 : : if (!CreateRestrictedProcess(pgwin32_CommandLine(false), &pi, true))
1641 : : {
1642 : : pgwin32_SetServiceStatus(SERVICE_STOPPED);
1643 : : return;
1644 : : }
1645 : : postmasterPID = pi.dwProcessId;
1646 : : postmasterProcess = pi.hProcess;
1647 : : CloseHandle(pi.hThread);
1648 : :
1649 : : if (do_wait)
1650 : : {
1651 : : write_eventlog(EVENTLOG_INFORMATION_TYPE, _("Waiting for server startup...\n"));
1652 : : if (wait_for_postmaster_start(postmasterPID, true) != POSTMASTER_READY)
1653 : : {
1654 : : write_eventlog(EVENTLOG_ERROR_TYPE, _("Timed out waiting for server startup\n"));
1655 : : pgwin32_SetServiceStatus(SERVICE_STOPPED);
1656 : : return;
1657 : : }
1658 : : write_eventlog(EVENTLOG_INFORMATION_TYPE, _("Server started and accepting connections\n"));
1659 : : }
1660 : :
1661 : : pgwin32_SetServiceStatus(SERVICE_RUNNING);
1662 : :
1663 : : /* Wait for quit... */
1664 : : ret = WaitForMultipleObjects(2, shutdownHandles, FALSE, INFINITE);
1665 : :
1666 : : pgwin32_SetServiceStatus(SERVICE_STOP_PENDING);
1667 : : switch (ret)
1668 : : {
1669 : : case WAIT_OBJECT_0: /* shutdown event */
1670 : : {
1671 : : /*
1672 : : * status.dwCheckPoint can be incremented by
1673 : : * wait_for_postmaster_start(), so it might not start from 0.
1674 : : */
1675 : : int maxShutdownCheckPoint = status.dwCheckPoint + 12;
1676 : :
1677 : : kill(postmasterPID, SIGINT);
1678 : :
1679 : : /*
1680 : : * Increment the checkpoint and try again. Abort after 12
1681 : : * checkpoints as the postmaster has probably hung.
1682 : : */
1683 : : while (WaitForSingleObject(postmasterProcess, 5000) == WAIT_TIMEOUT && status.dwCheckPoint < maxShutdownCheckPoint)
1684 : : {
1685 : : status.dwCheckPoint++;
1686 : : SetServiceStatus(hStatus, (LPSERVICE_STATUS) &status);
1687 : : }
1688 : : break;
1689 : : }
1690 : :
1691 : : case (WAIT_OBJECT_0 + 1): /* postmaster went down */
1692 : : break;
1693 : :
1694 : : default:
1695 : : /* shouldn't get here? */
1696 : : break;
1697 : : }
1698 : :
1699 : : CloseHandle(shutdownEvent);
1700 : : CloseHandle(postmasterProcess);
1701 : :
1702 : : pgwin32_SetServiceStatus(SERVICE_STOPPED);
1703 : : }
1704 : :
1705 : : static void
1706 : : pgwin32_doRunAsService(void)
1707 : : {
1708 : : SERVICE_TABLE_ENTRY st[] = {{register_servicename, pgwin32_ServiceMain},
1709 : : {NULL, NULL}};
1710 : :
1711 : : if (StartServiceCtrlDispatcher(st) == 0)
1712 : : {
1713 : : write_stderr(_("%s: could not start service \"%s\": error code %lu\n"),
1714 : : progname, register_servicename,
1715 : : (unsigned long) GetLastError());
1716 : : exit(1);
1717 : : }
1718 : : }
1719 : :
1720 : :
1721 : : /*
1722 : : * Set up STARTUPINFO for the new process to inherit this process' handles.
1723 : : *
1724 : : * Process started as services appear to have "empty" handles (GetStdHandle()
1725 : : * returns NULL) rather than invalid ones. But passing down NULL ourselves
1726 : : * doesn't work, it's interpreted as STARTUPINFO->hStd* not being set. But we
1727 : : * can pass down INVALID_HANDLE_VALUE - which makes GetStdHandle() in the new
1728 : : * process (and its child processes!) return INVALID_HANDLE_VALUE. Which
1729 : : * achieves the goal of postmaster running in a similar environment as pg_ctl.
1730 : : */
1731 : : static void
1732 : : InheritStdHandles(STARTUPINFO *si)
1733 : : {
1734 : : si->dwFlags |= STARTF_USESTDHANDLES;
1735 : : si->hStdInput = GetStdHandle(STD_INPUT_HANDLE);
1736 : : if (si->hStdInput == NULL)
1737 : : si->hStdInput = INVALID_HANDLE_VALUE;
1738 : : si->hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
1739 : : if (si->hStdOutput == NULL)
1740 : : si->hStdOutput = INVALID_HANDLE_VALUE;
1741 : : si->hStdError = GetStdHandle(STD_ERROR_HANDLE);
1742 : : if (si->hStdError == NULL)
1743 : : si->hStdError = INVALID_HANDLE_VALUE;
1744 : : }
1745 : :
1746 : : /*
1747 : : * Create a restricted token, a job object sandbox, and execute the specified
1748 : : * process with it.
1749 : : *
1750 : : * Returns 0 on success, non-zero on failure, same as CreateProcess().
1751 : : *
1752 : : * NOTE! Job object will only work when running as a service, because it's
1753 : : * automatically destroyed when pg_ctl exits.
1754 : : */
1755 : : static int
1756 : : CreateRestrictedProcess(char *cmd, PROCESS_INFORMATION *processInfo, bool as_service)
1757 : : {
1758 : : int r;
1759 : : BOOL b;
1760 : : STARTUPINFO si;
1761 : : HANDLE origToken;
1762 : : HANDLE restrictedToken;
1763 : : BOOL inJob;
1764 : : SID_IDENTIFIER_AUTHORITY NtAuthority = {SECURITY_NT_AUTHORITY};
1765 : : SID_AND_ATTRIBUTES dropSids[2];
1766 : : PTOKEN_PRIVILEGES delPrivs;
1767 : :
1768 : : ZeroMemory(&si, sizeof(si));
1769 : : si.cb = sizeof(si);
1770 : :
1771 : : /*
1772 : : * Set stdin/stdout/stderr handles to be inherited in the child process.
1773 : : * That allows postmaster and the processes it starts to perform
1774 : : * additional checks to see if running in a service (otherwise they get
1775 : : * the default console handles - which point to "somewhere").
1776 : : */
1777 : : InheritStdHandles(&si);
1778 : :
1779 : : /* Open the current token to use as a base for the restricted one */
1780 : : if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &origToken))
1781 : : {
1782 : : /*
1783 : : * Most Windows targets make DWORD a 32-bit unsigned long, but in case
1784 : : * it doesn't cast DWORD before printing.
1785 : : */
1786 : : write_stderr(_("%s: could not open process token: error code %lu\n"),
1787 : : progname, (unsigned long) GetLastError());
1788 : : return 0;
1789 : : }
1790 : :
1791 : : /* Allocate list of SIDs to remove */
1792 : : ZeroMemory(&dropSids, sizeof(dropSids));
1793 : : if (!AllocateAndInitializeSid(&NtAuthority, 2,
1794 : : SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0,
1795 : : 0, &dropSids[0].Sid) ||
1796 : : !AllocateAndInitializeSid(&NtAuthority, 2,
1797 : : SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_POWER_USERS, 0, 0, 0, 0, 0,
1798 : : 0, &dropSids[1].Sid))
1799 : : {
1800 : : write_stderr(_("%s: could not allocate SIDs: error code %lu\n"),
1801 : : progname, (unsigned long) GetLastError());
1802 : : return 0;
1803 : : }
1804 : :
1805 : : /* Get list of privileges to remove */
1806 : : delPrivs = GetPrivilegesToDelete(origToken);
1807 : : if (delPrivs == NULL)
1808 : : /* Error message already printed */
1809 : : return 0;
1810 : :
1811 : : b = CreateRestrictedToken(origToken,
1812 : : 0,
1813 : : sizeof(dropSids) / sizeof(dropSids[0]),
1814 : : dropSids,
1815 : : delPrivs->PrivilegeCount, delPrivs->Privileges,
1816 : : 0, NULL,
1817 : : &restrictedToken);
1818 : :
1819 : : free(delPrivs);
1820 : : FreeSid(dropSids[1].Sid);
1821 : : FreeSid(dropSids[0].Sid);
1822 : : CloseHandle(origToken);
1823 : :
1824 : : if (!b)
1825 : : {
1826 : : write_stderr(_("%s: could not create restricted token: error code %lu\n"),
1827 : : progname, (unsigned long) GetLastError());
1828 : : return 0;
1829 : : }
1830 : :
1831 : : AddUserToTokenDacl(restrictedToken);
1832 : : r = CreateProcessAsUser(restrictedToken, NULL, cmd, NULL, NULL, TRUE, CREATE_SUSPENDED, NULL, NULL, &si, processInfo);
1833 : :
1834 : : if (IsProcessInJob(processInfo->hProcess, NULL, &inJob))
1835 : : {
1836 : : if (!inJob)
1837 : : {
1838 : : /*
1839 : : * Job objects are working, and the new process isn't in one, so
1840 : : * we can create one safely. If any problems show up when setting
1841 : : * it, we're going to ignore them.
1842 : : */
1843 : : HANDLE job;
1844 : : char jobname[128];
1845 : :
1846 : : sprintf(jobname, "PostgreSQL_%lu",
1847 : : (unsigned long) processInfo->dwProcessId);
1848 : :
1849 : : job = CreateJobObject(NULL, jobname);
1850 : : if (job)
1851 : : {
1852 : : JOBOBJECT_BASIC_LIMIT_INFORMATION basicLimit;
1853 : : JOBOBJECT_BASIC_UI_RESTRICTIONS uiRestrictions;
1854 : : JOBOBJECT_SECURITY_LIMIT_INFORMATION securityLimit;
1855 : :
1856 : : ZeroMemory(&basicLimit, sizeof(basicLimit));
1857 : : ZeroMemory(&uiRestrictions, sizeof(uiRestrictions));
1858 : : ZeroMemory(&securityLimit, sizeof(securityLimit));
1859 : :
1860 : : basicLimit.LimitFlags = JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION | JOB_OBJECT_LIMIT_PRIORITY_CLASS;
1861 : : basicLimit.PriorityClass = NORMAL_PRIORITY_CLASS;
1862 : : SetInformationJobObject(job, JobObjectBasicLimitInformation, &basicLimit, sizeof(basicLimit));
1863 : :
1864 : : uiRestrictions.UIRestrictionsClass = JOB_OBJECT_UILIMIT_DESKTOP | JOB_OBJECT_UILIMIT_DISPLAYSETTINGS |
1865 : : JOB_OBJECT_UILIMIT_EXITWINDOWS | JOB_OBJECT_UILIMIT_READCLIPBOARD |
1866 : : JOB_OBJECT_UILIMIT_SYSTEMPARAMETERS | JOB_OBJECT_UILIMIT_WRITECLIPBOARD;
1867 : :
1868 : : SetInformationJobObject(job, JobObjectBasicUIRestrictions, &uiRestrictions, sizeof(uiRestrictions));
1869 : :
1870 : : securityLimit.SecurityLimitFlags = JOB_OBJECT_SECURITY_NO_ADMIN | JOB_OBJECT_SECURITY_ONLY_TOKEN;
1871 : : securityLimit.JobToken = restrictedToken;
1872 : : SetInformationJobObject(job, JobObjectSecurityLimitInformation, &securityLimit, sizeof(securityLimit));
1873 : :
1874 : : AssignProcessToJobObject(job, processInfo->hProcess);
1875 : : }
1876 : : }
1877 : : }
1878 : :
1879 : : CloseHandle(restrictedToken);
1880 : :
1881 : : ResumeThread(processInfo->hThread);
1882 : :
1883 : : /*
1884 : : * We intentionally don't close the job object handle, because we want the
1885 : : * object to live on until pg_ctl shuts down.
1886 : : */
1887 : : return r;
1888 : : }
1889 : :
1890 : : /*
1891 : : * Get a list of privileges to delete from the access token. We delete all privileges
1892 : : * except SeLockMemoryPrivilege which is needed to use large pages, and
1893 : : * SeChangeNotifyPrivilege which is enabled by default in DISABLE_MAX_PRIVILEGE.
1894 : : */
1895 : : static PTOKEN_PRIVILEGES
1896 : : GetPrivilegesToDelete(HANDLE hToken)
1897 : : {
1898 : : int i,
1899 : : j;
1900 : : DWORD length;
1901 : : PTOKEN_PRIVILEGES tokenPrivs;
1902 : : LUID luidLockPages;
1903 : : LUID luidChangeNotify;
1904 : :
1905 : : if (!LookupPrivilegeValue(NULL, SE_LOCK_MEMORY_NAME, &luidLockPages) ||
1906 : : !LookupPrivilegeValue(NULL, SE_CHANGE_NOTIFY_NAME, &luidChangeNotify))
1907 : : {
1908 : : write_stderr(_("%s: could not get LUIDs for privileges: error code %lu\n"),
1909 : : progname, (unsigned long) GetLastError());
1910 : : return NULL;
1911 : : }
1912 : :
1913 : : if (!GetTokenInformation(hToken, TokenPrivileges, NULL, 0, &length) &&
1914 : : GetLastError() != ERROR_INSUFFICIENT_BUFFER)
1915 : : {
1916 : : write_stderr(_("%s: could not get token information: error code %lu\n"),
1917 : : progname, (unsigned long) GetLastError());
1918 : : return NULL;
1919 : : }
1920 : :
1921 : : tokenPrivs = (PTOKEN_PRIVILEGES) pg_malloc_extended(length,
1922 : : MCXT_ALLOC_NO_OOM);
1923 : : if (tokenPrivs == NULL)
1924 : : {
1925 : : write_stderr(_("%s: out of memory\n"), progname);
1926 : : return NULL;
1927 : : }
1928 : :
1929 : : if (!GetTokenInformation(hToken, TokenPrivileges, tokenPrivs, length, &length))
1930 : : {
1931 : : write_stderr(_("%s: could not get token information: error code %lu\n"),
1932 : : progname, (unsigned long) GetLastError());
1933 : : free(tokenPrivs);
1934 : : return NULL;
1935 : : }
1936 : :
1937 : : for (i = 0; i < tokenPrivs->PrivilegeCount; i++)
1938 : : {
1939 : : if (memcmp(&tokenPrivs->Privileges[i].Luid, &luidLockPages, sizeof(LUID)) == 0 ||
1940 : : memcmp(&tokenPrivs->Privileges[i].Luid, &luidChangeNotify, sizeof(LUID)) == 0)
1941 : : {
1942 : : for (j = i; j < tokenPrivs->PrivilegeCount - 1; j++)
1943 : : tokenPrivs->Privileges[j] = tokenPrivs->Privileges[j + 1];
1944 : : tokenPrivs->PrivilegeCount--;
1945 : : }
1946 : : }
1947 : :
1948 : : return tokenPrivs;
1949 : : }
1950 : : #endif /* WIN32 */
1951 : :
1952 : : static void
1953 : 1 : do_advice(void)
1954 : : {
7117 peter_e@gmx.net 1955 : 1 : write_stderr(_("Try \"%s --help\" for more information.\n"), progname);
7262 bruce@momjian.us 1956 : 1 : }
1957 : :
1958 : :
1959 : :
1960 : : static void
1961 : 1 : do_help(void)
1962 : : {
4694 peter_e@gmx.net 1963 : 1 : printf(_("%s is a utility to initialize, start, stop, or control a PostgreSQL server.\n\n"), progname);
7262 bruce@momjian.us 1964 : 1 : printf(_("Usage:\n"));
2052 akorotkov@postgresql 1965 : 1 : printf(_(" %s init[db] [-D DATADIR] [-s] [-o OPTIONS]\n"), progname);
1966 : 1 : printf(_(" %s start [-D DATADIR] [-l FILENAME] [-W] [-t SECS] [-s]\n"
1967 : : " [-o OPTIONS] [-p PATH] [-c]\n"), progname);
1968 : 1 : printf(_(" %s stop [-D DATADIR] [-m SHUTDOWN-MODE] [-W] [-t SECS] [-s]\n"), progname);
1969 : 1 : printf(_(" %s restart [-D DATADIR] [-m SHUTDOWN-MODE] [-W] [-t SECS] [-s]\n"
1970 : : " [-o OPTIONS] [-c]\n"), progname);
1971 : 1 : printf(_(" %s reload [-D DATADIR] [-s]\n"), progname);
1972 : 1 : printf(_(" %s status [-D DATADIR]\n"), progname);
1973 : 1 : printf(_(" %s promote [-D DATADIR] [-W] [-t SECS] [-s]\n"), progname);
1974 : 1 : printf(_(" %s logrotate [-D DATADIR] [-s]\n"), progname);
1975 : 1 : printf(_(" %s kill SIGNALNAME PID\n"), progname);
1976 : : #ifdef WIN32
1977 : : printf(_(" %s register [-D DATADIR] [-N SERVICENAME] [-U USERNAME] [-P PASSWORD]\n"
1978 : : " [-S START-TYPE] [-e SOURCE] [-W] [-t SECS] [-s] [-o OPTIONS]\n"), progname);
1979 : : printf(_(" %s unregister [-N SERVICENAME]\n"), progname);
1980 : : #endif
1981 : :
7117 peter_e@gmx.net 1982 : 1 : printf(_("\nCommon options:\n"));
4353 1983 : 1 : printf(_(" -D, --pgdata=DATADIR location of the database storage area\n"));
1984 : : #ifdef WIN32
1985 : : printf(_(" -e SOURCE event source for logging when running as a service\n"));
1986 : : #endif
3123 1987 : 1 : printf(_(" -s, --silent only print errors, no informational messages\n"));
4353 1988 : 1 : printf(_(" -t, --timeout=SECS seconds to wait when using -w option\n"));
4318 1989 : 1 : printf(_(" -V, --version output version information, then exit\n"));
2648 1990 : 1 : printf(_(" -w, --wait wait until operation completes (default)\n"));
2734 1991 : 1 : printf(_(" -W, --no-wait do not wait until operation completes\n"));
4318 1992 : 1 : printf(_(" -?, --help show this help, then exit\n"));
7117 1993 : 1 : printf(_("If the -D option is omitted, the environment variable PGDATA is used.\n"));
1994 : :
1995 : 1 : printf(_("\nOptions for start or restart:\n"));
1996 : : #if defined(HAVE_GETRLIMIT)
6309 andrew@dunslane.net 1997 : 1 : printf(_(" -c, --core-files allow postgres to produce core files\n"));
1998 : : #else
1999 : : printf(_(" -c, --core-files not applicable on this platform\n"));
2000 : : #endif
4353 peter_e@gmx.net 2001 : 1 : printf(_(" -l, --log=FILENAME write (or append) server log to FILENAME\n"));
2734 2002 : 1 : printf(_(" -o, --options=OPTIONS command line options to pass to postgres\n"
2003 : : " (PostgreSQL server executable) or initdb\n"));
5527 2004 : 1 : printf(_(" -p PATH-TO-POSTGRES normally not necessary\n"));
3531 fujii@postgresql.org 2005 : 1 : printf(_("\nOptions for stop or restart:\n"));
4353 peter_e@gmx.net 2006 : 1 : printf(_(" -m, --mode=MODE MODE can be \"smart\", \"fast\", or \"immediate\"\n"));
2007 : :
7117 2008 : 1 : printf(_("\nShutdown modes are:\n"));
7262 bruce@momjian.us 2009 : 1 : printf(_(" smart quit after all clients have disconnected\n"));
2551 tgl@sss.pgh.pa.us 2010 : 1 : printf(_(" fast quit directly, with proper shutdown (default)\n"));
7117 peter_e@gmx.net 2011 : 1 : printf(_(" immediate quit without complete shutdown; will lead to recovery on restart\n"));
2012 : :
2013 : 1 : printf(_("\nAllowed signal names for kill:\n"));
2387 andres@anarazel.de 2014 : 1 : printf(" ABRT HUP INT KILL QUIT TERM USR1 USR2\n");
2015 : :
2016 : : #ifdef WIN32
2017 : : printf(_("\nOptions for register and unregister:\n"));
2018 : : printf(_(" -N SERVICENAME service name with which to register PostgreSQL server\n"));
2019 : : printf(_(" -P PASSWORD password of account to register PostgreSQL server\n"));
2020 : : printf(_(" -U USERNAME user name of account to register PostgreSQL server\n"));
2021 : : printf(_(" -S START-TYPE service start type to register PostgreSQL server\n"));
2022 : :
2023 : : printf(_("\nStart types are:\n"));
2024 : : printf(_(" auto start service automatically during system startup (default)\n"));
2025 : : printf(_(" demand start service on demand\n"));
2026 : : #endif
2027 : :
1507 peter@eisentraut.org 2028 : 1 : printf(_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
2029 : 1 : printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
7262 bruce@momjian.us 2030 : 1 : }
2031 : :
2032 : :
2033 : :
2034 : : static void
2035 : 532 : set_mode(char *modeopt)
2036 : : {
2037 [ + - + + ]: 532 : if (strcmp(modeopt, "s") == 0 || strcmp(modeopt, "smart") == 0)
2038 : : {
2039 : 17 : shutdown_mode = SMART_MODE;
2040 : 17 : sig = SIGTERM;
2041 : : }
2042 [ + - + + ]: 515 : else if (strcmp(modeopt, "f") == 0 || strcmp(modeopt, "fast") == 0)
2043 : : {
2044 : 216 : shutdown_mode = FAST_MODE;
2045 : 216 : sig = SIGINT;
2046 : : }
2047 [ + - + - ]: 299 : else if (strcmp(modeopt, "i") == 0 || strcmp(modeopt, "immediate") == 0)
2048 : : {
2049 : 299 : shutdown_mode = IMMEDIATE_MODE;
2050 : 299 : sig = SIGQUIT;
2051 : : }
2052 : : else
2053 : : {
7124 peter_e@gmx.net 2054 :UBC 0 : write_stderr(_("%s: unrecognized shutdown mode \"%s\"\n"), progname, modeopt);
7262 bruce@momjian.us 2055 : 0 : do_advice();
2056 : 0 : exit(1);
2057 : : }
7262 bruce@momjian.us 2058 :CBC 532 : }
2059 : :
2060 : :
2061 : :
2062 : : static void
2063 : 6 : set_sig(char *signame)
2064 : : {
4492 peter_e@gmx.net 2065 [ - + ]: 6 : if (strcmp(signame, "HUP") == 0)
7262 bruce@momjian.us 2066 :UBC 0 : sig = SIGHUP;
4492 peter_e@gmx.net 2067 [ - + ]:CBC 6 : else if (strcmp(signame, "INT") == 0)
7262 bruce@momjian.us 2068 :UBC 0 : sig = SIGINT;
4492 peter_e@gmx.net 2069 [ + + ]:CBC 6 : else if (strcmp(signame, "QUIT") == 0)
7262 bruce@momjian.us 2070 : 2 : sig = SIGQUIT;
4492 peter_e@gmx.net 2071 [ - + ]: 4 : else if (strcmp(signame, "ABRT") == 0)
7262 bruce@momjian.us 2072 :UBC 0 : sig = SIGABRT;
4326 bruce@momjian.us 2073 [ + - ]:CBC 4 : else if (strcmp(signame, "KILL") == 0)
4492 peter_e@gmx.net 2074 : 4 : sig = SIGKILL;
4492 peter_e@gmx.net 2075 [ # # ]:UBC 0 : else if (strcmp(signame, "TERM") == 0)
7262 bruce@momjian.us 2076 : 0 : sig = SIGTERM;
4492 peter_e@gmx.net 2077 [ # # ]: 0 : else if (strcmp(signame, "USR1") == 0)
7262 bruce@momjian.us 2078 : 0 : sig = SIGUSR1;
4492 peter_e@gmx.net 2079 [ # # ]: 0 : else if (strcmp(signame, "USR2") == 0)
7262 bruce@momjian.us 2080 : 0 : sig = SIGUSR2;
2081 : : else
2082 : : {
7124 peter_e@gmx.net 2083 : 0 : write_stderr(_("%s: unrecognized signal name \"%s\"\n"), progname, signame);
7262 bruce@momjian.us 2084 : 0 : do_advice();
2085 : 0 : exit(1);
2086 : : }
7262 bruce@momjian.us 2087 :CBC 6 : }
2088 : :
2089 : :
2090 : : #ifdef WIN32
2091 : : static void
2092 : : set_starttype(char *starttypeopt)
2093 : : {
2094 : : if (strcmp(starttypeopt, "a") == 0 || strcmp(starttypeopt, "auto") == 0)
2095 : : pgctl_start_type = SERVICE_AUTO_START;
2096 : : else if (strcmp(starttypeopt, "d") == 0 || strcmp(starttypeopt, "demand") == 0)
2097 : : pgctl_start_type = SERVICE_DEMAND_START;
2098 : : else
2099 : : {
2100 : : write_stderr(_("%s: unrecognized start type \"%s\"\n"), progname, starttypeopt);
2101 : : do_advice();
2102 : : exit(1);
2103 : : }
2104 : : }
2105 : : #endif
2106 : :
2107 : : /*
2108 : : * adjust_data_dir
2109 : : *
2110 : : * If a configuration-only directory was specified, find the real data dir.
2111 : : */
2112 : : static void
4574 2113 : 1448 : adjust_data_dir(void)
2114 : : {
2115 : : char filename[MAXPGPATH];
2116 : : char *my_exec_path,
2117 : : *cmd;
2118 : : FILE *fd;
2119 : :
2120 : : /* do nothing if we're working without knowledge of data dir */
4325 tgl@sss.pgh.pa.us 2121 [ + + ]: 1448 : if (pg_config == NULL)
2122 : 1448 : return;
2123 : :
2124 : : /* If there is no postgresql.conf, it can't be a config-only dir */
4574 bruce@momjian.us 2125 : 1442 : snprintf(filename, sizeof(filename), "%s/postgresql.conf", pg_config);
2126 [ + + ]: 1442 : if ((fd = fopen(filename, "r")) == NULL)
2127 : 4 : return;
2128 : 1438 : fclose(fd);
2129 : :
2130 : : /* If PG_VERSION exists, it can't be a config-only dir */
2131 : 1438 : snprintf(filename, sizeof(filename), "%s/PG_VERSION", pg_config);
2132 [ + - ]: 1438 : if ((fd = fopen(filename, "r")) != NULL)
2133 : : {
2134 : 1438 : fclose(fd);
2135 : 1438 : return;
2136 : : }
2137 : :
2138 : : /* Must be a configuration directory, so find the data directory */
2139 : :
2140 : : /* we use a private my_exec_path to avoid interfering with later uses */
4574 bruce@momjian.us 2141 [ # # ]:UBC 0 : if (exec_path == NULL)
2142 : 0 : my_exec_path = find_other_exec_or_die(argv0, "postgres", PG_BACKEND_VERSIONSTR);
2143 : : else
4212 tgl@sss.pgh.pa.us 2144 : 0 : my_exec_path = pg_strdup(exec_path);
2145 : :
2146 : : /* it's important for -C to be the first option, see main.c */
954 2147 : 0 : cmd = psprintf("\"%s\" -C data_directory %s%s",
2148 : : my_exec_path,
2149 [ # # ]: 0 : pgdata_opt ? pgdata_opt : "",
2150 [ # # ]: 0 : post_opts ? post_opts : "");
594 2151 : 0 : fflush(NULL);
2152 : :
4574 bruce@momjian.us 2153 : 0 : fd = popen(cmd, "r");
516 peter@eisentraut.org 2154 [ # # # # : 0 : if (fd == NULL || fgets(filename, sizeof(filename), fd) == NULL || pclose(fd) != 0)
# # ]
2155 : : {
4304 peter_e@gmx.net 2156 : 0 : write_stderr(_("%s: could not determine the data directory using command \"%s\"\n"), progname, cmd);
4574 bruce@momjian.us 2157 : 0 : exit(1);
2158 : : }
2159 : 0 : free(my_exec_path);
2160 : :
2161 : : /* strip trailing newline and carriage return */
1710 michael@paquier.xyz 2162 : 0 : (void) pg_strip_crlf(filename);
2163 : :
4574 bruce@momjian.us 2164 : 0 : free(pg_data);
4212 tgl@sss.pgh.pa.us 2165 : 0 : pg_data = pg_strdup(filename);
4574 bruce@momjian.us 2166 : 0 : canonicalize_path(pg_data);
2167 : : }
2168 : :
2169 : :
2170 : : static DBState
2819 peter_e@gmx.net 2171 :CBC 143 : get_control_dbstate(void)
2172 : : {
2173 : : DBState ret;
2174 : : bool crc_ok;
1840 peter@eisentraut.org 2175 : 143 : ControlFileData *control_file_data = get_controlfile(pg_data, &crc_ok);
2176 : :
2755 peter_e@gmx.net 2177 [ - + ]: 143 : if (!crc_ok)
2178 : : {
2819 peter_e@gmx.net 2179 :UBC 0 : write_stderr(_("%s: control file appears to be corrupt\n"), progname);
2180 : 0 : exit(1);
2181 : : }
2182 : :
2755 peter_e@gmx.net 2183 :CBC 143 : ret = control_file_data->state;
2184 : 143 : pfree(control_file_data);
2185 : 143 : return ret;
2186 : : }
2187 : :
2188 : :
2189 : : int
7262 bruce@momjian.us 2190 : 1496 : main(int argc, char **argv)
2191 : : {
2192 : : static struct option long_options[] = {
2193 : : {"help", no_argument, NULL, '?'},
2194 : : {"version", no_argument, NULL, 'V'},
2195 : : {"log", required_argument, NULL, 'l'},
2196 : : {"mode", required_argument, NULL, 'm'},
2197 : : {"pgdata", required_argument, NULL, 'D'},
2198 : : {"options", required_argument, NULL, 'o'},
2199 : : {"silent", no_argument, NULL, 's'},
2200 : : {"timeout", required_argument, NULL, 't'},
2201 : : {"core-files", no_argument, NULL, 'c'},
2202 : : {"wait", no_argument, NULL, 'w'},
2203 : : {"no-wait", no_argument, NULL, 'W'},
2204 : : {NULL, 0, NULL, 0}
2205 : : };
2206 : :
2207 : : char *env_wait;
2208 : : int option_index;
2209 : : int c;
540 peter@eisentraut.org 2210 : 1496 : pid_t killproc = 0;
2211 : :
1840 2212 : 1496 : pg_logging_init(argv[0]);
7262 bruce@momjian.us 2213 : 1496 : progname = get_progname(argv[0]);
5603 peter_e@gmx.net 2214 : 1496 : set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_ctl"));
4853 bruce@momjian.us 2215 : 1496 : start_time = time(NULL);
2216 : :
2217 : : /*
2218 : : * save argv[0] so do_start() can look for the postmaster if necessary. we
2219 : : * don't look for postmaster here because in many cases we won't need it.
2220 : : */
7262 2221 : 1496 : argv0 = argv[0];
2222 : :
2223 : : /* Set restrictive mode mask until PGDATA permissions are checked */
2199 sfrost@snowman.net 2224 : 1496 : umask(PG_MODE_MASK_OWNER);
2225 : :
2226 : : /* support --help and --version even if invoked as root */
7168 bruce@momjian.us 2227 [ + - ]: 1496 : if (argc > 1)
2228 : : {
3940 2229 [ + + - + ]: 1496 : if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
2230 : : {
7262 2231 : 1 : do_help();
2232 : 1 : exit(0);
2233 : : }
3940 2234 [ + + + + ]: 1495 : else if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
2235 : : {
6641 peter_e@gmx.net 2236 : 46 : puts("pg_ctl (PostgreSQL) " PG_VERSION);
7262 bruce@momjian.us 2237 : 46 : exit(0);
2238 : : }
2239 : : }
2240 : :
2241 : : /*
2242 : : * Disallow running as root, to forestall any possible security holes.
2243 : : */
2244 : : #ifndef WIN32
7114 tgl@sss.pgh.pa.us 2245 [ - + ]: 1449 : if (geteuid() == 0)
2246 : : {
7114 tgl@sss.pgh.pa.us 2247 :UBC 0 : write_stderr(_("%s: cannot be run as root\n"
2248 : : "Please log in (using, e.g., \"su\") as the "
2249 : : "(unprivileged) user that will\n"
2250 : : "own the server process.\n"),
2251 : : progname);
2252 : 0 : exit(1);
2253 : : }
2254 : : #endif
2255 : :
2986 noah@leadboat.com 2256 :CBC 1449 : env_wait = getenv("PGCTLTIMEOUT");
2257 [ - + ]: 1449 : if (env_wait != NULL)
2986 noah@leadboat.com 2258 :UBC 0 : wait_seconds = atoi(env_wait);
2259 : :
2260 : : /* process command-line options */
275 nathan@postgresql.or 2261 :GNC 5440 : while ((c = getopt_long(argc, argv, "cD:e:l:m:N:o:p:P:sS:t:U:wW",
2262 [ + + ]: 5440 : long_options, &option_index)) != -1)
2263 : : {
2264 [ + - + + : 3992 : switch (c)
- + - - +
- - - + +
- + ]
2265 : : {
2266 : 1442 : case 'D':
2267 : : {
2268 : : char *pgdata_D;
2269 : :
2270 : 1442 : pgdata_D = pg_strdup(optarg);
2271 : 1442 : canonicalize_path(pgdata_D);
2272 : 1442 : setenv("PGDATA", pgdata_D, 1);
2273 : :
2274 : : /*
2275 : : * We could pass PGDATA just in an environment variable
2276 : : * but we do -D too for clearer postmaster 'ps' display
2277 : : */
2278 : 1442 : pgdata_opt = psprintf("-D \"%s\" ", pgdata_D);
2279 : 1442 : free(pgdata_D);
7262 bruce@momjian.us 2280 : 1442 : break;
2281 : : }
275 nathan@postgresql.or 2282 :UNC 0 : case 'e':
2283 : 0 : event_source = pg_strdup(optarg);
2284 : 0 : break;
275 nathan@postgresql.or 2285 :GNC 676 : case 'l':
2286 : 676 : log_file = pg_strdup(optarg);
2287 : 676 : break;
2288 : 532 : case 'm':
2289 : 532 : set_mode(optarg);
2290 : 532 : break;
275 nathan@postgresql.or 2291 :UNC 0 : case 'N':
2292 : 0 : register_servicename = pg_strdup(optarg);
2293 : 0 : break;
275 nathan@postgresql.or 2294 :GNC 580 : case 'o':
2295 : : /* append option? */
2296 [ + + ]: 580 : if (!post_opts)
2297 : 570 : post_opts = pg_strdup(optarg);
2298 : : else
2299 : : {
2300 : 10 : char *old_post_opts = post_opts;
2301 : :
2302 : 10 : post_opts = psprintf("%s %s", old_post_opts, optarg);
2303 : 10 : free(old_post_opts);
2304 : : }
2305 : 580 : break;
275 nathan@postgresql.or 2306 :UNC 0 : case 'p':
2307 : 0 : exec_path = pg_strdup(optarg);
2308 : 0 : break;
2309 : 0 : case 'P':
2310 : 0 : register_password = pg_strdup(optarg);
2311 : 0 : break;
275 nathan@postgresql.or 2312 :GNC 106 : case 's':
2313 : 106 : silent_mode = true;
2314 : 106 : break;
275 nathan@postgresql.or 2315 :UNC 0 : case 'S':
2316 : : #ifdef WIN32
2317 : : set_starttype(optarg);
2318 : : #else
2319 : 0 : write_stderr(_("%s: -S option not supported on this platform\n"),
2320 : : progname);
2321 : 0 : exit(1);
2322 : : #endif
2323 : : break;
2324 : 0 : case 't':
2325 : 0 : wait_seconds = atoi(optarg);
2326 : 0 : wait_seconds_arg = true;
2327 : 0 : break;
2328 : 0 : case 'U':
2329 [ # # ]: 0 : if (strchr(optarg, '\\'))
2330 : 0 : register_username = pg_strdup(optarg);
2331 : : else
2332 : : /* Prepend .\ for local accounts */
2333 : 0 : register_username = psprintf(".\\%s", optarg);
2334 : 0 : break;
275 nathan@postgresql.or 2335 :GNC 654 : case 'w':
2336 : 654 : do_wait = true;
2337 : 654 : break;
2338 : 1 : case 'W':
2339 : 1 : do_wait = false;
2340 : 1 : break;
275 nathan@postgresql.or 2341 :UNC 0 : case 'c':
2342 : 0 : allow_core_files = true;
2343 : 0 : break;
275 nathan@postgresql.or 2344 :GNC 1 : default:
2345 : : /* getopt_long already issued a suitable error message */
2346 : 1 : do_advice();
2347 : 1 : exit(1);
2348 : : }
2349 : : }
2350 : :
2351 : : /* Process an action */
2352 [ + - ]: 1448 : if (optind < argc)
2353 : : {
2354 [ + - ]: 1448 : if (strcmp(argv[optind], "init") == 0
2355 [ + + ]: 1448 : || strcmp(argv[optind], "initdb") == 0)
2356 : 1 : ctl_command = INIT_COMMAND;
2357 [ + + ]: 1447 : else if (strcmp(argv[optind], "start") == 0)
2358 : 557 : ctl_command = START_COMMAND;
2359 [ + + ]: 890 : else if (strcmp(argv[optind], "stop") == 0)
2360 : 632 : ctl_command = STOP_COMMAND;
2361 [ + + ]: 258 : else if (strcmp(argv[optind], "restart") == 0)
2362 : 97 : ctl_command = RESTART_COMMAND;
2363 [ + + ]: 161 : else if (strcmp(argv[optind], "reload") == 0)
2364 : 110 : ctl_command = RELOAD_COMMAND;
2365 [ + + ]: 51 : else if (strcmp(argv[optind], "status") == 0)
2366 : 3 : ctl_command = STATUS_COMMAND;
2367 [ + + ]: 48 : else if (strcmp(argv[optind], "promote") == 0)
2368 : 41 : ctl_command = PROMOTE_COMMAND;
2369 [ + + ]: 7 : else if (strcmp(argv[optind], "logrotate") == 0)
2370 : 1 : ctl_command = LOGROTATE_COMMAND;
2371 [ + - ]: 6 : else if (strcmp(argv[optind], "kill") == 0)
2372 : : {
2373 [ - + ]: 6 : if (argc - optind < 3)
2374 : : {
275 nathan@postgresql.or 2375 :UNC 0 : write_stderr(_("%s: missing arguments for kill mode\n"), progname);
7262 bruce@momjian.us 2376 :UBC 0 : do_advice();
2377 : 0 : exit(1);
2378 : : }
275 nathan@postgresql.or 2379 :GNC 6 : ctl_command = KILL_COMMAND;
2380 : 6 : set_sig(argv[++optind]);
2381 : 6 : killproc = atol(argv[++optind]);
2382 : : }
2383 : : #ifdef WIN32
2384 : : else if (strcmp(argv[optind], "register") == 0)
2385 : : ctl_command = REGISTER_COMMAND;
2386 : : else if (strcmp(argv[optind], "unregister") == 0)
2387 : : ctl_command = UNREGISTER_COMMAND;
2388 : : else if (strcmp(argv[optind], "runservice") == 0)
2389 : : ctl_command = RUN_AS_SERVICE_COMMAND;
2390 : : #endif
2391 : : else
2392 : : {
275 nathan@postgresql.or 2393 :UNC 0 : write_stderr(_("%s: unrecognized operation mode \"%s\"\n"), progname, argv[optind]);
2394 : 0 : do_advice();
2395 : 0 : exit(1);
2396 : : }
275 nathan@postgresql.or 2397 :GNC 1448 : optind++;
2398 : : }
2399 : :
2400 [ - + ]: 1448 : if (optind < argc)
2401 : : {
275 nathan@postgresql.or 2402 :UNC 0 : write_stderr(_("%s: too many command-line arguments (first is \"%s\")\n"), progname, argv[optind]);
2403 : 0 : do_advice();
2404 : 0 : exit(1);
2405 : : }
2406 : :
7262 bruce@momjian.us 2407 [ - + ]:CBC 1448 : if (ctl_command == NO_COMMAND)
2408 : : {
7234 tgl@sss.pgh.pa.us 2409 :UBC 0 : write_stderr(_("%s: no operation specified\n"), progname);
7262 bruce@momjian.us 2410 : 0 : do_advice();
2411 : 0 : exit(1);
2412 : : }
2413 : :
2414 : : /* Note we put any -D switch into the env var above */
4574 bruce@momjian.us 2415 :CBC 1448 : pg_config = getenv("PGDATA");
2416 [ + + ]: 1448 : if (pg_config)
2417 : : {
4212 tgl@sss.pgh.pa.us 2418 : 1442 : pg_config = pg_strdup(pg_config);
4574 bruce@momjian.us 2419 : 1442 : canonicalize_path(pg_config);
4212 tgl@sss.pgh.pa.us 2420 : 1442 : pg_data = pg_strdup(pg_config);
2421 : : }
2422 : :
2423 : : /* -D might point at config-only directory; if so find the real PGDATA */
4574 bruce@momjian.us 2424 : 1448 : adjust_data_dir();
2425 : :
2426 : : /* Complain if -D needed and not provided */
2427 [ + + ]: 1448 : if (pg_config == NULL &&
7234 tgl@sss.pgh.pa.us 2428 [ - + - - ]: 6 : ctl_command != KILL_COMMAND && ctl_command != UNREGISTER_COMMAND)
2429 : : {
4930 alvherre@alvh.no-ip. 2430 :UBC 0 : write_stderr(_("%s: no database directory specified and environment variable PGDATA unset\n"),
2431 : : progname);
7262 bruce@momjian.us 2432 : 0 : do_advice();
2433 : 0 : exit(1);
2434 : : }
2435 : :
7262 bruce@momjian.us 2436 [ + + ]:CBC 1448 : if (ctl_command == RELOAD_COMMAND)
2437 : : {
2438 : 110 : sig = SIGHUP;
2439 : 110 : do_wait = false;
2440 : : }
2441 : :
6402 2442 [ + + ]: 1448 : if (pg_data)
2443 : : {
2444 : 1442 : snprintf(postopts_file, MAXPGPATH, "%s/postmaster.opts", pg_data);
3690 2445 : 1442 : snprintf(version_file, MAXPGPATH, "%s/PG_VERSION", pg_data);
6402 2446 : 1442 : snprintf(pid_file, MAXPGPATH, "%s/postmaster.pid", pg_data);
2447 : :
2448 : : /*
2449 : : * Set mask based on PGDATA permissions,
2450 : : *
2451 : : * Don't error here if the data directory cannot be stat'd. This is
2452 : : * handled differently based on the command and we don't want to
2453 : : * interfere with that logic.
2454 : : */
2199 sfrost@snowman.net 2455 [ + + ]: 1442 : if (GetDataDirectoryCreatePerm(pg_data))
2456 : 1438 : umask(pg_mode_mask);
2457 : : }
2458 : :
7262 bruce@momjian.us 2459 [ + + + + : 1448 : switch (ctl_command)
+ + + + +
- ]
2460 : : {
5239 peter_e@gmx.net 2461 : 1 : case INIT_COMMAND:
2462 : 1 : do_init();
2463 : 1 : break;
7262 bruce@momjian.us 2464 : 3 : case STATUS_COMMAND:
2465 : 3 : do_status();
2466 : 1 : break;
2467 : 557 : case START_COMMAND:
2468 : 557 : do_start();
2469 : 551 : break;
2470 : 632 : case STOP_COMMAND:
2471 : 632 : do_stop();
2472 : 631 : break;
2473 : 97 : case RESTART_COMMAND:
2474 : 97 : do_restart();
2475 : 95 : break;
2476 : 110 : case RELOAD_COMMAND:
2477 : 110 : do_reload();
2478 : 110 : break;
4694 peter_e@gmx.net 2479 : 41 : case PROMOTE_COMMAND:
2480 : 41 : do_promote();
2481 : 38 : break;
2052 akorotkov@postgresql 2482 : 1 : case LOGROTATE_COMMAND:
2483 : 1 : do_logrotate();
2484 : 1 : break;
7262 bruce@momjian.us 2485 : 6 : case KILL_COMMAND:
7258 2486 : 6 : do_kill(killproc);
7262 2487 : 6 : break;
2488 : : #ifdef WIN32
2489 : : case REGISTER_COMMAND:
2490 : : pgwin32_doRegister();
2491 : : break;
2492 : : case UNREGISTER_COMMAND:
2493 : : pgwin32_doUnregister();
2494 : : break;
2495 : : case RUN_AS_SERVICE_COMMAND:
2496 : : pgwin32_doRunAsService();
2497 : : break;
2498 : : #endif
7262 bruce@momjian.us 2499 :UBC 0 : default:
2500 : 0 : break;
2501 : : }
2502 : :
7262 bruce@momjian.us 2503 :CBC 1434 : exit(0);
2504 : : }
|
