bgwriter.h File Reference

#include "parser/parse_node.h"
#include "storage/block.h"
#include "storage/relfilelocator.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:

Go to the source code of this file.

Functions
pg_noreturn void	BackgroundWriterMain (const void *startup_data, size_t startup_data_len)
pg_noreturn void	CheckpointerMain (const void *startup_data, size_t startup_data_len)
void	ExecCheckpoint (ParseState *pstate, CheckPointStmt *stmt)
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
PGDLLIMPORT int	BgWriterDelay
PGDLLIMPORT int	CheckPointTimeout
PGDLLIMPORT int	CheckPointWarning
PGDLLIMPORT double	CheckPointCompletionTarget

Function Documentation

AbsorbSyncRequests()

void AbsorbSyncRequests

(

void

)

Definition at line 1437 of file checkpointer.c.

{
    CheckpointerRequest *requests = NULL;
    CheckpointerRequest *request;
    int         n,
                i;
    bool        loop;
 
    if (!AmCheckpointerProcess())
        return;
 
    do
    {
        LWLockAcquire(CheckpointerCommLock, LW_EXCLUSIVE);
 
        /*---
         * We try to avoid holding the lock for a long time by:
         * 1. Copying the request array and processing the requests after
         *    releasing the lock;
         * 2. Processing not the whole queue, but only batches of
         *    CKPT_REQ_BATCH_SIZE at once.
         *
         * Once we have cleared the requests from shared memory, we must
         * PANIC if we then fail to absorb them (e.g., 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.
         *
         * Note: The maximum possible size of a ring buffer is
         * MAX_CHECKPOINT_REQUESTS entries, which fit into a maximum palloc
         * allocation size of 1Gb.  Our maximum batch size,
         * CKPT_REQ_BATCH_SIZE, is even smaller.
         */
        n = Min(CheckpointerShmem->num_requests, CKPT_REQ_BATCH_SIZE);
        if (n > 0)
        {
            if (!requests)
                requests = (CheckpointerRequest *) palloc(n * sizeof(CheckpointerRequest));
 
            for (i = 0; i < n; i++)
            {
                requests[i] = CheckpointerShmem->requests[CheckpointerShmem->head];
                CheckpointerShmem->head = (CheckpointerShmem->head + 1) % CheckpointerShmem->max_requests;
            }
 
            CheckpointerShmem->num_requests -= n;
 
        }
 
        START_CRIT_SECTION();
 
        /* Are there any requests in the queue? If so, keep going. */
        loop = CheckpointerShmem->num_requests != 0;
 
        LWLockRelease(CheckpointerCommLock);
 
        for (request = requests; n > 0; request++, n--)
            RememberSyncRequest(&request->ftag, request->type);
 
        END_CRIT_SECTION();
    } while (loop);
 
    if (requests)
        pfree(requests);
}

References AmCheckpointerProcess, CheckpointerShmem, CKPT_REQ_BATCH_SIZE, END_CRIT_SECTION, CheckpointerRequest::ftag, CheckpointerShmemStruct::head, i, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), CheckpointerShmemStruct::max_requests, Min, CheckpointerShmemStruct::num_requests, palloc(), pfree(), RememberSyncRequest(), CheckpointerShmemStruct::requests, START_CRIT_SECTION, and CheckpointerRequest::type.

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

BackgroundWriterMain()

pg_noreturn void BackgroundWriterMain	(	const void *	startup_data,
		size_t	startup_data_len
	)

Definition at line 88 of file bgwriter.c.

{
    sigjmp_buf  local_sigjmp_buf;
    MemoryContext bgwriter_context;
    bool        prev_hibernate;
    WritebackContext wb_context;
 
    Assert(startup_data_len == 0);
 
    MyBackendType = B_BG_WRITER;
    AuxiliaryProcessMainCommon();
 
    /*
     * 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();
        pgaio_error_cleanup();
        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 */
        MemoryContextReset(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);
 
        /* 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)
     */
    sigprocmask(SIG_SETMASK, &UnBlockSig, NULL);
 
    /*
     * Reset hibernation state after any error.
     */
    prev_hibernate = false;
 
    /*
     * Loop forever
     */
    for (;;)
    {
        bool        can_hibernate;
        int         rc;
 
        /* Clear any already-pending wakeups */
        ResetLatch(MyLatch);
 
        ProcessMainLoopInterrupts();
 
        /*
         * Do one cycle of dirty-buffer writing.
         */
        can_hibernate = BgBufferSync(&wb_context);
 
        /* Report pending statistics to the cumulative stats system */
        pgstat_report_bgwriter();
        pgstat_report_wal(true);
 
        if (FirstCallSinceLastCheckpoint())
        {
            /*
             * After any checkpoint, free all smgr objects.  Otherwise we
             * would never do so for dropped relations, as the bgwriter does
             * not process shared invalidation messages or call
             * AtEOXact_SMgr().
             */
            smgrdestroyall();
        }
 
        /*
         * 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(MyProcNumber);
            /* 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;
    }
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), AtEOXact_Buffers(), AtEOXact_Files(), AtEOXact_HashTables(), AtEOXact_SMgr(), AuxiliaryProcessMainCommon(), B_BG_WRITER, BgBufferSync(), bgwriter_flush_after, BgWriterDelay, ConditionVariableCancelSleep(), EmitErrorReport(), error_context_stack, FirstCallSinceLastCheckpoint(), FlushErrorState(), GetCurrentTimestamp(), GetLastImportantRecPtr(), HIBERNATE_FACTOR, HOLD_INTERRUPTS, last_snapshot_lsn, last_snapshot_ts, LOG_SNAPSHOT_INTERVAL_MS, LogStandbySnapshot(), LWLockReleaseAll(), MemoryContextReset(), MemoryContextSwitchTo(), MyBackendType, MyLatch, MyProcNumber, now(), PG_exception_stack, pg_usleep(), pgaio_error_cleanup(), pgstat_report_bgwriter(), pgstat_report_wait_end(), pgstat_report_wal(), pqsignal, ProcessMainLoopInterrupts(), procsignal_sigusr1_handler(), RecoveryInProgress(), ReleaseAuxProcessResources(), ResetLatch(), RESUME_INTERRUPTS, SIGALRM, SIGCHLD, SIGHUP, SignalHandlerForConfigReload(), SignalHandlerForShutdownRequest(), SIGPIPE, SIGUSR1, SIGUSR2, smgrdestroyall(), StrategyNotifyBgWriter(), TimestampTzPlusMilliseconds, TopMemoryContext, UnBlockSig, UnlockBuffers(), WaitLatch(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, WL_TIMEOUT, WritebackContextInit(), and XLogStandbyInfoActive.

CheckpointerMain()

pg_noreturn void CheckpointerMain	(	const void *	startup_data,
		size_t	startup_data_len
	)

Definition at line 195 of file checkpointer.c.

{
    sigjmp_buf  local_sigjmp_buf;
    MemoryContext checkpointer_context;
 
    Assert(startup_data_len == 0);
 
    MyBackendType = B_CHECKPOINTER;
    AuxiliaryProcessMainCommon();
 
    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, ReqShutdownXLOG);
    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);
 
    /*
     * Write out stats after shutdown. This needs to be called by exactly one
     * process during a normal shutdown, and since checkpointer is shut down
     * very late...
     *
     * While e.g. walsenders are active after the shutdown checkpoint has been
     * written (and thus could produce more stats), checkpointer stays around
     * after the shutdown checkpoint has been written. postmaster will only
     * signal checkpointer to exit after all processes that could emit stats
     * have been shut down.
     */
    before_shmem_exit(pgstat_before_server_shutdown, 0);
 
    /*
     * 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();
        pgaio_error_cleanup();
        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 */
        MemoryContextReset(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);
    }
 
    /* We can now handle ereport(ERROR) */
    PG_exception_stack = &local_sigjmp_buf;
 
    /*
     * Unblock signals (they were blocked when the postmaster forked us)
     */
    sigprocmask(SIG_SETMASK, &UnBlockSig, NULL);
 
    /*
     * 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 proc number that backends can use to wake us up while
     * we're sleeping.
     */
    ProcGlobal->checkpointerProc = MyProcNumber;
 
    /*
     * Loop until we've been asked to write the shutdown checkpoint or
     * terminate.
     */
    for (;;)
    {
        bool        do_checkpoint = false;
        int         flags = 0;
        pg_time_t   now;
        int         elapsed_secs;
        int         cur_timeout;
        bool        chkpt_or_rstpt_requested = false;
        bool        chkpt_or_rstpt_timed = false;
 
        /* Clear any already-pending wakeups */
        ResetLatch(MyLatch);
 
        /*
         * Process any requests or signals received recently.
         */
        AbsorbSyncRequests();
 
        ProcessCheckpointerInterrupts();
        if (ShutdownXLOGPending || ShutdownRequestPending)
            break;
 
        /*
         * 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;
            chkpt_or_rstpt_requested = true;
        }
 
        /*
         * 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)
                chkpt_or_rstpt_timed = true;
            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. */
            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;
 
            if (chkpt_or_rstpt_timed)
            {
                chkpt_or_rstpt_timed = false;
                if (do_restartpoint)
                    PendingCheckpointerStats.restartpoints_timed++;
                else
                    PendingCheckpointerStats.num_timed++;
            }
 
            if (chkpt_or_rstpt_requested)
            {
                chkpt_or_rstpt_requested = false;
                if (do_restartpoint)
                    PendingCheckpointerStats.restartpoints_requested++;
                else
                    PendingCheckpointerStats.num_requested++;
            }
 
            /*
             * 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 \"%s\".", "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)
                ckpt_performed = CreateCheckPoint(flags);
            else
                ckpt_performed = CreateRestartPoint(flags);
 
            /*
             * After any checkpoint, free all smgr objects.  Otherwise we
             * would never do so for dropped relations, as the checkpointer
             * does not process shared invalidation messages or call
             * AtEOXact_SMgr().
             */
            smgrdestroyall();
 
            /*
             * 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 (!do_restartpoint)
            {
                /*
                 * 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;
 
                if (ckpt_performed)
                    PendingCheckpointerStats.num_performed++;
            }
            else
            {
                if (ckpt_performed)
                {
                    /*
                     * The same as for checkpoint. Please see the
                     * corresponding comment.
                     */
                    last_checkpoint_time = now;
 
                    PendingCheckpointerStats.restartpoints_performed++;
                }
                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;
 
            /*
             * We may have received an interrupt during the checkpoint and the
             * latch might have been reset (e.g. in CheckpointWriteDelay).
             */
            ProcessCheckpointerInterrupts();
            if (ShutdownXLOGPending || ShutdownRequestPending)
                break;
        }
 
        /*
         * Disable logical decoding if someone requested it. See comments atop
         * logicalctl.c.
         */
        DisableLogicalDecodingIfNecessary();
 
        /* Check for archive_timeout and switch xlog files if necessary. */
        CheckArchiveTimeout();
 
        /* Report pending statistics to the cumulative stats system */
        pgstat_report_checkpointer();
        pgstat_report_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);
    }
 
    /*
     * From here on, elog(ERROR) should end with exit(1), not send control
     * back to the sigsetjmp block above.
     */
    ExitOnAnyError = true;
 
    if (ShutdownXLOGPending)
    {
        /*
         * Close down the database.
         *
         * Since ShutdownXLOG() creates restartpoint or checkpoint, and
         * updates the statistics, increment the checkpoint request and flush
         * out pending statistic.
         */
        PendingCheckpointerStats.num_requested++;
        ShutdownXLOG(0, 0);
        pgstat_report_checkpointer();
        pgstat_report_wal(true);
 
        /*
         * Tell postmaster that we're done.
         */
        SendPostmasterSignal(PMSIGNAL_XLOG_IS_SHUTDOWN);
        ShutdownXLOGPending = false;
    }
 
    /*
     * Wait until we're asked to shut down. By separating the writing of the
     * shutdown checkpoint from checkpointer exiting, checkpointer can perform
     * some should-be-as-late-as-possible work like writing out stats.
     */
    for (;;)
    {
        /* Clear any already-pending wakeups */
        ResetLatch(MyLatch);
 
        ProcessCheckpointerInterrupts();
 
        if (ShutdownRequestPending)
            break;
 
        (void) WaitLatch(MyLatch,
                         WL_LATCH_SET | WL_EXIT_ON_PM_DEATH,
                         0,
                         WAIT_EVENT_CHECKPOINTER_SHUTDOWN);
    }
 
    /* Normal exit from the checkpointer is here */
    proc_exit(0);               /* done */
}

References AbsorbSyncRequests(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), AtEOXact_Buffers(), AtEOXact_Files(), AtEOXact_HashTables(), AtEOXact_SMgr(), AuxiliaryProcessMainCommon(), B_CHECKPOINTER, before_shmem_exit(), CheckArchiveTimeout(), CHECKPOINT_CAUSE_TIME, CHECKPOINT_CAUSE_XLOG, CHECKPOINT_END_OF_RECOVERY, CheckpointerShmemStruct::checkpointer_pid, PROC_HDR::checkpointerProc, CheckpointerShmem, CheckPointTimeout, CheckPointWarning, ckpt_active, ckpt_cached_elapsed, CheckpointerShmemStruct::ckpt_done, CheckpointerShmemStruct::ckpt_failed, CheckpointerShmemStruct::ckpt_flags, CheckpointerShmemStruct::ckpt_lck, ckpt_start_recptr, ckpt_start_time, CheckpointerShmemStruct::ckpt_started, ConditionVariableBroadcast(), ConditionVariableCancelSleep(), CreateCheckPoint(), CreateRestartPoint(), DisableLogicalDecodingIfNecessary(), CheckpointerShmemStruct::done_cv, EmitErrorReport(), ereport, errhint(), errmsg_plural(), error_context_stack, ExitOnAnyError, FlushErrorState(), GetInsertRecPtr(), GetXLogReplayRecPtr(), HOLD_INTERRUPTS, last_checkpoint_time, last_xlog_switch_time, LOG, LWLockReleaseAll(), MemoryContextReset(), MemoryContextSwitchTo(), Min, MyBackendType, MyLatch, MyProcNumber, MyProcPid, now(), PgStat_CheckpointerStats::num_performed, PgStat_CheckpointerStats::num_requested, PgStat_CheckpointerStats::num_timed, PendingCheckpointerStats, PG_exception_stack, pg_usleep(), pgaio_error_cleanup(), pgstat_before_server_shutdown(), pgstat_report_checkpointer(), pgstat_report_wait_end(), pgstat_report_wal(), PMSIGNAL_XLOG_IS_SHUTDOWN, pqsignal, proc_exit(), ProcessCheckpointerInterrupts(), ProcGlobal, procsignal_sigusr1_handler(), RecoveryInProgress(), ReleaseAuxProcessResources(), ReqShutdownXLOG(), ResetLatch(), PgStat_CheckpointerStats::restartpoints_performed, PgStat_CheckpointerStats::restartpoints_requested, PgStat_CheckpointerStats::restartpoints_timed, RESUME_INTERRUPTS, SendPostmasterSignal(), ShutdownRequestPending, ShutdownXLOG(), ShutdownXLOGPending, SIGALRM, SIGCHLD, SIGHUP, SignalHandlerForConfigReload(), SignalHandlerForShutdownRequest(), SIGPIPE, SIGUSR1, SIGUSR2, smgrdestroyall(), SpinLockAcquire, SpinLockRelease, CheckpointerShmemStruct::start_cv, TopMemoryContext, UnBlockSig, UnlockBuffers(), UpdateSharedMemoryConfig(), WaitLatch(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, WL_TIMEOUT, and XLogArchiveTimeout.

CheckpointerShmemInit()

void CheckpointerShmemInit

(

void

)

Definition at line 979 of file checkpointer.c.

{
    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 = Min(NBuffers, MAX_CHECKPOINT_REQUESTS);
        CheckpointerShmem->head = CheckpointerShmem->tail = 0;
        ConditionVariableInit(&CheckpointerShmem->start_cv);
        ConditionVariableInit(&CheckpointerShmem->done_cv);
    }
}

References CheckpointerShmem, CheckpointerShmemSize(), CheckpointerShmemStruct::ckpt_lck, ConditionVariableInit(), CheckpointerShmemStruct::done_cv, CheckpointerShmemStruct::head, MAX_CHECKPOINT_REQUESTS, CheckpointerShmemStruct::max_requests, MemSet, Min, NBuffers, ShmemInitStruct(), SpinLockInit, CheckpointerShmemStruct::start_cv, and CheckpointerShmemStruct::tail.

Referenced by CreateOrAttachShmemStructs().

CheckpointerShmemSize()

Size CheckpointerShmemSize

(

void

)

Definition at line 957 of file checkpointer.c.

{
    Size        size;
 
    /*
     * The size of the requests[] array is arbitrarily set equal to NBuffers.
     * But there is a cap of MAX_CHECKPOINT_REQUESTS to prevent accumulating
     * too many checkpoint requests in the ring buffer.
     */
    size = offsetof(CheckpointerShmemStruct, requests);
    size = add_size(size, mul_size(Min(NBuffers,
                                       MAX_CHECKPOINT_REQUESTS),
                                   sizeof(CheckpointerRequest)));
 
    return size;
}

References add_size(), MAX_CHECKPOINT_REQUESTS, Min, mul_size(), and NBuffers.

Referenced by CalculateShmemSize(), and CheckpointerShmemInit().

CheckpointWriteDelay()

void CheckpointWriteDelay	(	int	flags,
		double	progress
	)

Definition at line 791 of file checkpointer.c.

{
    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_FAST) &&
        !ShutdownXLOGPending &&
        !ShutdownRequestPending &&
        !FastCheckpointRequested() &&
        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 statistics to the cumulative stats system */
        pgstat_report_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.
         */
        WaitLatch(MyLatch, WL_LATCH_SET | WL_EXIT_ON_PM_DEATH | WL_TIMEOUT,
                  100,
                  WAIT_EVENT_CHECKPOINT_WRITE_DELAY);
        ResetLatch(MyLatch);
    }
    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();
}

References AbsorbSyncRequests(), AmCheckpointerProcess, CheckArchiveTimeout(), CHECKPOINT_FAST, ConfigReloadPending, FastCheckpointRequested(), IsCheckpointOnSchedule(), MyLatch, PGC_SIGHUP, pgstat_report_checkpointer(), ProcessConfigFile(), ProcessProcSignalBarrier(), ProcSignalBarrierPending, progress, ResetLatch(), ShutdownRequestPending, ShutdownXLOGPending, UpdateSharedMemoryConfig(), WaitLatch(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, WL_TIMEOUT, and WRITES_PER_ABSORB.

Referenced by BufferSync().

ExecCheckpoint()

void ExecCheckpoint	(	ParseState *	pstate,
		CheckPointStmt *	stmt
	)

Definition at line 1012 of file checkpointer.c.

{
    bool        fast = true;
    bool        unlogged = false;
 
    foreach_ptr(DefElem, opt, stmt->options)
    {
        if (strcmp(opt->defname, "mode") == 0)
        {
            char       *mode = defGetString(opt);
 
            if (strcmp(mode, "spread") == 0)
                fast = false;
            else if (strcmp(mode, "fast") != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("unrecognized value for %s option \"%s\": \"%s\"",
                                "CHECKPOINT", "mode", mode),
                         parser_errposition(pstate, opt->location)));
        }
        else if (strcmp(opt->defname, "flush_unlogged") == 0)
            unlogged = defGetBoolean(opt);
        else
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("unrecognized %s option \"%s\"",
                            "CHECKPOINT", opt->defname),
                     parser_errposition(pstate, opt->location)));
    }
 
    if (!has_privs_of_role(GetUserId(), ROLE_PG_CHECKPOINT))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
        /* translator: %s is name of an SQL command (e.g., CHECKPOINT) */
                 errmsg("permission denied to execute %s command",
                        "CHECKPOINT"),
                 errdetail("Only roles with privileges of the \"%s\" role may execute this command.",
                           "pg_checkpoint")));
 
    RequestCheckpoint(CHECKPOINT_WAIT |
                      (fast ? CHECKPOINT_FAST : 0) |
                      (unlogged ? CHECKPOINT_FLUSH_UNLOGGED : 0) |
                      (RecoveryInProgress() ? 0 : CHECKPOINT_FORCE));
}

References CHECKPOINT_FAST, CHECKPOINT_FLUSH_UNLOGGED, CHECKPOINT_FORCE, CHECKPOINT_WAIT, defGetBoolean(), defGetString(), ereport, errcode(), errdetail(), errmsg(), ERROR, foreach_ptr, GetUserId(), has_privs_of_role(), mode, parser_errposition(), RecoveryInProgress(), RequestCheckpoint(), and stmt.

Referenced by standard_ProcessUtility().

FirstCallSinceLastCheckpoint()

bool FirstCallSinceLastCheckpoint

(

void

)

Definition at line 1527 of file checkpointer.c.

{
    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;
}

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

Referenced by BackgroundWriterMain().

ForwardSyncRequest()

bool ForwardSyncRequest	(	const FileTag *	ftag,
		SyncRequestType	type
	)

Definition at line 1225 of file checkpointer.c.

{
    CheckpointerRequest *request;
    bool        too_full;
    int         insert_pos;
 
    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);
 
    /*
     * 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()))
    {
        LWLockRelease(CheckpointerCommLock);
        return false;
    }
 
    /* OK, insert request */
    insert_pos = CheckpointerShmem->tail;
    request = &CheckpointerShmem->requests[insert_pos];
    request->ftag = *ftag;
    request->type = type;
 
    CheckpointerShmem->tail = (CheckpointerShmem->tail + 1) % CheckpointerShmem->max_requests;
    CheckpointerShmem->num_requests++;
 
    /* 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)
    {
        volatile PROC_HDR *procglobal = ProcGlobal;
        ProcNumber  checkpointerProc = procglobal->checkpointerProc;
 
        if (checkpointerProc != INVALID_PROC_NUMBER)
            SetLatch(&GetPGProcByNumber(checkpointerProc)->procLatch);
    }
 
    return true;
}

References AmCheckpointerProcess, CheckpointerShmemStruct::checkpointer_pid, PROC_HDR::checkpointerProc, CheckpointerShmem, CompactCheckpointerRequestQueue(), elog, ERROR, CheckpointerRequest::ftag, GetPGProcByNumber, INVALID_PROC_NUMBER, IsUnderPostmaster, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), CheckpointerShmemStruct::max_requests, CheckpointerShmemStruct::num_requests, ProcGlobal, CheckpointerShmemStruct::requests, SetLatch(), CheckpointerShmemStruct::tail, CheckpointerRequest::type, and type.

Referenced by RegisterSyncRequest().

RequestCheckpoint()

void RequestCheckpoint

(

int

flags

)

Definition at line 1075 of file checkpointer.c.

{
    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_FAST);
 
        /* Free all smgr objects, as CheckpointerMain() normally would. */
        smgrdestroyall();
 
        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);
 
    /*
     * Set checkpointer's latch to request checkpoint.  It's possible that the
     * checkpointer hasn't started yet, 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 set the latch to be
     * nonfatal and merely LOG it.  The checkpointer should see the request
     * when it does start, with or without the SetLatch().
     */
#define MAX_SIGNAL_TRIES 600    /* max wait 60.0 sec */
    for (ntries = 0;; ntries++)
    {
        volatile PROC_HDR *procglobal = ProcGlobal;
        ProcNumber  checkpointerProc = procglobal->checkpointerProc;
 
        if (checkpointerProc == INVALID_PROC_NUMBER)
        {
            if (ntries >= MAX_SIGNAL_TRIES || !(flags & CHECKPOINT_WAIT))
            {
                elog((flags & CHECKPOINT_WAIT) ? ERROR : LOG,
                     "could not notify checkpoint: checkpointer is not running");
                break;
            }
        }
        else
        {
            SetLatch(&GetPGProcByNumber(checkpointerProc)->procLatch);
            /* notified successfully */
            break;
        }
 
        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.")));
    }
}

References CHECK_FOR_INTERRUPTS, CHECKPOINT_FAST, CHECKPOINT_REQUESTED, CHECKPOINT_WAIT, PROC_HDR::checkpointerProc, CheckpointerShmem, CheckpointerShmemStruct::ckpt_done, CheckpointerShmemStruct::ckpt_failed, CheckpointerShmemStruct::ckpt_flags, CheckpointerShmemStruct::ckpt_lck, CheckpointerShmemStruct::ckpt_started, ConditionVariableCancelSleep(), ConditionVariablePrepareToSleep(), ConditionVariableSleep(), CreateCheckPoint(), CheckpointerShmemStruct::done_cv, elog, ereport, errhint(), errmsg(), ERROR, GetPGProcByNumber, INVALID_PROC_NUMBER, IsPostmasterEnvironment, LOG, MAX_SIGNAL_TRIES, pg_usleep(), ProcGlobal, SetLatch(), smgrdestroyall(), SpinLockAcquire, SpinLockRelease, and CheckpointerShmemStruct::start_cv.

Referenced by CreateDatabaseUsingFileCopy(), do_pg_backup_start(), dropdb(), DropTableSpace(), ExecCheckpoint(), movedb(), PerformRecoveryXLogAction(), StartupXLOG(), XLogPageRead(), and XLogWrite().

Variable Documentation

BgWriterDelay

PGDLLIMPORT int BgWriterDelay

extern

Definition at line 58 of file bgwriter.c.

Referenced by BackgroundWriterMain(), and BgBufferSync().

CheckPointCompletionTarget

PGDLLIMPORT double CheckPointCompletionTarget

extern

Definition at line 159 of file checkpointer.c.

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

CheckPointTimeout

PGDLLIMPORT int CheckPointTimeout

extern

Definition at line 157 of file checkpointer.c.

Referenced by CheckpointerMain(), and IsCheckpointOnSchedule().

CheckPointWarning

PGDLLIMPORT int CheckPointWarning

extern

Definition at line 158 of file checkpointer.c.

Referenced by CheckpointerMain().