pgarch.c File Reference

#include "postgres.h"
#include <time.h>
#include <sys/stat.h>
#include <unistd.h>
#include "access/xlog.h"
#include "access/xlog_internal.h"
#include "archive/archive_module.h"
#include "archive/shell_archive.h"
#include "lib/binaryheap.h"
#include "libpq/pqsignal.h"
#include "pgstat.h"
#include "postmaster/auxprocess.h"
#include "postmaster/interrupt.h"
#include "postmaster/pgarch.h"
#include "storage/condition_variable.h"
#include "storage/aio_subsys.h"
#include "storage/fd.h"
#include "storage/ipc.h"
#include "storage/latch.h"
#include "storage/pmsignal.h"
#include "storage/proc.h"
#include "storage/procsignal.h"
#include "storage/shmem.h"
#include "utils/guc.h"
#include "utils/memutils.h"
#include "utils/ps_status.h"
#include "utils/resowner.h"
#include "utils/timeout.h"

Include dependency graph for pgarch.c:

Go to the source code of this file.

Data Structures
struct	PgArchData
struct	arch_files_state

Macros
#define	PGARCH_AUTOWAKE_INTERVAL
#define	PGARCH_RESTART_INTERVAL
#define	NUM_ARCHIVE_RETRIES   3
#define	NUM_ORPHAN_CLEANUP_RETRIES   3
#define	NUM_FILES_PER_DIRECTORY_SCAN   64

Typedefs
typedef struct PgArchData	PgArchData

Functions
static void	pgarch_waken_stop (SIGNAL_ARGS)
static void	pgarch_MainLoop (void)
static void	pgarch_ArchiverCopyLoop (void)
static bool	pgarch_archiveXlog (char *xlog)
static bool	pgarch_readyXlog (char *xlog)
static void	pgarch_archiveDone (char *xlog)
static void	pgarch_die (int code, Datum arg)
static void	ProcessPgArchInterrupts (void)
static int	ready_file_comparator (Datum a, Datum b, void *arg)
static void	LoadArchiveLibrary (void)
static void	pgarch_call_module_shutdown_cb (int code, Datum arg)
Size	PgArchShmemSize (void)
void	PgArchShmemInit (void)
bool	PgArchCanRestart (void)
void	PgArchiverMain (const void *startup_data, size_t startup_data_len)
void	PgArchWakeup (void)
void	PgArchForceDirScan (void)

Variables
char *	XLogArchiveLibrary = ""
char *	arch_module_check_errdetail_string
static time_t	last_sigterm_time = 0
static PgArchData *	PgArch = NULL
static const ArchiveModuleCallbacks *	ArchiveCallbacks
static ArchiveModuleState *	archive_module_state
static MemoryContext	archive_context
static struct arch_files_state *	arch_files = NULL
static volatile sig_atomic_t	ready_to_stop = false

Macro Definition Documentation

NUM_ARCHIVE_RETRIES

#define NUM_ARCHIVE_RETRIES   3

Definition at line 69 of file pgarch.c.

NUM_FILES_PER_DIRECTORY_SCAN

#define NUM_FILES_PER_DIRECTORY_SCAN   64

Definition at line 80 of file pgarch.c.

NUM_ORPHAN_CLEANUP_RETRIES

#define NUM_ORPHAN_CLEANUP_RETRIES   3

Definition at line 75 of file pgarch.c.

PGARCH_AUTOWAKE_INTERVAL

#define PGARCH_AUTOWAKE_INTERVAL

Value:

                                     60 /* How often to force a poll of the
                                     * archive status directory; in seconds. */

Definition at line 62 of file pgarch.c.

PGARCH_RESTART_INTERVAL

#define PGARCH_RESTART_INTERVAL

Value:

                                     10 /* How often to attempt to restart a
                                     * failed archiver; in seconds. */

Definition at line 63 of file pgarch.c.

Typedef Documentation

PgArchData

typedef struct PgArchData PgArchData

Function Documentation

LoadArchiveLibrary()

static void LoadArchiveLibrary ( void  )

static

Definition at line 915 of file pgarch.c.

{
    ArchiveModuleInit archive_init;
 
    if (XLogArchiveLibrary[0] != '\0' && XLogArchiveCommand[0] != '\0')
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("both \"archive_command\" and \"archive_library\" set"),
                 errdetail("Only one of \"archive_command\", \"archive_library\" may be set.")));
 
    /*
     * If shell archiving is enabled, use our special initialization function.
     * Otherwise, load the library and call its _PG_archive_module_init().
     */
    if (XLogArchiveLibrary[0] == '\0')
        archive_init = shell_archive_init;
    else
        archive_init = (ArchiveModuleInit)
            load_external_function(XLogArchiveLibrary,
                                   "_PG_archive_module_init", false, NULL);
 
    if (archive_init == NULL)
        ereport(ERROR,
                (errmsg("archive modules have to define the symbol %s", "_PG_archive_module_init")));
 
    ArchiveCallbacks = (*archive_init) ();
 
    if (ArchiveCallbacks->archive_file_cb == NULL)
        ereport(ERROR,
                (errmsg("archive modules must register an archive callback")));
 
    archive_module_state = (ArchiveModuleState *) palloc0(sizeof(ArchiveModuleState));
    if (ArchiveCallbacks->startup_cb != NULL)
        ArchiveCallbacks->startup_cb(archive_module_state);
 

References ArchiveModuleCallbacks::archive_file_cb, archive_module_state, ArchiveCallbacks, before_shmem_exit(), ereport, errcode(), errdetail(), errmsg(), ERROR, load_external_function(), palloc0(), pgarch_call_module_shutdown_cb(), shell_archive_init(), ArchiveModuleCallbacks::startup_cb, XLogArchiveCommand, and XLogArchiveLibrary.

Referenced by PgArchiverMain().

pgarch_archiveDone()

static void pgarch_archiveDone ( char *  xlog )

static

Definition at line 820 of file pgarch.c.

{
    char        rlogready[MAXPGPATH];
    char        rlogdone[MAXPGPATH];
 
    StatusFilePath(rlogready, xlog, ".ready");
    StatusFilePath(rlogdone, xlog, ".done");
 
    /*
     * To avoid extra overhead, we don't durably rename the .ready file to
     * .done.  Archive commands and libraries must gracefully handle attempts
     * to re-archive files (e.g., if the server crashes just before this
     * function is called), so it should be okay if the .ready file reappears
     * after a crash.
     */
    if (rename(rlogready, rlogdone) < 0)
        ereport(WARNING,
                (errcode_for_file_access(),
                 errmsg("could not rename file \"%s\" to \"%s\": %m",

References ereport, errcode_for_file_access(), errmsg(), MAXPGPATH, StatusFilePath(), and WARNING.

Referenced by pgarch_ArchiverCopyLoop().

pgarch_ArchiverCopyLoop()

static void pgarch_ArchiverCopyLoop ( void  )

static

Definition at line 383 of file pgarch.c.

{
    char        xlog[MAX_XFN_CHARS + 1];
 
    /* force directory scan in the first call to pgarch_readyXlog() */
    arch_files->arch_files_size = 0;
 
    /*
     * loop through all xlogs with archive_status of .ready and archive
     * them...mostly we expect this to be a single file, though it is possible
     * some backend will add files onto the list of those that need archiving
     * while we are still copying earlier archives
     */
    while (pgarch_readyXlog(xlog))
    {
        int         failures = 0;
        int         failures_orphan = 0;
 
        for (;;)
        {
            struct stat stat_buf;
            char        pathname[MAXPGPATH];
 
            /*
             * Do not initiate any more archive commands after receiving
             * SIGTERM, nor after the postmaster has died unexpectedly. The
             * first condition is to try to keep from having init SIGKILL the
             * command, and the second is to avoid conflicts with another
             * archiver spawned by a newer postmaster.
             */
            if (ShutdownRequestPending || !PostmasterIsAlive())
                return;
 
            /*
             * Check for barrier events and config update.  This is so that
             * we'll adopt a new setting for archive_command as soon as
             * possible, even if there is a backlog of files to be archived.
             */
            ProcessPgArchInterrupts();
 
            /* Reset variables that might be set by the callback */
            arch_module_check_errdetail_string = NULL;
 
            /* can't do anything if not configured ... */
            if (ArchiveCallbacks->check_configured_cb != NULL &&
                !ArchiveCallbacks->check_configured_cb(archive_module_state))
            {
                ereport(WARNING,
                        (errmsg("\"archive_mode\" enabled, yet archiving is not configured"),
                         arch_module_check_errdetail_string ?
                         errdetail_internal("%s", arch_module_check_errdetail_string) : 0));
                return;
            }
 
            /*
             * Since archive status files are not removed in a durable manner,
             * a system crash could leave behind .ready files for WAL segments
             * that have already been recycled or removed.  In this case,
             * simply remove the orphan status file and move on.  unlink() is
             * used here as even on subsequent crashes the same orphan files
             * would get removed, so there is no need to worry about
             * durability.
             */
            snprintf(pathname, MAXPGPATH, XLOGDIR "/%s", xlog);
            if (stat(pathname, &stat_buf) != 0 && errno == ENOENT)
            {
                char        xlogready[MAXPGPATH];
 
                StatusFilePath(xlogready, xlog, ".ready");
                if (unlink(xlogready) == 0)
                {
                    ereport(WARNING,
                            (errmsg("removed orphan archive status file \"%s\"",
                                    xlogready)));
 
                    /* leave loop and move to the next status file */
                    break;
                }
 
                if (++failures_orphan >= NUM_ORPHAN_CLEANUP_RETRIES)
                {
                    ereport(WARNING,
                            (errmsg("removal of orphan archive status file \"%s\" failed too many times, will try again later",
                                    xlogready)));
 
                    /* give up cleanup of orphan status files */
                    return;
                }
 
                /* wait a bit before retrying */
                pg_usleep(1000000L);
                continue;
            }
 
            if (pgarch_archiveXlog(xlog))
            {
                /* successful */
                pgarch_archiveDone(xlog);
 
                /*
                 * Tell the cumulative stats system about the WAL file that we
                 * successfully archived
                 */
                pgstat_report_archiver(xlog, false);
 
                break;          /* out of inner retry loop */
            }
            else
            {
                /*
                 * Tell the cumulative stats system about the WAL file that we
                 * failed to archive
                 */
                pgstat_report_archiver(xlog, true);
 
                if (++failures >= NUM_ARCHIVE_RETRIES)
                {
                    ereport(WARNING,
                            (errmsg("archiving write-ahead log file \"%s\" failed too many times, will try again later",
                                    xlog)));
                    return;     /* give up archiving for now */
                }
                pg_usleep(1000000L);    /* wait a bit before retrying */
            }
        }

References arch_files, arch_files_state::arch_files_size, arch_module_check_errdetail_string, archive_module_state, ArchiveCallbacks, ArchiveModuleCallbacks::check_configured_cb, ereport, errdetail_internal(), errmsg(), MAX_XFN_CHARS, MAXPGPATH, NUM_ARCHIVE_RETRIES, NUM_ORPHAN_CLEANUP_RETRIES, pg_usleep(), pgarch_archiveDone(), pgarch_archiveXlog(), pgarch_readyXlog(), pgstat_report_archiver(), PostmasterIsAlive, ProcessPgArchInterrupts(), ShutdownRequestPending, snprintf, stat, StatusFilePath(), WARNING, and XLOGDIR.

Referenced by pgarch_MainLoop().

pgarch_archiveXlog()

static bool pgarch_archiveXlog ( char *  xlog )

static

Definition at line 519 of file pgarch.c.

{
    sigjmp_buf  local_sigjmp_buf;
    MemoryContext oldcontext;
    char        pathname[MAXPGPATH];
    char        activitymsg[MAXFNAMELEN + 16];
    bool        ret;
 
    snprintf(pathname, MAXPGPATH, XLOGDIR "/%s", xlog);
 
    /* Report archive activity in PS display */
    snprintf(activitymsg, sizeof(activitymsg), "archiving %s", xlog);
    set_ps_display(activitymsg);
 
    oldcontext = MemoryContextSwitchTo(archive_context);
 
    /*
     * Since the archiver operates at the bottom of the exception stack,
     * ERRORs turn into FATALs and cause the archiver process to restart.
     * However, using ereport(ERROR, ...) when there are problems is easy to
     * code and maintain.  Therefore, we create our own exception handler to
     * catch ERRORs and return false instead of restarting the archiver
     * whenever there is a failure.
     *
     * We assume ERRORs from the archiving callback are the most common
     * exceptions experienced by the archiver, so we opt to handle exceptions
     * here instead of PgArchiverMain() to avoid reinitializing the archiver
     * too frequently.  We could instead add a sigsetjmp() block to
     * PgArchiverMain() and use PG_TRY/PG_CATCH here, but the extra code to
     * avoid the odd archiver restart doesn't seem worth it.
     */
    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();
 
        /*
         * Try to clean up anything the archive module left behind.  We try to
         * cover anything that an archive module could conceivably have left
         * behind, but it is of course possible that modules could be doing
         * unexpected things that require additional cleanup.  Module authors
         * should be sure to do any extra required cleanup in a PG_CATCH block
         * within the archiving callback, and they are encouraged to notify
         * the pgsql-hackers mailing list so that we can add it here.
         */
        disable_all_timeouts(false);
        LWLockReleaseAll();
        ConditionVariableCancelSleep();
        pgstat_report_wait_end();
        pgaio_error_cleanup();
        ReleaseAuxProcessResources(false);
        AtEOXact_Files(false);
        AtEOXact_HashTables(false);
 
        /*
         * Return to the original memory context and clear ErrorContext for
         * next time.
         */
        MemoryContextSwitchTo(oldcontext);
        FlushErrorState();
 
        /* Flush any leaked data */
        MemoryContextReset(archive_context);
 
        /* Remove our exception handler */
        PG_exception_stack = NULL;
 
        /* Now we can allow interrupts again */
        RESUME_INTERRUPTS();
 
        /* Report failure so that the archiver retries this file */
        ret = false;
    }
    else
    {
        /* Enable our exception handler */
        PG_exception_stack = &local_sigjmp_buf;
 
        /* Archive the file! */
        ret = ArchiveCallbacks->archive_file_cb(archive_module_state,
                                                xlog, pathname);
 
        /* Remove our exception handler */
        PG_exception_stack = NULL;
 
        /* Reset our memory context and switch back to the original one */
        MemoryContextSwitchTo(oldcontext);
        MemoryContextReset(archive_context);
    }
 
    if (ret)
        snprintf(activitymsg, sizeof(activitymsg), "last was %s", xlog);
    else
        snprintf(activitymsg, sizeof(activitymsg), "failed on %s", xlog);
    set_ps_display(activitymsg);
 

References archive_context, ArchiveModuleCallbacks::archive_file_cb, archive_module_state, ArchiveCallbacks, AtEOXact_Files(), AtEOXact_HashTables(), ConditionVariableCancelSleep(), disable_all_timeouts(), EmitErrorReport(), error_context_stack, FlushErrorState(), HOLD_INTERRUPTS, LWLockReleaseAll(), MAXFNAMELEN, MAXPGPATH, MemoryContextReset(), MemoryContextSwitchTo(), PG_exception_stack, pgaio_error_cleanup(), pgstat_report_wait_end(), ReleaseAuxProcessResources(), RESUME_INTERRUPTS, set_ps_display(), snprintf, and XLOGDIR.

Referenced by pgarch_ArchiverCopyLoop().

pgarch_call_module_shutdown_cb()

static void pgarch_call_module_shutdown_cb ( int  code, Datum  arg  )

static

Definition at line 957 of file pgarch.c.

{
    if (ArchiveCallbacks->shutdown_cb != NULL)

References archive_module_state, ArchiveCallbacks, and ArchiveModuleCallbacks::shutdown_cb.

Referenced by LoadArchiveLibrary().

pgarch_die()

static void pgarch_die ( int  code, Datum  arg  )

static

Definition at line 849 of file pgarch.c.

{

References INVALID_PROC_NUMBER, PgArch, and PgArchData::pgprocno.

Referenced by PgArchiverMain().

pgarch_MainLoop()

static void pgarch_MainLoop ( void  )

static

Definition at line 312 of file pgarch.c.

{
    bool        time_to_stop;
 
    /*
     * There shouldn't be anything for the archiver to do except to wait for a
     * signal ... however, the archiver exists to protect our data, so it
     * wakes up occasionally to allow itself to be proactive.
     */
    do
    {
        ResetLatch(MyLatch);
 
        /* When we get SIGUSR2, we do one more archive cycle, then exit */
        time_to_stop = ready_to_stop;
 
        /* Check for barrier events and config update */
        ProcessPgArchInterrupts();
 
        /*
         * If we've gotten SIGTERM, we normally just sit and do nothing until
         * SIGUSR2 arrives.  However, that means a random SIGTERM would
         * disable archiving indefinitely, which doesn't seem like a good
         * idea.  If more than 60 seconds pass since SIGTERM, exit anyway, so
         * that the postmaster can start a new archiver if needed.  Also exit
         * if time unexpectedly goes backward.
         */
        if (ShutdownRequestPending)
        {
            time_t      curtime = time(NULL);
 
            if (last_sigterm_time == 0)
                last_sigterm_time = curtime;
            else if (curtime < last_sigterm_time ||
                     curtime - last_sigterm_time >= 60)
                break;
        }
 
        /* Do what we're here for */
        pgarch_ArchiverCopyLoop();
 
        /*
         * Sleep until a signal is received, or until a poll is forced by
         * PGARCH_AUTOWAKE_INTERVAL, or until postmaster dies.
         */
        if (!time_to_stop)      /* Don't wait during last iteration */
        {
            int         rc;
 
            rc = WaitLatch(MyLatch,
                           WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH,
                           PGARCH_AUTOWAKE_INTERVAL * 1000L,
                           WAIT_EVENT_ARCHIVER_MAIN);
            if (rc & WL_POSTMASTER_DEATH)
                time_to_stop = true;
        }
 
        /*
         * The archiver quits either when the postmaster dies (not expected)
         * or after completing one more archiving cycle after receiving
         * SIGUSR2.
         */

References last_sigterm_time, MyLatch, pgarch_ArchiverCopyLoop(), PGARCH_AUTOWAKE_INTERVAL, ProcessPgArchInterrupts(), ready_to_stop, ResetLatch(), ShutdownRequestPending, time_to_stop, WaitLatch(), WL_LATCH_SET, WL_POSTMASTER_DEATH, and WL_TIMEOUT.

Referenced by PgArchiverMain().

pgarch_readyXlog()

static bool pgarch_readyXlog ( char *  xlog )

static

Definition at line 647 of file pgarch.c.

{
    char        XLogArchiveStatusDir[MAXPGPATH];
    DIR        *rldir;
    struct dirent *rlde;
 
    /*
     * If a directory scan was requested, clear the stored file names and
     * proceed.
     */
    if (pg_atomic_exchange_u32(&PgArch->force_dir_scan, 0) == 1)
        arch_files->arch_files_size = 0;
 
    /*
     * If we still have stored file names from the previous directory scan,
     * try to return one of those.  We check to make sure the status file is
     * still present, as the archive_command for a previous file may have
     * already marked it done.
     */
    while (arch_files->arch_files_size > 0)
    {
        struct stat st;
        char        status_file[MAXPGPATH];
        char       *arch_file;
 
        arch_files->arch_files_size--;
        arch_file = arch_files->arch_files[arch_files->arch_files_size];
        StatusFilePath(status_file, arch_file, ".ready");
 
        if (stat(status_file, &st) == 0)
        {
            strcpy(xlog, arch_file);
            return true;
        }
        else if (errno != ENOENT)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not stat file \"%s\": %m", status_file)));
    }
 
    /* arch_heap is probably empty, but let's make sure */
    binaryheap_reset(arch_files->arch_heap);
 
    /*
     * Open the archive status directory and read through the list of files
     * with the .ready suffix, looking for the earliest files.
     */
    snprintf(XLogArchiveStatusDir, MAXPGPATH, XLOGDIR "/archive_status");
    rldir = AllocateDir(XLogArchiveStatusDir);
 
    while ((rlde = ReadDir(rldir, XLogArchiveStatusDir)) != NULL)
    {
        int         basenamelen = (int) strlen(rlde->d_name) - 6;
        char        basename[MAX_XFN_CHARS + 1];
        char       *arch_file;
 
        /* Ignore entries with unexpected number of characters */
        if (basenamelen < MIN_XFN_CHARS ||
            basenamelen > MAX_XFN_CHARS)
            continue;
 
        /* Ignore entries with unexpected characters */
        if (strspn(rlde->d_name, VALID_XFN_CHARS) < basenamelen)
            continue;
 
        /* Ignore anything not suffixed with .ready */
        if (strcmp(rlde->d_name + basenamelen, ".ready") != 0)
            continue;
 
        /* Truncate off the .ready */
        memcpy(basename, rlde->d_name, basenamelen);
        basename[basenamelen] = '\0';
 
        /*
         * Store the file in our max-heap if it has a high enough priority.
         */
        if (binaryheap_size(arch_files->arch_heap) < NUM_FILES_PER_DIRECTORY_SCAN)
        {
            /* If the heap isn't full yet, quickly add it. */
            arch_file = arch_files->arch_filenames[binaryheap_size(arch_files->arch_heap)];
            strcpy(arch_file, basename);
            binaryheap_add_unordered(arch_files->arch_heap, CStringGetDatum(arch_file));
 
            /* If we just filled the heap, make it a valid one. */
            if (binaryheap_size(arch_files->arch_heap) == NUM_FILES_PER_DIRECTORY_SCAN)
                binaryheap_build(arch_files->arch_heap);
        }
        else if (ready_file_comparator(binaryheap_first(arch_files->arch_heap),
                                       CStringGetDatum(basename), NULL) > 0)
        {
            /*
             * Remove the lowest priority file and add the current one to the
             * heap.
             */
            arch_file = DatumGetCString(binaryheap_remove_first(arch_files->arch_heap));
            strcpy(arch_file, basename);
            binaryheap_add(arch_files->arch_heap, CStringGetDatum(arch_file));
        }
    }
    FreeDir(rldir);
 
    /* If no files were found, simply return. */
    if (binaryheap_empty(arch_files->arch_heap))
        return false;
 
    /*
     * If we didn't fill the heap, we didn't make it a valid one.  Do that
     * now.
     */
    if (binaryheap_size(arch_files->arch_heap) < NUM_FILES_PER_DIRECTORY_SCAN)
        binaryheap_build(arch_files->arch_heap);
 
    /*
     * Fill arch_files array with the files to archive in ascending order of
     * priority.
     */
    arch_files->arch_files_size = binaryheap_size(arch_files->arch_heap);
    for (int i = 0; i < arch_files->arch_files_size; i++)
        arch_files->arch_files[i] = DatumGetCString(binaryheap_remove_first(arch_files->arch_heap));
 
    /* Return the highest priority file. */
    arch_files->arch_files_size--;
    strcpy(xlog, arch_files->arch_files[arch_files->arch_files_size]);
 

References AllocateDir(), arch_files_state::arch_filenames, arch_files_state::arch_files, arch_files, arch_files_state::arch_files_size, arch_files_state::arch_heap, binaryheap_add(), binaryheap_add_unordered(), binaryheap_build(), binaryheap_empty, binaryheap_first(), binaryheap_remove_first(), binaryheap_reset(), binaryheap_size, CStringGetDatum(), dirent::d_name, DatumGetCString(), ereport, errcode_for_file_access(), errmsg(), ERROR, PgArchData::force_dir_scan, FreeDir(), i, MAX_XFN_CHARS, MAXPGPATH, MIN_XFN_CHARS, NUM_FILES_PER_DIRECTORY_SCAN, pg_atomic_exchange_u32(), PgArch, ReadDir(), ready_file_comparator(), snprintf, stat, StatusFilePath(), VALID_XFN_CHARS, and XLOGDIR.

Referenced by pgarch_ArchiverCopyLoop().

pgarch_waken_stop()

static void pgarch_waken_stop ( SIGNAL_ARGS  )

static

Definition at line 299 of file pgarch.c.

{
    /* set flag to do a final cycle and shut down afterwards */
    ready_to_stop = true;

References MyLatch, ready_to_stop, and SetLatch().

Referenced by PgArchiverMain().

PgArchCanRestart()

bool PgArchCanRestart

(

void

)

Definition at line 196 of file pgarch.c.

{
    static time_t last_pgarch_start_time = 0;
    time_t      curtime = time(NULL);
 
    /*
     * If first time through, or time somehow went backwards, always update
     * last_pgarch_start_time to match the current clock and allow archiver
     * start.  Otherwise allow it only once enough time has elapsed.
     */
    if (last_pgarch_start_time == 0 ||
        curtime < last_pgarch_start_time ||
        curtime - last_pgarch_start_time >= PGARCH_RESTART_INTERVAL)
    {
        last_pgarch_start_time = curtime;
        return true;
    }

References PGARCH_RESTART_INTERVAL.

Referenced by LaunchMissingBackgroundProcesses().

PgArchForceDirScan()

void PgArchForceDirScan

(

void

)

Definition at line 806 of file pgarch.c.

{

References PgArchData::force_dir_scan, pg_atomic_write_membarrier_u32(), and PgArch.

Referenced by XLogArchiveNotify().

PgArchiverMain()

void PgArchiverMain	(	const void *	startup_data,
		size_t	startup_data_len
	)

Definition at line 219 of file pgarch.c.

{
    Assert(startup_data_len == 0);
 
    MyBackendType = B_ARCHIVER;
    AuxiliaryProcessMainCommon();
 
    /*
     * Ignore all signals usually bound to some action in the postmaster,
     * except for SIGHUP, SIGTERM, SIGUSR1, SIGUSR2, and SIGQUIT.
     */
    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, pgarch_waken_stop);
 
    /* Reset some signals that are accepted by postmaster but not here */
    pqsignal(SIGCHLD, SIG_DFL);
 
    /* Unblock signals (they were blocked when the postmaster forked us) */
    sigprocmask(SIG_SETMASK, &UnBlockSig, NULL);
 
    /* We shouldn't be launched unnecessarily. */
    Assert(XLogArchivingActive());
 
    /* Arrange to clean up at archiver exit */
    on_shmem_exit(pgarch_die, 0);
 
    /*
     * Advertise our proc number so that backends can use our latch to wake us
     * up while we're sleeping.
     */
    PgArch->pgprocno = MyProcNumber;
 
    /* Create workspace for pgarch_readyXlog() */
    arch_files = palloc(sizeof(struct arch_files_state));
    arch_files->arch_files_size = 0;
 
    /* Initialize our max-heap for prioritizing files to archive. */
    arch_files->arch_heap = binaryheap_allocate(NUM_FILES_PER_DIRECTORY_SCAN,
                                                ready_file_comparator, NULL);
 
    /* Initialize our memory context. */
    archive_context = AllocSetContextCreate(TopMemoryContext,
                                            "archiver",
                                            ALLOCSET_DEFAULT_SIZES);
 
    /* Load the archive_library. */
    LoadArchiveLibrary();
 
    pgarch_MainLoop();
 

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, arch_files, arch_files_state::arch_files_size, arch_files_state::arch_heap, archive_context, Assert(), AuxiliaryProcessMainCommon(), B_ARCHIVER, binaryheap_allocate(), LoadArchiveLibrary(), MyBackendType, MyProcNumber, NUM_FILES_PER_DIRECTORY_SCAN, on_shmem_exit(), palloc(), PgArch, pgarch_die(), pgarch_MainLoop(), pgarch_waken_stop(), PgArchData::pgprocno, pqsignal, proc_exit(), procsignal_sigusr1_handler(), ready_file_comparator(), SIGALRM, SIGCHLD, SIGHUP, SignalHandlerForConfigReload(), SignalHandlerForShutdownRequest(), SIGPIPE, SIGUSR1, SIGUSR2, TopMemoryContext, UnBlockSig, and XLogArchivingActive.

PgArchShmemInit()

void PgArchShmemInit

(

void

)

Definition at line 167 of file pgarch.c.

{
    bool        found;
 
    PgArch = (PgArchData *)
        ShmemInitStruct("Archiver Data", PgArchShmemSize(), &found);
 
    if (!found)
    {
        /* First time through, so initialize */
        MemSet(PgArch, 0, PgArchShmemSize());
        PgArch->pgprocno = INVALID_PROC_NUMBER;
        pg_atomic_init_u32(&PgArch->force_dir_scan, 0);

References PgArchData::force_dir_scan, INVALID_PROC_NUMBER, MemSet, pg_atomic_init_u32(), PgArch, PgArchShmemSize(), PgArchData::pgprocno, and ShmemInitStruct().

Referenced by CreateOrAttachShmemStructs().

PgArchShmemSize()

Size PgArchShmemSize

(

void

)

Definition at line 156 of file pgarch.c.

{
    Size        size = 0;
 
    size = add_size(size, sizeof(PgArchData));
 

References add_size().

Referenced by CalculateShmemSize(), and PgArchShmemInit().

PgArchWakeup()

void PgArchWakeup

(

void

)

Definition at line 282 of file pgarch.c.

{
    int         arch_pgprocno = PgArch->pgprocno;
 
    /*
     * We don't acquire ProcArrayLock here.  It's actually fine because
     * procLatch isn't ever freed, so we just can potentially set the wrong
     * process' (or no process') latch.  Even in that case the archiver will
     * be relaunched shortly and will start archiving.
     */
    if (arch_pgprocno != INVALID_PROC_NUMBER)

References PROC_HDR::allProcs, INVALID_PROC_NUMBER, PgArch, PgArchData::pgprocno, ProcGlobal, PGPROC::procLatch, and SetLatch().

Referenced by XLogArchiveNotify().

ProcessPgArchInterrupts()

static void ProcessPgArchInterrupts ( void  )

static

Definition at line 863 of file pgarch.c.

{
    if (ProcSignalBarrierPending)
        ProcessProcSignalBarrier();
 
    /* Perform logging of memory contexts of this process */
    if (LogMemoryContextPending)
        ProcessLogMemoryContextInterrupt();
 
    if (ConfigReloadPending)
    {
        char       *archiveLib = pstrdup(XLogArchiveLibrary);
        bool        archiveLibChanged;
 
        ConfigReloadPending = false;
        ProcessConfigFile(PGC_SIGHUP);
 
        if (XLogArchiveLibrary[0] != '\0' && XLogArchiveCommand[0] != '\0')
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("both \"archive_command\" and \"archive_library\" set"),
                     errdetail("Only one of \"archive_command\", \"archive_library\" may be set.")));
 
        archiveLibChanged = strcmp(XLogArchiveLibrary, archiveLib) != 0;
        pfree(archiveLib);
 
        if (archiveLibChanged)
        {
            /*
             * Ideally, we would simply unload the previous archive module and
             * load the new one, but there is presently no mechanism for
             * unloading a library (see the comment above
             * internal_load_library()).  To deal with this, we simply restart
             * the archiver.  The new archive module will be loaded when the
             * new archiver process starts up.  Note that this triggers the
             * module's shutdown callback, if defined.
             */
            ereport(LOG,
                    (errmsg("restarting archiver process because value of "
                            "\"archive_library\" was changed")));
 
            proc_exit(0);
        }

References ConfigReloadPending, ereport, errcode(), errdetail(), errmsg(), ERROR, LOG, LogMemoryContextPending, pfree(), PGC_SIGHUP, proc_exit(), ProcessConfigFile(), ProcessLogMemoryContextInterrupt(), ProcessProcSignalBarrier(), ProcSignalBarrierPending, pstrdup(), XLogArchiveCommand, and XLogArchiveLibrary.

Referenced by pgarch_ArchiverCopyLoop(), and pgarch_MainLoop().

ready_file_comparator()

static int ready_file_comparator ( Datum  a, Datum  b, void *  arg  )

static

Definition at line 783 of file pgarch.c.

{
    char       *a_str = DatumGetCString(a);
    char       *b_str = DatumGetCString(b);
    bool        a_history = IsTLHistoryFileName(a_str);
    bool        b_history = IsTLHistoryFileName(b_str);
 
    /* Timeline history files always have the highest priority. */
    if (a_history != b_history)
        return a_history ? -1 : 1;
 
    /* Priority is given to older files. */

References a, b, DatumGetCString(), and IsTLHistoryFileName().

Referenced by pgarch_readyXlog(), and PgArchiverMain().

Variable Documentation

arch_files

struct arch_files_state* arch_files = NULL

static

Definition at line 131 of file pgarch.c.

Referenced by pgarch_ArchiverCopyLoop(), pgarch_readyXlog(), and PgArchiverMain().

arch_module_check_errdetail_string

char* arch_module_check_errdetail_string

Definition at line 94 of file pgarch.c.

Referenced by pgarch_ArchiverCopyLoop().

archive_context

MemoryContext archive_context

static

Definition at line 105 of file pgarch.c.

Referenced by pgarch_archiveXlog(), and PgArchiverMain().

archive_module_state

ArchiveModuleState* archive_module_state

static

Definition at line 104 of file pgarch.c.

Referenced by LoadArchiveLibrary(), pgarch_ArchiverCopyLoop(), pgarch_archiveXlog(), and pgarch_call_module_shutdown_cb().

ArchiveCallbacks

const ArchiveModuleCallbacks* ArchiveCallbacks

static

Definition at line 103 of file pgarch.c.

Referenced by LoadArchiveLibrary(), pgarch_ArchiverCopyLoop(), pgarch_archiveXlog(), and pgarch_call_module_shutdown_cb().

last_sigterm_time

time_t last_sigterm_time = 0

static

Definition at line 101 of file pgarch.c.

Referenced by pgarch_MainLoop().

PgArch

PgArchData* PgArch = NULL

static

Definition at line 102 of file pgarch.c.

Referenced by pgarch_die(), pgarch_readyXlog(), PgArchForceDirScan(), PgArchiverMain(), PgArchShmemInit(), and PgArchWakeup().

ready_to_stop

volatile sig_atomic_t ready_to_stop = false

static

Definition at line 136 of file pgarch.c.

Referenced by pgarch_MainLoop(), and pgarch_waken_stop().

XLogArchiveLibrary

char* XLogArchiveLibrary = ""

Definition at line 93 of file pgarch.c.

Referenced by LoadArchiveLibrary(), and ProcessPgArchInterrupts().