Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * startup.c
4 : : *
5 : : * The Startup process initialises the server and performs any recovery
6 : : * actions that have been specified. Notice that there is no "main loop"
7 : : * since the Startup process ends as soon as initialisation is complete.
8 : : * (in standby mode, one can think of the replay loop as a main loop,
9 : : * though.)
10 : : *
11 : : *
12 : : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
13 : : *
14 : : *
15 : : * IDENTIFICATION
16 : : * src/backend/postmaster/startup.c
17 : : *
18 : : *-------------------------------------------------------------------------
19 : : */
20 : : #include "postgres.h"
21 : :
22 : : #include "access/xlog.h"
23 : : #include "access/xlogrecovery.h"
24 : : #include "access/xlogutils.h"
25 : : #include "libpq/pqsignal.h"
26 : : #include "miscadmin.h"
27 : : #include "postmaster/auxprocess.h"
28 : : #include "postmaster/startup.h"
29 : : #include "storage/ipc.h"
30 : : #include "storage/pmsignal.h"
31 : : #include "storage/procsignal.h"
32 : : #include "storage/standby.h"
33 : : #include "utils/guc.h"
34 : : #include "utils/memutils.h"
35 : : #include "utils/timeout.h"
36 : :
37 : :
38 : : #ifndef USE_POSTMASTER_DEATH_SIGNAL
39 : : /*
40 : : * On systems that need to make a system call to find out if the postmaster has
41 : : * gone away, we'll do so only every Nth call to ProcessStartupProcInterrupts().
42 : : * This only affects how long it takes us to detect the condition while we're
43 : : * busy replaying WAL. Latch waits and similar which should react immediately
44 : : * through the usual techniques.
45 : : */
46 : : #define POSTMASTER_POLL_RATE_LIMIT 1024
47 : : #endif
48 : :
49 : : /*
50 : : * Flags set by interrupt handlers for later service in the redo loop.
51 : : */
52 : : static volatile sig_atomic_t got_SIGHUP = false;
53 : : static volatile sig_atomic_t shutdown_requested = false;
54 : : static volatile sig_atomic_t promote_signaled = false;
55 : :
56 : : /*
57 : : * Flag set when executing a restore command, to tell SIGTERM signal handler
58 : : * that it's safe to just proc_exit.
59 : : */
60 : : static volatile sig_atomic_t in_restore_command = false;
61 : :
62 : : /*
63 : : * Time at which the most recent startup operation started.
64 : : */
65 : : static TimestampTz startup_progress_phase_start_time;
66 : :
67 : : /*
68 : : * Indicates whether the startup progress interval mentioned by the user is
69 : : * elapsed or not. TRUE if timeout occurred, FALSE otherwise.
70 : : */
71 : : static volatile sig_atomic_t startup_progress_timer_expired = false;
72 : :
73 : : /*
74 : : * Time between progress updates for long-running startup operations.
75 : : */
76 : : int log_startup_progress_interval = 10000; /* 10 sec */
77 : :
78 : : /* Signal handlers */
79 : : static void StartupProcTriggerHandler(SIGNAL_ARGS);
80 : : static void StartupProcSigHupHandler(SIGNAL_ARGS);
81 : :
82 : : /* Callbacks */
83 : : static void StartupProcExit(int code, Datum arg);
84 : :
85 : :
86 : : /* --------------------------------
87 : : * signal handler routines
88 : : * --------------------------------
89 : : */
90 : :
91 : : /* SIGUSR2: set flag to finish recovery */
92 : : static void
93 : 59 : StartupProcTriggerHandler(SIGNAL_ARGS)
94 : : {
95 : 59 : promote_signaled = true;
96 : 59 : WakeupRecovery();
97 : 59 : }
98 : :
99 : : /* SIGHUP: set flag to re-read config file at next convenient time */
100 : : static void
101 : 37 : StartupProcSigHupHandler(SIGNAL_ARGS)
102 : : {
103 : 37 : got_SIGHUP = true;
104 : 37 : WakeupRecovery();
105 : 37 : }
106 : :
107 : : /* SIGTERM: set flag to abort redo and exit */
108 : : static void
109 : 78 : StartupProcShutdownHandler(SIGNAL_ARGS)
110 : : {
111 [ + + ]: 78 : if (in_restore_command)
112 : 1 : proc_exit(1);
113 : : else
114 : 77 : shutdown_requested = true;
115 : 77 : WakeupRecovery();
116 : 77 : }
117 : :
118 : : /*
119 : : * Re-read the config file.
120 : : *
121 : : * If one of the critical walreceiver options has changed, request the startup
122 : : * process to restart the walreceiver.
123 : : */
124 : : static void
125 : 37 : StartupRereadConfig(void)
126 : : {
127 : 37 : char *conninfo = pstrdup(PrimaryConnInfo);
128 : 37 : char *slotname = pstrdup(PrimarySlotName);
129 : 37 : bool tempSlot = wal_receiver_create_temp_slot;
130 : : bool conninfoChanged;
131 : : bool slotnameChanged;
132 : 37 : bool tempSlotChanged = false;
133 : :
134 : 37 : ProcessConfigFile(PGC_SIGHUP);
135 : :
136 : 37 : conninfoChanged = strcmp(conninfo, PrimaryConnInfo) != 0;
137 : 37 : slotnameChanged = strcmp(slotname, PrimarySlotName) != 0;
138 : :
139 : : /*
140 : : * wal_receiver_create_temp_slot is used only when we have no slot
141 : : * configured. We do not need to track this change if it has no effect.
142 : : */
143 [ + - + + ]: 37 : if (!slotnameChanged && strcmp(PrimarySlotName, "") == 0)
144 : 17 : tempSlotChanged = tempSlot != wal_receiver_create_temp_slot;
145 : 37 : pfree(conninfo);
146 : 37 : pfree(slotname);
147 : :
148 [ + + + - : 37 : if (conninfoChanged || slotnameChanged || tempSlotChanged)
- + ]
149 : 16 : StartupRequestWalReceiverRestart();
150 : 37 : }
151 : :
152 : : /* Process various signals that might be sent to the startup process */
153 : : void
154 : 2991271 : ProcessStartupProcInterrupts(void)
155 : : {
156 : : #ifdef POSTMASTER_POLL_RATE_LIMIT
157 : : static uint32 postmaster_poll_count = 0;
158 : : #endif
159 : :
160 : : /*
161 : : * Process any requests or signals received recently.
162 : : */
163 [ + + ]: 2991271 : if (got_SIGHUP)
164 : : {
165 : 37 : got_SIGHUP = false;
166 : 37 : StartupRereadConfig();
167 : : }
168 : :
169 : : /*
170 : : * Check if we were requested to exit without finishing recovery.
171 : : */
172 [ + + ]: 2991271 : if (shutdown_requested)
173 : 69 : proc_exit(1);
174 : :
175 : : /*
176 : : * Emergency bailout if postmaster has died. This is to avoid the
177 : : * necessity for manual cleanup of all postmaster children. Do this less
178 : : * frequently on systems for which we don't have signals to make that
179 : : * cheap.
180 : : */
181 [ + + ]: 2991202 : if (IsUnderPostmaster &&
182 : : #ifdef POSTMASTER_POLL_RATE_LIMIT
183 : : postmaster_poll_count++ % POSTMASTER_POLL_RATE_LIMIT == 0 &&
184 : : #endif
185 [ - + ]: 2965775 : !PostmasterIsAlive())
186 : 0 : exit(1);
187 : :
188 : : /* Process barrier events */
189 [ - + ]: 2991202 : if (ProcSignalBarrierPending)
190 : 0 : ProcessProcSignalBarrier();
191 : :
192 : : /* Perform logging of memory contexts of this process */
193 [ - + ]: 2991202 : if (LogMemoryContextPending)
194 : 0 : ProcessLogMemoryContextInterrupt();
195 : 2991202 : }
196 : :
197 : :
198 : : /* --------------------------------
199 : : * signal handler routines
200 : : * --------------------------------
201 : : */
202 : : static void
203 : 1035 : StartupProcExit(int code, Datum arg)
204 : : {
205 : : /* Shutdown the recovery environment */
206 [ + + ]: 1035 : if (standbyState != STANDBY_DISABLED)
207 : 137 : ShutdownRecoveryTransactionEnvironment();
208 : 1035 : }
209 : :
210 : :
211 : : /* ----------------------------------
212 : : * Startup Process main entry point
213 : : * ----------------------------------
214 : : */
215 : : void
216 : 1035 : StartupProcessMain(const void *startup_data, size_t startup_data_len)
217 : : {
218 : : Assert(startup_data_len == 0);
219 : :
220 : 1035 : AuxiliaryProcessMainCommon();
221 : :
222 : : /* Arrange to clean up at startup process exit */
223 : 1035 : on_shmem_exit(StartupProcExit, 0);
224 : :
225 : : /*
226 : : * Properly accept or ignore signals the postmaster might send us.
227 : : */
228 : 1035 : pqsignal(SIGHUP, StartupProcSigHupHandler); /* reload config file */
229 : 1035 : pqsignal(SIGINT, PG_SIG_IGN); /* ignore query cancel */
230 : 1035 : pqsignal(SIGTERM, StartupProcShutdownHandler); /* request shutdown */
231 : : /* SIGQUIT handler was already set up by InitPostmasterChild */
232 : 1035 : InitializeTimeouts(); /* establishes SIGALRM handler */
233 : 1035 : pqsignal(SIGPIPE, PG_SIG_IGN);
234 : 1035 : pqsignal(SIGUSR1, procsignal_sigusr1_handler);
235 : 1035 : pqsignal(SIGUSR2, StartupProcTriggerHandler);
236 : :
237 : : /*
238 : : * Register timeouts needed for standby mode
239 : : */
240 : 1035 : RegisterTimeout(STANDBY_DEADLOCK_TIMEOUT, StandbyDeadLockHandler);
241 : 1035 : RegisterTimeout(STANDBY_TIMEOUT, StandbyTimeoutHandler);
242 : 1035 : RegisterTimeout(STANDBY_LOCK_TIMEOUT, StandbyLockTimeoutHandler);
243 : :
244 : : /*
245 : : * Unblock signals (they were blocked when the postmaster forked us)
246 : : */
247 : 1035 : sigprocmask(SIG_SETMASK, &UnBlockSig, NULL);
248 : :
249 : : /*
250 : : * Do what we came for.
251 : : */
252 : 1035 : StartupXLOG();
253 : :
254 : : /*
255 : : * Exit normally. Exit code 0 tells postmaster that we completed recovery
256 : : * successfully.
257 : : */
258 : 953 : proc_exit(0);
259 : : }
260 : :
261 : : void
262 : 552 : PreRestoreCommand(void)
263 : : {
264 : : /*
265 : : * Set in_restore_command to tell the signal handler that we should exit
266 : : * right away on SIGTERM. We know that we're at a safe point to do that.
267 : : * Check if we had already received the signal, so that we don't miss a
268 : : * shutdown request received just before this.
269 : : */
270 : 552 : in_restore_command = true;
271 [ - + ]: 552 : if (shutdown_requested)
272 : 0 : proc_exit(1);
273 : 552 : }
274 : :
275 : : void
276 : 551 : PostRestoreCommand(void)
277 : : {
278 : 551 : in_restore_command = false;
279 : 551 : }
280 : :
281 : : bool
282 : 16673 : IsPromoteSignaled(void)
283 : : {
284 : 16673 : return promote_signaled;
285 : : }
286 : :
287 : : void
288 : 59 : ResetPromoteSignaled(void)
289 : : {
290 : 59 : promote_signaled = false;
291 : 59 : }
292 : :
293 : : /*
294 : : * Set a flag indicating that it's time to log a progress report.
295 : : */
296 : : void
297 : 27 : startup_progress_timeout_handler(void)
298 : : {
299 : 27 : startup_progress_timer_expired = true;
300 : 27 : }
301 : :
302 : : void
303 : 684 : disable_startup_progress_timeout(void)
304 : : {
305 : : /* Feature is disabled. */
306 [ - + ]: 684 : if (log_startup_progress_interval == 0)
307 : 0 : return;
308 : :
309 : 684 : disable_timeout(STARTUP_PROGRESS_TIMEOUT, false);
310 : 684 : startup_progress_timer_expired = false;
311 : : }
312 : :
313 : : /*
314 : : * Set the start timestamp of the current operation and enable the timeout.
315 : : */
316 : : void
317 : 549 : enable_startup_progress_timeout(void)
318 : : {
319 : : TimestampTz fin_time;
320 : :
321 : : /* Feature is disabled. */
322 [ - + ]: 549 : if (log_startup_progress_interval == 0)
323 : 0 : return;
324 : :
325 : 549 : startup_progress_phase_start_time = GetCurrentTimestamp();
326 : 549 : fin_time = TimestampTzPlusMilliseconds(startup_progress_phase_start_time,
327 : : log_startup_progress_interval);
328 : 549 : enable_timeout_every(STARTUP_PROGRESS_TIMEOUT, fin_time,
329 : : log_startup_progress_interval);
330 : : }
331 : :
332 : : /*
333 : : * A thin wrapper to first disable and then enable the startup progress
334 : : * timeout.
335 : : */
336 : : void
337 : 549 : begin_startup_progress_phase(void)
338 : : {
339 : : /* Feature is disabled. */
340 [ - + ]: 549 : if (log_startup_progress_interval == 0)
341 : 0 : return;
342 : :
343 : 549 : disable_startup_progress_timeout();
344 : 549 : enable_startup_progress_timeout();
345 : : }
346 : :
347 : : /*
348 : : * Report whether startup progress timeout has occurred. Reset the timer flag
349 : : * if it did, set the elapsed time to the out parameters and return true,
350 : : * otherwise return false.
351 : : */
352 : : bool
353 : 329128 : has_startup_progress_timeout_expired(long *secs, int *usecs)
354 : : {
355 : : long seconds;
356 : : int useconds;
357 : : TimestampTz now;
358 : :
359 : : /* No timeout has occurred. */
360 [ + - ]: 329128 : if (!startup_progress_timer_expired)
361 : 329128 : return false;
362 : :
363 : : /* Calculate the elapsed time. */
364 : 0 : now = GetCurrentTimestamp();
365 : 0 : TimestampDifference(startup_progress_phase_start_time, now, &seconds, &useconds);
366 : :
367 : 0 : *secs = seconds;
368 : 0 : *usecs = useconds;
369 : 0 : startup_progress_timer_expired = false;
370 : :
371 : 0 : return true;
372 : : }
|