#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, bool reset_pending_lsn)

void	SetWalSummarizerLatch (void)

XLogRecPtr	WaitForWalSummarization (XLogRecPtr lsn, long timeout, XLogRecPtr *pending_lsn)

Variables
PGDLLIMPORT bool	summarize_wal

PGDLLIMPORT int	wal_summary_keep_time

Function Documentation

◆ GetOldestUnsummarizedLSN()

XLogRecPtr GetOldestUnsummarizedLSN	(	TimeLineID *	tli,
		bool *	lsn_is_exact,
		bool	reset_pending_lsn
	)

Definition at line 494 of file walsummarizer.c.

 {
     TimeLineID  latest_tli;
     LWLockMode  mode = reset_pending_lsn ? LW_EXCLUSIVE : LW_SHARED;
     int         n;
     List       *tles;
     XLogRecPtr  unsummarized_lsn = InvalidXLogRecPtr;
     TimeLineID  unsummarized_tli = 0;
     bool        should_make_exact = false;
     List       *existing_summaries;
     ListCell   *lc;
  
     /* If not summarizing WAL, do nothing. */
     if (!summarize_wal)
         return InvalidXLogRecPtr;
  
     /*
      * Unless we need to reset the pending_lsn, we initially acquire the lock
      * in shared mode and try to fetch the required information. If we acquire
      * in shared mode and find that the data structure hasn't been
      * initialized, we reacquire the lock in exclusive mode so that we can
      * initialize it. However, if someone else does that first before we get
      * the lock, then we can just return the requested information after all.
      */
     while (1)
     {
         LWLockAcquire(WALSummarizerLock, mode);
  
         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;
             if (reset_pending_lsn)
                 WalSummarizerCtl->pending_lsn =
                     WalSummarizerCtl->summarized_lsn;
             LWLockRelease(WALSummarizerLock);
             return unsummarized_lsn;
         }
  
         if (mode == LW_EXCLUSIVE)
             break;
  
         LWLockRelease(WALSummarizerLock);
         mode = LW_EXCLUSIVE;
     }
  
     /*
      * The data structure needs to be initialized, and we are the first to
      * obtain the lock in exclusive mode, so it's our job to do that
      * initialization.
      *
      * So, find the oldest timeline on which WAL still exists, and the
      * earliest segment for which it exists.
      */
     (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;
         }
     }
  
     /* 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));
  
     /*
      * 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;
         }
     }
  
     /* Update shared memory with the discovered values. */
     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;
  
     /* 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 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(), mode, 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 433 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 621 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()

XLogRecPtr WaitForWalSummarization	(	XLogRecPtr	lsn,
		long	timeout,
		XLogRecPtr *	pending_lsn
	)

Definition at line 646 of file walsummarizer.c.

 {
     TimestampTz start_time = GetCurrentTimestamp();
     TimestampTz deadline = TimestampTzPlusMilliseconds(start_time, timeout);
     XLogRecPtr  summarized_lsn;
  
     Assert(!XLogRecPtrIsInvalid(lsn));
     Assert(timeout > 0);
  
     while (1)
     {
         TimestampTz now;
         long        remaining_timeout;
  
         /*
          * 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 (summarized_lsn >= lsn)
             break;
  
         /* Timeout reached? If yes, stop. */
         now = GetCurrentTimestamp();
         remaining_timeout = TimestampDifferenceMilliseconds(now, deadline);
         if (remaining_timeout <= 0)
             break;
  
         /* Wait and see. */
         ConditionVariableTimedSleep(&WalSummarizerCtl->summary_file_cv,
                                     remaining_timeout,
                                     WAIT_EVENT_WAL_SUMMARY_READY);
     }
  
     return summarized_lsn;
 }

References Assert, ConditionVariableTimedSleep(), GetCurrentTimestamp(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), now(), WalSummarizerData::pending_lsn, start_time, WalSummarizerData::summarized_lsn, WalSummarizerData::summary_file_cv, TimestampDifferenceMilliseconds(), TimestampTzPlusMilliseconds, WalSummarizerCtl, and XLogRecPtrIsInvalid.

Referenced by PrepareForIncrementalBackup().

◆ WalSummarizerMain()

void WalSummarizerMain	(	char *	startup_data,
		size_t	startup_data_len
	)

Definition at line 210 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, true);
     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.
          */
         if (!XLogRecPtrIsInvalid(switch_lsn) && current_lsn >= switch_lsn)
         {
             current_tli = switch_tli;
             switch_lsn = InvalidXLogRecPtr;
             switch_tli = 0;
             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);
         Assert(WalSummarizerCtl->pending_lsn <= end_of_summary_lsn);
         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 179 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 170 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 GetOldestUnsummarizedLSN(), HandleWalSummarizerInterrupts(), MaybeStartWalSummarizer(), parse_basebackup_options(), and PostmasterMain().

◆ wal_summary_keep_time

PGDLLIMPORT int wal_summary_keep_time