#include "postgres.h"
#include <signal.h>
#include <sys/time.h>
#include <unistd.h>
#include "access/xlog.h"
#include "access/xlog_internal.h"
#include "libpq/pqsignal.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "postmaster/bgwriter.h"
#include "replication/syncrep.h"
#include "storage/bufmgr.h"
#include "storage/condition_variable.h"
#include "storage/fd.h"
#include "storage/ipc.h"
#include "storage/lwlock.h"
#include "storage/proc.h"
#include "storage/procsignal.h"
#include "storage/shmem.h"
#include "storage/smgr.h"
#include "storage/spin.h"
#include "utils/guc.h"
#include "utils/memutils.h"
#include "utils/resowner.h"

Include dependency graph for checkpointer.c:

Data Structures
struct	CheckpointerRequest

struct	CheckpointerShmemStruct

Macros
#define	WRITES_PER_ABSORB 1000

#define	MAX_SIGNAL_TRIES 600 /* max wait 60.0 sec */

Functions
static void	CheckArchiveTimeout (void)

static bool	IsCheckpointOnSchedule (double progress)

static bool	ImmediateCheckpointRequested (void)

static bool	CompactCheckpointerRequestQueue (void)

static void	UpdateSharedMemoryConfig (void)

static void	chkpt_quickdie (SIGNAL_ARGS)

static void	ChkptSigHupHandler (SIGNAL_ARGS)

static void	ReqCheckpointHandler (SIGNAL_ARGS)

static void	ReqShutdownHandler (SIGNAL_ARGS)

void	CheckpointerMain (void)

void	CheckpointWriteDelay (int flags, double progress)

Size	CheckpointerShmemSize (void)

void	CheckpointerShmemInit (void)

void	RequestCheckpoint (int flags)

bool	ForwardSyncRequest (const FileTag *ftag, SyncRequestType type)

void	AbsorbSyncRequests (void)

bool	FirstCallSinceLastCheckpoint (void)

Variables
static CheckpointerShmemStruct *	CheckpointerShmem

int	CheckPointTimeout = 300

int	CheckPointWarning = 30

double	CheckPointCompletionTarget = 0.5

static volatile sig_atomic_t	got_SIGHUP = false

static volatile sig_atomic_t	shutdown_requested = false

static bool	ckpt_active = false

static pg_time_t	ckpt_start_time

static XLogRecPtr	ckpt_start_recptr

static double	ckpt_cached_elapsed

static pg_time_t	last_checkpoint_time

static pg_time_t	last_xlog_switch_time

Macro Definition Documentation

◆ MAX_SIGNAL_TRIES

#define MAX_SIGNAL_TRIES 600 /* max wait 60.0 sec */

Referenced by RequestCheckpoint().

◆ WRITES_PER_ABSORB

#define WRITES_PER_ABSORB 1000

Definition at line 142 of file checkpointer.c.

Referenced by CheckpointWriteDelay().

Function Documentation

◆ AbsorbSyncRequests()

void AbsorbSyncRequests ( void )

Definition at line 1274 of file checkpointer.c.

References AmCheckpointerProcess, BgWriterStats, END_CRIT_SECTION, CheckpointerRequest::ftag, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PgStat_MsgBgWriter::m_buf_fsync_backend, PgStat_MsgBgWriter::m_buf_written_backend, CheckpointerShmemStruct::num_backend_fsync, CheckpointerShmemStruct::num_backend_writes, CheckpointerShmemStruct::num_requests, palloc(), pfree(), RememberSyncRequest(), CheckpointerShmemStruct::requests, START_CRIT_SECTION, and CheckpointerRequest::type.

Referenced by CheckpointerMain(), CheckpointWriteDelay(), ProcessSyncRequests(), and SyncPostCheckpoint().

 {
     CheckpointerRequest *requests = NULL;
     CheckpointerRequest *request;
     int         n;
 
     if (!AmCheckpointerProcess())
         return;
 
     LWLockAcquire(CheckpointerCommLock, LW_EXCLUSIVE);
 
     /* Transfer stats counts into pending pgstats message */
     BgWriterStats.m_buf_written_backend += CheckpointerShmem->num_backend_writes;
     BgWriterStats.m_buf_fsync_backend += CheckpointerShmem->num_backend_fsync;
 
     CheckpointerShmem->num_backend_writes = 0;
     CheckpointerShmem->num_backend_fsync = 0;
 
     /*
      * We try to avoid holding the lock for a long time by copying the request
      * array, and processing the requests after releasing the lock.
      *
      * Once we have cleared the requests from shared memory, we have to PANIC
      * if we then fail to absorb them (eg, because our hashtable runs out of
      * memory).  This is because the system cannot run safely if we are unable
      * to fsync what we have been told to fsync.  Fortunately, the hashtable
      * is so small that the problem is quite unlikely to arise in practice.
      */
     n = CheckpointerShmem->num_requests;
     if (n > 0)
     {
         requests = (CheckpointerRequest *) palloc(n * sizeof(CheckpointerRequest));
         memcpy(requests, CheckpointerShmem->requests, n * sizeof(CheckpointerRequest));
     }
 
     START_CRIT_SECTION();
 
     CheckpointerShmem->num_requests = 0;
 
     LWLockRelease(CheckpointerCommLock);
 
     for (request = requests; n > 0; request++, n--)
         RememberSyncRequest(&request->ftag, request->type);
 
     END_CRIT_SECTION();
 
     if (requests)
         pfree(requests);
 }

◆ CheckArchiveTimeout()

static void CheckArchiveTimeout ( void )

static

Definition at line 574 of file checkpointer.c.

References DEBUG1, elog, GetLastImportantRecPtr(), GetLastSegSwitchData(), last_xlog_switch_time, Max, now(), RecoveryInProgress(), RequestXLogSwitch(), wal_segment_size, XLogArchiveTimeout, and XLogSegmentOffset.

Referenced by CheckpointerMain(), and CheckpointWriteDelay().

 {
     pg_time_t   now;
     pg_time_t   last_time;
     XLogRecPtr  last_switch_lsn;
 
     if (XLogArchiveTimeout <= 0 || RecoveryInProgress())
         return;
 
     now = (pg_time_t) time(NULL);
 
     /* First we do a quick check using possibly-stale local state. */
     if ((int) (now - last_xlog_switch_time) < XLogArchiveTimeout)
         return;
 
     /*
      * Update local state ... note that last_xlog_switch_time is the last time
      * a switch was performed *or requested*.
      */
     last_time = GetLastSegSwitchData(&last_switch_lsn);
 
     last_xlog_switch_time = Max(last_xlog_switch_time, last_time);
 
     /* Now we can do the real checks */
     if ((int) (now - last_xlog_switch_time) >= XLogArchiveTimeout)
     {
         /*
          * Switch segment only when "important" WAL has been logged since the
          * last segment switch (last_switch_lsn points to end of segment
          * switch occurred in).
          */
         if (GetLastImportantRecPtr() > last_switch_lsn)
         {
             XLogRecPtr  switchpoint;
 
             /* mark switch as unimportant, avoids triggering checkpoints */
             switchpoint = RequestXLogSwitch(true);
 
             /*
              * If the returned pointer points exactly to a segment boundary,
              * assume nothing happened.
              */
             if (XLogSegmentOffset(switchpoint, wal_segment_size) != 0)
                 elog(DEBUG1, "write-ahead log switch forced (archive_timeout=%d)",
                      XLogArchiveTimeout);
         }
 
         /*
          * Update state in any case, so we don't retry constantly when the
          * system is idle.
          */
         last_xlog_switch_time = now;
     }
 }

◆ CheckpointerMain()

void CheckpointerMain ( void )

Definition at line 193 of file checkpointer.c.

Referenced by AuxiliaryProcessMain().

 {
     sigjmp_buf  local_sigjmp_buf;
     MemoryContext checkpointer_context;
 
     CheckpointerShmem->checkpointer_pid = MyProcPid;
 
     /*
      * Properly accept or ignore signals the postmaster might send us
      *
      * Note: we deliberately ignore SIGTERM, because during a standard Unix
      * system shutdown cycle, init will SIGTERM all processes at once.  We
      * want to wait for the backends to exit, whereupon the postmaster will
      * tell us it's okay to shut down (via SIGUSR2).
      */
     pqsignal(SIGHUP, ChkptSigHupHandler);   /* set flag to read config file */
     pqsignal(SIGINT, ReqCheckpointHandler); /* request checkpoint */
     pqsignal(SIGTERM, SIG_IGN); /* ignore SIGTERM */
     pqsignal(SIGQUIT, chkpt_quickdie);  /* hard crash time */
     pqsignal(SIGALRM, SIG_IGN);
     pqsignal(SIGPIPE, SIG_IGN);
     pqsignal(SIGUSR1, procsignal_sigusr1_handler);
     pqsignal(SIGUSR2, ReqShutdownHandler);  /* request shutdown */
 
     /*
      * Reset some signals that are accepted by postmaster but not here
      */
     pqsignal(SIGCHLD, SIG_DFL);
 
     /* We allow SIGQUIT (quickdie) at all times */
     sigdelset(&BlockSig, SIGQUIT);
 
     /*
      * Initialize so that first time-driven event happens at the correct time.
      */
     last_checkpoint_time = last_xlog_switch_time = (pg_time_t) time(NULL);
 
     /*
      * Create a memory context that we will do all our work in.  We do this so
      * that we can reset the context during error recovery and thereby avoid
      * possible memory leaks.  Formerly this code just ran in
      * TopMemoryContext, but resetting that would be a really bad idea.
      */
     checkpointer_context = AllocSetContextCreate(TopMemoryContext,
                                                  "Checkpointer",
                                                  ALLOCSET_DEFAULT_SIZES);
     MemoryContextSwitchTo(checkpointer_context);
 
     /*
      * If an exception is encountered, processing resumes here.
      *
      * See notes in postgres.c about the design of this coding.
      */
     if (sigsetjmp(local_sigjmp_buf, 1) != 0)
     {
         /* Since not using PG_TRY, must reset error stack by hand */
         error_context_stack = NULL;
 
         /* Prevent interrupts while cleaning up */
         HOLD_INTERRUPTS();
 
         /* Report the error to the server log */
         EmitErrorReport();
 
         /*
          * These operations are really just a minimal subset of
          * AbortTransaction().  We don't have very many resources to worry
          * about in checkpointer, but we do have LWLocks, buffers, and temp
          * files.
          */
         LWLockReleaseAll();
         ConditionVariableCancelSleep();
         pgstat_report_wait_end();
         AbortBufferIO();
         UnlockBuffers();
         ReleaseAuxProcessResources(false);
         AtEOXact_Buffers(false);
         AtEOXact_SMgr();
         AtEOXact_Files(false);
         AtEOXact_HashTables(false);
 
         /* Warn any waiting backends that the checkpoint failed. */
         if (ckpt_active)
         {
             SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
             CheckpointerShmem->ckpt_failed++;
             CheckpointerShmem->ckpt_done = CheckpointerShmem->ckpt_started;
             SpinLockRelease(&CheckpointerShmem->ckpt_lck);
 
             ConditionVariableBroadcast(&CheckpointerShmem->done_cv);
 
             ckpt_active = false;
         }
 
         /*
          * Now return to normal top-level context and clear ErrorContext for
          * next time.
          */
         MemoryContextSwitchTo(checkpointer_context);
         FlushErrorState();
 
         /* Flush any leaked data in the top-level context */
         MemoryContextResetAndDeleteChildren(checkpointer_context);
 
         /* Now we can allow interrupts again */
         RESUME_INTERRUPTS();
 
         /*
          * Sleep at least 1 second after any error.  A write error is likely
          * to be repeated, and we don't want to be filling the error logs as
          * fast as we can.
          */
         pg_usleep(1000000L);
 
         /*
          * Close all open files after any error.  This is helpful on Windows,
          * where holding deleted files open causes various strange errors.
          * It's not clear we need it elsewhere, but shouldn't hurt.
          */
         smgrcloseall();
     }
 
     /* We can now handle ereport(ERROR) */
     PG_exception_stack = &local_sigjmp_buf;
 
     /*
      * Unblock signals (they were blocked when the postmaster forked us)
      */
     PG_SETMASK(&UnBlockSig);
 
     /*
      * Ensure all shared memory values are set correctly for the config. Doing
      * this here ensures no race conditions from other concurrent updaters.
      */
     UpdateSharedMemoryConfig();
 
     /*
      * Advertise our latch that backends can use to wake us up while we're
      * sleeping.
      */
     ProcGlobal->checkpointerLatch = &MyProc->procLatch;
 
     /*
      * Loop forever
      */
     for (;;)
     {
         bool        do_checkpoint = false;
         int         flags = 0;
         pg_time_t   now;
         int         elapsed_secs;
         int         cur_timeout;
 
         /* Clear any already-pending wakeups */
         ResetLatch(MyLatch);
 
         /*
          * Process any requests or signals received recently.
          */
         AbsorbSyncRequests();
 
         if (got_SIGHUP)
         {
             got_SIGHUP = false;
             ProcessConfigFile(PGC_SIGHUP);
 
             /*
              * Checkpointer is the last process to shut down, so we ask it to
              * hold the keys for a range of other tasks required most of which
              * have nothing to do with checkpointing at all.
              *
              * For various reasons, some config values can change dynamically
              * so the primary copy of them is held in shared memory to make
              * sure all backends see the same value.  We make Checkpointer
              * responsible for updating the shared memory copy if the
              * parameter setting changes because of SIGHUP.
              */
             UpdateSharedMemoryConfig();
         }
         if (shutdown_requested)
         {
             /*
              * From here on, elog(ERROR) should end with exit(1), not send
              * control back to the sigsetjmp block above
              */
             ExitOnAnyError = true;
             /* Close down the database */
             ShutdownXLOG(0, 0);
             /* Normal exit from the checkpointer is here */
             proc_exit(0);       /* done */
         }
 
         /*
          * Detect a pending checkpoint request by checking whether the flags
          * word in shared memory is nonzero.  We shouldn't need to acquire the
          * ckpt_lck for this.
          */
         if (((volatile CheckpointerShmemStruct *) CheckpointerShmem)->ckpt_flags)
         {
             do_checkpoint = true;
             BgWriterStats.m_requested_checkpoints++;
         }
 
         /*
          * Force a checkpoint if too much time has elapsed since the last one.
          * Note that we count a timed checkpoint in stats only when this
          * occurs without an external request, but we set the CAUSE_TIME flag
          * bit even if there is also an external request.
          */
         now = (pg_time_t) time(NULL);
         elapsed_secs = now - last_checkpoint_time;
         if (elapsed_secs >= CheckPointTimeout)
         {
             if (!do_checkpoint)
                 BgWriterStats.m_timed_checkpoints++;
             do_checkpoint = true;
             flags |= CHECKPOINT_CAUSE_TIME;
         }
 
         /*
          * Do a checkpoint if requested.
          */
         if (do_checkpoint)
         {
             bool        ckpt_performed = false;
             bool        do_restartpoint;
 
             /*
              * Check if we should perform a checkpoint or a restartpoint. As a
              * side-effect, RecoveryInProgress() initializes TimeLineID if
              * it's not set yet.
              */
             do_restartpoint = RecoveryInProgress();
 
             /*
              * Atomically fetch the request flags to figure out what kind of a
              * checkpoint we should perform, and increase the started-counter
              * to acknowledge that we've started a new checkpoint.
              */
             SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
             flags |= CheckpointerShmem->ckpt_flags;
             CheckpointerShmem->ckpt_flags = 0;
             CheckpointerShmem->ckpt_started++;
             SpinLockRelease(&CheckpointerShmem->ckpt_lck);
 
             ConditionVariableBroadcast(&CheckpointerShmem->start_cv);
 
             /*
              * The end-of-recovery checkpoint is a real checkpoint that's
              * performed while we're still in recovery.
              */
             if (flags & CHECKPOINT_END_OF_RECOVERY)
                 do_restartpoint = false;
 
             /*
              * We will warn if (a) too soon since last checkpoint (whatever
              * caused it) and (b) somebody set the CHECKPOINT_CAUSE_XLOG flag
              * since the last checkpoint start.  Note in particular that this
              * implementation will not generate warnings caused by
              * CheckPointTimeout < CheckPointWarning.
              */
             if (!do_restartpoint &&
                 (flags & CHECKPOINT_CAUSE_XLOG) &&
                 elapsed_secs < CheckPointWarning)
                 ereport(LOG,
                         (errmsg_plural("checkpoints are occurring too frequently (%d second apart)",
                                        "checkpoints are occurring too frequently (%d seconds apart)",
                                        elapsed_secs,
                                        elapsed_secs),
                          errhint("Consider increasing the configuration parameter \"max_wal_size\".")));
 
             /*
              * Initialize checkpointer-private variables used during
              * checkpoint.
              */
             ckpt_active = true;
             if (do_restartpoint)
                 ckpt_start_recptr = GetXLogReplayRecPtr(NULL);
             else
                 ckpt_start_recptr = GetInsertRecPtr();
             ckpt_start_time = now;
             ckpt_cached_elapsed = 0;
 
             /*
              * Do the checkpoint.
              */
             if (!do_restartpoint)
             {
                 CreateCheckPoint(flags);
                 ckpt_performed = true;
             }
             else
                 ckpt_performed = CreateRestartPoint(flags);
 
             /*
              * After any checkpoint, close all smgr files.  This is so we
              * won't hang onto smgr references to deleted files indefinitely.
              */
             smgrcloseall();
 
             /*
              * Indicate checkpoint completion to any waiting backends.
              */
             SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
             CheckpointerShmem->ckpt_done = CheckpointerShmem->ckpt_started;
             SpinLockRelease(&CheckpointerShmem->ckpt_lck);
 
             ConditionVariableBroadcast(&CheckpointerShmem->done_cv);
 
             if (ckpt_performed)
             {
                 /*
                  * Note we record the checkpoint start time not end time as
                  * last_checkpoint_time.  This is so that time-driven
                  * checkpoints happen at a predictable spacing.
                  */
                 last_checkpoint_time = now;
             }
             else
             {
                 /*
                  * We were not able to perform the restartpoint (checkpoints
                  * throw an ERROR in case of error).  Most likely because we
                  * have not received any new checkpoint WAL records since the
                  * last restartpoint. Try again in 15 s.
                  */
                 last_checkpoint_time = now - CheckPointTimeout + 15;
             }
 
             ckpt_active = false;
         }
 
         /* Check for archive_timeout and switch xlog files if necessary. */
         CheckArchiveTimeout();
 
         /*
          * Send off activity statistics to the stats collector.  (The reason
          * why we re-use bgwriter-related code for this is that the bgwriter
          * and checkpointer used to be just one process.  It's probably not
          * worth the trouble to split the stats support into two independent
          * stats message types.)
          */
         pgstat_send_bgwriter();
 
         /*
          * Sleep until we are signaled or it's time for another checkpoint or
          * xlog file switch.
          */
         now = (pg_time_t) time(NULL);
         elapsed_secs = now - last_checkpoint_time;
         if (elapsed_secs >= CheckPointTimeout)
             continue;           /* no sleep for us ... */
         cur_timeout = CheckPointTimeout - elapsed_secs;
         if (XLogArchiveTimeout > 0 && !RecoveryInProgress())
         {
             elapsed_secs = now - last_xlog_switch_time;
             if (elapsed_secs >= XLogArchiveTimeout)
                 continue;       /* no sleep for us ... */
             cur_timeout = Min(cur_timeout, XLogArchiveTimeout - elapsed_secs);
         }
 
         (void) WaitLatch(MyLatch,
                          WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
                          cur_timeout * 1000L /* convert to ms */ ,
                          WAIT_EVENT_CHECKPOINTER_MAIN);
     }
 }

◆ CheckpointerShmemInit()

void CheckpointerShmemInit ( void )

Definition at line 898 of file checkpointer.c.

References CheckpointerShmemSize(), CheckpointerShmemStruct::ckpt_lck, ConditionVariableInit(), CheckpointerShmemStruct::done_cv, CheckpointerShmemStruct::max_requests, MemSet, NBuffers, ShmemInitStruct(), SpinLockInit, and CheckpointerShmemStruct::start_cv.

Referenced by CreateSharedMemoryAndSemaphores().

 {
     Size        size = CheckpointerShmemSize();
     bool        found;
 
     CheckpointerShmem = (CheckpointerShmemStruct *)
         ShmemInitStruct("Checkpointer Data",
                         size,
                         &found);
 
     if (!found)
     {
         /*
          * First time through, so initialize.  Note that we zero the whole
          * requests array; this is so that CompactCheckpointerRequestQueue can
          * assume that any pad bytes in the request structs are zeroes.
          */
         MemSet(CheckpointerShmem, 0, size);
         SpinLockInit(&CheckpointerShmem->ckpt_lck);
         CheckpointerShmem->max_requests = NBuffers;
         ConditionVariableInit(&CheckpointerShmem->start_cv);
         ConditionVariableInit(&CheckpointerShmem->done_cv);
     }
 }

◆ CheckpointerShmemSize()

Size CheckpointerShmemSize ( void )

Definition at line 879 of file checkpointer.c.

References add_size(), mul_size(), NBuffers, and offsetof.

Referenced by CheckpointerShmemInit(), and CreateSharedMemoryAndSemaphores().

 {
     Size        size;
 
     /*
      * Currently, the size of the requests[] array is arbitrarily set equal to
      * NBuffers.  This may prove too large or small ...
      */
     size = offsetof(CheckpointerShmemStruct, requests);
     size = add_size(size, mul_size(NBuffers, sizeof(CheckpointerRequest)));
 
     return size;
 }

◆ CheckpointWriteDelay()

void CheckpointWriteDelay	(	int	flags,
		double	progress
	)

Definition at line 662 of file checkpointer.c.

References AbsorbSyncRequests(), AmCheckpointerProcess, CheckArchiveTimeout(), CHECKPOINT_IMMEDIATE, got_SIGHUP, ImmediateCheckpointRequested(), IsCheckpointOnSchedule(), pg_usleep(), PGC_SIGHUP, pgstat_send_bgwriter(), ProcessConfigFile(), shutdown_requested, UpdateSharedMemoryConfig(), and WRITES_PER_ABSORB.

Referenced by BufferSync().

 {
     static int  absorb_counter = WRITES_PER_ABSORB;
 
     /* Do nothing if checkpoint is being executed by non-checkpointer process */
     if (!AmCheckpointerProcess())
         return;
 
     /*
      * Perform the usual duties and take a nap, unless we're behind schedule,
      * in which case we just try to catch up as quickly as possible.
      */
     if (!(flags & CHECKPOINT_IMMEDIATE) &&
         !shutdown_requested &&
         !ImmediateCheckpointRequested() &&
         IsCheckpointOnSchedule(progress))
     {
         if (got_SIGHUP)
         {
             got_SIGHUP = false;
             ProcessConfigFile(PGC_SIGHUP);
             /* update shmem copies of config variables */
             UpdateSharedMemoryConfig();
         }
 
         AbsorbSyncRequests();
         absorb_counter = WRITES_PER_ABSORB;
 
         CheckArchiveTimeout();
 
         /*
          * Report interim activity statistics to the stats collector.
          */
         pgstat_send_bgwriter();
 
         /*
          * This sleep used to be connected to bgwriter_delay, typically 200ms.
          * That resulted in more frequent wakeups if not much work to do.
          * Checkpointer and bgwriter are no longer related so take the Big
          * Sleep.
          */
         pg_usleep(100000L);
     }
     else if (--absorb_counter <= 0)
     {
         /*
          * Absorb pending fsync requests after each WRITES_PER_ABSORB write
          * operations even when we don't sleep, to prevent overflow of the
          * fsync request queue.
          */
         AbsorbSyncRequests();
         absorb_counter = WRITES_PER_ABSORB;
     }
 }

◆ chkpt_quickdie()

static void chkpt_quickdie ( SIGNAL_ARGS )

static

Definition at line 810 of file checkpointer.c.

Referenced by CheckpointerMain().

 {
     /*
      * We DO NOT want to run proc_exit() or atexit() callbacks -- we're here
      * because shared memory may be corrupted, so we don't want to try to
      * clean up our transaction.  Just nail the windows shut and get out of
      * town.  The callbacks wouldn't be safe to run from a signal handler,
      * anyway.
      *
      * Note we do _exit(2) not _exit(0).  This is to force the postmaster into
      * a system reset cycle if someone sends a manual SIGQUIT to a random
      * backend.  This is necessary precisely because we don't clean up our
      * shared memory state.  (The "dead man switch" mechanism in pmsignal.c
      * should ensure the postmaster sees this as a crash, too, but no harm in
      * being doubly sure.)
      */
     _exit(2);
 }

◆ ChkptSigHupHandler()

static void ChkptSigHupHandler ( SIGNAL_ARGS )

static

Definition at line 831 of file checkpointer.c.

References got_SIGHUP, MyLatch, and SetLatch().

Referenced by CheckpointerMain().

 {
     int         save_errno = errno;
 
     got_SIGHUP = true;
     SetLatch(MyLatch);
 
     errno = save_errno;
 }

◆ CompactCheckpointerRequestQueue()

static bool CompactCheckpointerRequestQueue ( void )

static

Definition at line 1167 of file checkpointer.c.

References Assert, CurrentMemoryContext, DEBUG1, HASHCTL::entrysize, ereport, errmsg(), HASH_BLOBS, HASH_CONTEXT, hash_create(), hash_destroy(), HASH_ELEM, HASH_ENTER, hash_search(), HASHCTL::hcxt, HASHCTL::keysize, LWLockHeldByMe(), MemSet, CheckpointerShmemStruct::num_requests, palloc0(), pfree(), and CheckpointerShmemStruct::requests.

Referenced by ForwardSyncRequest().

 {
     struct CheckpointerSlotMapping
     {
         CheckpointerRequest request;
         int         slot;
     };
 
     int         n,
                 preserve_count;
     int         num_skipped = 0;
     HASHCTL     ctl;
     HTAB       *htab;
     bool       *skip_slot;
 
     /* must hold CheckpointerCommLock in exclusive mode */
     Assert(LWLockHeldByMe(CheckpointerCommLock));
 
     /* Initialize skip_slot array */
     skip_slot = palloc0(sizeof(bool) * CheckpointerShmem->num_requests);
 
     /* Initialize temporary hash table */
     MemSet(&ctl, 0, sizeof(ctl));
     ctl.keysize = sizeof(CheckpointerRequest);
     ctl.entrysize = sizeof(struct CheckpointerSlotMapping);
     ctl.hcxt = CurrentMemoryContext;
 
     htab = hash_create("CompactCheckpointerRequestQueue",
                        CheckpointerShmem->num_requests,
                        &ctl,
                        HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
 
     /*
      * The basic idea here is that a request can be skipped if it's followed
      * by a later, identical request.  It might seem more sensible to work
      * backwards from the end of the queue and check whether a request is
      * *preceded* by an earlier, identical request, in the hopes of doing less
      * copying.  But that might change the semantics, if there's an
      * intervening SYNC_FORGET_REQUEST or SYNC_FILTER_REQUEST, so we do it
      * this way.  It would be possible to be even smarter if we made the code
      * below understand the specific semantics of such requests (it could blow
      * away preceding entries that would end up being canceled anyhow), but
      * it's not clear that the extra complexity would buy us anything.
      */
     for (n = 0; n < CheckpointerShmem->num_requests; n++)
     {
         CheckpointerRequest *request;
         struct CheckpointerSlotMapping *slotmap;
         bool        found;
 
         /*
          * We use the request struct directly as a hashtable key.  This
          * assumes that any padding bytes in the structs are consistently the
          * same, which should be okay because we zeroed them in
          * CheckpointerShmemInit.  Note also that RelFileNode had better
          * contain no pad bytes.
          */
         request = &CheckpointerShmem->requests[n];
         slotmap = hash_search(htab, request, HASH_ENTER, &found);
         if (found)
         {
             /* Duplicate, so mark the previous occurrence as skippable */
             skip_slot[slotmap->slot] = true;
             num_skipped++;
         }
         /* Remember slot containing latest occurrence of this request value */
         slotmap->slot = n;
     }
 
     /* Done with the hash table. */
     hash_destroy(htab);
 
     /* If no duplicates, we're out of luck. */
     if (!num_skipped)
     {
         pfree(skip_slot);
         return false;
     }
 
     /* We found some duplicates; remove them. */
     preserve_count = 0;
     for (n = 0; n < CheckpointerShmem->num_requests; n++)
     {
         if (skip_slot[n])
             continue;
         CheckpointerShmem->requests[preserve_count++] = CheckpointerShmem->requests[n];
     }
     ereport(DEBUG1,
             (errmsg("compacted fsync request queue from %d entries to %d entries",
                     CheckpointerShmem->num_requests, preserve_count)));
     CheckpointerShmem->num_requests = preserve_count;
 
     /* Cleanup. */
     pfree(skip_slot);
     return true;
 }

◆ FirstCallSinceLastCheckpoint()

bool FirstCallSinceLastCheckpoint ( void )

Definition at line 1347 of file checkpointer.c.

References CheckpointerShmemStruct::ckpt_done, CheckpointerShmemStruct::ckpt_lck, SpinLockAcquire, and SpinLockRelease.

Referenced by BackgroundWriterMain().

 {
     static int  ckpt_done = 0;
     int         new_done;
     bool        FirstCall = false;
 
     SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
     new_done = CheckpointerShmem->ckpt_done;
     SpinLockRelease(&CheckpointerShmem->ckpt_lck);
 
     if (new_done != ckpt_done)
         FirstCall = true;
 
     ckpt_done = new_done;
 
     return FirstCall;
 }

◆ ForwardSyncRequest()

bool ForwardSyncRequest	(	const FileTag *	ftag,
		SyncRequestType	type
	)

Definition at line 1096 of file checkpointer.c.

References AmBackgroundWriterProcess, AmCheckpointerProcess, CheckpointerShmemStruct::checkpointer_pid, PROC_HDR::checkpointerLatch, CompactCheckpointerRequestQueue(), elog, ERROR, CheckpointerRequest::ftag, IsUnderPostmaster, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), CheckpointerShmemStruct::max_requests, CheckpointerShmemStruct::num_backend_fsync, CheckpointerShmemStruct::num_backend_writes, CheckpointerShmemStruct::num_requests, ProcGlobal, CheckpointerShmemStruct::requests, SetLatch(), CheckpointerRequest::type, and generate_unaccent_rules::type.

Referenced by RegisterSyncRequest().

 {
     CheckpointerRequest *request;
     bool        too_full;
 
     if (!IsUnderPostmaster)
         return false;           /* probably shouldn't even get here */
 
     if (AmCheckpointerProcess())
         elog(ERROR, "ForwardSyncRequest must not be called in checkpointer");
 
     LWLockAcquire(CheckpointerCommLock, LW_EXCLUSIVE);
 
     /* Count all backend writes regardless of if they fit in the queue */
     if (!AmBackgroundWriterProcess())
         CheckpointerShmem->num_backend_writes++;
 
     /*
      * If the checkpointer isn't running or the request queue is full, the
      * backend will have to perform its own fsync request.  But before forcing
      * that to happen, we can try to compact the request queue.
      */
     if (CheckpointerShmem->checkpointer_pid == 0 ||
         (CheckpointerShmem->num_requests >= CheckpointerShmem->max_requests &&
          !CompactCheckpointerRequestQueue()))
     {
         /*
          * Count the subset of writes where backends have to do their own
          * fsync
          */
         if (!AmBackgroundWriterProcess())
             CheckpointerShmem->num_backend_fsync++;
         LWLockRelease(CheckpointerCommLock);
         return false;
     }
 
     /* OK, insert request */
     request = &CheckpointerShmem->requests[CheckpointerShmem->num_requests++];
     request->ftag = *ftag;
     request->type = type;
 
     /* If queue is more than half full, nudge the checkpointer to empty it */
     too_full = (CheckpointerShmem->num_requests >=
                 CheckpointerShmem->max_requests / 2);
 
     LWLockRelease(CheckpointerCommLock);
 
     /* ... but not till after we release the lock */
     if (too_full && ProcGlobal->checkpointerLatch)
         SetLatch(ProcGlobal->checkpointerLatch);
 
     return true;
 }

◆ ImmediateCheckpointRequested()

static bool ImmediateCheckpointRequested ( void )

static

Definition at line 635 of file checkpointer.c.

References CHECKPOINT_IMMEDIATE, CheckpointerShmem, and CheckpointerShmemStruct::ckpt_flags.

Referenced by CheckpointWriteDelay().

 {
     volatile CheckpointerShmemStruct *cps = CheckpointerShmem;
 
     /*
      * We don't need to acquire the ckpt_lck in this case because we're only
      * looking at a single flag bit.
      */
     if (cps->ckpt_flags & CHECKPOINT_IMMEDIATE)
         return true;
     return false;
 }

◆ IsCheckpointOnSchedule()

static bool IsCheckpointOnSchedule ( double progress )

static

Definition at line 726 of file checkpointer.c.

References Assert, CheckPointCompletionTarget, CheckPointSegments, CheckPointTimeout, ckpt_active, ckpt_cached_elapsed, ckpt_start_recptr, ckpt_start_time, elapsed_time(), GetInsertRecPtr(), gettimeofday(), GetXLogReplayRecPtr(), RecoveryInProgress(), and wal_segment_size.

Referenced by CheckpointWriteDelay().

 {
     XLogRecPtr  recptr;
     struct timeval now;
     double      elapsed_xlogs,
                 elapsed_time;
 
     Assert(ckpt_active);
 
     /* Scale progress according to checkpoint_completion_target. */
     progress *= CheckPointCompletionTarget;
 
     /*
      * Check against the cached value first. Only do the more expensive
      * calculations once we reach the target previously calculated. Since
      * neither time or WAL insert pointer moves backwards, a freshly
      * calculated value can only be greater than or equal to the cached value.
      */
     if (progress < ckpt_cached_elapsed)
         return false;
 
     /*
      * Check progress against WAL segments written and CheckPointSegments.
      *
      * We compare the current WAL insert location against the location
      * computed before calling CreateCheckPoint. The code in XLogInsert that
      * actually triggers a checkpoint when CheckPointSegments is exceeded
      * compares against RedoRecPtr, so this is not completely accurate.
      * However, it's good enough for our purposes, we're only calculating an
      * estimate anyway.
      *
      * During recovery, we compare last replayed WAL record's location with
      * the location computed before calling CreateRestartPoint. That maintains
      * the same pacing as we have during checkpoints in normal operation, but
      * we might exceed max_wal_size by a fair amount. That's because there can
      * be a large gap between a checkpoint's redo-pointer and the checkpoint
      * record itself, and we only start the restartpoint after we've seen the
      * checkpoint record. (The gap is typically up to CheckPointSegments *
      * checkpoint_completion_target where checkpoint_completion_target is the
      * value that was in effect when the WAL was generated).
      */
     if (RecoveryInProgress())
         recptr = GetXLogReplayRecPtr(NULL);
     else
         recptr = GetInsertRecPtr();
     elapsed_xlogs = (((double) (recptr - ckpt_start_recptr)) /
                      wal_segment_size) / CheckPointSegments;
 
     if (progress < elapsed_xlogs)
     {
         ckpt_cached_elapsed = elapsed_xlogs;
         return false;
     }
 
     /*
      * Check progress against time elapsed and checkpoint_timeout.
      */
     gettimeofday(&now, NULL);
     elapsed_time = ((double) ((pg_time_t) now.tv_sec - ckpt_start_time) +
                     now.tv_usec / 1000000.0) / CheckPointTimeout;
 
     if (progress < elapsed_time)
     {
         ckpt_cached_elapsed = elapsed_time;
         return false;
     }
 
     /* It looks like we're on schedule. */
     return true;
 }

◆ ReqCheckpointHandler()

static void ReqCheckpointHandler ( SIGNAL_ARGS )

static

Definition at line 843 of file checkpointer.c.

References MyLatch, and SetLatch().

Referenced by CheckpointerMain().

 {
     int         save_errno = errno;
 
     /*
      * The signalling process should have set ckpt_flags nonzero, so all we
      * need do is ensure that our main loop gets kicked out of any wait.
      */
     SetLatch(MyLatch);
 
     errno = save_errno;
 }

◆ ReqShutdownHandler()

static void ReqShutdownHandler ( SIGNAL_ARGS )

static

Definition at line 858 of file checkpointer.c.

References MyLatch, SetLatch(), and shutdown_requested.

Referenced by CheckpointerMain().

 {
     int         save_errno = errno;
 
     shutdown_requested = true;
     SetLatch(MyLatch);
 
     errno = save_errno;
 }

◆ RequestCheckpoint()

void RequestCheckpoint ( int flags )

Definition at line 941 of file checkpointer.c.

Referenced by createdb(), do_pg_start_backup(), dropdb(), DropTableSpace(), movedb(), standard_ProcessUtility(), StartupXLOG(), XLogPageRead(), and XLogWrite().

 {
     int         ntries;
     int         old_failed,
                 old_started;
 
     /*
      * If in a standalone backend, just do it ourselves.
      */
     if (!IsPostmasterEnvironment)
     {
         /*
          * There's no point in doing slow checkpoints in a standalone backend,
          * because there's no other backends the checkpoint could disrupt.
          */
         CreateCheckPoint(flags | CHECKPOINT_IMMEDIATE);
 
         /*
          * After any checkpoint, close all smgr files.  This is so we won't
          * hang onto smgr references to deleted files indefinitely.
          */
         smgrcloseall();
 
         return;
     }
 
     /*
      * Atomically set the request flags, and take a snapshot of the counters.
      * When we see ckpt_started > old_started, we know the flags we set here
      * have been seen by checkpointer.
      *
      * Note that we OR the flags with any existing flags, to avoid overriding
      * a "stronger" request by another backend.  The flag senses must be
      * chosen to make this work!
      */
     SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
 
     old_failed = CheckpointerShmem->ckpt_failed;
     old_started = CheckpointerShmem->ckpt_started;
     CheckpointerShmem->ckpt_flags |= (flags | CHECKPOINT_REQUESTED);
 
     SpinLockRelease(&CheckpointerShmem->ckpt_lck);
 
     /*
      * Send signal to request checkpoint.  It's possible that the checkpointer
      * hasn't started yet, or is in process of restarting, so we will retry a
      * few times if needed.  (Actually, more than a few times, since on slow
      * or overloaded buildfarm machines, it's been observed that the
      * checkpointer can take several seconds to start.)  However, if not told
      * to wait for the checkpoint to occur, we consider failure to send the
      * signal to be nonfatal and merely LOG it.  The checkpointer should see
      * the request when it does start, with or without getting a signal.
      */
 #define MAX_SIGNAL_TRIES 600    /* max wait 60.0 sec */
     for (ntries = 0;; ntries++)
     {
         if (CheckpointerShmem->checkpointer_pid == 0)
         {
             if (ntries >= MAX_SIGNAL_TRIES || !(flags & CHECKPOINT_WAIT))
             {
                 elog((flags & CHECKPOINT_WAIT) ? ERROR : LOG,
                      "could not signal for checkpoint: checkpointer is not running");
                 break;
             }
         }
         else if (kill(CheckpointerShmem->checkpointer_pid, SIGINT) != 0)
         {
             if (ntries >= MAX_SIGNAL_TRIES || !(flags & CHECKPOINT_WAIT))
             {
                 elog((flags & CHECKPOINT_WAIT) ? ERROR : LOG,
                      "could not signal for checkpoint: %m");
                 break;
             }
         }
         else
             break;              /* signal sent successfully */
 
         CHECK_FOR_INTERRUPTS();
         pg_usleep(100000L);     /* wait 0.1 sec, then retry */
     }
 
     /*
      * If requested, wait for completion.  We detect completion according to
      * the algorithm given above.
      */
     if (flags & CHECKPOINT_WAIT)
     {
         int         new_started,
                     new_failed;
 
         /* Wait for a new checkpoint to start. */
         ConditionVariablePrepareToSleep(&CheckpointerShmem->start_cv);
         for (;;)
         {
             SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
             new_started = CheckpointerShmem->ckpt_started;
             SpinLockRelease(&CheckpointerShmem->ckpt_lck);
 
             if (new_started != old_started)
                 break;
 
             ConditionVariableSleep(&CheckpointerShmem->start_cv,
                                    WAIT_EVENT_CHECKPOINT_START);
         }
         ConditionVariableCancelSleep();
 
         /*
          * We are waiting for ckpt_done >= new_started, in a modulo sense.
          */
         ConditionVariablePrepareToSleep(&CheckpointerShmem->done_cv);
         for (;;)
         {
             int         new_done;
 
             SpinLockAcquire(&CheckpointerShmem->ckpt_lck);
             new_done = CheckpointerShmem->ckpt_done;
             new_failed = CheckpointerShmem->ckpt_failed;
             SpinLockRelease(&CheckpointerShmem->ckpt_lck);
 
             if (new_done - new_started >= 0)
                 break;
 
             ConditionVariableSleep(&CheckpointerShmem->done_cv,
                                    WAIT_EVENT_CHECKPOINT_DONE);
         }
         ConditionVariableCancelSleep();
 
         if (new_failed != old_failed)
             ereport(ERROR,
                     (errmsg("checkpoint request failed"),
                      errhint("Consult recent messages in the server log for details.")));
     }
 }

◆ UpdateSharedMemoryConfig()

static void UpdateSharedMemoryConfig ( void )

static

Definition at line 1328 of file checkpointer.c.

References DEBUG2, elog, SyncRepUpdateSyncStandbysDefined(), and UpdateFullPageWrites().

Referenced by CheckpointerMain(), and CheckpointWriteDelay().

 {
     /* update global shmem state for sync rep */
     SyncRepUpdateSyncStandbysDefined();
 
     /*
      * If full_page_writes has been changed by SIGHUP, we update it in shared
      * memory and write an XLOG_FPW_CHANGE record.
      */
     UpdateFullPageWrites();
 
     elog(DEBUG2, "checkpointer updated shared memory configuration values");
 }

Variable Documentation

◆ CheckPointCompletionTarget

double CheckPointCompletionTarget = 0.5

Definition at line 149 of file checkpointer.c.

Referenced by assign_checkpoint_completion_target(), CalculateCheckpointSegments(), IsCheckpointOnSchedule(), and XLOGfileslop().

◆ CheckpointerShmem

CheckpointerShmemStruct* CheckpointerShmem

static

Definition at line 139 of file checkpointer.c.

Referenced by ImmediateCheckpointRequested().

◆ CheckPointTimeout

int CheckPointTimeout = 300

Definition at line 147 of file checkpointer.c.

Referenced by CheckpointerMain(), and IsCheckpointOnSchedule().

◆ CheckPointWarning

int CheckPointWarning = 30

Definition at line 148 of file checkpointer.c.

Referenced by CheckpointerMain().

◆ ckpt_active

bool ckpt_active = false

static

Definition at line 160 of file checkpointer.c.

Referenced by CheckpointerMain(), and IsCheckpointOnSchedule().

◆ ckpt_cached_elapsed

double ckpt_cached_elapsed

static

Definition at line 165 of file checkpointer.c.

Referenced by CheckpointerMain(), and IsCheckpointOnSchedule().

◆ ckpt_start_recptr

XLogRecPtr ckpt_start_recptr

static

Definition at line 164 of file checkpointer.c.

Referenced by CheckpointerMain(), and IsCheckpointOnSchedule().

◆ ckpt_start_time

pg_time_t ckpt_start_time

static

Definition at line 163 of file checkpointer.c.

Referenced by CheckpointerMain(), and IsCheckpointOnSchedule().

◆ got_SIGHUP

volatile sig_atomic_t got_SIGHUP = false

static

Definition at line 154 of file checkpointer.c.

Referenced by CheckpointerMain(), CheckpointWriteDelay(), and ChkptSigHupHandler().

◆ last_checkpoint_time

pg_time_t last_checkpoint_time

static

Definition at line 167 of file checkpointer.c.

Referenced by CheckpointerMain().

◆ last_xlog_switch_time

pg_time_t last_xlog_switch_time

static

Definition at line 168 of file checkpointer.c.

Referenced by CheckArchiveTimeout(), and CheckpointerMain().

◆ shutdown_requested

volatile sig_atomic_t shutdown_requested = false

static

Definition at line 155 of file checkpointer.c.

Referenced by CheckpointerMain(), CheckpointWriteDelay(), and ReqShutdownHandler().

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

◆ MAX_SIGNAL_TRIES

◆ WRITES_PER_ABSORB

Function Documentation

◆ AbsorbSyncRequests()

◆ CheckArchiveTimeout()

◆ CheckpointerMain()

◆ CheckpointerShmemInit()

◆ CheckpointerShmemSize()

◆ CheckpointWriteDelay()

◆ chkpt_quickdie()

◆ ChkptSigHupHandler()

◆ CompactCheckpointerRequestQueue()

◆ FirstCallSinceLastCheckpoint()

◆ ForwardSyncRequest()

◆ ImmediateCheckpointRequested()

◆ IsCheckpointOnSchedule()

◆ ReqCheckpointHandler()

◆ ReqShutdownHandler()

◆ RequestCheckpoint()

◆ UpdateSharedMemoryConfig()

Variable Documentation

◆ CheckPointCompletionTarget

◆ CheckpointerShmem

◆ CheckPointTimeout

◆ CheckPointWarning

◆ ckpt_active

◆ ckpt_cached_elapsed

◆ ckpt_start_recptr

◆ ckpt_start_time

◆ got_SIGHUP

◆ last_checkpoint_time

◆ last_xlog_switch_time

◆ shutdown_requested