autovacuum.h File Reference

#include "storage/block.h"

Include dependency graph for autovacuum.h:

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

Go to the source code of this file.

Enumerations
enum	AutoVacuumWorkItemType { AVW_BRINSummarizeRange }

Functions
bool	AutoVacuumingActive (void)
void	autovac_init (void)
void	AutoVacWorkerFailed (void)
pg_noreturn void	AutoVacLauncherMain (const void *startup_data, size_t startup_data_len)
pg_noreturn void	AutoVacWorkerMain (const void *startup_data, size_t startup_data_len)
bool	AutoVacuumRequestWork (AutoVacuumWorkItemType type, Oid relationId, BlockNumber blkno)
Size	AutoVacuumShmemSize (void)
void	AutoVacuumShmemInit (void)

Variables
PGDLLIMPORT bool	autovacuum_start_daemon
PGDLLIMPORT int	autovacuum_worker_slots
PGDLLIMPORT int	autovacuum_max_workers
PGDLLIMPORT int	autovacuum_work_mem
PGDLLIMPORT int	autovacuum_naptime
PGDLLIMPORT int	autovacuum_vac_thresh
PGDLLIMPORT int	autovacuum_vac_max_thresh
PGDLLIMPORT double	autovacuum_vac_scale
PGDLLIMPORT int	autovacuum_vac_ins_thresh
PGDLLIMPORT double	autovacuum_vac_ins_scale
PGDLLIMPORT int	autovacuum_anl_thresh
PGDLLIMPORT double	autovacuum_anl_scale
PGDLLIMPORT int	autovacuum_freeze_max_age
PGDLLIMPORT int	autovacuum_multixact_freeze_max_age
PGDLLIMPORT double	autovacuum_vac_cost_delay
PGDLLIMPORT int	autovacuum_vac_cost_limit
PGDLLIMPORT int	Log_autovacuum_min_duration
PGDLLIMPORT int	Log_autoanalyze_min_duration

Enumeration Type Documentation

AutoVacuumWorkItemType

enum AutoVacuumWorkItemType

Enumerator
AVW_BRINSummarizeRange

Definition at line 23 of file autovacuum.h.

{
    AVW_BRINSummarizeRange,
} AutoVacuumWorkItemType;

Function Documentation

autovac_init()

void autovac_init ( void  )

extern

Definition at line 3344 of file autovacuum.c.

{
    if (!autovacuum_start_daemon)
        return;
    else if (!pgstat_track_counts)
        ereport(WARNING,
                (errmsg("autovacuum not started because of misconfiguration"),
                 errhint("Enable the \"track_counts\" option.")));
    else
        check_av_worker_gucs();
}

References autovacuum_start_daemon, check_av_worker_gucs(), ereport, errhint(), errmsg, pgstat_track_counts, and WARNING.

Referenced by PostmasterMain().

AutoVacLauncherMain()

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

extern

Definition at line 376 of file autovacuum.c.

{
    sigjmp_buf  local_sigjmp_buf;
 
    Assert(startup_data_len == 0);
 
    /* Release postmaster's working memory context */
    if (PostmasterContext)
    {
        MemoryContextDelete(PostmasterContext);
        PostmasterContext = NULL;
    }
 
    init_ps_display(NULL);
 
    ereport(DEBUG1,
            (errmsg_internal("autovacuum launcher started")));
 
    if (PostAuthDelay)
        pg_usleep(PostAuthDelay * 1000000L);
 
    Assert(GetProcessingMode() == InitProcessing);
 
    /*
     * Set up signal handlers.  We operate on databases much like a regular
     * backend, so we use the same signal handling.  See equivalent code in
     * tcop/postgres.c.
     */
    pqsignal(SIGHUP, SignalHandlerForConfigReload);
    pqsignal(SIGINT, StatementCancelHandler);
    pqsignal(SIGTERM, SignalHandlerForShutdownRequest);
    /* SIGQUIT handler was already set up by InitPostmasterChild */
 
    InitializeTimeouts();       /* establishes SIGALRM handler */
 
    pqsignal(SIGPIPE, SIG_IGN);
    pqsignal(SIGUSR1, procsignal_sigusr1_handler);
    pqsignal(SIGUSR2, avl_sigusr2_handler);
    pqsignal(SIGFPE, FloatExceptionHandler);
    pqsignal(SIGCHLD, SIG_DFL);
 
    /*
     * Create a per-backend PGPROC struct in shared memory.  We must do this
     * before we can use LWLocks or access any shared memory.
     */
    InitProcess();
 
    /* Early initialization */
    BaseInit();
 
    InitPostgres(NULL, InvalidOid, NULL, InvalidOid, 0, NULL);
 
    SetProcessingMode(NormalProcessing);
 
    /*
     * 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.
     */
    AutovacMemCxt = AllocSetContextCreate(TopMemoryContext,
                                          "Autovacuum Launcher",
                                          ALLOCSET_DEFAULT_SIZES);
    MemoryContextSwitchTo(AutovacMemCxt);
 
    /*
     * If an exception is encountered, processing resumes here.
     *
     * This code is a stripped down version of PostgresMain error recovery.
     *
     * 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;
 
        /* Prevents interrupts while cleaning up */
        HOLD_INTERRUPTS();
 
        /* Forget any pending QueryCancel or timeout request */
        disable_all_timeouts(false);
        QueryCancelPending = false; /* second to avoid race condition */
 
        /* Report the error to the server log */
        EmitErrorReport();
 
        /* Abort the current transaction in order to recover */
        AbortCurrentTransaction();
 
        /*
         * Release any other resources, for the case where we were not in a
         * transaction.
         */
        LWLockReleaseAll();
        pgstat_report_wait_end();
        pgaio_error_cleanup();
        UnlockBuffers();
        /* this is probably dead code, but let's be safe: */
        if (AuxProcessResourceOwner)
            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(AutovacMemCxt);
        FlushErrorState();
 
        /* Flush any leaked data in the top-level context */
        MemoryContextReset(AutovacMemCxt);
 
        /* don't leave dangling pointers to freed memory */
        DatabaseListCxt = NULL;
        dlist_init(&DatabaseList);
 
        /* Now we can allow interrupts again */
        RESUME_INTERRUPTS();
 
        /* if in shutdown mode, no need for anything further; just go away */
        if (ShutdownRequestPending)
            AutoVacLauncherShutdown();
 
        /*
         * Sleep at least 1 second after any error.  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;
 
    /* must unblock signals before calling rebuild_database_list */
    sigprocmask(SIG_SETMASK, &UnBlockSig, NULL);
 
    /*
     * Set always-secure search path.  Launcher doesn't connect to a database,
     * so this has no effect.
     */
    SetConfigOption("search_path", "", PGC_SUSET, PGC_S_OVERRIDE);
 
    /*
     * Force zero_damaged_pages OFF in the autovac process, even if it is set
     * in postgresql.conf.  We don't really want such a dangerous option being
     * applied non-interactively.
     */
    SetConfigOption("zero_damaged_pages", "false", PGC_SUSET, PGC_S_OVERRIDE);
 
    /*
     * Force settable timeouts off to avoid letting these settings prevent
     * regular maintenance from being executed.
     */
    SetConfigOption("statement_timeout", "0", PGC_SUSET, PGC_S_OVERRIDE);
    SetConfigOption("transaction_timeout", "0", PGC_SUSET, PGC_S_OVERRIDE);
    SetConfigOption("lock_timeout", "0", PGC_SUSET, PGC_S_OVERRIDE);
    SetConfigOption("idle_in_transaction_session_timeout", "0",
                    PGC_SUSET, PGC_S_OVERRIDE);
 
    /*
     * Force default_transaction_isolation to READ COMMITTED.  We don't want
     * to pay the overhead of serializable mode, nor add any risk of causing
     * deadlocks or delaying other transactions.
     */
    SetConfigOption("default_transaction_isolation", "read committed",
                    PGC_SUSET, PGC_S_OVERRIDE);
 
    /*
     * Even when system is configured to use a different fetch consistency,
     * for autovac we always want fresh stats.
     */
    SetConfigOption("stats_fetch_consistency", "none", PGC_SUSET, PGC_S_OVERRIDE);
 
    /*
     * In emergency mode, just start a worker (unless shutdown was requested)
     * and go away.
     */
    if (!AutoVacuumingActive())
    {
        if (!ShutdownRequestPending)
            do_start_worker();
        proc_exit(0);           /* done */
    }
 
    AutoVacuumShmem->av_launcherpid = MyProcPid;
 
    /*
     * Create the initial database list.  The invariant we want this list to
     * keep is that it's ordered by decreasing next_worker.  As soon as an
     * entry is updated to a higher time, it will be moved to the front (which
     * is correct because the only operation is to add autovacuum_naptime to
     * the entry, and time always increases).
     */
    rebuild_database_list(InvalidOid);
 
    /* loop until shutdown request */
    while (!ShutdownRequestPending)
    {
        struct timeval nap;
        TimestampTz current_time = 0;
        bool        can_launch;
 
        /*
         * This loop is a bit different from the normal use of WaitLatch,
         * because we'd like to sleep before the first launch of a child
         * process.  So it's WaitLatch, then ResetLatch, then check for
         * wakening conditions.
         */
 
        launcher_determine_sleep(av_worker_available(), false, &nap);
 
        /*
         * Wait until naptime expires or we get some type of signal (all the
         * signal handlers will wake us by calling SetLatch).
         */
        (void) WaitLatch(MyLatch,
                         WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
                         (nap.tv_sec * 1000L) + (nap.tv_usec / 1000L),
                         WAIT_EVENT_AUTOVACUUM_MAIN);
 
        ResetLatch(MyLatch);
 
        ProcessAutoVacLauncherInterrupts();
 
        /*
         * a worker finished, or postmaster signaled failure to start a worker
         */
        if (got_SIGUSR2)
        {
            got_SIGUSR2 = false;
 
            /* rebalance cost limits, if needed */
            if (AutoVacuumShmem->av_signal[AutoVacRebalance])
            {
                LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE);
                AutoVacuumShmem->av_signal[AutoVacRebalance] = false;
                autovac_recalculate_workers_for_balance();
                LWLockRelease(AutovacuumLock);
            }
 
            if (AutoVacuumShmem->av_signal[AutoVacForkFailed])
            {
                /*
                 * If the postmaster failed to start a new worker, we sleep
                 * for a little while and resend the signal.  The new worker's
                 * state is still in memory, so this is sufficient.  After
                 * that, we restart the main loop.
                 *
                 * XXX should we put a limit to the number of times we retry?
                 * I don't think it makes much sense, because a future start
                 * of a worker will continue to fail in the same way.
                 */
                AutoVacuumShmem->av_signal[AutoVacForkFailed] = false;
                pg_usleep(1000000L);    /* 1s */
                SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_WORKER);
                continue;
            }
        }
 
        /*
         * There are some conditions that we need to check before trying to
         * start a worker.  First, we need to make sure that there is a worker
         * slot available.  Second, we need to make sure that no other worker
         * failed while starting up.
         */
 
        current_time = GetCurrentTimestamp();
        LWLockAcquire(AutovacuumLock, LW_SHARED);
 
        can_launch = av_worker_available();
 
        if (AutoVacuumShmem->av_startingWorker != NULL)
        {
            int         waittime;
            WorkerInfo  worker = AutoVacuumShmem->av_startingWorker;
 
            /*
             * We can't launch another worker when another one is still
             * starting up (or failed while doing so), so just sleep for a bit
             * more; that worker will wake us up again as soon as it's ready.
             * We will only wait autovacuum_naptime seconds (up to a maximum
             * of 60 seconds) for this to happen however.  Note that failure
             * to connect to a particular database is not a problem here,
             * because the worker removes itself from the startingWorker
             * pointer before trying to connect.  Problems detected by the
             * postmaster (like fork() failure) are also reported and handled
             * differently.  The only problems that may cause this code to
             * fire are errors in the earlier sections of AutoVacWorkerMain,
             * before the worker removes the WorkerInfo from the
             * startingWorker pointer.
             */
            waittime = Min(autovacuum_naptime, 60) * 1000;
            if (TimestampDifferenceExceeds(worker->wi_launchtime, current_time,
                                           waittime))
            {
                LWLockRelease(AutovacuumLock);
                LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE);
 
                /*
                 * No other process can put a worker in starting mode, so if
                 * startingWorker is still INVALID after exchanging our lock,
                 * we assume it's the same one we saw above (so we don't
                 * recheck the launch time).
                 */
                if (AutoVacuumShmem->av_startingWorker != NULL)
                {
                    worker = AutoVacuumShmem->av_startingWorker;
                    worker->wi_dboid = InvalidOid;
                    worker->wi_tableoid = InvalidOid;
                    worker->wi_sharedrel = false;
                    worker->wi_proc = NULL;
                    worker->wi_launchtime = 0;
                    dclist_push_head(&AutoVacuumShmem->av_freeWorkers,
                                     &worker->wi_links);
                    AutoVacuumShmem->av_startingWorker = NULL;
                    ereport(WARNING,
                            errmsg("autovacuum worker took too long to start; canceled"));
                }
            }
            else
                can_launch = false;
        }
        LWLockRelease(AutovacuumLock);  /* either shared or exclusive */
 
        /* if we can't do anything, just go back to sleep */
        if (!can_launch)
            continue;
 
        /* We're OK to start a new worker */
 
        if (dlist_is_empty(&DatabaseList))
        {
            /*
             * Special case when the list is empty: start a worker right away.
             * This covers the initial case, when no database is in pgstats
             * (thus the list is empty).  Note that the constraints in
             * launcher_determine_sleep keep us from starting workers too
             * quickly (at most once every autovacuum_naptime when the list is
             * empty).
             */
            launch_worker(current_time);
        }
        else
        {
            /*
             * because rebuild_database_list constructs a list with most
             * distant adl_next_worker first, we obtain our database from the
             * tail of the list.
             */
            avl_dbase  *avdb;
 
            avdb = dlist_tail_element(avl_dbase, adl_node, &DatabaseList);
 
            /*
             * launch a worker if next_worker is right now or it is in the
             * past
             */
            if (TimestampDifferenceExceeds(avdb->adl_next_worker,
                                           current_time, 0))
                launch_worker(current_time);
        }
    }
 
    AutoVacLauncherShutdown();
}

References AbortCurrentTransaction(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, AtEOXact_Buffers(), AtEOXact_Files(), AtEOXact_HashTables(), AtEOXact_SMgr(), autovac_recalculate_workers_for_balance(), AutoVacForkFailed, AutoVacLauncherShutdown(), AutovacMemCxt, AutoVacRebalance, autovacuum_naptime, AutoVacuumingActive(), AutoVacuumShmem, AuxProcessResourceOwner, AutoVacuumShmemStruct::av_freeWorkers, AutoVacuumShmemStruct::av_launcherpid, AutoVacuumShmemStruct::av_signal, AutoVacuumShmemStruct::av_startingWorker, av_worker_available(), avl_sigusr2_handler(), BaseInit(), DatabaseList, DatabaseListCxt, dclist_push_head(), DEBUG1, disable_all_timeouts(), dlist_init(), dlist_is_empty(), dlist_tail_element, do_start_worker(), EmitErrorReport(), ereport, errmsg, errmsg_internal(), error_context_stack, fb(), FloatExceptionHandler(), FlushErrorState(), GetCurrentTimestamp(), GetProcessingMode, got_SIGUSR2, HOLD_INTERRUPTS, init_ps_display(), InitializeTimeouts(), InitPostgres(), InitProcess(), InitProcessing, InvalidOid, launch_worker(), launcher_determine_sleep(), LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), LWLockReleaseAll(), MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), Min, MyLatch, MyProcPid, NormalProcessing, PG_exception_stack, pg_usleep(), pgaio_error_cleanup(), PGC_S_OVERRIDE, PGC_SUSET, pgstat_report_wait_end(), PMSIGNAL_START_AUTOVAC_WORKER, PostAuthDelay, PostmasterContext, pqsignal, proc_exit(), ProcessAutoVacLauncherInterrupts(), procsignal_sigusr1_handler(), QueryCancelPending, rebuild_database_list(), ReleaseAuxProcessResources(), ResetLatch(), RESUME_INTERRUPTS, SendPostmasterSignal(), SetConfigOption(), SetProcessingMode, ShutdownRequestPending, SIGCHLD, SIGHUP, SignalHandlerForConfigReload(), SignalHandlerForShutdownRequest(), SIGPIPE, SIGUSR1, SIGUSR2, StatementCancelHandler(), TimestampDifferenceExceeds(), TopMemoryContext, UnBlockSig, UnlockBuffers(), WaitLatch(), WARNING, WorkerInfoData::wi_dboid, WorkerInfoData::wi_launchtime, WorkerInfoData::wi_links, WorkerInfoData::wi_proc, WorkerInfoData::wi_sharedrel, WorkerInfoData::wi_tableoid, WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, and WL_TIMEOUT.

AutoVacuumingActive()

bool AutoVacuumingActive ( void  )

extern

Definition at line 3290 of file autovacuum.c.

{
    if (!autovacuum_start_daemon || !pgstat_track_counts)
        return false;
    return true;
}

References autovacuum_start_daemon, and pgstat_track_counts.

Referenced by AutoVacLauncherMain(), index_update_stats(), LaunchMissingBackgroundProcesses(), ProcessAutoVacLauncherInterrupts(), and relation_needs_vacanalyze().

AutoVacuumRequestWork()

bool AutoVacuumRequestWork ( AutoVacuumWorkItemType  type, Oid  relationId, BlockNumber  blkno  )

extern

Definition at line 3302 of file autovacuum.c.

{
    int         i;
    bool        result = false;
 
    LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE);
 
    /*
     * Locate an unused work item and fill it with the given data.
     */
    for (i = 0; i < NUM_WORKITEMS; i++)
    {
        AutoVacuumWorkItem *workitem = &AutoVacuumShmem->av_workItems[i];
 
        if (workitem->avw_used)
            continue;
 
        workitem->avw_used = true;
        workitem->avw_active = false;
        workitem->avw_type = type;
        workitem->avw_database = MyDatabaseId;
        workitem->avw_relation = relationId;
        workitem->avw_blockNumber = blkno;
        result = true;
 
        /* done */
        break;
    }
 
    LWLockRelease(AutovacuumLock);
 
    return result;
}

References AutoVacuumShmem, AutoVacuumShmemStruct::av_workItems, AutoVacuumWorkItem::avw_used, fb(), i, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyDatabaseId, NUM_WORKITEMS, and type.

Referenced by brininsert().

AutoVacuumShmemInit()

void AutoVacuumShmemInit ( void  )

extern

Definition at line 3380 of file autovacuum.c.

{
    bool        found;
 
    AutoVacuumShmem = (AutoVacuumShmemStruct *)
        ShmemInitStruct("AutoVacuum Data",
                        AutoVacuumShmemSize(),
                        &found);
 
    if (!IsUnderPostmaster)
    {
        WorkerInfo  worker;
        int         i;
 
        Assert(!found);
 
        AutoVacuumShmem->av_launcherpid = 0;
        dclist_init(&AutoVacuumShmem->av_freeWorkers);
        dlist_init(&AutoVacuumShmem->av_runningWorkers);
        AutoVacuumShmem->av_startingWorker = NULL;
        memset(AutoVacuumShmem->av_workItems, 0,
               sizeof(AutoVacuumWorkItem) * NUM_WORKITEMS);
 
        worker = (WorkerInfo) ((char *) AutoVacuumShmem +
                               MAXALIGN(sizeof(AutoVacuumShmemStruct)));
 
        /* initialize the WorkerInfo free list */
        for (i = 0; i < autovacuum_worker_slots; i++)
        {
            dclist_push_head(&AutoVacuumShmem->av_freeWorkers,
                             &worker[i].wi_links);
            pg_atomic_init_flag(&worker[i].wi_dobalance);
        }
 
        pg_atomic_init_u32(&AutoVacuumShmem->av_nworkersForBalance, 0);
 
    }
    else
        Assert(found);
}

References Assert, autovacuum_worker_slots, AutoVacuumShmem, AutoVacuumShmemSize(), AutoVacuumShmemStruct::av_freeWorkers, AutoVacuumShmemStruct::av_launcherpid, AutoVacuumShmemStruct::av_nworkersForBalance, AutoVacuumShmemStruct::av_runningWorkers, AutoVacuumShmemStruct::av_startingWorker, AutoVacuumShmemStruct::av_workItems, dclist_init(), dclist_push_head(), dlist_init(), fb(), i, IsUnderPostmaster, MAXALIGN, NUM_WORKITEMS, pg_atomic_init_flag(), pg_atomic_init_u32(), ShmemInitStruct(), and WorkerInfoData::wi_links.

Referenced by CreateOrAttachShmemStructs().

AutoVacuumShmemSize()

Size AutoVacuumShmemSize ( void  )

extern

Definition at line 3361 of file autovacuum.c.

{
    Size        size;
 
    /*
     * Need the fixed struct and the array of WorkerInfoData.
     */
    size = sizeof(AutoVacuumShmemStruct);
    size = MAXALIGN(size);
    size = add_size(size, mul_size(autovacuum_worker_slots,
                                   sizeof(WorkerInfoData)));
    return size;
}

References add_size(), autovacuum_worker_slots, MAXALIGN, and mul_size().

Referenced by AutoVacuumShmemInit(), and CalculateShmemSize().

AutoVacWorkerFailed()

void AutoVacWorkerFailed ( void  )

extern

Definition at line 1365 of file autovacuum.c.

{
    AutoVacuumShmem->av_signal[AutoVacForkFailed] = true;
}

References AutoVacForkFailed, AutoVacuumShmem, and AutoVacuumShmemStruct::av_signal.

Referenced by StartAutovacuumWorker().

AutoVacWorkerMain()

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

extern

Definition at line 1387 of file autovacuum.c.

{
    sigjmp_buf  local_sigjmp_buf;
    Oid         dbid;
 
    Assert(startup_data_len == 0);
 
    /* Release postmaster's working memory context */
    if (PostmasterContext)
    {
        MemoryContextDelete(PostmasterContext);
        PostmasterContext = NULL;
    }
 
    init_ps_display(NULL);
 
    Assert(GetProcessingMode() == InitProcessing);
 
    /*
     * Set up signal handlers.  We operate on databases much like a regular
     * backend, so we use the same signal handling.  See equivalent code in
     * tcop/postgres.c.
     */
    pqsignal(SIGHUP, SignalHandlerForConfigReload);
 
    /*
     * SIGINT is used to signal canceling the current table's vacuum; SIGTERM
     * means abort and exit cleanly, and SIGQUIT means abandon ship.
     */
    pqsignal(SIGINT, StatementCancelHandler);
    pqsignal(SIGTERM, die);
    /* SIGQUIT handler was already set up by InitPostmasterChild */
 
    InitializeTimeouts();       /* establishes SIGALRM handler */
 
    pqsignal(SIGPIPE, SIG_IGN);
    pqsignal(SIGUSR1, procsignal_sigusr1_handler);
    pqsignal(SIGUSR2, SIG_IGN);
    pqsignal(SIGFPE, FloatExceptionHandler);
    pqsignal(SIGCHLD, SIG_DFL);
 
    /*
     * Create a per-backend PGPROC struct in shared memory.  We must do this
     * before we can use LWLocks or access any shared memory.
     */
    InitProcess();
 
    /* Early initialization */
    BaseInit();
 
    /*
     * If an exception is encountered, processing resumes here.
     *
     * Unlike most auxiliary processes, we don't attempt to continue
     * processing after an error; we just clean up and exit.  The autovac
     * launcher is responsible for spawning another worker later.
     *
     * 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 exit.  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;
 
        /* Prevents interrupts while cleaning up */
        HOLD_INTERRUPTS();
 
        /* Report the error to the server log */
        EmitErrorReport();
 
        /*
         * We can now go away.  Note that because we called InitProcess, a
         * callback was registered to do ProcKill, which will clean up
         * necessary state.
         */
        proc_exit(0);
    }
 
    /* We can now handle ereport(ERROR) */
    PG_exception_stack = &local_sigjmp_buf;
 
    sigprocmask(SIG_SETMASK, &UnBlockSig, NULL);
 
    /*
     * Set always-secure search path, so malicious users can't redirect user
     * code (e.g. pg_index.indexprs).  (That code runs in a
     * SECURITY_RESTRICTED_OPERATION sandbox, so malicious users could not
     * take control of the entire autovacuum worker in any case.)
     */
    SetConfigOption("search_path", "", PGC_SUSET, PGC_S_OVERRIDE);
 
    /*
     * Force zero_damaged_pages OFF in the autovac process, even if it is set
     * in postgresql.conf.  We don't really want such a dangerous option being
     * applied non-interactively.
     */
    SetConfigOption("zero_damaged_pages", "false", PGC_SUSET, PGC_S_OVERRIDE);
 
    /*
     * Force settable timeouts off to avoid letting these settings prevent
     * regular maintenance from being executed.
     */
    SetConfigOption("statement_timeout", "0", PGC_SUSET, PGC_S_OVERRIDE);
    SetConfigOption("transaction_timeout", "0", PGC_SUSET, PGC_S_OVERRIDE);
    SetConfigOption("lock_timeout", "0", PGC_SUSET, PGC_S_OVERRIDE);
    SetConfigOption("idle_in_transaction_session_timeout", "0",
                    PGC_SUSET, PGC_S_OVERRIDE);
 
    /*
     * Force default_transaction_isolation to READ COMMITTED.  We don't want
     * to pay the overhead of serializable mode, nor add any risk of causing
     * deadlocks or delaying other transactions.
     */
    SetConfigOption("default_transaction_isolation", "read committed",
                    PGC_SUSET, PGC_S_OVERRIDE);
 
    /*
     * Force synchronous replication off to allow regular maintenance even if
     * we are waiting for standbys to connect. This is important to ensure we
     * aren't blocked from performing anti-wraparound tasks.
     */
    if (synchronous_commit > SYNCHRONOUS_COMMIT_LOCAL_FLUSH)
        SetConfigOption("synchronous_commit", "local",
                        PGC_SUSET, PGC_S_OVERRIDE);
 
    /*
     * Even when system is configured to use a different fetch consistency,
     * for autovac we always want fresh stats.
     */
    SetConfigOption("stats_fetch_consistency", "none", PGC_SUSET, PGC_S_OVERRIDE);
 
    /*
     * Get the info about the database we're going to work on.
     */
    LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE);
 
    /*
     * beware of startingWorker being INVALID; this should normally not
     * happen, but if a worker fails after forking and before this, the
     * launcher might have decided to remove it from the queue and start
     * again.
     */
    if (AutoVacuumShmem->av_startingWorker != NULL)
    {
        MyWorkerInfo = AutoVacuumShmem->av_startingWorker;
        dbid = MyWorkerInfo->wi_dboid;
        MyWorkerInfo->wi_proc = MyProc;
 
        /* insert into the running list */
        dlist_push_head(&AutoVacuumShmem->av_runningWorkers,
                        &MyWorkerInfo->wi_links);
 
        /*
         * remove from the "starting" pointer, so that the launcher can start
         * a new worker if required
         */
        AutoVacuumShmem->av_startingWorker = NULL;
        LWLockRelease(AutovacuumLock);
 
        on_shmem_exit(FreeWorkerInfo, 0);
 
        /* wake up the launcher */
        if (AutoVacuumShmem->av_launcherpid != 0)
            kill(AutoVacuumShmem->av_launcherpid, SIGUSR2);
    }
    else
    {
        /* no worker entry for me, go away */
        elog(WARNING, "autovacuum worker started without a worker entry");
        dbid = InvalidOid;
        LWLockRelease(AutovacuumLock);
    }
 
    if (OidIsValid(dbid))
    {
        char        dbname[NAMEDATALEN];
 
        /*
         * Report autovac startup to the cumulative stats system.  We
         * deliberately do this before InitPostgres, so that the
         * last_autovac_time will get updated even if the connection attempt
         * fails.  This is to prevent autovac from getting "stuck" repeatedly
         * selecting an unopenable database, rather than making any progress
         * on stuff it can connect to.
         */
        pgstat_report_autovac(dbid);
 
        /*
         * Connect to the selected database, specifying no particular user,
         * and ignoring datallowconn.  Collect the database's name for
         * display.
         *
         * Note: if we have selected a just-deleted database (due to using
         * stale stats info), we'll fail and exit here.
         */
        InitPostgres(NULL, dbid, NULL, InvalidOid,
                     INIT_PG_OVERRIDE_ALLOW_CONNS,
                     dbname);
        SetProcessingMode(NormalProcessing);
        set_ps_display(dbname);
        ereport(DEBUG1,
                (errmsg_internal("autovacuum: processing database \"%s\"", dbname)));
 
        if (PostAuthDelay)
            pg_usleep(PostAuthDelay * 1000000L);
 
        /* And do an appropriate amount of work */
        recentXid = ReadNextTransactionId();
        recentMulti = ReadNextMultiXactId();
        do_autovacuum();
    }
 
    /* All done, go away */
    proc_exit(0);
}

References Assert, AutoVacuumShmem, AutoVacuumShmemStruct::av_launcherpid, AutoVacuumShmemStruct::av_runningWorkers, AutoVacuumShmemStruct::av_startingWorker, BaseInit(), dbname, DEBUG1, die, dlist_push_head(), do_autovacuum(), elog, EmitErrorReport(), ereport, errmsg_internal(), error_context_stack, fb(), FloatExceptionHandler(), FreeWorkerInfo(), GetProcessingMode, HOLD_INTERRUPTS, INIT_PG_OVERRIDE_ALLOW_CONNS, init_ps_display(), InitializeTimeouts(), InitPostgres(), InitProcess(), InitProcessing, InvalidOid, kill, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MemoryContextDelete(), MyProc, MyWorkerInfo, NAMEDATALEN, NormalProcessing, OidIsValid, on_shmem_exit(), PG_exception_stack, pg_usleep(), PGC_S_OVERRIDE, PGC_SUSET, pgstat_report_autovac(), PostAuthDelay, PostmasterContext, pqsignal, proc_exit(), procsignal_sigusr1_handler(), ReadNextMultiXactId(), ReadNextTransactionId(), recentMulti, recentXid, set_ps_display(), SetConfigOption(), SetProcessingMode, SIGCHLD, SIGHUP, SignalHandlerForConfigReload(), SIGPIPE, SIGUSR1, SIGUSR2, StatementCancelHandler(), synchronous_commit, SYNCHRONOUS_COMMIT_LOCAL_FLUSH, UnBlockSig, WARNING, WorkerInfoData::wi_dboid, WorkerInfoData::wi_links, and WorkerInfoData::wi_proc.

Variable Documentation

autovacuum_anl_scale

PGDLLIMPORT double autovacuum_anl_scale

extern

Definition at line 130 of file autovacuum.c.

Referenced by relation_needs_vacanalyze().

autovacuum_anl_thresh

PGDLLIMPORT int autovacuum_anl_thresh

extern

Definition at line 129 of file autovacuum.c.

Referenced by relation_needs_vacanalyze().

autovacuum_freeze_max_age

PGDLLIMPORT int autovacuum_freeze_max_age

extern

Definition at line 131 of file autovacuum.c.

Referenced by do_start_worker(), relation_needs_vacanalyze(), SetTransactionIdLimit(), vacuum_get_cutoffs(), and vacuum_xid_failsafe_check().

autovacuum_max_workers

PGDLLIMPORT int autovacuum_max_workers

extern

Definition at line 121 of file autovacuum.c.

Referenced by av_worker_available(), check_av_worker_gucs(), and ProcessAutoVacLauncherInterrupts().

autovacuum_multixact_freeze_max_age

PGDLLIMPORT int autovacuum_multixact_freeze_max_age

extern

Definition at line 132 of file autovacuum.c.

Referenced by MultiXactMemberFreezeThreshold(), SetMultiXactIdLimit(), and vacuum_xid_failsafe_check().

autovacuum_naptime

PGDLLIMPORT int autovacuum_naptime

extern

Definition at line 123 of file autovacuum.c.

Referenced by AutoVacLauncherMain(), do_start_worker(), launch_worker(), launcher_determine_sleep(), and rebuild_database_list().

autovacuum_start_daemon

PGDLLIMPORT bool autovacuum_start_daemon

extern

Definition at line 119 of file autovacuum.c.

Referenced by autovac_init(), AutoVacuumingActive(), and removable_cutoff().

autovacuum_vac_cost_delay

PGDLLIMPORT double autovacuum_vac_cost_delay

extern

Definition at line 134 of file autovacuum.c.

Referenced by VacuumUpdateCosts().

autovacuum_vac_cost_limit

PGDLLIMPORT int autovacuum_vac_cost_limit

extern

Definition at line 135 of file autovacuum.c.

Referenced by AutoVacuumUpdateCostLimit().

autovacuum_vac_ins_scale

PGDLLIMPORT double autovacuum_vac_ins_scale

extern

Definition at line 128 of file autovacuum.c.

Referenced by relation_needs_vacanalyze().

autovacuum_vac_ins_thresh

PGDLLIMPORT int autovacuum_vac_ins_thresh

extern

Definition at line 127 of file autovacuum.c.

Referenced by relation_needs_vacanalyze().

autovacuum_vac_max_thresh

PGDLLIMPORT int autovacuum_vac_max_thresh

extern

Definition at line 125 of file autovacuum.c.

Referenced by relation_needs_vacanalyze().

autovacuum_vac_scale

PGDLLIMPORT double autovacuum_vac_scale

extern

Definition at line 126 of file autovacuum.c.

Referenced by relation_needs_vacanalyze().

autovacuum_vac_thresh

PGDLLIMPORT int autovacuum_vac_thresh

extern

Definition at line 124 of file autovacuum.c.

Referenced by relation_needs_vacanalyze().

autovacuum_work_mem

PGDLLIMPORT int autovacuum_work_mem

extern

Definition at line 122 of file autovacuum.c.

Referenced by dead_items_alloc(), and ginInsertCleanup().

autovacuum_worker_slots

PGDLLIMPORT int autovacuum_worker_slots

extern

Definition at line 120 of file autovacuum.c.

Referenced by AutoVacuumShmemInit(), AutoVacuumShmemSize(), av_worker_available(), check_av_worker_gucs(), InitializeMaxBackends(), InitPostmasterChildSlots(), and InitProcGlobal().

Log_autoanalyze_min_duration

PGDLLIMPORT int Log_autoanalyze_min_duration

extern

Definition at line 138 of file autovacuum.c.

Referenced by table_recheck_autovac().

Log_autovacuum_min_duration

PGDLLIMPORT int Log_autovacuum_min_duration

extern

Definition at line 137 of file autovacuum.c.

Referenced by table_recheck_autovac().