#include "access/xlogdefs.h"

Include dependency graph for walsummarizer.h:

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

Functions
Size	WalSummarizerShmemSize (void)

void	WalSummarizerShmemInit (void)

void	WalSummarizerMain (char *startup_data, size_t startup_data_len) pg_attribute_noreturn()

void	GetWalSummarizerState (TimeLineID summarized_tli, XLogRecPtr summarized_lsn, XLogRecPtr pending_lsn, int summarizer_pid)

XLogRecPtr	GetOldestUnsummarizedLSN (TimeLineID tli, bool lsn_is_exact)

void	SetWalSummarizerLatch (void)

void	WaitForWalSummarization (XLogRecPtr lsn)

Variables
PGDLLIMPORT bool	summarize_wal

PGDLLIMPORT int	wal_summary_keep_time

Function Documentation

◆ GetOldestUnsummarizedLSN()

XLogRecPtr GetOldestUnsummarizedLSN	(	TimeLineID *	tli,
		bool *	lsn_is_exact
	)

Definition at line 505 of file walsummarizer.c.

 {
     TimeLineID  latest_tli;
     int         n;
     List       *tles;
     XLogRecPtr  unsummarized_lsn = InvalidXLogRecPtr;
     TimeLineID  unsummarized_tli = 0;
     bool        should_make_exact = false;
     List       *existing_summaries;
     ListCell   *lc;
     bool        am_wal_summarizer = AmWalSummarizerProcess();
  
     /* If not summarizing WAL, do nothing. */
     if (!summarize_wal)
         return InvalidXLogRecPtr;
  
     /*
      * If we are not the WAL summarizer process, then we normally just want to
      * read the values from shared memory. However, as an exception, if shared
      * memory hasn't been initialized yet, then we need to do that so that we
      * can read legal values and not remove any WAL too early.
      */
     if (!am_wal_summarizer)
     {
         LWLockAcquire(WALSummarizerLock, LW_SHARED);
  
         if (WalSummarizerCtl->initialized)
         {
             unsummarized_lsn = WalSummarizerCtl->summarized_lsn;
             if (tli != NULL)
                 *tli = WalSummarizerCtl->summarized_tli;
             if (lsn_is_exact != NULL)
                 *lsn_is_exact = WalSummarizerCtl->lsn_is_exact;
             LWLockRelease(WALSummarizerLock);
             return unsummarized_lsn;
         }
  
         LWLockRelease(WALSummarizerLock);
     }
  
     /*
      * Find the oldest timeline on which WAL still exists, and the earliest
      * segment for which it exists.
      *
      * Note that we do this every time the WAL summarizer process restarts or
      * recovers from an error, in case the contents of pg_wal have changed
      * under us e.g. if some files were removed, either manually - which
      * shouldn't really happen, but might - or by postgres itself, if
      * summarize_wal was turned off and then back on again.
      */
     (void) GetLatestLSN(&latest_tli);
     tles = readTimeLineHistory(latest_tli);
     for (n = list_length(tles) - 1; n >= 0; --n)
     {
         TimeLineHistoryEntry *tle = list_nth(tles, n);
         XLogSegNo   oldest_segno;
  
         oldest_segno = XLogGetOldestSegno(tle->tli);
         if (oldest_segno != 0)
         {
             /* Compute oldest LSN that still exists on disk. */
             XLogSegNoOffsetToRecPtr(oldest_segno, 0, wal_segment_size,
                                     unsummarized_lsn);
  
             unsummarized_tli = tle->tli;
             break;
         }
     }
  
     /*
      * Don't try to summarize anything older than the end LSN of the newest
      * summary file that exists for this timeline.
      */
     existing_summaries =
         GetWalSummaries(unsummarized_tli,
                         InvalidXLogRecPtr, InvalidXLogRecPtr);
     foreach(lc, existing_summaries)
     {
         WalSummaryFile *ws = lfirst(lc);
  
         if (ws->end_lsn > unsummarized_lsn)
         {
             unsummarized_lsn = ws->end_lsn;
             should_make_exact = true;
         }
     }
  
     /* It really should not be possible for us to find no WAL. */
     if (unsummarized_tli == 0)
         ereport(ERROR,
                 errcode(ERRCODE_INTERNAL_ERROR),
                 errmsg_internal("no WAL found on timeline %u", latest_tli));
  
     /*
      * If we're the WAL summarizer, we always want to store the values we just
      * computed into shared memory, because those are the values we're going
      * to use to drive our operation, and so they are the authoritative
      * values. Otherwise, we only store values into shared memory if shared
      * memory is uninitialized. Our values are not canonical in such a case,
      * but it's better to have something than nothing, to guide WAL retention.
      */
     LWLockAcquire(WALSummarizerLock, LW_EXCLUSIVE);
     if (am_wal_summarizer || !WalSummarizerCtl->initialized)
     {
         WalSummarizerCtl->initialized = true;
         WalSummarizerCtl->summarized_lsn = unsummarized_lsn;
         WalSummarizerCtl->summarized_tli = unsummarized_tli;
         WalSummarizerCtl->lsn_is_exact = should_make_exact;
         WalSummarizerCtl->pending_lsn = unsummarized_lsn;
     }
     else
         unsummarized_lsn = WalSummarizerCtl->summarized_lsn;
  
     /* Also return the to the caller as required. */
     if (tli != NULL)
         *tli = WalSummarizerCtl->summarized_tli;
     if (lsn_is_exact != NULL)
         *lsn_is_exact = WalSummarizerCtl->lsn_is_exact;
     LWLockRelease(WALSummarizerLock);
  
     return unsummarized_lsn;
 }

References AmWalSummarizerProcess, WalSummaryFile::end_lsn, ereport, errcode(), errmsg_internal(), ERROR, GetLatestLSN(), GetWalSummaries(), WalSummarizerData::initialized, InvalidXLogRecPtr, lfirst, list_length(), list_nth(), WalSummarizerData::lsn_is_exact, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), WalSummarizerData::pending_lsn, readTimeLineHistory(), summarize_wal, WalSummarizerData::summarized_lsn, WalSummarizerData::summarized_tli, TimeLineHistoryEntry::tli, wal_segment_size, WalSummarizerCtl, XLogGetOldestSegno(), and XLogSegNoOffsetToRecPtr.

Referenced by KeepLogSeg(), and WalSummarizerMain().

◆ GetWalSummarizerState()

void GetWalSummarizerState	(	TimeLineID *	summarized_tli,
		XLogRecPtr *	summarized_lsn,
		XLogRecPtr *	pending_lsn,
		int *	summarizer_pid
	)

Definition at line 447 of file walsummarizer.c.

 {
     LWLockAcquire(WALSummarizerLock, LW_SHARED);
     if (!WalSummarizerCtl->initialized)
     {
         /*
          * If initialized is false, the rest of the structure contents are
          * undefined.
          */
         *summarized_tli = 0;
         *summarized_lsn = InvalidXLogRecPtr;
         *pending_lsn = InvalidXLogRecPtr;
         *summarizer_pid = -1;
     }
     else
     {
         int         summarizer_pgprocno = WalSummarizerCtl->summarizer_pgprocno;
  
         *summarized_tli = WalSummarizerCtl->summarized_tli;
         *summarized_lsn = WalSummarizerCtl->summarized_lsn;
         if (summarizer_pgprocno == INVALID_PROC_NUMBER)
         {
             /*
              * If the summarizer has exited, the fact that it had processed
              * beyond summarized_lsn is irrelevant now.
              */
             *pending_lsn = WalSummarizerCtl->summarized_lsn;
             *summarizer_pid = -1;
         }
         else
         {
             *pending_lsn = WalSummarizerCtl->pending_lsn;
  
             /*
              * We're not fussed about inexact answers here, since they could
              * become stale instantly, so we don't bother taking the lock, but
              * make sure that invalid PID values are normalized to -1.
              */
             *summarizer_pid = GetPGProcByNumber(summarizer_pgprocno)->pid;
             if (*summarizer_pid <= 0)
                 *summarizer_pid = -1;
         }
     }
     LWLockRelease(WALSummarizerLock);
 }

References GetPGProcByNumber, WalSummarizerData::initialized, INVALID_PROC_NUMBER, InvalidXLogRecPtr, LW_SHARED, LWLockAcquire(), LWLockRelease(), WalSummarizerData::pending_lsn, WalSummarizerData::summarized_lsn, WalSummarizerData::summarized_tli, WalSummarizerData::summarizer_pgprocno, and WalSummarizerCtl.

Referenced by pg_get_wal_summarizer_state().

◆ SetWalSummarizerLatch()

void SetWalSummarizerLatch ( void )

Definition at line 637 of file walsummarizer.c.

 {
     ProcNumber  pgprocno;
  
     if (WalSummarizerCtl == NULL)
         return;
  
     LWLockAcquire(WALSummarizerLock, LW_EXCLUSIVE);
     pgprocno = WalSummarizerCtl->summarizer_pgprocno;
     LWLockRelease(WALSummarizerLock);
  
     if (pgprocno != INVALID_PROC_NUMBER)
         SetLatch(&ProcGlobal->allProcs[pgprocno].procLatch);
 }

References PROC_HDR::allProcs, INVALID_PROC_NUMBER, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ProcGlobal, PGPROC::procLatch, SetLatch(), WalSummarizerData::summarizer_pgprocno, and WalSummarizerCtl.

Referenced by CreateCheckPoint().

◆ WaitForWalSummarization()

void WaitForWalSummarization ( XLogRecPtr lsn )

Definition at line 660 of file walsummarizer.c.

 {
     TimestampTz initial_time,
                 cycle_time,
                 current_time;
     XLogRecPtr  prior_pending_lsn = InvalidXLogRecPtr;
     int         deadcycles = 0;
  
     initial_time = cycle_time = GetCurrentTimestamp();
  
     while (1)
     {
         long        timeout_in_ms = 10000;
         XLogRecPtr  summarized_lsn;
         XLogRecPtr  pending_lsn;
  
         CHECK_FOR_INTERRUPTS();
  
         /* If WAL summarization is disabled while we're waiting, give up. */
         if (!summarize_wal)
             return;
  
         /*
          * If the LSN summarized on disk has reached the target value, stop.
          */
         LWLockAcquire(WALSummarizerLock, LW_EXCLUSIVE);
         summarized_lsn = WalSummarizerCtl->summarized_lsn;
         pending_lsn = WalSummarizerCtl->pending_lsn;
         LWLockRelease(WALSummarizerLock);
  
         /* If WAL summarization has progressed sufficiently, stop waiting. */
         if (summarized_lsn >= lsn)
             break;
  
         /* Recheck current time. */
         current_time = GetCurrentTimestamp();
  
         /* Have we finished the current cycle of waiting? */
         if (TimestampDifferenceMilliseconds(cycle_time,
                                             current_time) >= timeout_in_ms)
         {
             long        elapsed_seconds;
  
             /* Begin new wait cycle. */
             cycle_time = TimestampTzPlusMilliseconds(cycle_time,
                                                      timeout_in_ms);
  
             /*
              * Keep track of the number of cycles during which there has been
              * no progression of pending_lsn. If pending_lsn is not advancing,
              * that means that not only are no new files appearing on disk,
              * but we're not even incorporating new records into the in-memory
              * state.
              */
             if (pending_lsn > prior_pending_lsn)
             {
                 prior_pending_lsn = pending_lsn;
                 deadcycles = 0;
             }
             else
                 ++deadcycles;
  
             /*
              * If we've managed to wait for an entire minute without the WAL
              * summarizer absorbing a single WAL record, error out; probably
              * something is wrong.
              *
              * We could consider also erroring out if the summarizer is taking
              * too long to catch up, but it's not clear what rate of progress
              * would be acceptable and what would be too slow. So instead, we
              * just try to error out in the case where there's no progress at
              * all. That seems likely to catch a reasonable number of the
              * things that can go wrong in practice (e.g. the summarizer
              * process is completely hung, say because somebody hooked up a
              * debugger to it or something) without giving up too quickly when
              * the system is just slow.
              */
             if (deadcycles >= 6)
                 ereport(ERROR,
                         (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                          errmsg("WAL summarization is not progressing"),
                          errdetail("Summarization is needed through %X/%X, but is stuck at %X/%X on disk and %X/%X in memory.",
                                    LSN_FORMAT_ARGS(lsn),
                                    LSN_FORMAT_ARGS(summarized_lsn),
                                    LSN_FORMAT_ARGS(pending_lsn))));
  
  
             /*
              * Otherwise, just let the user know what's happening.
              */
             elapsed_seconds =
                 TimestampDifferenceMilliseconds(initial_time,
                                                 current_time) / 1000;
             ereport(WARNING,
                     (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                      errmsg("still waiting for WAL summarization through %X/%X after %ld seconds",
                             LSN_FORMAT_ARGS(lsn),
                             elapsed_seconds),
                      errdetail("Summarization has reached %X/%X on disk and %X/%X in memory.",
                                LSN_FORMAT_ARGS(summarized_lsn),
                                LSN_FORMAT_ARGS(pending_lsn))));
         }
  
         /*
          * Align the wait time to prevent drift. This doesn't really matter,
          * but we'd like the warnings about how long we've been waiting to say
          * 10 seconds, 20 seconds, 30 seconds, 40 seconds ... without ever
          * drifting to something that is not a multiple of ten.
          */
         timeout_in_ms -=
             TimestampDifferenceMilliseconds(cycle_time, current_time);
  
         /* Wait and see. */
         ConditionVariableTimedSleep(&WalSummarizerCtl->summary_file_cv,
                                     timeout_in_ms,
                                     WAIT_EVENT_WAL_SUMMARY_READY);
     }
  
     ConditionVariableCancelSleep();
 }

References CHECK_FOR_INTERRUPTS, ConditionVariableCancelSleep(), ConditionVariableTimedSleep(), ereport, errcode(), errdetail(), errmsg(), ERROR, GetCurrentTimestamp(), InvalidXLogRecPtr, LSN_FORMAT_ARGS, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), WalSummarizerData::pending_lsn, summarize_wal, WalSummarizerData::summarized_lsn, WalSummarizerData::summary_file_cv, TimestampDifferenceMilliseconds(), TimestampTzPlusMilliseconds, WalSummarizerCtl, and WARNING.

Referenced by CleanupAfterArchiveRecovery(), and PrepareForIncrementalBackup().

◆ WalSummarizerMain()

void WalSummarizerMain	(	char *	startup_data,
		size_t	startup_data_len
	)

Definition at line 211 of file walsummarizer.c.

 {
     sigjmp_buf  local_sigjmp_buf;
     MemoryContext context;
  
     /*
      * Within this function, 'current_lsn' and 'current_tli' refer to the
      * point from which the next WAL summary file should start. 'exact' is
      * true if 'current_lsn' is known to be the start of a WAL record or WAL
      * segment, and false if it might be in the middle of a record someplace.
      *
      * 'switch_lsn' and 'switch_tli', if set, are the LSN at which we need to
      * switch to a new timeline and the timeline to which we need to switch.
      * If not set, we either haven't figured out the answers yet or we're
      * already on the latest timeline.
      */
     XLogRecPtr  current_lsn;
     TimeLineID  current_tli;
     bool        exact;
     XLogRecPtr  switch_lsn = InvalidXLogRecPtr;
     TimeLineID  switch_tli = 0;
  
     Assert(startup_data_len == 0);
  
     MyBackendType = B_WAL_SUMMARIZER;
     AuxiliaryProcessMainCommon();
  
     ereport(DEBUG1,
             (errmsg_internal("WAL summarizer started")));
  
     /*
      * Properly accept or ignore signals the postmaster might send us
      *
      * We have no particular use for SIGINT at the moment, but seems
      * reasonable to treat like SIGTERM.
      */
     pqsignal(SIGHUP, SignalHandlerForConfigReload);
     pqsignal(SIGINT, SignalHandlerForShutdownRequest);
     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); /* not used */
  
     /* Advertise ourselves. */
     on_shmem_exit(WalSummarizerShutdown, (Datum) 0);
     LWLockAcquire(WALSummarizerLock, LW_EXCLUSIVE);
     WalSummarizerCtl->summarizer_pgprocno = MyProcNumber;
     LWLockRelease(WALSummarizerLock);
  
     /* Create and switch to a memory context that we can reset on error. */
     context = AllocSetContextCreate(TopMemoryContext,
                                     "Wal Summarizer",
                                     ALLOCSET_DEFAULT_SIZES);
     MemoryContextSwitchTo(context);
  
     /*
      * Reset some signals that are accepted by postmaster but not here
      */
     pqsignal(SIGCHLD, SIG_DFL);
  
     /*
      * If an exception is encountered, processing resumes here.
      */
     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();
  
         /* Release resources we might have acquired. */
         LWLockReleaseAll();
         ConditionVariableCancelSleep();
         pgstat_report_wait_end();
         ReleaseAuxProcessResources(false);
         AtEOXact_Files(false);
         AtEOXact_HashTables(false);
  
         /*
          * Now return to normal top-level context and clear ErrorContext for
          * next time.
          */
         MemoryContextSwitchTo(context);
         FlushErrorState();
  
         /* Flush any leaked data in the top-level context */
         MemoryContextReset(context);
  
         /* Now we can allow interrupts again */
         RESUME_INTERRUPTS();
  
         /*
          * Sleep for 10 seconds before attempting to resume operations in
          * order to avoid excessive logging.
          *
          * Many of the likely error conditions are things that will repeat
          * every time. For example, if the WAL can't be read or the summary
          * can't be written, only administrator action will cure the problem.
          * So a really fast retry time doesn't seem to be especially
          * beneficial, and it will clutter the logs.
          */
         (void) WaitLatch(MyLatch,
                          WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
                          10000,
                          WAIT_EVENT_WAL_SUMMARIZER_ERROR);
     }
  
     /* 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);
  
     /*
      * Fetch information about previous progress from shared memory, and ask
      * GetOldestUnsummarizedLSN to reset pending_lsn to summarized_lsn. We
      * might be recovering from an error, and if so, pending_lsn might have
      * advanced past summarized_lsn, but any WAL we read previously has been
      * lost and will need to be reread.
      *
      * If we discover that WAL summarization is not enabled, just exit.
      */
     current_lsn = GetOldestUnsummarizedLSN(&current_tli, &exact);
     if (XLogRecPtrIsInvalid(current_lsn))
         proc_exit(0);
  
     /*
      * Loop forever
      */
     for (;;)
     {
         XLogRecPtr  latest_lsn;
         TimeLineID  latest_tli;
         XLogRecPtr  end_of_summary_lsn;
  
         /* Flush any leaked data in the top-level context */
         MemoryContextReset(context);
  
         /* Process any signals received recently. */
         HandleWalSummarizerInterrupts();
  
         /* If it's time to remove any old WAL summaries, do that now. */
         MaybeRemoveOldWalSummaries();
  
         /* Find the LSN and TLI up to which we can safely summarize. */
         latest_lsn = GetLatestLSN(&latest_tli);
  
         /*
          * If we're summarizing a historic timeline and we haven't yet
          * computed the point at which to switch to the next timeline, do that
          * now.
          *
          * Note that if this is a standby, what was previously the current
          * timeline could become historic at any time.
          *
          * We could try to make this more efficient by caching the results of
          * readTimeLineHistory when latest_tli has not changed, but since we
          * only have to do this once per timeline switch, we probably wouldn't
          * save any significant amount of work in practice.
          */
         if (current_tli != latest_tli && XLogRecPtrIsInvalid(switch_lsn))
         {
             List       *tles = readTimeLineHistory(latest_tli);
  
             switch_lsn = tliSwitchPoint(current_tli, tles, &switch_tli);
             ereport(DEBUG1,
                     errmsg("switch point from TLI %u to TLI %u is at %X/%X",
                            current_tli, switch_tli, LSN_FORMAT_ARGS(switch_lsn)));
         }
  
         /*
          * If we've reached the switch LSN, we can't summarize anything else
          * on this timeline. Switch to the next timeline and go around again,
          * backing up to the exact switch point if we passed it.
          */
         if (!XLogRecPtrIsInvalid(switch_lsn) && current_lsn >= switch_lsn)
         {
             /* Restart summarization from switch point. */
             current_tli = switch_tli;
             current_lsn = switch_lsn;
  
             /* Next timeline and switch point, if any, not yet known. */
             switch_lsn = InvalidXLogRecPtr;
             switch_tli = 0;
  
             /* Update (really, rewind, if needed) state in shared memory. */
             LWLockAcquire(WALSummarizerLock, LW_EXCLUSIVE);
             WalSummarizerCtl->summarized_lsn = current_lsn;
             WalSummarizerCtl->summarized_tli = current_tli;
             WalSummarizerCtl->lsn_is_exact = true;
             WalSummarizerCtl->pending_lsn = current_lsn;
             LWLockRelease(WALSummarizerLock);
  
             continue;
         }
  
         /* Summarize WAL. */
         end_of_summary_lsn = SummarizeWAL(current_tli,
                                           current_lsn, exact,
                                           switch_lsn, latest_lsn);
         Assert(!XLogRecPtrIsInvalid(end_of_summary_lsn));
         Assert(end_of_summary_lsn >= current_lsn);
  
         /*
          * Update state for next loop iteration.
          *
          * Next summary file should start from exactly where this one ended.
          */
         current_lsn = end_of_summary_lsn;
         exact = true;
  
         /* Update state in shared memory. */
         LWLockAcquire(WALSummarizerLock, LW_EXCLUSIVE);
         WalSummarizerCtl->summarized_lsn = end_of_summary_lsn;
         WalSummarizerCtl->summarized_tli = current_tli;
         WalSummarizerCtl->lsn_is_exact = true;
         WalSummarizerCtl->pending_lsn = end_of_summary_lsn;
         LWLockRelease(WALSummarizerLock);
  
         /* Wake up anyone waiting for more summary files to be written. */
         ConditionVariableBroadcast(&WalSummarizerCtl->summary_file_cv);
     }
 }

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, AtEOXact_Files(), AtEOXact_HashTables(), AuxiliaryProcessMainCommon(), B_WAL_SUMMARIZER, ConditionVariableBroadcast(), ConditionVariableCancelSleep(), context, DEBUG1, EmitErrorReport(), ereport, errmsg(), errmsg_internal(), error_context_stack, FlushErrorState(), GetLatestLSN(), GetOldestUnsummarizedLSN(), HandleWalSummarizerInterrupts(), HOLD_INTERRUPTS, InvalidXLogRecPtr, LSN_FORMAT_ARGS, WalSummarizerData::lsn_is_exact, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), LWLockReleaseAll(), MaybeRemoveOldWalSummaries(), MemoryContextReset(), MemoryContextSwitchTo(), MyBackendType, MyLatch, MyProcNumber, on_shmem_exit(), WalSummarizerData::pending_lsn, PG_exception_stack, pgstat_report_wait_end(), pqsignal(), proc_exit(), procsignal_sigusr1_handler(), readTimeLineHistory(), ReleaseAuxProcessResources(), RESUME_INTERRUPTS, SIG_DFL, SIG_IGN, SIGALRM, SIGCHLD, SIGHUP, SignalHandlerForConfigReload(), SignalHandlerForShutdownRequest(), SIGPIPE, SIGUSR1, SIGUSR2, WalSummarizerData::summarized_lsn, WalSummarizerData::summarized_tli, WalSummarizerData::summarizer_pgprocno, SummarizeWAL(), WalSummarizerData::summary_file_cv, tliSwitchPoint(), TopMemoryContext, UnBlockSig, WaitLatch(), WalSummarizerCtl, WalSummarizerShutdown(), WL_EXIT_ON_PM_DEATH, WL_TIMEOUT, and XLogRecPtrIsInvalid.

◆ WalSummarizerShmemInit()

void WalSummarizerShmemInit ( void )

Definition at line 180 of file walsummarizer.c.

 {
     bool        found;
  
     WalSummarizerCtl = (WalSummarizerData *)
         ShmemInitStruct("Wal Summarizer Ctl", WalSummarizerShmemSize(),
                         &found);
  
     if (!found)
     {
         /*
          * First time through, so initialize.
          *
          * We're just filling in dummy values here -- the real initialization
          * will happen when GetOldestUnsummarizedLSN() is called for the first
          * time.
          */
         WalSummarizerCtl->initialized = false;
         WalSummarizerCtl->summarized_tli = 0;
         WalSummarizerCtl->summarized_lsn = InvalidXLogRecPtr;
         WalSummarizerCtl->lsn_is_exact = false;
         WalSummarizerCtl->summarizer_pgprocno = INVALID_PROC_NUMBER;
         WalSummarizerCtl->pending_lsn = InvalidXLogRecPtr;
         ConditionVariableInit(&WalSummarizerCtl->summary_file_cv);
     }
 }

References ConditionVariableInit(), WalSummarizerData::initialized, INVALID_PROC_NUMBER, InvalidXLogRecPtr, WalSummarizerData::lsn_is_exact, WalSummarizerData::pending_lsn, ShmemInitStruct(), WalSummarizerData::summarized_lsn, WalSummarizerData::summarized_tli, WalSummarizerData::summarizer_pgprocno, WalSummarizerData::summary_file_cv, WalSummarizerCtl, and WalSummarizerShmemSize().

Referenced by CreateOrAttachShmemStructs().

◆ WalSummarizerShmemSize()

Size WalSummarizerShmemSize ( void )

Definition at line 171 of file walsummarizer.c.

 {
     return sizeof(WalSummarizerData);
 }

Referenced by CalculateShmemSize(), and WalSummarizerShmemInit().

Variable Documentation

◆ summarize_wal

PGDLLIMPORT bool summarize_wal

extern

Definition at line 142 of file walsummarizer.c.

Referenced by CleanupAfterArchiveRecovery(), GetOldestUnsummarizedLSN(), HandleWalSummarizerInterrupts(), MaybeStartWalSummarizer(), parse_basebackup_options(), PostmasterMain(), and WaitForWalSummarization().

◆ wal_summary_keep_time

PGDLLIMPORT int wal_summary_keep_time