timeout.h File Reference

#include "datatype/timestamp.h"

Include dependency graph for timeout.h:

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

Go to the source code of this file.

Data Structures
struct	EnableTimeoutParams
struct	DisableTimeoutParams

Typedefs
typedef enum TimeoutId	TimeoutId
typedef void(*	timeout_handler_proc) (void)
typedef enum TimeoutType	TimeoutType

Enumerations
enum	TimeoutId {   STARTUP_PACKET_TIMEOUT , DEADLOCK_TIMEOUT , LOCK_TIMEOUT , STATEMENT_TIMEOUT ,   STANDBY_DEADLOCK_TIMEOUT , STANDBY_TIMEOUT , STANDBY_LOCK_TIMEOUT , IDLE_IN_TRANSACTION_SESSION_TIMEOUT ,   IDLE_SESSION_TIMEOUT , IDLE_STATS_UPDATE_TIMEOUT , CLIENT_CONNECTION_CHECK_TIMEOUT , STARTUP_PROGRESS_TIMEOUT ,   USER_TIMEOUT , MAX_TIMEOUTS = USER_TIMEOUT + 10 }
enum	TimeoutType { TMPARAM_AFTER , TMPARAM_AT , TMPARAM_EVERY }

Functions
void	InitializeTimeouts (void)
TimeoutId	RegisterTimeout (TimeoutId id, timeout_handler_proc handler)
void	reschedule_timeouts (void)
void	enable_timeout_after (TimeoutId id, int delay_ms)
void	enable_timeout_every (TimeoutId id, TimestampTz fin_time, int delay_ms)
void	enable_timeout_at (TimeoutId id, TimestampTz fin_time)
void	enable_timeouts (const EnableTimeoutParams *timeouts, int count)
void	disable_timeout (TimeoutId id, bool keep_indicator)
void	disable_timeouts (const DisableTimeoutParams *timeouts, int count)
void	disable_all_timeouts (bool keep_indicators)
bool	get_timeout_active (TimeoutId id)
bool	get_timeout_indicator (TimeoutId id, bool reset_indicator)
TimestampTz	get_timeout_start_time (TimeoutId id)
TimestampTz	get_timeout_finish_time (TimeoutId id)

Typedef Documentation

timeout_handler_proc

typedef void(* timeout_handler_proc) (void)

Definition at line 45 of file timeout.h.

TimeoutId

typedef enum TimeoutId TimeoutId

TimeoutType

typedef enum TimeoutType TimeoutType

Enumeration Type Documentation

TimeoutId

enum TimeoutId

Enumerator
STARTUP_PACKET_TIMEOUT
DEADLOCK_TIMEOUT
LOCK_TIMEOUT
STATEMENT_TIMEOUT
STANDBY_DEADLOCK_TIMEOUT
STANDBY_TIMEOUT
STANDBY_LOCK_TIMEOUT
IDLE_IN_TRANSACTION_SESSION_TIMEOUT
IDLE_SESSION_TIMEOUT
IDLE_STATS_UPDATE_TIMEOUT
CLIENT_CONNECTION_CHECK_TIMEOUT
STARTUP_PROGRESS_TIMEOUT
USER_TIMEOUT
MAX_TIMEOUTS

Definition at line 23 of file timeout.h.

{
    /* Predefined timeout reasons */
    STARTUP_PACKET_TIMEOUT,
    DEADLOCK_TIMEOUT,
    LOCK_TIMEOUT,
    STATEMENT_TIMEOUT,
    STANDBY_DEADLOCK_TIMEOUT,
    STANDBY_TIMEOUT,
    STANDBY_LOCK_TIMEOUT,
    IDLE_IN_TRANSACTION_SESSION_TIMEOUT,
    IDLE_SESSION_TIMEOUT,
    IDLE_STATS_UPDATE_TIMEOUT,
    CLIENT_CONNECTION_CHECK_TIMEOUT,
    STARTUP_PROGRESS_TIMEOUT,
    /* First user-definable timeout reason */
    USER_TIMEOUT,
    /* Maximum number of timeout reasons */
    MAX_TIMEOUTS = USER_TIMEOUT + 10
} TimeoutId;

TimeoutType

enum TimeoutType

Enumerator
TMPARAM_AFTER
TMPARAM_AT
TMPARAM_EVERY

Definition at line 50 of file timeout.h.

{
    TMPARAM_AFTER,
    TMPARAM_AT,
    TMPARAM_EVERY,
} TimeoutType;

Function Documentation

disable_all_timeouts()

void disable_all_timeouts

(

bool

keep_indicators

)

Definition at line 755 of file timeout.c.

{
    int         i;
 
    disable_alarm();
 
    /*
     * We used to disable the timer interrupt here, but in common usage
     * patterns it's cheaper to leave it enabled; that may save us from having
     * to enable it again shortly.  See comments in schedule_alarm().
     */
 
    num_active_timeouts = 0;
 
    for (i = 0; i < MAX_TIMEOUTS; i++)
    {
        all_timeouts[i].active = false;
        if (!keep_indicators)
            all_timeouts[i].indicator = false;
    }
}

References timeout_params::active, all_timeouts, disable_alarm, i, timeout_params::indicator, MAX_TIMEOUTS, and num_active_timeouts.

Referenced by AutoVacLauncherMain(), PostgresMain(), ResolveRecoveryConflictWithBufferPin(), and ResolveRecoveryConflictWithLock().

disable_timeout()

void disable_timeout	(	TimeoutId	id,
		bool	keep_indicator
	)

Definition at line 689 of file timeout.c.

{
    /* Assert request is sane */
    Assert(all_timeouts_initialized);
    Assert(all_timeouts[id].timeout_handler != NULL);
 
    /* Disable timeout interrupts for safety. */
    disable_alarm();
 
    /* Find the timeout and remove it from the active list. */
    if (all_timeouts[id].active)
        remove_timeout_index(find_active_timeout(id));
 
    /* Mark it inactive, whether it was active or not. */
    if (!keep_indicator)
        all_timeouts[id].indicator = false;
 
    /* Reschedule the interrupt, if any timeouts remain active. */
    if (num_active_timeouts > 0)
        schedule_alarm(GetCurrentTimestamp());
}

References all_timeouts, all_timeouts_initialized, Assert(), disable_alarm, find_active_timeout(), GetCurrentTimestamp(), timeout_params::indicator, num_active_timeouts, remove_timeout_index(), and schedule_alarm().

Referenced by BackendInitialize(), disable_startup_progress_timeout(), disable_statement_timeout(), enable_statement_timeout(), PerformAuthentication(), PostgresMain(), and ProcSleep().

disable_timeouts()

void disable_timeouts	(	const DisableTimeoutParams *	timeouts,
		int	count
	)

Definition at line 722 of file timeout.c.

{
    int         i;
 
    Assert(all_timeouts_initialized);
 
    /* Disable timeout interrupts for safety. */
    disable_alarm();
 
    /* Cancel the timeout(s). */
    for (i = 0; i < count; i++)
    {
        TimeoutId   id = timeouts[i].id;
 
        Assert(all_timeouts[id].timeout_handler != NULL);
 
        if (all_timeouts[id].active)
            remove_timeout_index(find_active_timeout(id));
 
        if (!timeouts[i].keep_indicator)
            all_timeouts[id].indicator = false;
    }
 
    /* Reschedule the interrupt, if any timeouts remain active. */
    if (num_active_timeouts > 0)
        schedule_alarm(GetCurrentTimestamp());
}

References all_timeouts, all_timeouts_initialized, Assert(), disable_alarm, find_active_timeout(), GetCurrentTimestamp(), i, DisableTimeoutParams::id, timeout_params::indicator, num_active_timeouts, remove_timeout_index(), and schedule_alarm().

Referenced by LockErrorCleanup(), and ProcSleep().

enable_timeout_after()

void enable_timeout_after	(	TimeoutId	id,
		int	delay_ms
	)

Definition at line 564 of file timeout.c.

{
    TimestampTz now;
    TimestampTz fin_time;
 
    /* Disable timeout interrupts for safety. */
    disable_alarm();
 
    /* Queue the timeout at the appropriate time. */
    now = GetCurrentTimestamp();
    fin_time = TimestampTzPlusMilliseconds(now, delay_ms);
    enable_timeout(id, now, fin_time, 0);
 
    /* Set the timer interrupt. */
    schedule_alarm(now);
}

References disable_alarm, enable_timeout(), GetCurrentTimestamp(), now(), schedule_alarm(), and TimestampTzPlusMilliseconds.

Referenced by BackendInitialize(), enable_statement_timeout(), PerformAuthentication(), PostgresMain(), ProcessInterrupts(), ProcSleep(), and start_xact_command().

enable_timeout_at()

void enable_timeout_at	(	TimeoutId	id,
		TimestampTz	fin_time
	)

Definition at line 611 of file timeout.c.

{
    TimestampTz now;
 
    /* Disable timeout interrupts for safety. */
    disable_alarm();
 
    /* Queue the timeout at the appropriate time. */
    now = GetCurrentTimestamp();
    enable_timeout(id, now, fin_time, 0);
 
    /* Set the timer interrupt. */
    schedule_alarm(now);
}

References disable_alarm, enable_timeout(), GetCurrentTimestamp(), now(), and schedule_alarm().

enable_timeout_every()

void enable_timeout_every	(	TimeoutId	id,
		TimestampTz	fin_time,
		int	delay_ms
	)

Definition at line 588 of file timeout.c.

{
    TimestampTz now;
 
    /* Disable timeout interrupts for safety. */
    disable_alarm();
 
    /* Queue the timeout at the appropriate time. */
    now = GetCurrentTimestamp();
    enable_timeout(id, now, fin_time, delay_ms);
 
    /* Set the timer interrupt. */
    schedule_alarm(now);
}

References disable_alarm, enable_timeout(), GetCurrentTimestamp(), now(), and schedule_alarm().

Referenced by enable_startup_progress_timeout().

enable_timeouts()

void enable_timeouts	(	const EnableTimeoutParams *	timeouts,
		int	count
	)

Definition at line 634 of file timeout.c.

{
    TimestampTz now;
    int         i;
 
    /* Disable timeout interrupts for safety. */
    disable_alarm();
 
    /* Queue the timeout(s) at the appropriate times. */
    now = GetCurrentTimestamp();
 
    for (i = 0; i < count; i++)
    {
        TimeoutId   id = timeouts[i].id;
        TimestampTz fin_time;
 
        switch (timeouts[i].type)
        {
            case TMPARAM_AFTER:
                fin_time = TimestampTzPlusMilliseconds(now,
                                                       timeouts[i].delay_ms);
                enable_timeout(id, now, fin_time, 0);
                break;
 
            case TMPARAM_AT:
                enable_timeout(id, now, timeouts[i].fin_time, 0);
                break;
 
            case TMPARAM_EVERY:
                fin_time = TimestampTzPlusMilliseconds(now,
                                                       timeouts[i].delay_ms);
                enable_timeout(id, now, fin_time, timeouts[i].delay_ms);
                break;
 
            default:
                elog(ERROR, "unrecognized timeout type %d",
                     (int) timeouts[i].type);
                break;
        }
    }
 
    /* Set the timer interrupt. */
    schedule_alarm(now);
}

References disable_alarm, elog(), enable_timeout(), ERROR, GetCurrentTimestamp(), i, EnableTimeoutParams::id, now(), schedule_alarm(), TimestampTzPlusMilliseconds, TMPARAM_AFTER, TMPARAM_AT, TMPARAM_EVERY, and type.

Referenced by ProcSleep(), ResolveRecoveryConflictWithBufferPin(), and ResolveRecoveryConflictWithLock().

get_timeout_active()

bool get_timeout_active

(

TimeoutId

id

)

Definition at line 784 of file timeout.c.

{
    return all_timeouts[id].active;
}

References timeout_params::active, and all_timeouts.

Referenced by disable_statement_timeout(), enable_statement_timeout(), PostgresMain(), and start_xact_command().

get_timeout_finish_time()

TimestampTz get_timeout_finish_time

(

TimeoutId

id

)

Definition at line 831 of file timeout.c.

{
    return all_timeouts[id].fin_time;
}

References all_timeouts, and timeout_params::fin_time.

Referenced by ProcessInterrupts().

get_timeout_indicator()

bool get_timeout_indicator	(	TimeoutId	id,
		bool	reset_indicator
	)

Definition at line 797 of file timeout.c.

{
    if (all_timeouts[id].indicator)
    {
        if (reset_indicator)
            all_timeouts[id].indicator = false;
        return true;
    }
    return false;
}

References all_timeouts, and timeout_params::indicator.

Referenced by ProcessInterrupts().

get_timeout_start_time()

TimestampTz get_timeout_start_time

(

TimeoutId

id

)

Definition at line 817 of file timeout.c.

{
    return all_timeouts[id].start_time;
}

References all_timeouts, and timeout_params::start_time.

Referenced by ProcSleep().

InitializeTimeouts()

void InitializeTimeouts

(

void

)

Definition at line 474 of file timeout.c.

{
    int         i;
 
    /* Initialize, or re-initialize, all local state */
    disable_alarm();
 
    num_active_timeouts = 0;
 
    for (i = 0; i < MAX_TIMEOUTS; i++)
    {
        all_timeouts[i].index = i;
        all_timeouts[i].active = false;
        all_timeouts[i].indicator = false;
        all_timeouts[i].timeout_handler = NULL;
        all_timeouts[i].start_time = 0;
        all_timeouts[i].fin_time = 0;
        all_timeouts[i].interval_in_ms = 0;
    }
 
    all_timeouts_initialized = true;
 
    /* Now establish the signal handler */
    pqsignal(SIGALRM, handle_sig_alarm);
}

References timeout_params::active, all_timeouts, all_timeouts_initialized, disable_alarm, timeout_params::fin_time, handle_sig_alarm(), i, timeout_params::index, timeout_params::indicator, timeout_params::interval_in_ms, MAX_TIMEOUTS, num_active_timeouts, pqsignal(), SIGALRM, timeout_params::start_time, and timeout_params::timeout_handler.

Referenced by AutoVacLauncherMain(), AutoVacWorkerMain(), BackendInitialize(), BackgroundWorkerMain(), PostgresMain(), StartupProcessMain(), and WalSndSignals().

RegisterTimeout()

TimeoutId RegisterTimeout	(	TimeoutId	id,
		timeout_handler_proc	handler
	)

Definition at line 509 of file timeout.c.

{
    Assert(all_timeouts_initialized);
 
    /* There's no need to disable the signal handler here. */
 
    if (id >= USER_TIMEOUT)
    {
        /* Allocate a user-defined timeout reason */
        for (id = USER_TIMEOUT; id < MAX_TIMEOUTS; id++)
            if (all_timeouts[id].timeout_handler == NULL)
                break;
        if (id >= MAX_TIMEOUTS)
            ereport(FATAL,
                    (errcode(ERRCODE_CONFIGURATION_LIMIT_EXCEEDED),
                     errmsg("cannot add more timeout reasons")));
    }
 
    Assert(all_timeouts[id].timeout_handler == NULL);
 
    all_timeouts[id].timeout_handler = handler;
 
    return id;
}

References all_timeouts, all_timeouts_initialized, Assert(), ereport, errcode(), errmsg(), FATAL, MAX_TIMEOUTS, timeout_params::timeout_handler, and USER_TIMEOUT.

Referenced by BackendInitialize(), InitPostgres(), StartupProcessMain(), and StartupXLOG().

reschedule_timeouts()

void reschedule_timeouts

(

void

)

Definition at line 544 of file timeout.c.

{
    /* For flexibility, allow this to be called before we're initialized. */
    if (!all_timeouts_initialized)
        return;
 
    /* Disable timeout interrupts for safety. */
    disable_alarm();
 
    /* Reschedule the interrupt, if any timeouts remain active. */
    if (num_active_timeouts > 0)
        schedule_alarm(GetCurrentTimestamp());
}

References all_timeouts_initialized, disable_alarm, GetCurrentTimestamp(), num_active_timeouts, and schedule_alarm().

Referenced by AbortSubTransaction(), and AbortTransaction().