Debian Codegraph @

src/backend/postmaster/checkpointer.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * checkpointer.c
4 *
5 * The checkpointer is new as of Postgres 9.2. It handles all checkpoints.
6 * Checkpoints are automatically dispatched after a certain amount of time has
7 * elapsed since the last one, and it can be signaled to perform requested
8 * checkpoints as well. (The GUC parameter that mandates a checkpoint every
9 * so many WAL segments is implemented by having backends signal when they
10 * fill WAL segments; the checkpointer itself doesn't watch for the
11 * condition.)
12 *
13 * The normal termination sequence is that checkpointer is instructed to
14 * execute the shutdown checkpoint by SIGINT. After that checkpointer waits
15 * to be terminated via SIGUSR2, which instructs the checkpointer to exit(0).
16 * All backends must be stopped before SIGINT or SIGUSR2 is issued!
17 *
18 * Emergency termination is by SIGQUIT; like any backend, the checkpointer
19 * will simply abort and exit on SIGQUIT.
20 *
21 * If the checkpointer exits unexpectedly, the postmaster treats that the same
22 * as a backend crash: shared memory may be corrupted, so remaining backends
23 * should be killed by SIGQUIT and then a recovery cycle started. (Even if
24 * shared memory isn't corrupted, we have lost information about which
25 * files need to be fsync'd for the next checkpoint, and so a system
26 * restart needs to be forced.)
27 *
28 *
29 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
30 *
31 *
32 * IDENTIFICATION
33 * src/backend/postmaster/checkpointer.c
34 *
35 *-------------------------------------------------------------------------
36 */
37 #include "postgres.h"
38
39 #include <sys/time.h>
40 #include <time.h>
41
42 #include "access/xlog.h"
43 #include "access/xlog_internal.h"
44 #include "access/xlogrecovery.h"
45 #include "libpq/pqsignal.h"
46 #include "miscadmin.h"
47 #include "pgstat.h"
48 #include "postmaster/auxprocess.h"
49 #include "postmaster/bgwriter.h"
50 #include "postmaster/interrupt.h"
51 #include "replication/syncrep.h"
52 #include "storage/aio_subsys.h"
53 #include "storage/bufmgr.h"
54 #include "storage/condition_variable.h"
55 #include "storage/fd.h"
56 #include "storage/ipc.h"
57 #include "storage/lwlock.h"
58 #include "storage/pmsignal.h"
59 #include "storage/proc.h"
60 #include "storage/procsignal.h"
61 #include "storage/shmem.h"
62 #include "storage/smgr.h"
63 #include "storage/spin.h"
64 #include "utils/guc.h"
65 #include "utils/memutils.h"
66 #include "utils/resowner.h"
67
68
69 /*----------
70 * Shared memory area for communication between checkpointer and backends
71 *
72 * The ckpt counters allow backends to watch for completion of a checkpoint
73 * request they send. Here's how it works:
74 * * At start of a checkpoint, checkpointer reads (and clears) the request
75 * flags and increments ckpt_started, while holding ckpt_lck.
76 * * On completion of a checkpoint, checkpointer sets ckpt_done to
77 * equal ckpt_started.
78 * * On failure of a checkpoint, checkpointer increments ckpt_failed
79 * and sets ckpt_done to equal ckpt_started.
80 *
81 * The algorithm for backends is:
82 * 1. Record current values of ckpt_failed and ckpt_started, and
83 * set request flags, while holding ckpt_lck.
84 * 2. Send signal to request checkpoint.
85 * 3. Sleep until ckpt_started changes. Now you know a checkpoint has
86 * begun since you started this algorithm (although *not* that it was
87 * specifically initiated by your signal), and that it is using your flags.
88 * 4. Record new value of ckpt_started.
89 * 5. Sleep until ckpt_done >= saved value of ckpt_started. (Use modulo
90 * arithmetic here in case counters wrap around.) Now you know a
91 * checkpoint has started and completed, but not whether it was
92 * successful.
93 * 6. If ckpt_failed is different from the originally saved value,
94 * assume request failed; otherwise it was definitely successful.
95 *
96 * ckpt_flags holds the OR of the checkpoint request flags sent by all
97 * requesting backends since the last checkpoint start. The flags are
98 * chosen so that OR'ing is the correct way to combine multiple requests.
99 *
100 * The requests array holds fsync requests sent by backends and not yet
101 * absorbed by the checkpointer.
102 *
103 * Unlike the checkpoint fields, requests related fields are protected by
104 * CheckpointerCommLock.
105 *----------
106 */
107 typedef struct
108 {
109 SyncRequestType type; /* request type */
110 FileTag ftag; /* file identifier */
111 } CheckpointerRequest;
112
113 typedef struct
114 {
115 pid_t checkpointer_pid; /* PID (0 if not started) */
116
117 slock_t ckpt_lck; /* protects all the ckpt_* fields */
118
119 int ckpt_started; /* advances when checkpoint starts */
120 int ckpt_done; /* advances when checkpoint done */
121 int ckpt_failed; /* advances when checkpoint fails */
122
123 int ckpt_flags; /* checkpoint flags, as defined in xlog.h */
124
125 ConditionVariable start_cv; /* signaled when ckpt_started advances */
126 ConditionVariable done_cv; /* signaled when ckpt_done advances */
127
128 int num_requests; /* current # of requests */
129 int max_requests; /* allocated array size */
130 CheckpointerRequest requests[FLEXIBLE_ARRAY_MEMBER];
131 } CheckpointerShmemStruct;
132
133 static CheckpointerShmemStruct *CheckpointerShmem;
134
135 /* interval for calling AbsorbSyncRequests in CheckpointWriteDelay */
136 #define WRITES_PER_ABSORB 1000
137
138 /* Max number of requests the checkpointer request queue can hold */
139 #define MAX_CHECKPOINT_REQUESTS 10000000
140
141 /*
142 * GUC parameters
143 */
144 int CheckPointTimeout = 300;
145 int CheckPointWarning = 30;
146 double CheckPointCompletionTarget = 0.9;
147
148 /*
149 * Private state
150 */
151 static bool ckpt_active = false;
152 static volatile sig_atomic_t ShutdownXLOGPending = false;
153
154 /* these values are valid when ckpt_active is true: */
155 static pg_time_t ckpt_start_time;
156 static XLogRecPtr ckpt_start_recptr;
157 static double ckpt_cached_elapsed;
158
159 static pg_time_t last_checkpoint_time;
160 static pg_time_t last_xlog_switch_time;
161
162 /* Prototypes for private functions */
163
164 static void ProcessCheckpointerInterrupts(void);
165 static void CheckArchiveTimeout(void);
166 static bool IsCheckpointOnSchedule(double progress);
167 static bool ImmediateCheckpointRequested(void);
168 static bool CompactCheckpointerRequestQueue(void);
169 static void UpdateSharedMemoryConfig(void);
170
171 /* Signal handlers */
172 static void ReqShutdownXLOG(SIGNAL_ARGS);
173
174
175 /*
176 * Main entry point for checkpointer process
177 *
178 * This is invoked from AuxiliaryProcessMain, which has already created the
179 * basic execution environment, but not enabled signals yet.
180 */
181 void
182 CheckpointerMain(const void *startup_data, size_t startup_data_len)
183 {
184 sigjmp_buf local_sigjmp_buf;
185 MemoryContext checkpointer_context;
186
187 Assert(startup_data_len == 0);
188
189 MyBackendType = B_CHECKPOINTER;
190 AuxiliaryProcessMainCommon();
191
192 CheckpointerShmem->checkpointer_pid = MyProcPid;
193
194 /*
195 * Properly accept or ignore signals the postmaster might send us
196 *
197 * Note: we deliberately ignore SIGTERM, because during a standard Unix
198 * system shutdown cycle, init will SIGTERM all processes at once. We
199 * want to wait for the backends to exit, whereupon the postmaster will
200 * tell us it's okay to shut down (via SIGUSR2).
201 */
202 pqsignal(SIGHUP, SignalHandlerForConfigReload);
203 pqsignal(SIGINT, ReqShutdownXLOG);
204 pqsignal(SIGTERM, SIG_IGN); /* ignore SIGTERM */
205 /* SIGQUIT handler was already set up by InitPostmasterChild */
206 pqsignal(SIGALRM, SIG_IGN);
207 pqsignal(SIGPIPE, SIG_IGN);
208 pqsignal(SIGUSR1, procsignal_sigusr1_handler);
209 pqsignal(SIGUSR2, SignalHandlerForShutdownRequest);
210
211 /*
212 * Reset some signals that are accepted by postmaster but not here
213 */
214 pqsignal(SIGCHLD, SIG_DFL);
215
216 /*
217 * Initialize so that first time-driven event happens at the correct time.
218 */
219 last_checkpoint_time = last_xlog_switch_time = (pg_time_t) time(NULL);
220
221 /*
222 * Write out stats after shutdown. This needs to be called by exactly one
223 * process during a normal shutdown, and since checkpointer is shut down
224 * very late...
225 *
226 * While e.g. walsenders are active after the shutdown checkpoint has been
227 * written (and thus could produce more stats), checkpointer stays around
228 * after the shutdown checkpoint has been written. postmaster will only
229 * signal checkpointer to exit after all processes that could emit stats
230 * have been shut down.
231 */
232 before_shmem_exit(pgstat_before_server_shutdown, 0);
233
234 /*
235 * Create a memory context that we will do all our work in. We do this so
236 * that we can reset the context during error recovery and thereby avoid
237 * possible memory leaks. Formerly this code just ran in
238 * TopMemoryContext, but resetting that would be a really bad idea.
239 */
240 checkpointer_context = AllocSetContextCreate(TopMemoryContext,
241 "Checkpointer",
242 ALLOCSET_DEFAULT_SIZES);
243 MemoryContextSwitchTo(checkpointer_context);
244
245 /*
246 * If an exception is encountered, processing resumes here.
247 *
248 * You might wonder why this isn't coded as an infinite loop around a
249 * PG_TRY construct. The reason is that this is the bottom of the
250 * exception stack, and so with PG_TRY there would be no exception handler
251 * in force at all during the CATCH part. By leaving the outermost setjmp
252 * always active, we have at least some chance of recovering from an error
253 * during error recovery. (If we get into an infinite loop thereby, it
254 * will soon be stopped by overflow of elog.c's internal state stack.)
255 *
256 * Note that we use sigsetjmp(..., 1), so that the prevailing signal mask
257 * (to wit, BlockSig) will be restored when longjmp'ing to here. Thus,
258 * signals other than SIGQUIT will be blocked until we complete error
259 * recovery. It might seem that this policy makes the HOLD_INTERRUPTS()
260 * call redundant, but it is not since InterruptPending might be set
261 * already.
262 */
263 if (sigsetjmp(local_sigjmp_buf, 1) != 0)
264 {
265 /* Since not using PG_TRY, must reset error stack by hand */
266 error_context_stack = NULL;
267
268 /* Prevent interrupts while cleaning up */
269 HOLD_INTERRUPTS();
270
271 /* Report the error to the server log */
272 EmitErrorReport();
273
274 /*
275 * These operations are really just a minimal subset of
276 * AbortTransaction(). We don't have very many resources to worry
277 * about in checkpointer, but we do have LWLocks, buffers, and temp
278 * files.
279 */
280 LWLockReleaseAll();
281 ConditionVariableCancelSleep();
282 pgstat_report_wait_end();
283 pgaio_error_cleanup();
284 UnlockBuffers();
285 ReleaseAuxProcessResources(false);
286 AtEOXact_Buffers(false);
287 AtEOXact_SMgr();
288 AtEOXact_Files(false);
289 AtEOXact_HashTables(false);
290
291 /* Warn any waiting backends that the checkpoint failed. */
292 if (ckpt_active)
293 {
294 SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
295 CheckpointerShmem->ckpt_failed++;
296 CheckpointerShmem->ckpt_done = CheckpointerShmem->ckpt_started;
297 SpinLockRelease(&CheckpointerShmem->ckpt_lck);
298
299 ConditionVariableBroadcast(&CheckpointerShmem->done_cv);
300
301 ckpt_active = false;
302 }
303
304 /*
305 * Now return to normal top-level context and clear ErrorContext for
306 * next time.
307 */
308 MemoryContextSwitchTo(checkpointer_context);
309 FlushErrorState();
310
311 /* Flush any leaked data in the top-level context */
312 MemoryContextReset(checkpointer_context);
313
314 /* Now we can allow interrupts again */
315 RESUME_INTERRUPTS();
316
317 /*
318 * Sleep at least 1 second after any error. A write error is likely
319 * to be repeated, and we don't want to be filling the error logs as
320 * fast as we can.
321 */
322 pg_usleep(1000000L);
323 }
324
325 /* We can now handle ereport(ERROR) */
326 PG_exception_stack = &local_sigjmp_buf;
327
328 /*
329 * Unblock signals (they were blocked when the postmaster forked us)
330 */
331 sigprocmask(SIG_SETMASK, &UnBlockSig, NULL);
332
333 /*
334 * Ensure all shared memory values are set correctly for the config. Doing
335 * this here ensures no race conditions from other concurrent updaters.
336 */
337 UpdateSharedMemoryConfig();
338
339 /*
340 * Advertise our proc number that backends can use to wake us up while
341 * we're sleeping.
342 */
343 ProcGlobal->checkpointerProc = MyProcNumber;
344
345 /*
346 * Loop until we've been asked to write the shutdown checkpoint or
347 * terminate.
348 */
349 for (;;)
350 {
351 bool do_checkpoint = false;
352 int flags = 0;
353 pg_time_t now;
354 int elapsed_secs;
355 int cur_timeout;
356 bool chkpt_or_rstpt_requested = false;
357 bool chkpt_or_rstpt_timed = false;
358
359 /* Clear any already-pending wakeups */
360 ResetLatch(MyLatch);
361
362 /*
363 * Process any requests or signals received recently.
364 */
365 AbsorbSyncRequests();
366
367 ProcessCheckpointerInterrupts();
368 if (ShutdownXLOGPending || ShutdownRequestPending)
369 break;
370
371 /*
372 * Detect a pending checkpoint request by checking whether the flags
373 * word in shared memory is nonzero. We shouldn't need to acquire the
374 * ckpt_lck for this.
375 */
376 if (((volatile CheckpointerShmemStruct *) CheckpointerShmem)->ckpt_flags)
377 {
378 do_checkpoint = true;
379 chkpt_or_rstpt_requested = true;
380 }
381
382 /*
383 * Force a checkpoint if too much time has elapsed since the last one.
384 * Note that we count a timed checkpoint in stats only when this
385 * occurs without an external request, but we set the CAUSE_TIME flag
386 * bit even if there is also an external request.
387 */
388 now = (pg_time_t) time(NULL);
389 elapsed_secs = now - last_checkpoint_time;
390 if (elapsed_secs >= CheckPointTimeout)
391 {
392 if (!do_checkpoint)
393 chkpt_or_rstpt_timed = true;
394 do_checkpoint = true;
395 flags |= CHECKPOINT_CAUSE_TIME;
396 }
397
398 /*
399 * Do a checkpoint if requested.
400 */
401 if (do_checkpoint)
402 {
403 bool ckpt_performed = false;
404 bool do_restartpoint;
405
406 /* Check if we should perform a checkpoint or a restartpoint. */
407 do_restartpoint = RecoveryInProgress();
408
409 /*
410 * Atomically fetch the request flags to figure out what kind of a
411 * checkpoint we should perform, and increase the started-counter
412 * to acknowledge that we've started a new checkpoint.
413 */
414 SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
415 flags |= CheckpointerShmem->ckpt_flags;
416 CheckpointerShmem->ckpt_flags = 0;
417 CheckpointerShmem->ckpt_started++;
418 SpinLockRelease(&CheckpointerShmem->ckpt_lck);
419
420 ConditionVariableBroadcast(&CheckpointerShmem->start_cv);
421
422 /*
423 * The end-of-recovery checkpoint is a real checkpoint that's
424 * performed while we're still in recovery.
425 */
426 if (flags & CHECKPOINT_END_OF_RECOVERY)
427 do_restartpoint = false;
428
429 if (chkpt_or_rstpt_timed)
430 {
431 chkpt_or_rstpt_timed = false;
432 if (do_restartpoint)
433 PendingCheckpointerStats.restartpoints_timed++;
434 else
435 PendingCheckpointerStats.num_timed++;
436 }
437
438 if (chkpt_or_rstpt_requested)
439 {
440 chkpt_or_rstpt_requested = false;
441 if (do_restartpoint)
442 PendingCheckpointerStats.restartpoints_requested++;
443 else
444 PendingCheckpointerStats.num_requested++;
445 }
446
447 /*
448 * We will warn if (a) too soon since last checkpoint (whatever
449 * caused it) and (b) somebody set the CHECKPOINT_CAUSE_XLOG flag
450 * since the last checkpoint start. Note in particular that this
451 * implementation will not generate warnings caused by
452 * CheckPointTimeout < CheckPointWarning.
453 */
454 if (!do_restartpoint &&
455 (flags & CHECKPOINT_CAUSE_XLOG) &&
456 elapsed_secs < CheckPointWarning)
457 ereport(LOG,
458 (errmsg_plural("checkpoints are occurring too frequently (%d second apart)",
459 "checkpoints are occurring too frequently (%d seconds apart)",
460 elapsed_secs,
461 elapsed_secs),
462 errhint("Consider increasing the configuration parameter \"%s\".", "max_wal_size")));
463
464 /*
465 * Initialize checkpointer-private variables used during
466 * checkpoint.
467 */
468 ckpt_active = true;
469 if (do_restartpoint)
470 ckpt_start_recptr = GetXLogReplayRecPtr(NULL);
471 else
472 ckpt_start_recptr = GetInsertRecPtr();
473 ckpt_start_time = now;
474 ckpt_cached_elapsed = 0;
475
476 /*
477 * Do the checkpoint.
478 */
479 if (!do_restartpoint)
480 ckpt_performed = CreateCheckPoint(flags);
481 else
482 ckpt_performed = CreateRestartPoint(flags);
483
484 /*
485 * After any checkpoint, free all smgr objects. Otherwise we
486 * would never do so for dropped relations, as the checkpointer
487 * does not process shared invalidation messages or call
488 * AtEOXact_SMgr().
489 */
490 smgrdestroyall();
491
492 /*
493 * Indicate checkpoint completion to any waiting backends.
494 */
495 SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
496 CheckpointerShmem->ckpt_done = CheckpointerShmem->ckpt_started;
497 SpinLockRelease(&CheckpointerShmem->ckpt_lck);
498
499 ConditionVariableBroadcast(&CheckpointerShmem->done_cv);
500
501 if (!do_restartpoint)
502 {
503 /*
504 * Note we record the checkpoint start time not end time as
505 * last_checkpoint_time. This is so that time-driven
506 * checkpoints happen at a predictable spacing.
507 */
508 last_checkpoint_time = now;
509
510 if (ckpt_performed)
511 PendingCheckpointerStats.num_performed++;
512 }
513 else
514 {
515 if (ckpt_performed)
516 {
517 /*
518 * The same as for checkpoint. Please see the
519 * corresponding comment.
520 */
521 last_checkpoint_time = now;
522
523 PendingCheckpointerStats.restartpoints_performed++;
524 }
525 else
526 {
527 /*
528 * We were not able to perform the restartpoint
529 * (checkpoints throw an ERROR in case of error). Most
530 * likely because we have not received any new checkpoint
531 * WAL records since the last restartpoint. Try again in
532 * 15 s.
533 */
534 last_checkpoint_time = now - CheckPointTimeout + 15;
535 }
536 }
537
538 ckpt_active = false;
539
540 /*
541 * We may have received an interrupt during the checkpoint and the
542 * latch might have been reset (e.g. in CheckpointWriteDelay).
543 */
544 ProcessCheckpointerInterrupts();
545 if (ShutdownXLOGPending || ShutdownRequestPending)
546 break;
547 }
548
549 /* Check for archive_timeout and switch xlog files if necessary. */
550 CheckArchiveTimeout();
551
552 /* Report pending statistics to the cumulative stats system */
553 pgstat_report_checkpointer();
554 pgstat_report_wal(true);
555
556 /*
557 * If any checkpoint flags have been set, redo the loop to handle the
558 * checkpoint without sleeping.
559 */
560 if (((volatile CheckpointerShmemStruct *) CheckpointerShmem)->ckpt_flags)
561 continue;
562
563 /*
564 * Sleep until we are signaled or it's time for another checkpoint or
565 * xlog file switch.
566 */
567 now = (pg_time_t) time(NULL);
568 elapsed_secs = now - last_checkpoint_time;
569 if (elapsed_secs >= CheckPointTimeout)
570 continue; /* no sleep for us ... */
571 cur_timeout = CheckPointTimeout - elapsed_secs;
572 if (XLogArchiveTimeout > 0 && !RecoveryInProgress())
573 {
574 elapsed_secs = now - last_xlog_switch_time;
575 if (elapsed_secs >= XLogArchiveTimeout)
576 continue; /* no sleep for us ... */
577 cur_timeout = Min(cur_timeout, XLogArchiveTimeout - elapsed_secs);
578 }
579
580 (void) WaitLatch(MyLatch,
581 WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
582 cur_timeout * 1000L /* convert to ms */ ,
583 WAIT_EVENT_CHECKPOINTER_MAIN);
584 }
585
586 /*
587 * From here on, elog(ERROR) should end with exit(1), not send control
588 * back to the sigsetjmp block above.
589 */
590 ExitOnAnyError = true;
591
592 if (ShutdownXLOGPending)
593 {
594 /*
595 * Close down the database.
596 *
597 * Since ShutdownXLOG() creates restartpoint or checkpoint, and
598 * updates the statistics, increment the checkpoint request and flush
599 * out pending statistic.
600 */
601 PendingCheckpointerStats.num_requested++;
602 ShutdownXLOG(0, 0);
603 pgstat_report_checkpointer();
604 pgstat_report_wal(true);
605
606 /*
607 * Tell postmaster that we're done.
608 */
609 SendPostmasterSignal(PMSIGNAL_XLOG_IS_SHUTDOWN);
610 ShutdownXLOGPending = false;
611 }
612
613 /*
614 * Wait until we're asked to shut down. By separating the writing of the
615 * shutdown checkpoint from checkpointer exiting, checkpointer can perform
616 * some should-be-as-late-as-possible work like writing out stats.
617 */
618 for (;;)
619 {
620 /* Clear any already-pending wakeups */
621 ResetLatch(MyLatch);
622
623 ProcessCheckpointerInterrupts();
624
625 if (ShutdownRequestPending)
626 break;
627
628 (void) WaitLatch(MyLatch,
629 WL_LATCH_SET | WL_EXIT_ON_PM_DEATH,
630 0,
631 WAIT_EVENT_CHECKPOINTER_SHUTDOWN);
632 }
633
634 /* Normal exit from the checkpointer is here */
635 proc_exit(0); /* done */
636 }
637
638 /*
639 * Process any new interrupts.
640 */
641 static void
642 ProcessCheckpointerInterrupts(void)
643 {
644 if (ProcSignalBarrierPending)
645 ProcessProcSignalBarrier();
646
647 if (ConfigReloadPending)
648 {
649 ConfigReloadPending = false;
650 ProcessConfigFile(PGC_SIGHUP);
651
652 /*
653 * Checkpointer is the last process to shut down, so we ask it to hold
654 * the keys for a range of other tasks required most of which have
655 * nothing to do with checkpointing at all.
656 *
657 * For various reasons, some config values can change dynamically so
658 * the primary copy of them is held in shared memory to make sure all
659 * backends see the same value. We make Checkpointer responsible for
660 * updating the shared memory copy if the parameter setting changes
661 * because of SIGHUP.
662 */
663 UpdateSharedMemoryConfig();
664 }
665
666 /* Perform logging of memory contexts of this process */
667 if (LogMemoryContextPending)
668 ProcessLogMemoryContextInterrupt();
669 }
670
671 /*
672 * CheckArchiveTimeout -- check for archive_timeout and switch xlog files
673 *
674 * This will switch to a new WAL file and force an archive file write if
675 * meaningful activity is recorded in the current WAL file. This includes most
676 * writes, including just a single checkpoint record, but excludes WAL records
677 * that were inserted with the XLOG_MARK_UNIMPORTANT flag being set (like
678 * snapshots of running transactions). Such records, depending on
679 * configuration, occur on regular intervals and don't contain important
680 * information. This avoids generating archives with a few unimportant
681 * records.
682 */
683 static void
684 CheckArchiveTimeout(void)
685 {
686 pg_time_t now;
687 pg_time_t last_time;
688 XLogRecPtr last_switch_lsn;
689
690 if (XLogArchiveTimeout <= 0 || RecoveryInProgress())
691 return;
692
693 now = (pg_time_t) time(NULL);
694
695 /* First we do a quick check using possibly-stale local state. */
696 if ((int) (now - last_xlog_switch_time) < XLogArchiveTimeout)
697 return;
698
699 /*
700 * Update local state ... note that last_xlog_switch_time is the last time
701 * a switch was performed *or requested*.
702 */
703 last_time = GetLastSegSwitchData(&last_switch_lsn);
704
705 last_xlog_switch_time = Max(last_xlog_switch_time, last_time);
706
707 /* Now we can do the real checks */
708 if ((int) (now - last_xlog_switch_time) >= XLogArchiveTimeout)
709 {
710 /*
711 * Switch segment only when "important" WAL has been logged since the
712 * last segment switch (last_switch_lsn points to end of segment
713 * switch occurred in).
714 */
715 if (GetLastImportantRecPtr() > last_switch_lsn)
716 {
717 XLogRecPtr switchpoint;
718
719 /* mark switch as unimportant, avoids triggering checkpoints */
720 switchpoint = RequestXLogSwitch(true);
721
722 /*
723 * If the returned pointer points exactly to a segment boundary,
724 * assume nothing happened.
725 */
726 if (XLogSegmentOffset(switchpoint, wal_segment_size) != 0)
727 elog(DEBUG1, "write-ahead log switch forced (\"archive_timeout\"=%d)",
728 XLogArchiveTimeout);
729 }
730
731 /*
732 * Update state in any case, so we don't retry constantly when the
733 * system is idle.
734 */
735 last_xlog_switch_time = now;
736 }
737 }
738
739 /*
740 * Returns true if an immediate checkpoint request is pending. (Note that
741 * this does not check the *current* checkpoint's IMMEDIATE flag, but whether
742 * there is one pending behind it.)
743 */
744 static bool
745 ImmediateCheckpointRequested(void)
746 {
747 volatile CheckpointerShmemStruct *cps = CheckpointerShmem;
748
749 /*
750 * We don't need to acquire the ckpt_lck in this case because we're only
751 * looking at a single flag bit.
752 */
753 if (cps->ckpt_flags & CHECKPOINT_IMMEDIATE)
754 return true;
755 return false;
756 }
757
758 /*
759 * CheckpointWriteDelay -- control rate of checkpoint
760 *
761 * This function is called after each page write performed by BufferSync().
762 * It is responsible for throttling BufferSync()'s write rate to hit
763 * checkpoint_completion_target.
764 *
765 * The checkpoint request flags should be passed in; currently the only one
766 * examined is CHECKPOINT_IMMEDIATE, which disables delays between writes.
767 *
768 * 'progress' is an estimate of how much of the work has been done, as a
769 * fraction between 0.0 meaning none, and 1.0 meaning all done.
770 */
771 void
772 CheckpointWriteDelay(int flags, double progress)
773 {
774 static int absorb_counter = WRITES_PER_ABSORB;
775
776 /* Do nothing if checkpoint is being executed by non-checkpointer process */
777 if (!AmCheckpointerProcess())
778 return;
779
780 /*
781 * Perform the usual duties and take a nap, unless we're behind schedule,
782 * in which case we just try to catch up as quickly as possible.
783 */
784 if (!(flags & CHECKPOINT_IMMEDIATE) &&
785 !ShutdownXLOGPending &&
786 !ShutdownRequestPending &&
787 !ImmediateCheckpointRequested() &&
788 IsCheckpointOnSchedule(progress))
789 {
790 if (ConfigReloadPending)
791 {
792 ConfigReloadPending = false;
793 ProcessConfigFile(PGC_SIGHUP);
794 /* update shmem copies of config variables */
795 UpdateSharedMemoryConfig();
796 }
797
798 AbsorbSyncRequests();
799 absorb_counter = WRITES_PER_ABSORB;
800
801 CheckArchiveTimeout();
802
803 /* Report interim statistics to the cumulative stats system */
804 pgstat_report_checkpointer();
805
806 /*
807 * This sleep used to be connected to bgwriter_delay, typically 200ms.
808 * That resulted in more frequent wakeups if not much work to do.
809 * Checkpointer and bgwriter are no longer related so take the Big
810 * Sleep.
811 */
812 WaitLatch(MyLatch, WL_LATCH_SET | WL_EXIT_ON_PM_DEATH | WL_TIMEOUT,
813 100,
814 WAIT_EVENT_CHECKPOINT_WRITE_DELAY);
815 ResetLatch(MyLatch);
816 }
817 else if (--absorb_counter <= 0)
818 {
819 /*
820 * Absorb pending fsync requests after each WRITES_PER_ABSORB write
821 * operations even when we don't sleep, to prevent overflow of the
822 * fsync request queue.
823 */
824 AbsorbSyncRequests();
825 absorb_counter = WRITES_PER_ABSORB;
826 }
827
828 /* Check for barrier events. */
829 if (ProcSignalBarrierPending)
830 ProcessProcSignalBarrier();
831 }
832
833 /*
834 * IsCheckpointOnSchedule -- are we on schedule to finish this checkpoint
835 * (or restartpoint) in time?
836 *
837 * Compares the current progress against the time/segments elapsed since last
838 * checkpoint, and returns true if the progress we've made this far is greater
839 * than the elapsed time/segments.
840 */
841 static bool
842 IsCheckpointOnSchedule(double progress)
843 {
844 XLogRecPtr recptr;
845 struct timeval now;
846 double elapsed_xlogs,
847 elapsed_time;
848
849 Assert(ckpt_active);
850
851 /* Scale progress according to checkpoint_completion_target. */
852 progress *= CheckPointCompletionTarget;
853
854 /*
855 * Check against the cached value first. Only do the more expensive
856 * calculations once we reach the target previously calculated. Since
857 * neither time or WAL insert pointer moves backwards, a freshly
858 * calculated value can only be greater than or equal to the cached value.
859 */
860 if (progress < ckpt_cached_elapsed)
861 return false;
862
863 /*
864 * Check progress against WAL segments written and CheckPointSegments.
865 *
866 * We compare the current WAL insert location against the location
867 * computed before calling CreateCheckPoint. The code in XLogInsert that
868 * actually triggers a checkpoint when CheckPointSegments is exceeded
869 * compares against RedoRecPtr, so this is not completely accurate.
870 * However, it's good enough for our purposes, we're only calculating an
871 * estimate anyway.
872 *
873 * During recovery, we compare last replayed WAL record's location with
874 * the location computed before calling CreateRestartPoint. That maintains
875 * the same pacing as we have during checkpoints in normal operation, but
876 * we might exceed max_wal_size by a fair amount. That's because there can
877 * be a large gap between a checkpoint's redo-pointer and the checkpoint
878 * record itself, and we only start the restartpoint after we've seen the
879 * checkpoint record. (The gap is typically up to CheckPointSegments *
880 * checkpoint_completion_target where checkpoint_completion_target is the
881 * value that was in effect when the WAL was generated).
882 */
883 if (RecoveryInProgress())
884 recptr = GetXLogReplayRecPtr(NULL);
885 else
886 recptr = GetInsertRecPtr();
887 elapsed_xlogs = (((double) (recptr - ckpt_start_recptr)) /
888 wal_segment_size) / CheckPointSegments;
889
890 if (progress < elapsed_xlogs)
891 {
892 ckpt_cached_elapsed = elapsed_xlogs;
893 return false;
894 }
895
896 /*
897 * Check progress against time elapsed and checkpoint_timeout.
898 */
899 gettimeofday(&now, NULL);
900 elapsed_time = ((double) ((pg_time_t) now.tv_sec - ckpt_start_time) +
901 now.tv_usec / 1000000.0) / CheckPointTimeout;
902
903 if (progress < elapsed_time)
904 {
905 ckpt_cached_elapsed = elapsed_time;
906 return false;
907 }
908
909 /* It looks like we're on schedule. */
910 return true;
911 }
912
913
914 /* --------------------------------
915 * signal handler routines
916 * --------------------------------
917 */
918
919 /* SIGINT: set flag to trigger writing of shutdown checkpoint */
920 static void
921 ReqShutdownXLOG(SIGNAL_ARGS)
922 {
923 ShutdownXLOGPending = true;
924 SetLatch(MyLatch);
925 }
926
927
928 /* --------------------------------
929 * communication with backends
930 * --------------------------------
931 */
932
933 /*
934 * CheckpointerShmemSize
935 * Compute space needed for checkpointer-related shared memory
936 */
937 Size
938 CheckpointerShmemSize(void)
939 {
940 Size size;
941
942 /*
943 * The size of the requests[] array is arbitrarily set equal to NBuffers.
944 * But there is a cap of MAX_CHECKPOINT_REQUESTS to prevent accumulating
945 * too many checkpoint requests in the ring buffer.
946 */
947 size = offsetof(CheckpointerShmemStruct, requests);
948 size = add_size(size, mul_size(Min(NBuffers,
949 MAX_CHECKPOINT_REQUESTS),
950 sizeof(CheckpointerRequest)));
951
952 return size;
953 }
954
955 /*
956 * CheckpointerShmemInit
957 * Allocate and initialize checkpointer-related shared memory
958 */
959 void
960 CheckpointerShmemInit(void)
961 {
962 Size size = CheckpointerShmemSize();
963 bool found;
964
965 CheckpointerShmem = (CheckpointerShmemStruct *)
966 ShmemInitStruct("Checkpointer Data",
967 size,
968 &found);
969
970 if (!found)
971 {
972 /*
973 * First time through, so initialize. Note that we zero the whole
974 * requests array; this is so that CompactCheckpointerRequestQueue can
975 * assume that any pad bytes in the request structs are zeroes.
976 */
977 MemSet(CheckpointerShmem, 0, size);
978 SpinLockInit(&CheckpointerShmem->ckpt_lck);
979 CheckpointerShmem->max_requests = Min(NBuffers, MAX_CHECKPOINT_REQUESTS);
980 ConditionVariableInit(&CheckpointerShmem->start_cv);
981 ConditionVariableInit(&CheckpointerShmem->done_cv);
982 }
983 }
984
985 /*
986 * RequestCheckpoint
987 * Called in backend processes to request a checkpoint
988 *
989 * flags is a bitwise OR of the following:
990 * CHECKPOINT_IS_SHUTDOWN: checkpoint is for database shutdown.
991 * CHECKPOINT_END_OF_RECOVERY: checkpoint is for end of WAL recovery.
992 * CHECKPOINT_IMMEDIATE: finish the checkpoint ASAP,
993 * ignoring checkpoint_completion_target parameter.
994 * CHECKPOINT_FORCE: force a checkpoint even if no XLOG activity has occurred
995 * since the last one (implied by CHECKPOINT_IS_SHUTDOWN or
996 * CHECKPOINT_END_OF_RECOVERY).
997 * CHECKPOINT_WAIT: wait for completion before returning (otherwise,
998 * just signal checkpointer to do it, and return).
999 * CHECKPOINT_CAUSE_XLOG: checkpoint is requested due to xlog filling.
1000 * (This affects logging, and in particular enables CheckPointWarning.)
1001 */
1002 void
1003 RequestCheckpoint(int flags)
1004 {
1005 int ntries;
1006 int old_failed,
1007 old_started;
1008
1009 /*
1010 * If in a standalone backend, just do it ourselves.
1011 */
1012 if (!IsPostmasterEnvironment)
1013 {
1014 /*
1015 * There's no point in doing slow checkpoints in a standalone backend,
1016 * because there's no other backends the checkpoint could disrupt.
1017 */
1018 CreateCheckPoint(flags | CHECKPOINT_IMMEDIATE);
1019
1020 /* Free all smgr objects, as CheckpointerMain() normally would. */
1021 smgrdestroyall();
1022
1023 return;
1024 }
1025
1026 /*
1027 * Atomically set the request flags, and take a snapshot of the counters.
1028 * When we see ckpt_started > old_started, we know the flags we set here
1029 * have been seen by checkpointer.
1030 *
1031 * Note that we OR the flags with any existing flags, to avoid overriding
1032 * a "stronger" request by another backend. The flag senses must be
1033 * chosen to make this work!
1034 */
1035 SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
1036
1037 old_failed = CheckpointerShmem->ckpt_failed;
1038 old_started = CheckpointerShmem->ckpt_started;
1039 CheckpointerShmem->ckpt_flags |= (flags | CHECKPOINT_REQUESTED);
1040
1041 SpinLockRelease(&CheckpointerShmem->ckpt_lck);
1042
1043 /*
1044 * Set checkpointer's latch to request checkpoint. It's possible that the
1045 * checkpointer hasn't started yet, so we will retry a few times if
1046 * needed. (Actually, more than a few times, since on slow or overloaded
1047 * buildfarm machines, it's been observed that the checkpointer can take
1048 * several seconds to start.) However, if not told to wait for the
1049 * checkpoint to occur, we consider failure to set the latch to be
1050 * nonfatal and merely LOG it. The checkpointer should see the request
1051 * when it does start, with or without the SetLatch().
1052 */
1053 #define MAX_SIGNAL_TRIES 600 /* max wait 60.0 sec */
1054 for (ntries = 0;; ntries++)
1055 {
1056 volatile PROC_HDR *procglobal = ProcGlobal;
1057 ProcNumber checkpointerProc = procglobal->checkpointerProc;
1058
1059 if (checkpointerProc == INVALID_PROC_NUMBER)
1060 {
1061 if (ntries >= MAX_SIGNAL_TRIES || !(flags & CHECKPOINT_WAIT))
1062 {
1063 elog((flags & CHECKPOINT_WAIT) ? ERROR : LOG,
1064 "could not notify checkpoint: checkpointer is not running");
1065 break;
1066 }
1067 }
1068 else
1069 {
1070 SetLatch(&GetPGProcByNumber(checkpointerProc)->procLatch);
1071 /* notified successfully */
1072 break;
1073 }
1074
1075 CHECK_FOR_INTERRUPTS();
1076 pg_usleep(100000L); /* wait 0.1 sec, then retry */
1077 }
1078
1079 /*
1080 * If requested, wait for completion. We detect completion according to
1081 * the algorithm given above.
1082 */
1083 if (flags & CHECKPOINT_WAIT)
1084 {
1085 int new_started,
1086 new_failed;
1087
1088 /* Wait for a new checkpoint to start. */
1089 ConditionVariablePrepareToSleep(&CheckpointerShmem->start_cv);
1090 for (;;)
1091 {
1092 SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
1093 new_started = CheckpointerShmem->ckpt_started;
1094 SpinLockRelease(&CheckpointerShmem->ckpt_lck);
1095
1096 if (new_started != old_started)
1097 break;
1098
1099 ConditionVariableSleep(&CheckpointerShmem->start_cv,
1100 WAIT_EVENT_CHECKPOINT_START);
1101 }
1102 ConditionVariableCancelSleep();
1103
1104 /*
1105 * We are waiting for ckpt_done >= new_started, in a modulo sense.
1106 */
1107 ConditionVariablePrepareToSleep(&CheckpointerShmem->done_cv);
1108 for (;;)
1109 {
1110 int new_done;
1111
1112 SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
1113 new_done = CheckpointerShmem->ckpt_done;
1114 new_failed = CheckpointerShmem->ckpt_failed;
1115 SpinLockRelease(&CheckpointerShmem->ckpt_lck);
1116
1117 if (new_done - new_started >= 0)
1118 break;
1119
1120 ConditionVariableSleep(&CheckpointerShmem->done_cv,
1121 WAIT_EVENT_CHECKPOINT_DONE);
1122 }
1123 ConditionVariableCancelSleep();
1124
1125 if (new_failed != old_failed)
1126 ereport(ERROR,
1127 (errmsg("checkpoint request failed"),
1128 errhint("Consult recent messages in the server log for details.")));
1129 }
1130 }
1131
1132 /*
1133 * ForwardSyncRequest
1134 * Forward a file-fsync request from a backend to the checkpointer
1135 *
1136 * Whenever a backend is compelled to write directly to a relation
1137 * (which should be seldom, if the background writer is getting its job done),
1138 * the backend calls this routine to pass over knowledge that the relation
1139 * is dirty and must be fsync'd before next checkpoint. We also use this
1140 * opportunity to count such writes for statistical purposes.
1141 *
1142 * To avoid holding the lock for longer than necessary, we normally write
1143 * to the requests[] queue without checking for duplicates. The checkpointer
1144 * will have to eliminate dups internally anyway. However, if we discover
1145 * that the queue is full, we make a pass over the entire queue to compact
1146 * it. This is somewhat expensive, but the alternative is for the backend
1147 * to perform its own fsync, which is far more expensive in practice. It
1148 * is theoretically possible a backend fsync might still be necessary, if
1149 * the queue is full and contains no duplicate entries. In that case, we
1150 * let the backend know by returning false.
1151 */
1152 bool
1153 ForwardSyncRequest(const FileTag *ftag, SyncRequestType type)
1154 {
1155 CheckpointerRequest *request;
1156 bool too_full;
1157
1158 if (!IsUnderPostmaster)
1159 return false; /* probably shouldn't even get here */
1160
1161 if (AmCheckpointerProcess())
1162 elog(ERROR, "ForwardSyncRequest must not be called in checkpointer");
1163
1164 LWLockAcquire(CheckpointerCommLock, LW_EXCLUSIVE);
1165
1166 /*
1167 * If the checkpointer isn't running or the request queue is full, the
1168 * backend will have to perform its own fsync request. But before forcing
1169 * that to happen, we can try to compact the request queue.
1170 */
1171 if (CheckpointerShmem->checkpointer_pid == 0 ||
1172 (CheckpointerShmem->num_requests >= CheckpointerShmem->max_requests &&
1173 !CompactCheckpointerRequestQueue()))
1174 {
1175 LWLockRelease(CheckpointerCommLock);
1176 return false;
1177 }
1178
1179 /* OK, insert request */
1180 request = &CheckpointerShmem->requests[CheckpointerShmem->num_requests++];
1181 request->ftag = *ftag;
1182 request->type = type;
1183
1184 /* If queue is more than half full, nudge the checkpointer to empty it */
1185 too_full = (CheckpointerShmem->num_requests >=
1186 CheckpointerShmem->max_requests / 2);
1187
1188 LWLockRelease(CheckpointerCommLock);
1189
1190 /* ... but not till after we release the lock */
1191 if (too_full)
1192 {
1193 volatile PROC_HDR *procglobal = ProcGlobal;
1194 ProcNumber checkpointerProc = procglobal->checkpointerProc;
1195
1196 if (checkpointerProc != INVALID_PROC_NUMBER)
1197 SetLatch(&GetPGProcByNumber(checkpointerProc)->procLatch);
1198 }
1199
1200 return true;
1201 }
1202
1203 /*
1204 * CompactCheckpointerRequestQueue
1205 * Remove duplicates from the request queue to avoid backend fsyncs.
1206 * Returns "true" if any entries were removed.
1207 *
1208 * Although a full fsync request queue is not common, it can lead to severe
1209 * performance problems when it does happen. So far, this situation has
1210 * only been observed to occur when the system is under heavy write load,
1211 * and especially during the "sync" phase of a checkpoint. Without this
1212 * logic, each backend begins doing an fsync for every block written, which
1213 * gets very expensive and can slow down the whole system.
1214 *
1215 * Trying to do this every time the queue is full could lose if there
1216 * aren't any removable entries. But that should be vanishingly rare in
1217 * practice: there's one queue entry per shared buffer.
1218 */
1219 static bool
1220 CompactCheckpointerRequestQueue(void)
1221 {
1222 struct CheckpointerSlotMapping
1223 {
1224 CheckpointerRequest request;
1225 int slot;
1226 };
1227
1228 int n,
1229 preserve_count;
1230 int num_skipped = 0;
1231 HASHCTL ctl;
1232 HTAB *htab;
1233 bool *skip_slot;
1234
1235 /* must hold CheckpointerCommLock in exclusive mode */
1236 Assert(LWLockHeldByMe(CheckpointerCommLock));
1237
1238 /* Avoid memory allocations in a critical section. */
1239 if (CritSectionCount > 0)
1240 return false;
1241
1242 /* Initialize skip_slot array */
1243 skip_slot = palloc0(sizeof(bool) * CheckpointerShmem->num_requests);
1244
1245 /* Initialize temporary hash table */
1246 ctl.keysize = sizeof(CheckpointerRequest);
1247 ctl.entrysize = sizeof(struct CheckpointerSlotMapping);
1248 ctl.hcxt = CurrentMemoryContext;
1249
1250 htab = hash_create("CompactCheckpointerRequestQueue",
1251 CheckpointerShmem->num_requests,
1252 &ctl,
1253 HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
1254
1255 /*
1256 * The basic idea here is that a request can be skipped if it's followed
1257 * by a later, identical request. It might seem more sensible to work
1258 * backwards from the end of the queue and check whether a request is
1259 * *preceded* by an earlier, identical request, in the hopes of doing less
1260 * copying. But that might change the semantics, if there's an
1261 * intervening SYNC_FORGET_REQUEST or SYNC_FILTER_REQUEST, so we do it
1262 * this way. It would be possible to be even smarter if we made the code
1263 * below understand the specific semantics of such requests (it could blow
1264 * away preceding entries that would end up being canceled anyhow), but
1265 * it's not clear that the extra complexity would buy us anything.
1266 */
1267 for (n = 0; n < CheckpointerShmem->num_requests; n++)
1268 {
1269 CheckpointerRequest *request;
1270 struct CheckpointerSlotMapping *slotmap;
1271 bool found;
1272
1273 /*
1274 * We use the request struct directly as a hashtable key. This
1275 * assumes that any padding bytes in the structs are consistently the
1276 * same, which should be okay because we zeroed them in
1277 * CheckpointerShmemInit. Note also that RelFileLocator had better
1278 * contain no pad bytes.
1279 */
1280 request = &CheckpointerShmem->requests[n];
1281 slotmap = hash_search(htab, request, HASH_ENTER, &found);
1282 if (found)
1283 {
1284 /* Duplicate, so mark the previous occurrence as skippable */
1285 skip_slot[slotmap->slot] = true;
1286 num_skipped++;
1287 }
1288 /* Remember slot containing latest occurrence of this request value */
1289 slotmap->slot = n;
1290 }
1291
1292 /* Done with the hash table. */
1293 hash_destroy(htab);
1294
1295 /* If no duplicates, we're out of luck. */
1296 if (!num_skipped)
1297 {
1298 pfree(skip_slot);
1299 return false;
1300 }
1301
1302 /* We found some duplicates; remove them. */
1303 preserve_count = 0;
1304 for (n = 0; n < CheckpointerShmem->num_requests; n++)
1305 {
1306 if (skip_slot[n])
1307 continue;
1308 CheckpointerShmem->requests[preserve_count++] = CheckpointerShmem->requests[n];
1309 }
1310 ereport(DEBUG1,
1311 (errmsg_internal("compacted fsync request queue from %d entries to %d entries",
1312 CheckpointerShmem->num_requests, preserve_count)));
1313 CheckpointerShmem->num_requests = preserve_count;
1314
1315 /* Cleanup. */
1316 pfree(skip_slot);
1317 return true;
1318 }
1319
1320 /*
1321 * AbsorbSyncRequests
1322 * Retrieve queued sync requests and pass them to sync mechanism.
1323 *
1324 * This is exported because it must be called during CreateCheckPoint;
1325 * we have to be sure we have accepted all pending requests just before
1326 * we start fsync'ing. Since CreateCheckPoint sometimes runs in
1327 * non-checkpointer processes, do nothing if not checkpointer.
1328 */
1329 void
1330 AbsorbSyncRequests(void)
1331 {
1332 CheckpointerRequest *requests = NULL;
1333 CheckpointerRequest *request;
1334 int n;
1335
1336 if (!AmCheckpointerProcess())
1337 return;
1338
1339 LWLockAcquire(CheckpointerCommLock, LW_EXCLUSIVE);
1340
1341 /*
1342 * We try to avoid holding the lock for a long time by copying the request
1343 * array, and processing the requests after releasing the lock.
1344 *
1345 * Once we have cleared the requests from shared memory, we have to PANIC
1346 * if we then fail to absorb them (eg, because our hashtable runs out of
1347 * memory). This is because the system cannot run safely if we are unable
1348 * to fsync what we have been told to fsync. Fortunately, the hashtable
1349 * is so small that the problem is quite unlikely to arise in practice.
1350 */
1351 n = CheckpointerShmem->num_requests;
1352 if (n > 0)
1353 {
1354 requests = (CheckpointerRequest *) palloc(n * sizeof(CheckpointerRequest));
1355 memcpy(requests, CheckpointerShmem->requests, n * sizeof(CheckpointerRequest));
1356 }
1357
1358 START_CRIT_SECTION();
1359
1360 CheckpointerShmem->num_requests = 0;
1361
1362 LWLockRelease(CheckpointerCommLock);
1363
1364 for (request = requests; n > 0; request++, n--)
1365 RememberSyncRequest(&request->ftag, request->type);
1366
1367 END_CRIT_SECTION();
1368
1369 if (requests)
1370 pfree(requests);
1371 }
1372
1373 /*
1374 * Update any shared memory configurations based on config parameters
1375 */
1376 static void
1377 UpdateSharedMemoryConfig(void)
1378 {
1379 /* update global shmem state for sync rep */
1380 SyncRepUpdateSyncStandbysDefined();
1381
1382 /*
1383 * If full_page_writes has been changed by SIGHUP, we update it in shared
1384 * memory and write an XLOG_FPW_CHANGE record.
1385 */
1386 UpdateFullPageWrites();
1387
1388 elog(DEBUG2, "checkpointer updated shared memory configuration values");
1389 }
1390
1391 /*
1392 * FirstCallSinceLastCheckpoint allows a process to take an action once
1393 * per checkpoint cycle by asynchronously checking for checkpoint completion.
1394 */
1395 bool
1396 FirstCallSinceLastCheckpoint(void)
1397 {
1398 static int ckpt_done = 0;
1399 int new_done;
1400 bool FirstCall = false;
1401
1402 SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
1403 new_done = CheckpointerShmem->ckpt_done;
1404 SpinLockRelease(&CheckpointerShmem->ckpt_lck);
1405
1406 if (new_done != ckpt_done)
1407 FirstCall = true;
1408
1409 ckpt_done = new_done;
1410
1411 return FirstCall;
1412 }