#include "storage/block.h"
#include "storage/relfilenode.h"
#include "storage/smgr.h"
#include "storage/sync.h"

Include dependency graph for bgwriter.h:

This graph shows which files directly or indirectly include this file:

Functions
void	BackgroundWriterMain (void) pg_attribute_noreturn()

void	CheckpointerMain (void) pg_attribute_noreturn()

void	RequestCheckpoint (int flags)

void	CheckpointWriteDelay (int flags, double progress)

bool	ForwardSyncRequest (const FileTag *ftag, SyncRequestType type)

void	AbsorbSyncRequests (void)

Size	CheckpointerShmemSize (void)

void	CheckpointerShmemInit (void)

bool	FirstCallSinceLastCheckpoint (void)

Variables
int	BgWriterDelay

int	CheckPointTimeout

int	CheckPointWarning

double	CheckPointCompletionTarget

Function Documentation

◆ AbsorbSyncRequests()

void AbsorbSyncRequests ( void )

Definition at line 1252 of file checkpointer.c.

References AmCheckpointerProcess, END_CRIT_SECTION, CheckpointerRequest::ftag, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PgStat_MsgCheckpointer::m_buf_fsync_backend, PgStat_MsgCheckpointer::m_buf_written_backend, CheckpointerShmemStruct::num_backend_fsync, CheckpointerShmemStruct::num_backend_writes, CheckpointerShmemStruct::num_requests, palloc(), PendingCheckpointerStats, 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 */
     PendingCheckpointerStats.m_buf_written_backend
         += CheckpointerShmem->num_backend_writes;
     PendingCheckpointerStats.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);
 }

◆ BackgroundWriterMain()

void BackgroundWriterMain ( void )

Definition at line 91 of file bgwriter.c.

References AbortBufferIO(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, AtEOXact_Buffers(), AtEOXact_Files(), AtEOXact_HashTables(), AtEOXact_SMgr(), BgBufferSync(), bgwriter_flush_after, BgWriterDelay, ConditionVariableCancelSleep(), EmitErrorReport(), error_context_stack, FirstCallSinceLastCheckpoint(), FlushErrorState(), GetCurrentTimestamp(), GetLastImportantRecPtr(), HandleMainLoopInterrupts(), HIBERNATE_FACTOR, HOLD_INTERRUPTS, last_snapshot_lsn, last_snapshot_ts, LOG_SNAPSHOT_INTERVAL_MS, LogStandbySnapshot(), LWLockReleaseAll(), MemoryContextResetAndDeleteChildren, MemoryContextSwitchTo(), MyLatch, MyProc, now(), PG_exception_stack, PG_SETMASK, pg_usleep(), PGPROC::pgprocno, pgstat_report_wait_end(), pgstat_send_bgwriter(), pqsignal(), procsignal_sigusr1_handler(), RecoveryInProgress(), ReleaseAuxProcessResources(), ResetLatch(), RESUME_INTERRUPTS, SIG_DFL, SIG_IGN, SIGALRM, SIGCHLD, SIGHUP, SignalHandlerForConfigReload(), SignalHandlerForShutdownRequest(), SIGPIPE, SIGUSR1, SIGUSR2, smgrcloseall(), StrategyNotifyBgWriter(), TimestampTzPlusMilliseconds, TopMemoryContext, UnBlockSig, UnlockBuffers(), WAIT_EVENT_BGWRITER_HIBERNATE, WAIT_EVENT_BGWRITER_MAIN, WaitLatch(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, WL_TIMEOUT, WritebackContextInit(), and XLogStandbyInfoActive.

Referenced by AuxiliaryProcessMain().

 {
     sigjmp_buf  local_sigjmp_buf;
     MemoryContext bgwriter_context;
     bool        prev_hibernate;
     WritebackContext wb_context;
 
     /*
      * Properly accept or ignore signals that might be sent to us.
      */
     pqsignal(SIGHUP, SignalHandlerForConfigReload);
     pqsignal(SIGINT, SIG_IGN);
     pqsignal(SIGTERM, SignalHandlerForShutdownRequest);
     /* SIGQUIT handler was already set up by InitPostmasterChild */
     pqsignal(SIGALRM, SIG_IGN);
     pqsignal(SIGPIPE, SIG_IGN);
     pqsignal(SIGUSR1, procsignal_sigusr1_handler);
     pqsignal(SIGUSR2, SIG_IGN);
 
     /*
      * Reset some signals that are accepted by postmaster but not here
      */
     pqsignal(SIGCHLD, SIG_DFL);
 
     /*
      * We just started, assume there has been either a shutdown or
      * end-of-recovery snapshot.
      */
     last_snapshot_ts = GetCurrentTimestamp();
 
     /*
      * 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.
      */
     bgwriter_context = AllocSetContextCreate(TopMemoryContext,
                                              "Background Writer",
                                              ALLOCSET_DEFAULT_SIZES);
     MemoryContextSwitchTo(bgwriter_context);
 
     WritebackContextInit(&wb_context, &bgwriter_flush_after);
 
     /*
      * If an exception is encountered, processing resumes here.
      *
      * You might wonder why this isn't coded as an infinite loop around a
      * PG_TRY construct.  The reason is that this is the bottom of the
      * exception stack, and so with PG_TRY there would be no exception handler
      * in force at all during the CATCH part.  By leaving the outermost setjmp
      * always active, we have at least some chance of recovering from an error
      * during error recovery.  (If we get into an infinite loop thereby, it
      * will soon be stopped by overflow of elog.c's internal state stack.)
      *
      * Note that we use sigsetjmp(..., 1), so that the prevailing signal mask
      * (to wit, BlockSig) will be restored when longjmp'ing to here.  Thus,
      * signals other than SIGQUIT will be blocked until we complete error
      * recovery.  It might seem that this policy makes the HOLD_INTERRUPTS()
      * call redundant, but it is not since InterruptPending might be set
      * already.
      */
     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 bgwriter, but we do have LWLocks, buffers, and temp files.
          */
         LWLockReleaseAll();
         ConditionVariableCancelSleep();
         AbortBufferIO();
         UnlockBuffers();
         ReleaseAuxProcessResources(false);
         AtEOXact_Buffers(false);
         AtEOXact_SMgr();
         AtEOXact_Files(false);
         AtEOXact_HashTables(false);
 
         /*
          * Now return to normal top-level context and clear ErrorContext for
          * next time.
          */
         MemoryContextSwitchTo(bgwriter_context);
         FlushErrorState();
 
         /* Flush any leaked data in the top-level context */
         MemoryContextResetAndDeleteChildren(bgwriter_context);
 
         /* re-initialize to avoid repeated errors causing problems */
         WritebackContextInit(&wb_context, &bgwriter_flush_after);
 
         /* 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();
 
         /* Report wait end here, when there is no further possibility of wait */
         pgstat_report_wait_end();
     }
 
     /* 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);
 
     /*
      * Reset hibernation state after any error.
      */
     prev_hibernate = false;
 
     /*
      * Loop forever
      */
     for (;;)
     {
         bool        can_hibernate;
         int         rc;
 
         /* Clear any already-pending wakeups */
         ResetLatch(MyLatch);
 
         HandleMainLoopInterrupts();
 
         /*
          * Do one cycle of dirty-buffer writing.
          */
         can_hibernate = BgBufferSync(&wb_context);
 
         /*
          * Send off activity statistics to the stats collector
          */
         pgstat_send_bgwriter();
 
         if (FirstCallSinceLastCheckpoint())
         {
             /*
              * After any checkpoint, close all smgr files.  This is so we
              * won't hang onto smgr references to deleted files indefinitely.
              */
             smgrcloseall();
         }
 
         /*
          * Log a new xl_running_xacts every now and then so replication can
          * get into a consistent state faster (think of suboverflowed
          * snapshots) and clean up resources (locks, KnownXids*) more
          * frequently. The costs of this are relatively low, so doing it 4
          * times (LOG_SNAPSHOT_INTERVAL_MS) a minute seems fine.
          *
          * We assume the interval for writing xl_running_xacts is
          * significantly bigger than BgWriterDelay, so we don't complicate the
          * overall timeout handling but just assume we're going to get called
          * often enough even if hibernation mode is active. It's not that
          * important that LOG_SNAPSHOT_INTERVAL_MS is met strictly. To make
          * sure we're not waking the disk up unnecessarily on an idle system
          * we check whether there has been any WAL inserted since the last
          * time we've logged a running xacts.
          *
          * We do this logging in the bgwriter as it is the only process that
          * is run regularly and returns to its mainloop all the time. E.g.
          * Checkpointer, when active, is barely ever in its mainloop and thus
          * makes it hard to log regularly.
          */
         if (XLogStandbyInfoActive() && !RecoveryInProgress())
         {
             TimestampTz timeout = 0;
             TimestampTz now = GetCurrentTimestamp();
 
             timeout = TimestampTzPlusMilliseconds(last_snapshot_ts,
                                                   LOG_SNAPSHOT_INTERVAL_MS);
 
             /*
              * Only log if enough time has passed and interesting records have
              * been inserted since the last snapshot.  Have to compare with <=
              * instead of < because GetLastImportantRecPtr() points at the
              * start of a record, whereas last_snapshot_lsn points just past
              * the end of the record.
              */
             if (now >= timeout &&
                 last_snapshot_lsn <= GetLastImportantRecPtr())
             {
                 last_snapshot_lsn = LogStandbySnapshot();
                 last_snapshot_ts = now;
             }
         }
 
         /*
          * Sleep until we are signaled or BgWriterDelay has elapsed.
          *
          * Note: the feedback control loop in BgBufferSync() expects that we
          * will call it every BgWriterDelay msec.  While it's not critical for
          * correctness that that be exact, the feedback loop might misbehave
          * if we stray too far from that.  Hence, avoid loading this process
          * down with latch events that are likely to happen frequently during
          * normal operation.
          */
         rc = WaitLatch(MyLatch,
                        WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
                        BgWriterDelay /* ms */ , WAIT_EVENT_BGWRITER_MAIN);
 
         /*
          * If no latch event and BgBufferSync says nothing's happening, extend
          * the sleep in "hibernation" mode, where we sleep for much longer
          * than bgwriter_delay says.  Fewer wakeups save electricity.  When a
          * backend starts using buffers again, it will wake us up by setting
          * our latch.  Because the extra sleep will persist only as long as no
          * buffer allocations happen, this should not distort the behavior of
          * BgBufferSync's control loop too badly; essentially, it will think
          * that the system-wide idle interval didn't exist.
          *
          * There is a race condition here, in that a backend might allocate a
          * buffer between the time BgBufferSync saw the alloc count as zero
          * and the time we call StrategyNotifyBgWriter.  While it's not
          * critical that we not hibernate anyway, we try to reduce the odds of
          * that by only hibernating when BgBufferSync says nothing's happening
          * for two consecutive cycles.  Also, we mitigate any possible
          * consequences of a missed wakeup by not hibernating forever.
          */
         if (rc == WL_TIMEOUT && can_hibernate && prev_hibernate)
         {
             /* Ask for notification at next buffer allocation */
             StrategyNotifyBgWriter(MyProc->pgprocno);
             /* Sleep ... */
             (void) WaitLatch(MyLatch,
                              WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
                              BgWriterDelay * HIBERNATE_FACTOR,
                              WAIT_EVENT_BGWRITER_HIBERNATE);
             /* Reset the notification request in case we timed out */
             StrategyNotifyBgWriter(-1);
         }
 
         prev_hibernate = can_hibernate;
     }
 }

◆ CheckpointerMain()

void CheckpointerMain ( void )

Definition at line 180 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, SignalHandlerForConfigReload);
     pqsignal(SIGINT, ReqCheckpointHandler); /* request checkpoint */
     pqsignal(SIGTERM, SIG_IGN); /* ignore SIGTERM */
     /* SIGQUIT handler was already set up by InitPostmasterChild */
     pqsignal(SIGALRM, SIG_IGN);
     pqsignal(SIGPIPE, SIG_IGN);
     pqsignal(SIGUSR1, procsignal_sigusr1_handler);
     pqsignal(SIGUSR2, SignalHandlerForShutdownRequest);
 
     /*
      * Reset some signals that are accepted by postmaster but not here
      */
     pqsignal(SIGCHLD, SIG_DFL);
 
     /*
      * 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.
      *
      * You might wonder why this isn't coded as an infinite loop around a
      * PG_TRY construct.  The reason is that this is the bottom of the
      * exception stack, and so with PG_TRY there would be no exception handler
      * in force at all during the CATCH part.  By leaving the outermost setjmp
      * always active, we have at least some chance of recovering from an error
      * during error recovery.  (If we get into an infinite loop thereby, it
      * will soon be stopped by overflow of elog.c's internal state stack.)
      *
      * Note that we use sigsetjmp(..., 1), so that the prevailing signal mask
      * (to wit, BlockSig) will be restored when longjmp'ing to here.  Thus,
      * signals other than SIGQUIT will be blocked until we complete error
      * recovery.  It might seem that this policy makes the HOLD_INTERRUPTS()
      * call redundant, but it is not since InterruptPending might be set
      * already.
      */
     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();
         HandleCheckpointerInterrupts();
 
         /*
          * 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;
             PendingCheckpointerStats.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)
                 PendingCheckpointerStats.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.
          */
         pgstat_send_checkpointer();
 
         /* Send WAL statistics to the stats collector. */
         pgstat_send_wal(true);
 
         /*
          * If any checkpoint flags have been set, redo the loop to handle the
          * checkpoint without sleeping.
          */
         if (((volatile CheckpointerShmemStruct *) CheckpointerShmem)->ckpt_flags)
             continue;
 
         /*
          * 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 877 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 858 of file checkpointer.c.

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

Referenced by CalculateShmemSize(), and CheckpointerShmemInit().

 {
     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 687 of file checkpointer.c.

References AbsorbSyncRequests(), AmCheckpointerProcess, CheckArchiveTimeout(), CHECKPOINT_IMMEDIATE, ConfigReloadPending, ImmediateCheckpointRequested(), IsCheckpointOnSchedule(), pg_usleep(), PGC_SIGHUP, pgstat_send_checkpointer(), ProcessConfigFile(), ProcessProcSignalBarrier(), ProcSignalBarrierPending, ShutdownRequestPending, 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) &&
         !ShutdownRequestPending &&
         !ImmediateCheckpointRequested() &&
         IsCheckpointOnSchedule(progress))
     {
         if (ConfigReloadPending)
         {
             ConfigReloadPending = false;
             ProcessConfigFile(PGC_SIGHUP);
             /* update shmem copies of config variables */
             UpdateSharedMemoryConfig();
         }
 
         AbsorbSyncRequests();
         absorb_counter = WRITES_PER_ABSORB;
 
         CheckArchiveTimeout();
 
         /*
          * Report interim activity statistics.
          */
         pgstat_send_checkpointer();
 
         /*
          * 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;
     }
 
     /* Check for barrier events. */
     if (ProcSignalBarrierPending)
         ProcessProcSignalBarrier();
 }

◆ FirstCallSinceLastCheckpoint()

bool FirstCallSinceLastCheckpoint ( void )

Definition at line 1327 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 1075 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;
 }

◆ RequestCheckpoint()

void RequestCheckpoint ( int flags )

Definition at line 920 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.")));
     }
 }

Variable Documentation

◆ BgWriterDelay

int BgWriterDelay

Definition at line 61 of file bgwriter.c.

Referenced by BackgroundWriterMain(), and BgBufferSync().

◆ CheckPointCompletionTarget

double CheckPointCompletionTarget

Definition at line 145 of file checkpointer.c.

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

◆ CheckPointTimeout

int CheckPointTimeout

Definition at line 143 of file checkpointer.c.

Referenced by CheckpointerMain(), and IsCheckpointOnSchedule().

◆ CheckPointWarning

int CheckPointWarning

Definition at line 144 of file checkpointer.c.

Referenced by CheckpointerMain().

Functions

Variables